Datasets:

docz-ict

/

ComBack

like 2

[ "<s>", "static", "void", "write_token", "(", "FILE", "*", "out", ",", "Token", "const", "*", "tok", ")", "{", "if", "(", "tok", "->", "space", ")", "fputc", "(", "' '", ",", "out", ")", ";", "switch", "(", "tok", "->", "kind", ")", "{", "case", "K_string", ":", "{", "const", "char", "*", "c", "=", "tok", "->", "ptr", "+", "1", ";", "size_t", "len", "=", "tok", "->", "len", "-", "2", ";", "fputs", "(", "\"\\\\\\\"\"", ",", "out", ")", ";", "while", "(", "len", ")", "{", "const", "char", "*", "bs", "=", "(", "const", "char", "*", ")", "memchr", "(", "c", ",", "'\\\\'", ",", "len", ")", ";", "size_t", "l", "=", "bs", "?", "bs", "-", "c", ":", "len", ";", "fprintf", "(", "out", ",", "\"%.*s\"", ",", "(", "int", ")", "l", ",", "c", ")", ";", "len", "-=", "l", ";", "c", "+=", "l", ";", "if", "(", "bs", ")", "{", "fputs", "(", "\"\\\\\\\\\"", ",", "out", ")", ";", "len", "--", ",", "c", "++", ";", "}", "}", "fputs", "(", "\"\\\\\\\"\"", ",", "out", ")", ";", "}", "break", ";", "default", ":", "fprintf", "(", "out", ",", "\"%.*s\"", ",", "tok", "->", "len", ",", "tok", "->", "ptr", ")", ";", "break", ";", "}", "if", "(", "tok", "->", "end", ")", "fputs", "(", "\"\\\\n\"", ",", "out", ")", ";", "}", "</s>" ]

[ "Write", "an", "encoded", "token", "." ]

[ "nvptx", "1", "2", "\"\\\\\\\"\"", "\"%.*s\"", "\"\\\\\\\\\"", "\"\\\\\\\"\"", "\"%.*s\"", "\"\\\\n\"" ]

[]

[ "<s>", "bool", "NVPTXPrologEpilogPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "STI", ".", "getFrameLowering", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "calculateFrameObjectOffsets", "(", "MF", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "continue", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "assert", "(", "i", "==", "0", "&&", "\"Frame indices can only appear as the first \"", "\"operand of a DBG_VALUE machine instruction\"", ")", ";", "Register", "Reg", ";", "int64_t", "Offset", "=", "TFI", ".", "getFrameIndexReference", "(", "MF", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ",", "Reg", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "setIsDebug", "(", ")", ";", "auto", "*", "DIExpr", "=", "DIExpression", "::", "prepend", "(", "MI", ".", "getDebugExpression", "(", ")", ",", "DIExpression", "::", "ApplyOffset", ",", "Offset", ")", ";", "MI", ".", "getOperand", "(", "3", ")", ".", "setMetadata", "(", "DIExpr", ")", ";", "continue", ";", "}", "TRI", ".", "eliminateFrameIndex", "(", "MI", ",", "0", ",", "i", ",", "nullptr", ")", ";", "Modified", "=", "true", ";", "}", "}", "}", "TFI", ".", "emitPrologue", "(", "MF", ",", "MF", ".", "front", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isReturnBlock", "(", ")", ")", "TFI", ".", "emitEpilogue", "(", "MF", ",", "*", "I", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "NVPTX", "NVPTX", "0", "0", "\"Frame indices can only appear as the first \"", "\"operand of a DBG_VALUE machine instruction\"", "0", "0", "0", "3", "0" ]

[]

[ "<s>", "int", "ix86_issue_rate", "(", "void", ")", "{", "switch", "(", "ix86_tune", ")", "{", "case", "PROCESSOR_PENTIUM", ":", "case", "PROCESSOR_LAKEMONT", ":", "case", "PROCESSOR_BONNELL", ":", "case", "PROCESSOR_SILVERMONT", ":", "case", "PROCESSOR_KNL", ":", "case", "PROCESSOR_KNM", ":", "case", "PROCESSOR_INTEL", ":", "case", "PROCESSOR_K6", ":", "case", "PROCESSOR_BTVER2", ":", "case", "PROCESSOR_PENTIUM4", ":", "case", "PROCESSOR_NOCONA", ":", "return", "2", ";", "case", "PROCESSOR_PENTIUMPRO", ":", "case", "PROCESSOR_ATHLON", ":", "case", "PROCESSOR_K8", ":", "case", "PROCESSOR_AMDFAM10", ":", "case", "PROCESSOR_BTVER1", ":", "case", "PROCESSOR_LUJIAZUI", ":", "return", "3", ";", "case", "PROCESSOR_BDVER1", ":", "case", "PROCESSOR_BDVER2", ":", "case", "PROCESSOR_BDVER3", ":", "case", "PROCESSOR_BDVER4", ":", "case", "PROCESSOR_ZNVER1", ":", "case", "PROCESSOR_ZNVER2", ":", "case", "PROCESSOR_ZNVER3", ":", "case", "PROCESSOR_ZNVER4", ":", "case", "PROCESSOR_CORE2", ":", "case", "PROCESSOR_NEHALEM", ":", "case", "PROCESSOR_SANDYBRIDGE", ":", "case", "PROCESSOR_HASWELL", ":", "case", "PROCESSOR_TREMONT", ":", "case", "PROCESSOR_SKYLAKE", ":", "case", "PROCESSOR_SKYLAKE_AVX512", ":", "case", "PROCESSOR_CASCADELAKE", ":", "case", "PROCESSOR_CANNONLAKE", ":", "case", "PROCESSOR_ALDERLAKE", ":", "case", "PROCESSOR_GENERIC", ":", "return", "4", ";", "case", "PROCESSOR_ICELAKE_CLIENT", ":", "case", "PROCESSOR_ICELAKE_SERVER", ":", "case", "PROCESSOR_TIGERLAKE", ":", "case", "PROCESSOR_COOPERLAKE", ":", "case", "PROCESSOR_ROCKETLAKE", ":", "return", "5", ";", "case", "PROCESSOR_SAPPHIRERAPIDS", ":", "return", "6", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Return", "the", "maximum", "number", "of", "instructions", "a", "cpu", "can", "issue", "." ]

[ "i386", "2", "3", "4", "5", "6", "1" ]

[]

[ "<s>", "void", "P2MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"==== begin encode ====\\n\"", ")", ";", "LLVM_DEBUG", "(", "MI", ".", "dump", "(", ")", ")", ";", "uint32_t", "bin", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "unsigned", "op_code", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "op_code", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"emitting instruction binary: \"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "(", "(", "bin", ">>", "(", "31", "-", "i", ")", ")", "&", "1", ")", ")", ";", "}", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "emitInstruction", "(", "bin", ",", "4", ",", "OS", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"==== end encode ====\\n\"", ")", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "P2", "P2", "\"==== begin encode ====\\n\"", "\"emitting instruction binary: \"", "0", "32", "31", "1", "\"\\n\"", "4", "\"==== end encode ====\\n\"" ]

[]

[ "<s>", "static", "void", "riscv_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "struct", "riscv_arg_info", "info", ";", "riscv_get_arg_info", "(", "&", "info", ",", "cum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "arg", ".", "named", ",", "false", ")", ";", "cum", "->", "num_fprs", "=", "info", ".", "fpr_offset", "+", "info", ".", "num_fprs", ";", "cum", "->", "num_gprs", "=", "info", ".", "gpr_offset", "+", "info", ".", "num_gprs", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_ADVANCE", "." ]

[ "riscv" ]

[]

[ "<s>", "PPCSubtarget", "::", "PPCSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "StackAlignment", "(", "16", ")", ",", "DarwinDirective", "(", "PPC", "::", "DIR_NONE", ")", ",", "IsGigaProcessor", "(", "false", ")", ",", "Has64BitSupport", "(", "false", ")", ",", "Use64BitRegs", "(", "false", ")", ",", "IsPPC64", "(", "is64Bit", ")", ",", "HasAltivec", "(", "false", ")", ",", "HasFSQRT", "(", "false", ")", ",", "HasSTFIWX", "(", "false", ")", ",", "HasLazyResolverStubs", "(", "false", ")", ",", "DarwinVers", "(", "0", ")", "{", "std", "::", "string", "CPU", "=", "\"generic\"", ";", "CPU", "=", "GetCurrentPowerPCCPU", "(", ")", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "if", "(", "is64Bit", ")", "{", "Has64BitSupport", "=", "true", ";", "Use64BitRegs", "=", "true", ";", "}", "if", "(", "use64BitRegs", "(", ")", "&&", "!", "has64BitSupport", "(", ")", ")", "Use64BitRegs", "=", "false", ";", "if", "(", "TT", ".", "length", "(", ")", ">", "7", ")", "{", "size_t", "DarwinPos", "=", "TT", ".", "find", "(", "\"-darwin\"", ")", ";", "if", "(", "DarwinPos", "!=", "std", "::", "string", "::", "npos", ")", "{", "if", "(", "isdigit", "(", "TT", "[", "DarwinPos", "+", "7", "]", ")", ")", "DarwinVers", "=", "atoi", "(", "&", "TT", "[", "DarwinPos", "+", "7", "]", ")", ";", "else", "DarwinVers", "=", "8", ";", "}", "}", "if", "(", "isDarwin", "(", ")", ")", "HasLazyResolverStubs", "=", "true", ";", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "PowerPC", "PPC", "PPC", "16", "PPC::DIR_NONE", "PPC", "0", "\"generic\"", "7", "\"-darwin\"", "7", "7", "8" ]

[]

[ "<s>", "bool", "VZeroUpperInserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "EverMadeChange", "=", "false", ";", "bool", "YMMUsed", "=", "false", ";", "const", "TargetRegisterClass", "*", "RC", "=", "X86", "::", "VR256RegisterClass", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "i", "=", "RC", "->", "begin", "(", ")", ",", "e", "=", "RC", "->", "end", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "if", "(", "MRI", ".", "isPhysRegUsed", "(", "*", "i", ")", ")", "{", "YMMUsed", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "YMMUsed", ")", "return", "EverMadeChange", ";", "FnHasLiveInYmm", "=", "checkFnHasLiveInYmm", "(", "MRI", ")", ";", "assert", "(", "BBState", ".", "empty", "(", ")", ")", ";", "BBState", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ",", "0", ")", ";", "BBSolved", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ",", "0", ")", ";", "while", "(", "1", ")", "{", "bool", "MadeChange", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "MadeChange", "|=", "processBasicBlock", "(", "MF", ",", "*", "I", ")", ";", "if", "(", "!", "MadeChange", ")", "break", ";", "EverMadeChange", "=", "true", ";", "}", "BBState", ".", "clear", "(", ")", ";", "BBSolved", ".", "clear", "(", ")", ";", "return", "EverMadeChange", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "X86", "X86::VR256RegisterClass", "0", "0", "1" ]

[]

[ "<s>", "FastISel", "*", "PPC", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "FuncInfo", ",", "const", "TargetLibraryInfo", "*", "LibInfo", ")", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "FuncInfo", ".", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "new", "PPCFastISel", "(", "FuncInfo", ",", "LibInfo", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "PowerPC", "PPC::createFastISel", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "tilepro_expand_epilogue", "(", "bool", "sibcall_p", ")", "{", "rtx", "reg_save_addr", "[", "ROUND_ROBIN_SIZE", "]", "=", "{", "NULL_RTX", ",", "NULL_RTX", ",", "NULL_RTX", ",", "NULL_RTX", "}", ";", "rtx_insn", "*", "last_insn", ",", "*", "insn", ";", "unsigned", "int", "which_scratch", ";", "int", "offset", ",", "start_offset", ",", "regno", ";", "rtx", "cfa_restores", "=", "NULL_RTX", ";", "int", "fp_copy_regno", "=", "-", "1", ";", "int", "next_scratch_regno", "=", "29", ";", "int", "total_size", "=", "compute_total_frame_size", "(", ")", ";", "last_insn", "=", "get_last_insn", "(", ")", ";", "insn", "=", "NULL", ";", "if", "(", "df_regs_ever_live_p", "(", "TILEPRO_LINK_REGNUM", ")", ")", "{", "insn", "=", "frame_emit_load", "(", "TILEPRO_LINK_REGNUM", ",", "compute_frame_addr", "(", "0", ",", "&", "next_scratch_regno", ")", ",", "&", "cfa_restores", ")", ";", "}", "if", "(", "total_size", "==", "0", ")", "{", "if", "(", "insn", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "cfa_restores", ";", "}", "goto", "done", ";", "}", "start_offset", "=", "-", "crtl", "->", "args", ".", "pretend_args_size", "-", "UNITS_PER_WORD", ";", "offset", "=", "start_offset", ";", "if", "(", "frame_pointer_needed", ")", "fp_copy_regno", "=", "next_scratch_regno", "--", ";", "which_scratch", "=", "0", ";", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", "-", "1", ";", "regno", ">=", "0", ";", "regno", "--", ")", "if", "(", "need_to_save_reg", "(", "regno", ")", ")", "{", "rtx", "r", "=", "reg_save_addr", "[", "which_scratch", "]", ";", "if", "(", "r", "==", "NULL_RTX", ")", "{", "r", "=", "compute_frame_addr", "(", "offset", ",", "&", "next_scratch_regno", ")", ";", "reg_save_addr", "[", "which_scratch", "]", "=", "r", ";", "}", "else", "{", "int", "stride", "=", "ROUND_ROBIN_SIZE", "*", "-", "UNITS_PER_WORD", ";", "rtx", "p", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "r", ",", "GEN_INT", "(", "stride", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "r", ",", "p", ")", ")", ";", "}", "if", "(", "fp_copy_regno", ">=", "0", "&&", "regno", "==", "HARD_FRAME_POINTER_REGNUM", ")", "frame_emit_load", "(", "fp_copy_regno", ",", "r", ",", "NULL", ")", ";", "else", "frame_emit_load", "(", "regno", ",", "r", ",", "&", "cfa_restores", ")", ";", "offset", "-=", "UNITS_PER_WORD", ";", "which_scratch", "=", "(", "which_scratch", "+", "1", ")", "%", "ROUND_ROBIN_SIZE", ";", "}", "if", "(", "!", "tilepro_current_function_is_leaf", "(", ")", ")", "cfa_restores", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "stack_pointer_rtx", ",", "cfa_restores", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "emit_insn", "(", "gen_sp_restore", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "cfa_restores", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "stack_pointer_rtx", ")", ";", "}", "else", "{", "insn", "=", "emit_sp_adjust", "(", "total_size", ",", "&", "next_scratch_regno", ",", "true", ",", "cfa_restores", ")", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_sp_adjust", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "gen_rtx_REG", "(", "Pmode", ",", "fp_copy_regno", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "hard_frame_pointer_rtx", ")", ";", "}", "if", "(", "flag_pic", ")", "{", "emit_use", "(", "cfun", "->", "machine", "->", "text_label_rtx", ")", ";", "emit_use", "(", "cfun", "->", "machine", "->", "got_rtx", ")", ";", "}", "done", ":", "if", "(", "!", "sibcall_p", ")", "{", "emit_jump_insn", "(", "gen__return", "(", ")", ")", ";", "}", "else", "{", "emit_use", "(", "gen_rtx_REG", "(", "Pmode", ",", "TILEPRO_LINK_REGNUM", ")", ")", ";", "}", "for", "(", ";", "last_insn", "!=", "NULL_RTX", ";", "last_insn", "=", "next_insn", "(", "last_insn", ")", ")", "RTX_FRAME_RELATED_P", "(", "last_insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Implement", "the", "epilogue", "and", "sibcall_epilogue", "patterns", ".", "SIBCALL_P", "is", "true", "for", "a", "sibcall_epilogue", "pattern", ",", "and", "false", "for", "an", "epilogue", "pattern", "." ]

[ "tilepro", "1", "29", "0", "0", "1", "0", "1", "0", "0", "1", "1", "1" ]

[]

[ "<s>", "static", "rtx", "sparc_function_arg_1", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ",", "bool", "incoming", ")", "{", "const", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "const", "int", "regbase", "=", "incoming", "?", "SPARC_INCOMING_INT_ARG_FIRST", ":", "SPARC_OUTGOING_INT_ARG_FIRST", ";", "int", "slotno", ",", "regno", ",", "padding", ";", "enum", "mode_class", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "slotno", "=", "function_arg_slotno", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "incoming", ",", "&", "regno", ",", "&", "padding", ")", ";", "if", "(", "slotno", "==", "-", "1", ")", "return", "0", ";", "if", "(", "type", "&&", "VECTOR_INTEGER_TYPE_P", "(", "type", ")", ")", "mclass", "=", "MODE_FLOAT", ";", "if", "(", "TARGET_ARCH32", ")", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "return", "function_arg_record_value", "(", "type", ",", "mode", ",", "slotno", ",", "named", ",", "regbase", ")", ";", "}", "else", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "return", "function_arg_union_value", "(", "size", ",", "mode", ",", "slotno", ",", "regno", ")", ";", "}", "else", "if", "(", "type", "&&", "VECTOR_TYPE_P", "(", "type", ")", "&&", "mode", "==", "BLKmode", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "return", "function_arg_vector_value", "(", "size", ",", "slotno", ",", "named", ",", "regno", ")", ";", "}", "else", "if", "(", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "SPARC_FP_REG_P", "(", "regno", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "if", "(", "cum", "->", "prototype_p", "||", "cum", "->", "libcall_p", ")", "return", "reg", ";", "else", "{", "rtx", "v0", ",", "v1", ";", "if", "(", "(", "regno", "-", "SPARC_FP_ARG_FIRST", ")", "<", "SPARC_INT_ARG_MAX", "*", "2", ")", "{", "int", "intreg", ";", "if", "(", "incoming", ")", "return", "reg", ";", "intreg", "=", "(", "SPARC_OUTGOING_INT_ARG_FIRST", "+", "(", "regno", "-", "SPARC_FP_ARG_FIRST", ")", "/", "2", ")", ";", "v0", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ";", "v1", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "intreg", ")", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "v0", ",", "v1", ")", ")", ";", "}", "else", "{", "v0", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "v1", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "v0", ",", "v1", ")", ")", ";", "}", "}", "}", "else", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "mode", "=", "int_mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "0", ")", ".", "else_blk", "(", ")", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "NAMED", "is", "true", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "INCOMING_P", "is", "false", "for", "TARGET_FUNCTION_ARG", ",", "true", "for", "TARGET_FUNCTION_INCOMING_ARG", "." ]

[ "sparc", "1", "0", "16", "16", "16", "2", "2", "2", "2", "16", "0" ]

[]

[ "<s>", "bool", "isTargetEHABICompatible", "(", ")", "const", "{", "return", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "EABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "EABIHF", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABIHF", "||", "isTargetAndroid", "(", ")", ")", "&&", "!", "isTargetDarwin", "(", ")", "&&", "!", "isTargetWindows", "(", ")", ";", "}", "</s>" ]

[ "Tests", "whether", "the", "target", "supports", "the", "EHABI", "exception", "handling", "standard", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "thumb_expand_movmemqi", "(", "rtx", "*", "operands", ")", "{", "rtx", "out", "=", "copy_to_mode_reg", "(", "SImode", ",", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", ";", "rtx", "in", "=", "copy_to_mode_reg", "(", "SImode", ",", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", ";", "HOST_WIDE_INT", "len", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "HOST_WIDE_INT", "offset", "=", "0", ";", "while", "(", "len", ">=", "12", ")", "{", "emit_insn", "(", "gen_movmem12b", "(", "out", ",", "in", ",", "out", ",", "in", ")", ")", ";", "len", "-=", "12", ";", "}", "if", "(", "len", ">=", "8", ")", "{", "emit_insn", "(", "gen_movmem8b", "(", "out", ",", "in", ",", "out", ",", "in", ")", ")", ";", "len", "-=", "8", ";", "}", "if", "(", "len", ">=", "4", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "gen_rtx_MEM", "(", "SImode", ",", "in", ")", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "gen_rtx_MEM", "(", "SImode", ",", "out", ")", ",", "reg", ")", ")", ";", "len", "-=", "4", ";", "offset", "+=", "4", ";", "}", "if", "(", "len", ">=", "2", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_movhi", "(", "reg", ",", "gen_rtx_MEM", "(", "HImode", ",", "plus_constant", "(", "in", ",", "offset", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_movhi", "(", "gen_rtx_MEM", "(", "HImode", ",", "plus_constant", "(", "out", ",", "offset", ")", ")", ",", "reg", ")", ")", ";", "len", "-=", "2", ";", "offset", "+=", "2", ";", "}", "if", "(", "len", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "emit_insn", "(", "gen_movqi", "(", "reg", ",", "gen_rtx_MEM", "(", "QImode", ",", "plus_constant", "(", "in", ",", "offset", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_movqi", "(", "gen_rtx_MEM", "(", "QImode", ",", "plus_constant", "(", "out", ",", "offset", ")", ")", ",", "reg", ")", ")", ";", "}", "}", "</s>" ]

[ "Routines", "for", "generating", "rtl", "." ]

[ "arm", "0", "0", "1", "0", "2", "0", "12", "12", "8", "8", "4", "4", "4", "2", "2", "2" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "addPass", "(", "&", "SIFoldOperandsID", ")", ";", "if", "(", "EnableDPPCombine", ")", "addPass", "(", "&", "GCNDPPCombineID", ")", ";", "addPass", "(", "&", "SILoadStoreOptimizerID", ")", ";", "if", "(", "EnableSDWAPeephole", ".", "getNumOccurrences", "(", ")", "?", "EnableSDWAPeephole", ":", "TM", "->", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "Less", ")", "{", "addPass", "(", "&", "SIPeepholeSDWAID", ")", ";", "addPass", "(", "&", "EarlyMachineLICMID", ")", ";", "addPass", "(", "&", "MachineCSEID", ")", ";", "addPass", "(", "&", "SIFoldOperandsID", ")", ";", "}", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "PIC16Section", "*", "PIC16Section", "::", "Create", "(", "const", "StringRef", "&", "Name", ",", "PIC16SectionType", "Ty", ",", "const", "std", "::", "string", "&", "Address", ",", "int", "Color", ",", "MCContext", "&", "Ctx", ")", "{", "SectionKind", "K", ";", "switch", "(", "Ty", ")", "{", "default", ":", "llvm_unreachable", "(", "\"can not create unknown section type\"", ")", ";", "case", "UDATA_OVR", ":", "{", "K", "=", "SectionKind", "::", "getThreadBSS", "(", ")", ";", "break", ";", "}", "case", "UDATA_SHR", ":", "case", "UDATA", ":", "{", "K", "=", "SectionKind", "::", "getBSS", "(", ")", ";", "break", ";", "}", "case", "ROMDATA", ":", "case", "IDATA", ":", "{", "K", "=", "SectionKind", "::", "getMetadata", "(", ")", ";", "break", ";", "}", "case", "CODE", ":", "{", "K", "=", "SectionKind", "::", "getText", "(", ")", ";", "break", ";", "}", "}", "PIC16Section", "*", "S", "=", "new", "(", "Ctx", ")", "PIC16Section", "(", "Name", ",", "K", ",", "Address", ",", "Color", ")", ";", "S", "->", "T", "=", "Ty", ";", "return", "S", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

[ "PIC16", "PIC16", "PIC16", "PIC16", "\"can not create unknown section type\"", "PIC16", "PIC16" ]

[]

[ "<s>", "unsigned", "ARCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "int", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "isStore", "(", "Opcode", ")", ")", "{", "if", "(", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "ARC", "ARC", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "M88kRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "return", "CSR_M88k_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "M88k", "M88k", "M88k" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Fix CF Live Intervals\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "AMDGPU", "\"SI Fix CF Live Intervals\"" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "requiresVirtualBaseRegisters", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "return", "!", "Subtarget", ".", "hasROPProtect", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "wants", "the", "LocalStackAllocation", "pass", "to", "be", "run", "and", "virtual", "base", "registers", "used", "for", "more", "efficient", "stack", "access", "." ]

[ "PowerPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "AArch64IndirectThunks", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "'\\n'", ")", ";", "auto", "&", "MMI", "=", "getAnalysis", "<", "MachineModuleInfoWrapperPass", ">", "(", ")", ".", "getMMI", "(", ")", ";", "return", "runTIs", "(", "MMI", ",", "MF", ",", "TIs", ")", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "int", "find_r0_life_regions", "(", "basic_block", "b", ")", "{", "rtx_insn", "*", "end", ",", "*", "insn", ";", "rtx", "pset", ";", "rtx", "r0_reg", ";", "int", "live", ";", "int", "set", ";", "int", "death", "=", "0", ";", "if", "(", "REGNO_REG_SET_P", "(", "df_get_live_in", "(", "b", ")", ",", "R0_REG", ")", ")", "{", "set", "=", "1", ";", "live", "=", "1", ";", "}", "else", "{", "set", "=", "0", ";", "live", "=", "0", ";", "}", "insn", "=", "BB_HEAD", "(", "b", ")", ";", "end", "=", "BB_END", "(", "b", ")", ";", "r0_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "R0_REG", ")", ";", "while", "(", "1", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "if", "(", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "R0_REG", ")", ")", "{", "death", "++", ";", "live", "=", "0", ";", "}", "if", "(", "!", "live", "&&", "(", "pset", "=", "single_set", "(", "insn", ")", ")", "&&", "reg_overlap_mentioned_p", "(", "r0_reg", ",", "SET_DEST", "(", "pset", ")", ")", "&&", "!", "find_regno_note", "(", "insn", ",", "REG_UNUSED", ",", "R0_REG", ")", ")", "{", "set", "++", ";", "live", "=", "1", ";", "}", "}", "if", "(", "insn", "==", "end", ")", "break", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "}", "return", "set", "-", "death", ";", "}", "</s>" ]

[ "Count", "life", "regions", "of", "r0", "for", "a", "block", "." ]

[ "sh", "0", "1", "1", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "const", "AMDGPUSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "R600" ]

[]

[ "<s>", "bool", "can_be_overloaded_p", "(", "enum", "predication_type_index", "pred", ")", "const", "override", "{", "return", "pred", "==", "PRED_TYPE_tu", "||", "pred", "==", "PRED_TYPE_tum", "||", "pred", "==", "PRED_TYPE_tumu", ";", "}", "</s>" ]

[ "Since", "most", "of", "intrinsics", "can", "be", "overloaded", ",", "we", "set", "it", "true", "by", "default", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "bool", "s390_is_vr128", "(", "machine_mode", "m", ")", "{", "return", "m", "==", "V1TFmode", "||", "(", "TARGET_VXE", "&&", "m", "==", "TFmode", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "mode", "M", "describes", "a", "128-bit", "float", "in", "a", "vector", "register", "." ]

[ "s390" ]

[]

[ "<s>", "unsigned", "AlphaRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "int", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToRegister", "(", "FP", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ",", "false", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FI: \"", "<<", "FrameIndex", "<<", "\" Offset: \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Corrected Offset \"", "<<", "Offset", "<<", "\" for stack size: \"", "<<", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Offset", ">", "IMM_HIGH", "||", "Offset", "<", "IMM_LOW", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Unconditionally using R28 for evil purposes Offset: \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToRegister", "(", "Alpha", "::", "R28", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "getLower16", "(", "Offset", ")", ")", ";", "MachineInstr", "*", "nMI", "=", "BuildMI", "(", "MF", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R28", ")", ".", "addImm", "(", "getUpper16", "(", "Offset", ")", ")", ".", "addReg", "(", "FP", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ")", ";", "MBB", ".", "insert", "(", "II", ",", "nMI", ")", ";", "}", "else", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "Alpha", "Alpha", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "1", "Alpha::R15", "Alpha::R30", "\"FI: \"", "\" Offset: \"", "\"\\n\"", "\"Corrected Offset \"", "\" for stack size: \"", "\"\\n\"", "\"Unconditionally using R28 for evil purposes Offset: \"", "\"\\n\"", "1", "Alpha::R28", "Alpha::LDAH", "Alpha::R28", "Alpha::R15", "Alpha::R30", "0" ]

[]

[ "<s>", "bool", "contains", "(", "MachineInstr", "*", "MI", ")", "{", "return", "Insts", ".", "count", "(", "MI", ")", ">", "0", ";", "}", "</s>" ]

[ "contains", "-", "Returns", "true", "if", "this", "trace", "contains", "the", "given", "basic", "block", "." ]

[ "AArch64", "0" ]

[]

[ "<s>", "virtual", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "Layout", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "R600" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "hasSSE2", "(", ")", ")", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "if", "(", "UseVZeroUpper", ")", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "X86", "X86", "X86", "X86::VR128RegClass", "X86", "X86", "X86" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "J2", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "J2", "J2::NumTargetFixupKinds" ]

[]

[ "<s>", "const", "char", "*", "XCoreTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "XCoreISD", "::", "BL", ":", "return", "\"XCoreISD::BL\"", ";", "case", "XCoreISD", "::", "PCRelativeWrapper", ":", "return", "\"XCoreISD::PCRelativeWrapper\"", ";", "case", "XCoreISD", "::", "DPRelativeWrapper", ":", "return", "\"XCoreISD::DPRelativeWrapper\"", ";", "case", "XCoreISD", "::", "CPRelativeWrapper", ":", "return", "\"XCoreISD::CPRelativeWrapper\"", ";", "case", "XCoreISD", "::", "STWSP", ":", "return", "\"XCoreISD::STWSP\"", ";", "case", "XCoreISD", "::", "RETSP", ":", "return", "\"XCoreISD::RETSP\"", ";", "case", "XCoreISD", "::", "LADD", ":", "return", "\"XCoreISD::LADD\"", ";", "case", "XCoreISD", "::", "LSUB", ":", "return", "\"XCoreISD::LSUB\"", ";", "case", "XCoreISD", "::", "BR_JT", ":", "return", "\"XCoreISD::BR_JT\"", ";", "case", "XCoreISD", "::", "BR_JT32", ":", "return", "\"XCoreISD::BR_JT32\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "XCore", "XCore", "XCoreISD::BL", "\"XCoreISD::BL\"", "XCoreISD::PCRelativeWrapper", "\"XCoreISD::PCRelativeWrapper\"", "XCoreISD::DPRelativeWrapper", "\"XCoreISD::DPRelativeWrapper\"", "XCoreISD::CPRelativeWrapper", "\"XCoreISD::CPRelativeWrapper\"", "XCoreISD::STWSP", "\"XCoreISD::STWSP\"", "XCoreISD::RETSP", "\"XCoreISD::RETSP\"", "XCoreISD::LADD", "\"XCoreISD::LADD\"", "XCoreISD::LSUB", "\"XCoreISD::LSUB\"", "XCoreISD::BR_JT", "\"XCoreISD::BR_JT\"", "XCoreISD::BR_JT32", "\"XCoreISD::BR_JT32\"" ]

[]

[ "<s>", "PreservedAnalyses", "AMDGPUPromoteKernelArgumentsPass", "::", "run", "(", "Function", "&", "F", ",", "FunctionAnalysisManager", "&", "AM", ")", "{", "MemorySSA", "&", "MSSA", "=", "AM", ".", "getResult", "<", "MemorySSAAnalysis", ">", "(", "F", ")", ".", "getMSSA", "(", ")", ";", "if", "(", "AMDGPUPromoteKernelArguments", "(", ")", ".", "run", "(", "F", ",", "MSSA", ")", ")", "{", "PreservedAnalyses", "PA", ";", "PA", ".", "preserveSet", "<", "CFGAnalyses", ">", "(", ")", ";", "PA", ".", "preserve", "<", "MemorySSAAnalysis", ">", "(", ")", ";", "return", "PA", ";", "}", "return", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "1", ",", "false", ",", "false", ",", "true", ",", "true", ",", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "const", "auto", "&", "ST", "=", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "return", "ST", ".", "hasAnyDataBarrier", "(", ")", "&&", "!", "ST", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", ")", "addPass", "(", "createARMParallelDSPPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardCheckPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "ARM", "ARM", "1", "ARM", "ARM" ]

[]

[ "<s>", "enum", "attr_cc", "compute_logical_op_cc", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "3", "]", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "intval", "=", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "&&", "register_operand", "(", "operands", "[", "1", "]", ",", "VOIDmode", ")", "?", "INTVAL", "(", "operands", "[", "2", "]", ")", ":", "0x55555555", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "det", "=", "(", "code", "!=", "AND", ")", "?", "intval", ":", "~", "intval", ";", "const", "unsigned", "HOST_WIDE_INT", "b0", "=", "(", "det", ">>", "0", ")", "&", "0xff", ";", "const", "unsigned", "HOST_WIDE_INT", "b1", "=", "(", "det", ">>", "8", ")", "&", "0xff", ";", "const", "unsigned", "HOST_WIDE_INT", "w0", "=", "(", "det", ">>", "0", ")", "&", "0xffff", ";", "const", "unsigned", "HOST_WIDE_INT", "w1", "=", "(", "det", ">>", "16", ")", "&", "0xffff", ";", "int", "lower_half_easy_p", "=", "0", ";", "int", "upper_half_easy_p", "=", "0", ";", "enum", "attr_cc", "cc", "=", "CC_CLOBBER", ";", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "if", "(", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "&&", "b0", "!=", "0", "&&", "b1", "!=", "0", ")", "{", "cc", "=", "CC_SET_ZNV", ";", "}", "break", ";", "case", "E_SImode", ":", "if", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "{", "lower_half_easy_p", "=", "(", "b0", "==", "0", "||", "b1", "==", "0", "||", "(", "code", "!=", "IOR", "&&", "w0", "==", "0xffff", ")", ")", ";", "upper_half_easy_p", "=", "(", "(", "code", "!=", "IOR", "&&", "w1", "==", "0xffff", ")", "||", "(", "code", "==", "AND", "&&", "w1", "==", "0xff00", ")", ")", ";", "}", "if", "(", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "&&", "w0", "!=", "0", "&&", "w1", "!=", "0", "&&", "!", "(", "lower_half_easy_p", "&&", "upper_half_easy_p", ")", "&&", "!", "(", "code", "==", "IOR", "&&", "w1", "==", "0xffff", "&&", "(", "w0", "&", "0x8000", ")", "!=", "0", "&&", "lower_half_easy_p", ")", ")", "{", "cc", "=", "CC_SET_ZNV", ";", "}", "else", "{", "if", "(", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "&&", "code", "==", "IOR", "&&", "w1", "==", "0xffff", "&&", "(", "w0", "&", "0x8000", ")", "!=", "0", ")", "{", "cc", "=", "CC_SET_ZNV", ";", "}", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "cc", ";", "}", "</s>" ]

[ "Compute", "which", "flag", "bits", "are", "valid", "after", "a", "logical", "insn", "." ]

[ "h8300", "3", "2", "1", "2", "0x55555555", "0", "0xff", "8", "0xff", "0", "0xffff", "16", "0xffff", "0", "0", "0", "0", "0", "0", "0xffff", "0xffff", "0xff00", "0", "0", "0xffff", "0x8000", "0", "0xffff", "0x8000", "0" ]

[]

[ "<s>", "void", "aarch64_expand_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "bval", ",", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ",", "x", ";", "machine_mode", "mode", ",", "cmp_mode", ";", "typedef", "rtx", "(", "*", "gen_cas_fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "int", "idx", ";", "gen_cas_fn", "gen", ";", "const", "gen_cas_fn", "split_cas", "[", "]", "=", "{", "gen_aarch64_compare_and_swapqi", ",", "gen_aarch64_compare_and_swaphi", ",", "gen_aarch64_compare_and_swapsi", ",", "gen_aarch64_compare_and_swapdi", "}", ";", "const", "gen_cas_fn", "atomic_cas", "[", "]", "=", "{", "gen_aarch64_compare_and_swapqi_lse", ",", "gen_aarch64_compare_and_swaphi_lse", ",", "gen_aarch64_compare_and_swapsi_lse", ",", "gen_aarch64_compare_and_swapdi_lse", "}", ";", "bval", "=", "operands", "[", "0", "]", ";", "rval", "=", "operands", "[", "1", "]", ";", "mem", "=", "operands", "[", "2", "]", ";", "oldval", "=", "operands", "[", "3", "]", ";", "newval", "=", "operands", "[", "4", "]", ";", "is_weak", "=", "operands", "[", "5", "]", ";", "mod_s", "=", "operands", "[", "6", "]", ";", "mod_f", "=", "operands", "[", "7", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "cmp_mode", "=", "mode", ";", "if", "(", "is_mm_acquire", "(", "memmodel_from_int", "(", "INTVAL", "(", "mod_f", ")", ")", ")", "&&", "is_mm_release", "(", "memmodel_from_int", "(", "INTVAL", "(", "mod_s", ")", ")", ")", ")", "mod_s", "=", "GEN_INT", "(", "MEMMODEL_ACQ_REL", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "cmp_mode", "=", "SImode", ";", "rval", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "oldval", "=", "convert_modes", "(", "SImode", ",", "mode", ",", "oldval", ",", "true", ")", ";", "case", "SImode", ":", "case", "DImode", ":", "if", "(", "!", "aarch64_plus_operand", "(", "oldval", ",", "mode", ")", ")", "oldval", "=", "force_reg", "(", "cmp_mode", ",", "oldval", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "idx", "=", "0", ";", "break", ";", "case", "HImode", ":", "idx", "=", "1", ";", "break", ";", "case", "SImode", ":", "idx", "=", "2", ";", "break", ";", "case", "DImode", ":", "idx", "=", "3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "TARGET_LSE", ")", "gen", "=", "atomic_cas", "[", "idx", "]", ";", "else", "gen", "=", "split_cas", "[", "idx", "]", ";", "emit_insn", "(", "gen", "(", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ")", ")", ";", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "emit_move_insn", "(", "operands", "[", "1", "]", ",", "gen_lowpart", "(", "mode", ",", "rval", ")", ")", ";", "x", "=", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ";", "x", "=", "gen_rtx_EQ", "(", "SImode", ",", "x", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "bval", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "compare", "and", "swap", "pattern", "." ]

[ "aarch64", "0", "1", "2", "3", "4", "5", "6", "7", "0", "1", "2", "3", "1" ]

[]

[ "<s>", "static", "void", "rs6000_init_dwarf_reg_sizes_extra", "(", "tree", "address", ")", "{", "if", "(", "TARGET_SPE", ")", "{", "int", "i", ";", "machine_mode", "mode", "=", "TYPE_MODE", "(", "char_type_node", ")", ";", "rtx", "addr", "=", "expand_expr", "(", "address", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "addr", ")", ";", "rtx", "value", "=", "gen_int_mode", "(", "4", ",", "mode", ")", ";", "for", "(", "i", "=", "FIRST_SPE_HIGH_REGNO", ";", "i", "<", "LAST_SPE_HIGH_REGNO", "+", "1", ";", "i", "++", ")", "{", "int", "column", "=", "DWARF_REG_TO_UNWIND_COLUMN", "(", "DWARF2_FRAME_REG_OUT", "(", "DWARF_FRAME_REGNUM", "(", "i", ")", ",", "true", ")", ")", ";", "HOST_WIDE_INT", "offset", "=", "column", "*", "GET_MODE_SIZE", "(", "mode", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "mem", ",", "mode", ",", "offset", ")", ",", "value", ")", ";", "}", "}", "if", "(", "TARGET_MACHO", "&&", "!", "TARGET_ALTIVEC", ")", "{", "int", "i", ";", "machine_mode", "mode", "=", "TYPE_MODE", "(", "char_type_node", ")", ";", "rtx", "addr", "=", "expand_expr", "(", "address", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "addr", ")", ";", "rtx", "value", "=", "gen_int_mode", "(", "16", ",", "mode", ")", ";", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<", "LAST_ALTIVEC_REGNO", "+", "1", ";", "i", "++", ")", "{", "int", "column", "=", "DWARF_REG_TO_UNWIND_COLUMN", "(", "DWARF2_FRAME_REG_OUT", "(", "DWARF_FRAME_REGNUM", "(", "i", ")", ",", "true", ")", ")", ";", "HOST_WIDE_INT", "offset", "=", "column", "*", "GET_MODE_SIZE", "(", "mode", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "mem", ",", "mode", ",", "offset", ")", ",", "value", ")", ";", "}", "}", "}", "</s>" ]

[ "Fill", "in", "sizes", "of", "registers", "used", "by", "unwinder", "." ]

[ "powerpcspe", "4", "1", "16", "1" ]

[]

[ "<s>", "static", "bool", "rs6000_gen_pic_addr_diff_vec", "(", "void", ")", "{", "return", "rs6000_relative_jumptables", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_GENERATE_PIC_ADDR_DIFF_VEC", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "bool", "rs6000_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "TARGET_ELF", "&&", "tls_referenced_p", "(", "x", ")", ")", "return", "false", ";", "if", "(", "CONST_DOUBLE_P", "(", "x", ")", ")", "return", "easy_fp_constant", "(", "x", ",", "mode", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "return", "easy_vector_constant", "(", "x", ",", "mode", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", ".", "On", "the", "RS/6000", ",", "all", "integer", "constants", "are", "acceptable", ",", "most", "wo", "n't", "be", "valid", "for", "particular", "insns", ",", "though", ".", "Only", "easy", "FP", "constants", "are", "acceptable", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "FalkorMarkStridedAccesses", "::", "run", "(", ")", "{", "bool", "MadeChange", "=", "false", ";", "for", "(", "Loop", "*", "L", ":", "LI", ")", "for", "(", "Loop", "*", "LIt", ":", "depth_first", "(", "L", ")", ")", "MadeChange", "|=", "runOnLoop", "(", "*", "LIt", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "fitsConstReadLimitations", "(", "const", "std", "::", "vector", "<", "MachineInstr", "*", ">", "&", "MIs", ")", "const", "{", "std", "::", "vector", "<", "unsigned", ">", "Consts", ";", "SmallSet", "<", "int64_t", ",", "4", ">", "Literals", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "MIs", ".", "size", "(", ")", ";", "i", "<", "n", ";", "i", "++", ")", "{", "MachineInstr", "*", "MI", "=", "MIs", "[", "i", "]", ";", "if", "(", "!", "isALUInstr", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "continue", ";", "const", "SmallVectorImpl", "<", "std", "::", "pair", "<", "MachineOperand", "*", ",", "int64_t", ">", ">", "&", "Srcs", "=", "getSrcs", "(", "MI", ")", ";", "for", "(", "unsigned", "j", "=", "0", ",", "e", "=", "Srcs", ".", "size", "(", ")", ";", "j", "<", "e", ";", "j", "++", ")", "{", "std", "::", "pair", "<", "MachineOperand", "*", ",", "unsigned", ">", "Src", "=", "Srcs", "[", "j", "]", ";", "if", "(", "Src", ".", "first", "->", "getReg", "(", ")", "==", "AMDGPU", "::", "ALU_LITERAL_X", ")", "Literals", ".", "insert", "(", "Src", ".", "second", ")", ";", "if", "(", "Literals", ".", "size", "(", ")", ">", "4", ")", "return", "false", ";", "if", "(", "Src", ".", "first", "->", "getReg", "(", ")", "==", "AMDGPU", "::", "ALU_CONST", ")", "Consts", ".", "push_back", "(", "Src", ".", "second", ")", ";", "if", "(", "AMDGPU", "::", "R600_KC0RegClass", ".", "contains", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", "||", "AMDGPU", "::", "R600_KC1RegClass", ".", "contains", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", ")", "{", "unsigned", "Index", "=", "RI", ".", "getEncodingValue", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", "&", "0xff", ";", "unsigned", "Chan", "=", "RI", ".", "getHWRegChan", "(", "Src", ".", "first", "->", "getReg", "(", ")", ")", ";", "Consts", ".", "push_back", "(", "(", "Index", "<<", "2", ")", "|", "Chan", ")", ";", "}", "}", "}", "return", "fitsConstReadLimitations", "(", "Consts", ")", ";", "}", "</s>" ]

[ "Same", "but", "using", "const", "index", "set", "instead", "of", "MI", "set", "." ]

[ "R600", "4", "0", "0", "4", "0xff", "2" ]

[]

[ "<s>", "void", "StackPU2TargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "Base", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "ProgmemDataSection", "=", "Ctx", ".", "getELFSection", "(", "\".progmem.data\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "StackPU2", "StackPU2", "\".progmem.data\"" ]

[]

[ "<s>", "static", "int", "get_num_immediates", "(", "rtx", "insn", ",", "int", "*", "imm", ",", "int", "*", "imm32", ",", "int", "*", "imm64", ")", "{", "imm_info", "imm_values", "=", "{", "0", ",", "0", ",", "0", "}", ";", "find_constant", "(", "insn", ",", "&", "imm_values", ")", ";", "*", "imm", "=", "imm_values", ".", "imm", ";", "*", "imm32", "=", "imm_values", ".", "imm32", ";", "*", "imm64", "=", "imm_values", ".", "imm64", ";", "return", "imm_values", ".", "imm32", "*", "4", "+", "imm_values", ".", "imm64", "*", "8", ";", "}", "</s>" ]

[ "Return", "total", "size", "of", "immediate", "operands", "of", "an", "instruction", "along", "with", "number", "of", "corresponding", "immediate-operands", ".", "It", "initializes", "its", "parameters", "to", "zero", "befor", "calling", "FIND_CONSTANT", ".", "INSN", "is", "the", "input", "instruction", ".", "IMM", "is", "the", "total", "of", "immediates", ".", "IMM32", "is", "the", "number", "of", "32", "bit", "immediates", ".", "IMM64", "is", "the", "number", "of", "64", "bit", "immediates", "." ]

[ "i386", "0", "0", "0", "4", "8" ]

[]

[ "<s>", "static", "inline", "tree", "rs6000_builtin_type", "(", "int", "id", ")", "{", "tree", "t", ";", "t", "=", "rs6000_builtin_types", "[", "id", "<", "0", "?", "~", "id", ":", "id", "]", ";", "return", "id", "<", "0", "?", "build_pointer_type", "(", "t", ")", ":", "t", ";", "}", "</s>" ]

[ "Convert", "a", "type", "stored", "into", "a", "struct", "altivec_builtin_types", "as", "ID", ",", "into", "a", "tree", ".", "The", "types", "are", "in", "rs6000_builtin_types", ":", "negative", "values", "create", "a", "pointer", "type", "for", "the", "type", "associated", "to", "~ID", ".", "Note", "it", "is", "a", "logical", "NOT", ",", "rather", "than", "a", "negation", ",", "otherwise", "you", "can", "not", "represent", "a", "pointer", "type", "for", "ID", "0", "." ]

[ "powerpcspe", "0", "0" ]

[]

[ "<s>", "void", "AArch64RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "AArch64InstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", "||", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "STACKMAP", "||", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "PATCHPOINT", ")", "{", "Offset", "=", "TFI", "->", "resolveFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ",", "true", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "Offset", "=", "TFI", "->", "resolveFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ";", "if", "(", "rewriteAArch64FrameIndex", "(", "MI", ",", "FIOperandNum", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ")", "return", ";", "assert", "(", "(", "!", "RS", "||", "!", "RS", "->", "isScavengingFrameIndex", "(", "FrameIndex", ")", ")", "&&", "\"Emergency spill slot is out of reach\"", ")", ";", "unsigned", "ScratchReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "AArch64", "::", "GPR64RegClass", ")", ";", "emitFrameOffset", "(", "MBB", ",", "II", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "ScratchReg", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "ScratchReg", ",", "false", ",", "false", ",", "true", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "AArch64", "AArch64", "0", "\"Unexpected\"", "AArch64", "AArch64", "AArch64", "1", "1", "AArch64", "\"Emergency spill slot is out of reach\"", "AArch64::GPR64RegClass" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_XCore", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "XCore", "XCore", "ISD::InputArg", "16", "XCore", "0", "1", "2", "0" ]

[]

[ "<s>", "void", "xstormy16_expand_builtin_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", "ATTRIBUTE_UNUSED", ")", "{", "tree", "f_base", ",", "f_count", ";", "tree", "base", ",", "count", ";", "tree", "t", ";", "if", "(", "xstormy16_interrupt_function_p", "(", ")", ")", "error", "(", "\"cannot use va_start in interrupt function\"", ")", ";", "f_base", "=", "TYPE_FIELDS", "(", "va_list_type_node", ")", ";", "f_count", "=", "TREE_CHAIN", "(", "f_base", ")", ";", "base", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_base", ")", ",", "valist", ",", "f_base", ",", "NULL_TREE", ")", ";", "count", "=", "build", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_count", ")", ",", "valist", ",", "f_count", ",", "NULL_TREE", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "base", ")", ",", "virtual_incoming_args_rtx", ")", ";", "t", "=", "build", "(", "PLUS_EXPR", ",", "TREE_TYPE", "(", "base", ")", ",", "t", ",", "build_int_cst", "(", "NULL_TREE", ",", "INCOMING_FRAME_SP_OFFSET", ")", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "base", ")", ",", "base", ",", "t", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "build", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "count", ")", ",", "count", ",", "build_int_cst", "(", "NULL_TREE", ",", "current_function_args_info", "*", "UNITS_PER_WORD", ")", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "1", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "</s>" ]

[ "Implement", "the", "stdarg/varargs", "va_start", "macro", ".", "STDARG_P", "is", "non-zero", "if", "this", "is", "stdarg.h", "instead", "of", "varargs.h", ".", "VALIST", "is", "the", "tree", "of", "the", "va_list", "variable", "to", "initialize", ".", "NEXTARG", "is", "the", "machine", "independent", "notion", "of", "the", "'next", "'", "argument", "after", "the", "variable", "arguments", "." ]

[ "stormy16", "\"cannot use va_start in interrupt function\"", "1", "1" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "SystemZMCAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "SystemZ", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"FK_390_PC12DBL\"", ",", "4", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"FK_390_PC16DBL\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"FK_390_PC24DBL\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"FK_390_PC32DBL\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"FK_390_TLS_CALL\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "SystemZ", "SystemZ", "SystemZ::NumTargetFixupKinds", "\"FK_390_PC12DBL\"", "4", "12", "\"FK_390_PC16DBL\"", "0", "16", "\"FK_390_PC24DBL\"", "0", "24", "\"FK_390_PC32DBL\"", "0", "32", "\"FK_390_TLS_CALL\"", "0", "0", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "bool", "AVRFrameLowering", "::", "canSimplifyCallFramePseudos", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "canSimplifyCallFramePseudos", "-", "If", "there", "is", "a", "reserved", "call", "frame", ",", "the", "call", "frame", "pseudos", "can", "be", "simplified", "." ]

[ "AVR", "AVR" ]

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "enterMBB", "(", "MachineBasicBlock", "*", "NextMBB", ")", "{", "assert", "(", "(", "SchedStates", ".", "find", "(", "NextMBB", ")", "==", "SchedStates", ".", "end", "(", ")", ")", "&&", "\"Entering MBB twice?\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"+++ Entering MBB#\"", "<<", "NextMBB", "->", "getNumber", "(", ")", ")", ";", "MBB", "=", "NextMBB", ";", "HazardRec", "=", "SchedStates", "[", "MBB", "]", "=", "new", "SystemZHazardRecognizer", "(", "TII", ",", "&", "SchedModel", ")", ";", "DEBUG", "(", "const", "MachineLoop", "*", "Loop", "=", "MLI", "->", "getLoopFor", "(", "MBB", ")", ";", "if", "(", "Loop", "&&", "Loop", "->", "getHeader", "(", ")", "==", "MBB", ")", "dbgs", "(", ")", "<<", "\" (Loop header)\"", ";", "dbgs", "(", ")", "<<", "\":\\n\"", ";", ")", ";", "MachineBasicBlock", "*", "SinglePredMBB", "=", "getSingleSchedPred", "(", "MBB", ",", "MLI", "->", "getLoopFor", "(", "MBB", ")", ")", ";", "if", "(", "SinglePredMBB", "==", "nullptr", "||", "SchedStates", ".", "find", "(", "SinglePredMBB", ")", "==", "SchedStates", ".", "end", "(", ")", ")", "return", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"+++ Continued scheduling from MBB#\"", "<<", "SinglePredMBB", "->", "getNumber", "(", ")", "<<", "\"\\n\"", ";", ")", ";", "HazardRec", "->", "copyState", "(", "SchedStates", "[", "SinglePredMBB", "]", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "SinglePredMBB", "->", "getFirstTerminator", "(", ")", ";", "I", "!=", "SinglePredMBB", "->", "end", "(", ")", ";", "I", "++", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"+++ Emitting incoming branch: \"", ";", "I", "->", "dump", "(", ")", ";", ")", ";", "bool", "TakenBranch", "=", "(", "I", "->", "isBranch", "(", ")", "&&", "(", "TII", "->", "getBranchInfo", "(", "*", "I", ")", ".", "Target", "->", "isReg", "(", ")", "||", "TII", "->", "getBranchInfo", "(", "*", "I", ")", ".", "Target", "->", "getMBB", "(", ")", "==", "MBB", ")", ")", ";", "HazardRec", "->", "emitInstruction", "(", "&", "*", "I", ",", "TakenBranch", ")", ";", "if", "(", "TakenBranch", ")", "break", ";", "}", "}", "</s>" ]

[ "Tell", "the", "strategy", "that", "MBB", "is", "about", "to", "be", "processed", "." ]

[ "SystemZ", "SystemZ", "\"Entering MBB twice?\"", "\"+++ Entering MBB#\"", "SystemZ", "\" (Loop header)\"", "\":\\n\"", "\"+++ Continued scheduling from MBB#\"", "\"\\n\"", "\"+++ Emitting incoming branch: \"" ]

[]

[ "<s>", "static", "void", "or1k_print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "rtx", "operand", "=", "x", ";", "switch", "(", "code", ")", "{", "case", "'#'", ":", "if", "(", "final_sequence", "==", "NULL", ")", "fputs", "(", "\"\\n\\t l.nop\\n\"", ",", "file", ")", ";", "break", ";", "case", "'r'", ":", "if", "(", "REG_P", "(", "x", ")", ")", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "operand", ")", "]", ")", ";", "else", "if", "(", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", ")", "fprintf", "(", "file", ",", "\"r0\"", ")", ";", "else", "output_operand_lossage", "(", "\"invalid %%r value\"", ")", ";", "break", ";", "case", "'H'", ":", "if", "(", "REG_P", "(", "x", ")", ")", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "operand", ")", "+", "1", "]", ")", ";", "else", "output_operand_lossage", "(", "\"invalid %%H value\"", ")", ";", "break", ";", "case", "'d'", ":", "if", "(", "REG_P", "(", "x", ")", ")", "{", "if", "(", "GET_MODE", "(", "x", ")", "==", "DFmode", "||", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "fprintf", "(", "file", ",", "\"%s,%s\"", ",", "reg_names", "[", "REGNO", "(", "operand", ")", "]", ",", "reg_names", "[", "REGNO", "(", "operand", ")", "+", "1", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "operand", ")", "]", ")", ";", "}", "else", "output_operand_lossage", "(", "\"invalid %%d value\"", ")", ";", "break", ";", "case", "'h'", ":", "print_reloc", "(", "file", ",", "x", ",", "0", ",", "RKIND_HI", ")", ";", "break", ";", "case", "'L'", ":", "print_reloc", "(", "file", ",", "x", ",", "0", ",", "RKIND_LO", ")", ";", "break", ";", "case", "'P'", ":", "if", "(", "!", "flag_pic", "||", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", "output_addr_const", "(", "file", ",", "x", ")", ";", "else", "output_addr_reloc", "(", "file", ",", "x", ",", "0", ",", "\"plt\"", ")", ";", "break", ";", "case", "0", ":", "switch", "(", "GET_CODE", "(", "operand", ")", ")", "{", "case", "REG", ":", "if", "(", "REGNO", "(", "operand", ")", ">", "31", ")", "internal_error", "(", "\"internal error: bad register: %d\"", ",", "REGNO", "(", "operand", ")", ")", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "operand", ")", "]", ")", ";", "break", ";", "case", "MEM", ":", "output_address", "(", "GET_MODE", "(", "XEXP", "(", "operand", ",", "0", ")", ")", ",", "XEXP", "(", "operand", ",", "0", ")", ")", ";", "break", ";", "case", "CODE_LABEL", ":", "case", "LABEL_REF", ":", "output_asm_label", "(", "operand", ")", ";", "break", ";", "default", ":", "if", "(", "CONSTANT_P", "(", "operand", ")", ")", "output_addr_const", "(", "file", ",", "operand", ")", ";", "else", "internal_error", "(", "\"unexpected operand: %d\"", ",", "GET_CODE", "(", "operand", ")", ")", ";", "break", ";", "}", "break", ";", "default", ":", "output_operand_lossage", "(", "\"unknown operand letter: '%c'\"", ",", "code", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Worker", "for", "TARGET_PRINT_OPERAND", ".", "Print", "operand", "X", ",", "an", "RTX", ",", "to", "the", "file", "FILE", ".", "The", "output", "is", "formed", "as", "expected", "by", "the", "OpenRISC", "assember", ".", "CODE", "is", "the", "letter", "following", "a", "'", "%", "'", "in", "an", "instrunction", "template", "used", "to", "control", "the", "RTX", "output", ".", "Example", "(", "s", ")", ":", "CODE", "RTX", "OUTPUT", "COMMENT", "0", "(", "reg", ":", "SI", "3", ")", "r3", "output", "an", "operand", "r", "(", "reg", ":", "SI", "3", ")", "r3", "output", "a", "register", "or", "const", "zero", "H", "(", "reg", ":", "SI", "3", ")", "r4", "output", "the", "high", "pair", "register", "h", "(", "symbol_ref", ":", "SI", "(", "``", "x", "''", ")", ")", "ha", "(", "x", ")", "output", "a", "signed", "high", "relocation", "L", "(", "symbol_ref", ":", "SI", "(", "``", "x", "''", ")", ")", "lo", "(", "x", ")", "output", "a", "low", "relocation", "Note", ",", "'", "#", "'", "is", "a", "special", "code", "used", "to", "fill", "the", "branch", "delay", "slot", "with", "an", "l.nop", "instruction", ".", "The", "l.nop", "(", "no-op", ")", "instruction", "is", "only", "outputted", "when", "the", "delay", "slot", "has", "not", "been", "filled", "." ]

[ "or1k", "\"\\n\\t l.nop\\n\"", "\"%s\"", "\"r0\"", "\"invalid %%r value\"", "\"%s\"", "1", "\"invalid %%H value\"", "\"%s,%s\"", "1", "\"%s\"", "\"invalid %%d value\"", "0", "0", "0", "\"plt\"", "0", "31", "\"internal error: bad register: %d\"", "\"%s\"", "0", "0", "\"unexpected operand: %d\"", "\"unknown operand letter: '%c'\"" ]

[]

[ "<s>", "static", "void", "rs6000_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"rs6000_conditional_register_usage called\\n\"", ")", ";", "if", "(", "TARGET_64BIT", ")", "fixed_regs", "[", "13", "]", "=", "call_used_regs", "[", "13", "]", "=", "1", ";", "if", "(", "TARGET_SOFT_FLOAT", ")", "for", "(", "i", "=", "32", ";", "i", "<", "64", ";", "i", "++", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "call_used_regs", "[", "2", "]", "=", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", "==", "2", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", "==", "1", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "flag_pic", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "!", "TARGET_ALTIVEC", "&&", "!", "TARGET_VSX", ")", "{", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "call_used_regs", "[", "VRSAVE_REGNO", "]", "=", "1", ";", "}", "if", "(", "TARGET_ALTIVEC", "||", "TARGET_VSX", ")", "global_regs", "[", "VSCR_REGNO", "]", "=", "1", ";", "if", "(", "TARGET_ALTIVEC_ABI", ")", "{", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "++", "i", ")", "call_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "TARGET_XCOFF", "&&", "!", "rs6000_aix_extabi", ")", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "i", "<", "FIRST_ALTIVEC_REGNO", "+", "32", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Change", "register", "usage", "conditional", "on", "target", "flags", "." ]

[ "rs6000", "\"rs6000_conditional_register_usage called\\n\"", "13", "13", "1", "32", "64", "1", "2", "0", "2", "1", "1", "1", "1", "1", "1", "1", "1", "20", "1", "20", "32", "1" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"OpenRISC Assembly Printer\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "OpenRISC", "\"OpenRISC Assembly Printer\"" ]

[]

[ "<s>", "bool", "CSKYFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "auto", "&", "CS", ":", "reverse", "(", "CSI", ")", ")", "{", "Register", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CS", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "CSKY", "CSKY", "\"loadRegFromStackSlot didn't insert any code!\"" ]

[]

[ "<s>", "static", "void", "s390_mainpool_cancel", "(", "struct", "constant_pool", "*", "pool", ")", "{", "s390_free_pool", "(", "pool", ")", ";", "}", "</s>" ]

[ "POOL", "holds", "the", "main", "literal", "pool", "as", "collected", "by", "s390_mainpool_start", ".", "We", "have", "decided", "we", "can", "not", "use", "this", "pool", ",", "so", "revert", "all", "changes", "to", "the", "current", "function", "that", "were", "done", "by", "s390_mainpool_start", "." ]

[ "s390" ]

[]

[ "<s>", "const", "LM32Subtarget", "*", "getSubtargetImpl", "(", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "LM32", "LM32" ]

[]

[ "<s>", "bool", "ThumbRegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", ".", "isThumb1Only", "(", ")", ")", "return", "ARMBaseRegisterInfo", "::", "saveScavengerRegister", "(", "MBB", ",", "I", ",", "UseMI", ",", "RC", ",", "Reg", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ")", ";", "bool", "done", "=", "false", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "II", "=", "I", ";", "!", "done", "&&", "II", "!=", "UseMI", ";", "++", "II", ")", "{", "if", "(", "II", "->", "isDebugValue", "(", ")", ")", "continue", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "II", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "II", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isRegMask", "(", ")", "&&", "MO", ".", "clobbersPhysReg", "(", "ARM", "::", "R12", ")", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isUndef", "(", ")", "||", "!", "MO", ".", "getReg", "(", ")", "||", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "continue", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "R12", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "}", "}", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Kill", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM::tMOVr", "ARM::R12", "0", "ARM::R12", "ARM::R12", "ARM::tMOVr", "ARM::R12" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSILowerControlFlowPass", "(", "*", "TM", ")", ",", "false", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "int", "PPCTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Op1Info", ",", "TTI", "::", "OperandValueKind", "Op2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ",", "const", "Instruction", "*", "CxtI", ")", "{", "assert", "(", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", "&&", "\"Invalid opcode\"", ")", ";", "int", "Cost", "=", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Op1Info", ",", "Op2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "return", "vectorCostAdjustment", "(", "Cost", ",", "Opcode", ",", "Ty", ",", "nullptr", ")", ";", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "PowerPC", "PPC", "\"Invalid opcode\"" ]

[]

[ "<s>", "void", "MipsFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MipsInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SP", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ";", "unsigned", "FP", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "FP_64", ":", "Mips", "::", "FP", ";", "unsigned", "ZERO", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "ZERO_64", ":", "Mips", "::", "ZERO", ";", "unsigned", "ADDu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDu", ":", "Mips", "::", "ADDu", ";", "unsigned", "ADDiu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDiu", ":", "Mips", "::", "ADDiu", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDu", ")", ",", "SP", ")", ".", "addReg", "(", "FP", ")", ".", "addReg", "(", "ZERO", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "if", "(", "isInt", "<", "16", ">", "(", "StackSize", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDiu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "StackSize", ")", ";", "else", "expandLargeImm", "(", "SP", ",", "StackSize", ",", "STI", ".", "isABI_N64", "(", ")", ",", "TII", ",", "MBB", ",", "MBBI", ",", "dl", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips::SP_64", "Mips::SP", "Mips::FP_64", "Mips::FP", "Mips::ZERO_64", "Mips::ZERO", "Mips::DADDu", "Mips::ADDu", "Mips::DADDiu", "Mips::ADDiu", "0", "16" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "EVT", "PPCTargetLowering", "::", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "if", "(", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "Op", ".", "size", "(", ")", ">=", "16", "&&", "(", "Op", ".", "isAligned", "(", "Align", "(", "16", ")", ")", "||", "(", "(", "Op", ".", "isMemset", "(", ")", "&&", "Subtarget", ".", "hasVSX", "(", ")", ")", "||", "Subtarget", ".", "hasP8Vector", "(", ")", ")", ")", ")", "return", "MVT", "::", "v4i32", ";", "}", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "return", "MVT", "::", "i64", ";", "}", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "PowerPC", "PPC", "16", "16", "MVT::v4i32", "PPC", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "const", "BlackfinInstrInfo", "&", "getInstrInfo", "(", ")", "{", "return", "*", "static_cast", "<", "const", "BlackfinTargetMachine", "&", ">", "(", "TM", ")", ".", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "Blackfin" ]

[]

[ "<s>", "void", "FixupLEAPass", "::", "processInstruction", "(", "MachineBasicBlock", "::", "iterator", "&", "I", ",", "MachineFunction", "::", "iterator", "MFI", ")", "{", "MachineInstr", "*", "MI", "=", "I", ";", "int", "opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "int", "AddrOffset", "=", "X86II", "::", "getMemoryOperandNo", "(", "Desc", ".", "TSFlags", ",", "opcode", ")", ";", "if", "(", "AddrOffset", ">=", "0", ")", "{", "AddrOffset", "+=", "X86II", "::", "getOperandBias", "(", "Desc", ")", ";", "MachineOperand", "&", "p", "=", "MI", "->", "getOperand", "(", "AddrOffset", "+", "X86", "::", "AddrBaseReg", ")", ";", "if", "(", "p", ".", "isReg", "(", ")", "&&", "p", ".", "getReg", "(", ")", "!=", "X86", "::", "ESP", ")", "{", "seekLEAFixup", "(", "p", ",", "I", ",", "MFI", ")", ";", "}", "MachineOperand", "&", "q", "=", "MI", "->", "getOperand", "(", "AddrOffset", "+", "X86", "::", "AddrIndexReg", ")", ";", "if", "(", "q", ".", "isReg", "(", ")", "&&", "q", ".", "getReg", "(", ")", "!=", "X86", "::", "ESP", ")", "{", "seekLEAFixup", "(", "q", ",", "I", ",", "MFI", ")", ";", "}", "}", "}", "</s>" ]

[ "Process", "a", "single", "instruction", "and", "collect", "debug", "info", "anchors", "." ]

[ "X86", "X86II::getMemoryOperandNo", "0", "X86II::getOperandBias", "X86::AddrBaseReg", "X86::ESP", "X86::AddrIndexReg", "X86::ESP" ]

[]

[ "<s>", "void", "PIC16TargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "0", ")", ";", "SDValue", "Res", ";", "unsigned", "i", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "LOAD", ":", "Res", "=", "ExpandLoad", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "break", ";", "default", ":", "{", "Res", "=", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "return", ";", "}", "}", "N", "=", "Res", ".", "getNode", "(", ")", ";", "unsigned", "NumValues", "=", "N", "->", "getNumValues", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NumValues", ";", "i", "++", ")", "{", "Results", ".", "push_back", "(", "SDValue", "(", "N", ",", "i", ")", ")", ";", "}", "}", "</s>" ]

[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]

[ "PIC16", "PIC16", "0", "ISD::LOAD", "0" ]

[]

[ "<s>", "static", "bool", "eco32_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "const", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "." ]

[ "eco32", "1" ]

[]

[ "<s>", "enum", "reg_class", "mep_secondary_output_reload_class", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "int", "rv", "=", "NO_REGS", ";", "fprintf", "(", "stderr", ",", "\"secondary output reload copy from %s %s to \"", ",", "reg_class_names", "[", "rclass", "]", ",", "mode_name", "[", "mode", "]", ")", ";", "debug_rtx", "(", "x", ")", ";", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "CR_REGS", ")", ")", "rv", "=", "mep_secondary_copro_reload_class", "(", "rclass", ",", "x", ")", ";", "else", "if", "(", "MEP_NONGENERAL_CLASS", "(", "rclass", ")", "&&", "(", "mep_nonregister", "(", "x", ")", "||", "mep_nongeneral_reg", "(", "x", ")", ")", ")", "rv", "=", "GENERAL_REGS", ";", "fprintf", "(", "stderr", ",", "\" - requires %s\\n\"", ",", "reg_class_names", "[", "rv", "]", ")", ";", "return", "(", "enum", "reg_class", ")", "rv", ";", "}", "</s>" ]

[ "Copying", "register", "in", "RCLASS", "to", "X", "." ]

[ "mep", "\"secondary output reload copy from %s %s to \"", "\" - requires %s\\n\"" ]

[]

[ "<s>", "static", "void", "mips16_lay_out_constants", "(", "void", ")", "{", "struct", "mips16_constant_pool", "pool", ";", "rtx", "insn", ",", "barrier", ";", "barrier", "=", "0", ";", "memset", "(", "&", "pool", ",", "0", ",", "sizeof", "(", "pool", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "for_each_rtx", "(", "&", "PATTERN", "(", "insn", ")", ",", "mips16_rewrite_pool_refs", ",", "&", "pool", ")", ";", "pool", ".", "insn_address", "+=", "mips16_insn_length", "(", "insn", ")", ";", "if", "(", "pool", ".", "first", "!=", "NULL", ")", "{", "if", "(", "barrier", "==", "0", "&&", "pool", ".", "insn_address", "+", "4", ">", "pool", ".", "highest_address", ")", "{", "rtx", "label", ",", "jump", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "jump", "=", "emit_jump_insn_before", "(", "gen_jump", "(", "label", ")", ",", "insn", ")", ";", "JUMP_LABEL", "(", "jump", ")", "=", "label", ";", "LABEL_NUSES", "(", "label", ")", "=", "1", ";", "barrier", "=", "emit_barrier_after", "(", "jump", ")", ";", "emit_label_after", "(", "label", ",", "barrier", ")", ";", "pool", ".", "insn_address", "+=", "4", ";", "}", "if", "(", "pool", ".", "insn_address", ">", "pool", ".", "highest_address", ")", "{", "dump_constants", "(", "pool", ".", "first", ",", "barrier", ")", ";", "pool", ".", "first", "=", "NULL", ";", "barrier", "=", "0", ";", "}", "else", "if", "(", "BARRIER_P", "(", "insn", ")", ")", "barrier", "=", "insn", ";", "}", "}", "dump_constants", "(", "pool", ".", "first", ",", "get_last_insn", "(", ")", ")", ";", "}", "</s>" ]

[ "Build", "MIPS16", "constant", "pools", "." ]

[ "mips", "0", "0", "0", "4", "1", "4", "0" ]

[]

[ "<s>", "v850_data_area", "v850_get_data_area", "(", "tree", "decl", ")", "{", "if", "(", "lookup_attribute", "(", "\"sda\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "!=", "NULL_TREE", ")", "return", "DATA_AREA_SDA", ";", "if", "(", "lookup_attribute", "(", "\"tda\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "!=", "NULL_TREE", ")", "return", "DATA_AREA_TDA", ";", "if", "(", "lookup_attribute", "(", "\"zda\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "!=", "NULL_TREE", ")", "return", "DATA_AREA_ZDA", ";", "return", "DATA_AREA_NORMAL", ";", "}", "</s>" ]

[ "Retrieve", "the", "data", "area", "that", "has", "been", "chosen", "for", "the", "given", "decl", "." ]

[ "v850", "\"sda\"", "\"tda\"", "\"zda\"" ]

[]

[ "<s>", "bool", "DLXAsmParser", "::", "ParseDirective", "(", "AsmToken", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "DLX", "DLX" ]

[]

[ "<s>", "unsigned", "getExplicitKernelArgOffset", "(", "const", "Function", "&", "F", ")", "const", "{", "return", "isAmdCodeObjectV2", "(", "F", ")", "?", "0", ":", "36", ";", "}", "</s>" ]

[ "Returns", "the", "offset", "in", "bytes", "from", "the", "start", "of", "the", "input", "buffer", "of", "the", "first", "explicit", "kernel", "argument", "." ]

[ "AMDGPU", "0", "36" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "assert", "(", "0", "&&", "\"relaxInstruction() unimplemented\"", ")", ";", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "Nyuzi", "0", "\"relaxInstruction() unimplemented\"" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "legalizeOpWithMove", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpIdx", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpIdx", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "RCID", "=", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "OpIdx", "]", ".", "RegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getRegClass", "(", "RCID", ")", ";", "unsigned", "Opcode", "=", "AMDGPU", "::", "V_MOV_B32_e32", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "Opcode", "=", "AMDGPU", "::", "COPY", ";", "else", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "Opcode", "=", "AMDGPU", "::", "S_MOV_B32", ";", "const", "TargetRegisterClass", "*", "VRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "RC", ")", ";", "if", "(", "RI", ".", "getCommonSubClass", "(", "&", "AMDGPU", "::", "VReg_64RegClass", ",", "VRC", ")", ")", "VRC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "else", "VRC", "=", "&", "AMDGPU", "::", "VReg_32RegClass", ";", "unsigned", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "VRC", ")", ";", "DebugLoc", "DL", "=", "MBB", "->", "findDebugLoc", "(", "I", ")", ";", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "addOperand", "(", "MO", ")", ";", "MO", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "}", "</s>" ]

[ "Legalize", "the", "OpIndex", "operand", "of", "this", "instruction", "by", "inserting", "a", "MOV", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "SavedRegs", ".", "set", "(", "TRI", "->", "getBaseRegister", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicLoadInIR", "(", "LoadInst", "*", "LI", ")", "const", "{", "unsigned", "Size", "=", "LI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "Size", "==", "128", "?", "AtomicExpansionKind", "::", "LLSC", ":", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "load", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

[ "AArch64", "AArch64", "128" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "SmallVector", "<", "MCInst", ",", "8", ">", "Instructions", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "{", "if", "(", "processInstruction", "(", "Inst", ",", "IDLoc", ",", "Instructions", ")", ")", "return", "true", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Instructions", ".", "size", "(", ")", ";", "i", "++", ")", "Out", ".", "EmitInstruction", "(", "Instructions", "[", "i", "]", ",", "STI", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "return", "true", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "MipsOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_RequiresDifferentSrcAndDst", ":", "return", "Error", "(", "IDLoc", ",", "\"source and destination must be different\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "Mips", "Mips", "8", "0", "\"instruction requires a CPU feature not currently enabled\"", "0ULL", "\"too few operands for instruction\"", "Mips", "\"invalid operand for instruction\"", "\"invalid instruction\"", "\"source and destination must be different\"" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "KnownZero", ".", "getBitWidth", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "assert", "(", "(", "Opc", ">=", "ISD", "::", "BUILTIN_OP_END", "||", "Opc", "==", "ISD", "::", "INTRINSIC_WO_CHAIN", "||", "Opc", "==", "ISD", "::", "INTRINSIC_W_CHAIN", "||", "Opc", "==", "ISD", "::", "INTRINSIC_VOID", ")", "&&", "\"Should use MaskedValueIsZero if you don't know whether Op\"", "\" is a target node!\"", ")", ";", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "BitWidth", ",", "0", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "X86ISD", "::", "ADD", ":", "case", "X86ISD", "::", "SUB", ":", "case", "X86ISD", "::", "ADC", ":", "case", "X86ISD", "::", "SBB", ":", "case", "X86ISD", "::", "SMUL", ":", "case", "X86ISD", "::", "UMUL", ":", "case", "X86ISD", "::", "INC", ":", "case", "X86ISD", "::", "DEC", ":", "case", "X86ISD", "::", "OR", ":", "case", "X86ISD", "::", "XOR", ":", "case", "X86ISD", "::", "AND", ":", "if", "(", "Op", ".", "getResNo", "(", ")", "==", "0", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "case", "X86ISD", "::", "SETCC", ":", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "1", ")", ";", "break", ";", "case", "X86ISD", "::", "MOVMSK", ":", "{", "unsigned", "NumLoBits", "=", "Op", ".", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ";", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "NumLoBits", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "X86", "X86", "ISD::BUILTIN_OP_END", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_VOID", "\"Should use MaskedValueIsZero if you don't know whether Op\"", "\" is a target node!\"", "0", "X86ISD::ADD", "X86ISD::SUB", "X86ISD::ADC", "X86ISD::SBB", "X86ISD::SMUL", "X86ISD::UMUL", "X86ISD::INC", "X86ISD::DEC", "X86ISD::OR", "X86ISD::XOR", "X86ISD::AND", "0", "X86ISD::SETCC", "1", "X86ISD::MOVMSK", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_option_valid_attribute_p", "(", "tree", "fndecl", ",", "tree", ",", "tree", "args", ",", "int", ")", "{", "struct", "cl_target_option", "cur_target", ";", "bool", "ret", ";", "tree", "old_optimize", ";", "tree", "new_target", ",", "new_optimize", ";", "tree", "existing_target", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "if", "(", "!", "existing_target", "&&", "args", "==", "current_target_pragma", ")", "{", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "=", "target_option_current_node", ";", "return", "true", ";", "}", "tree", "func_optimize", "=", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", ";", "old_optimize", "=", "build_optimization_node", "(", "&", "global_options", ")", ";", "func_optimize", "=", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", ";", "if", "(", "func_optimize", "&&", "func_optimize", "!=", "old_optimize", ")", "cl_optimization_restore", "(", "&", "global_options", ",", "TREE_OPTIMIZATION", "(", "func_optimize", ")", ")", ";", "cl_target_option_save", "(", "&", "cur_target", ",", "&", "global_options", ")", ";", "if", "(", "existing_target", ")", "{", "struct", "cl_target_option", "*", "existing_options", "=", "TREE_TARGET_OPTION", "(", "existing_target", ")", ";", "if", "(", "existing_options", ")", "cl_target_option_restore", "(", "&", "global_options", ",", "existing_options", ")", ";", "}", "else", "cl_target_option_restore", "(", "&", "global_options", ",", "TREE_TARGET_OPTION", "(", "target_option_current_node", ")", ")", ";", "ret", "=", "aarch64_process_target_attr", "(", "args", ",", "\"attribute\"", ")", ";", "if", "(", "ret", ")", "{", "aarch64_override_options_internal", "(", "&", "global_options", ")", ";", "if", "(", "TARGET_SIMD", ")", "{", "tree", "saved_current_target_pragma", "=", "current_target_pragma", ";", "current_target_pragma", "=", "NULL", ";", "aarch64_init_simd_builtins", "(", ")", ";", "current_target_pragma", "=", "saved_current_target_pragma", ";", "}", "new_target", "=", "build_target_option_node", "(", "&", "global_options", ")", ";", "}", "else", "new_target", "=", "NULL", ";", "new_optimize", "=", "build_optimization_node", "(", "&", "global_options", ")", ";", "if", "(", "fndecl", "&&", "ret", ")", "{", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "=", "new_target", ";", "if", "(", "old_optimize", "!=", "new_optimize", ")", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", "=", "new_optimize", ";", "}", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "cur_target", ")", ";", "if", "(", "old_optimize", "!=", "new_optimize", ")", "cl_optimization_restore", "(", "&", "global_options", ",", "TREE_OPTIMIZATION", "(", "old_optimize", ")", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_VALID_ATTRIBUTE_P", ".", "This", "is", "used", "to", "process", "attribute", "(", "(", "target", "(", "``", "...", "''", ")", ")", ")", "." ]

[ "aarch64", "\"attribute\"" ]

[]

[ "<s>", "bool", "AVRTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "int64_t", "Offs", "=", "AM", ".", "BaseOffs", ";", "if", "(", "AM", ".", "BaseGV", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "Offs", "==", "0", ")", "{", "return", "true", ";", "}", "if", "(", "isa", "<", "PointerType", ">", "(", "Ty", ")", "&&", "AS", "==", "AVR", "::", "ProgramMemory", ")", "{", "return", "false", ";", "}", "if", "(", "Offs", "<", "0", ")", "Offs", "=", "-", "Offs", ";", "if", "(", "AM", ".", "BaseGV", "==", "0", "&&", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "isUInt", "<", "6", ">", "(", "Offs", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "AVR", "AVR", "0", "0", "AVR::ProgramMemory", "0", "0", "0", "6" ]

[]

[ "<s>", "void", "ARMTargetAsmStreamer", "::", "emitInst", "(", "uint32_t", "Inst", ",", "char", "Suffix", ")", "{", "OS", "<<", "\"\\t.inst\"", ";", "if", "(", "Suffix", ")", "OS", "<<", "\".\"", "<<", "Suffix", ";", "OS", "<<", "\"\\t0x\"", "<<", "utohexstr", "(", "Inst", ")", "<<", "\"\\n\"", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".inst", "directive", "." ]

[ "ARM", "ARM", "\"\\t.inst\"", "\".\"", "\"\\t0x\"", "\"\\n\"" ]

[]

[ "<s>", "Context", "(", "Instruction", "*", "Exp", ")", ":", "Ctx", "(", "Exp", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getContext", "(", ")", ")", "{", "initialize", "(", "Exp", ")", ";", "}", "</s>" ]

[ "Pointer", "to", "a", "class", "instance", "holding", ",", "among", "other", "things", ",", "the", "table", "with", "the", "values", "of", "live", "string", "variables", "at", "the", "start", "of", "any", "given", "CHECK", "line", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "isScalarFPTypeInSSEReg", "(", "EVT", "VT", ")", "const", "{", "return", "(", "VT", "==", "MVT", "::", "f64", "&&", "Subtarget", "->", "hasSSE2", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "f32", "&&", "Subtarget", "->", "hasSSE1", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "f16", "&&", "Subtarget", "->", "hasFP16", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "scalar", "FP", "type", "is", "computed", "in", "an", "SSE", "register", ",", "not", "on", "the", "X87", "floating", "point", "stack", "." ]

[ "X86", "MVT::f64", "MVT::f32", "MVT::f16" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isLegalInterleavedAccessType", "(", "unsigned", "Factor", ",", "FixedVectorType", "*", "VecTy", ",", "const", "DataLayout", "&", "DL", ")", "const", "{", "unsigned", "VecSize", "=", "DL", ".", "getTypeSizeInBits", "(", "VecTy", ")", ";", "unsigned", "ElSize", "=", "DL", ".", "getTypeSizeInBits", "(", "VecTy", "->", "getElementType", "(", ")", ")", ";", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", "&&", "!", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", "&&", "VecTy", "->", "getElementType", "(", ")", "->", "isHalfTy", "(", ")", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", "&&", "Factor", "==", "3", ")", "return", "false", ";", "if", "(", "VecTy", "->", "getNumElements", "(", ")", "<", "2", ")", "return", "false", ";", "if", "(", "ElSize", "!=", "8", "&&", "ElSize", "!=", "16", "&&", "ElSize", "!=", "32", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", "&&", "VecSize", "==", "64", ")", "return", "true", ";", "return", "VecSize", "%", "128", "==", "0", ";", "}", "</s>" ]

[ "Returns", "whether", "or", "not", "generating", "a", "interleaved", "load/store", "intrinsic", "for", "this", "type", "will", "be", "legal", "." ]

[ "ARM", "ARM", "3", "2", "8", "16", "32", "64", "128", "0" ]

[]

[ "<s>", "static", "int", "mips_small_data_pattern_1", "(", "rtx", "x", ",", "enum", "mips_symbol_context", "context", ")", "{", "subrtx_var_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "x", ",", "ALL", ")", "{", "rtx", "x", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "||", "GET_CODE", "(", "x", ")", "==", "ASM_OPERANDS", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "else", "if", "(", "MEM_P", "(", "x", ")", ")", "{", "if", "(", "mips_small_data_pattern_1", "(", "XEXP", "(", "x", ",", "0", ")", ",", "SYMBOL_CONTEXT_MEM", ")", ")", "return", "true", ";", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "else", "if", "(", "mips_rewrite_small_data_p", "(", "x", ",", "context", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "A", "for_each_rtx", "callback", "for", "mips_small_data_pattern_p", "." ]

[ "mips", "0" ]

[]

[ "<s>", "static", "rtx", "riscv_pass_fpr_single", "(", "machine_mode", "type_mode", ",", "unsigned", "regno", ",", "machine_mode", "value_mode", ")", "{", "rtx", "x", "=", "gen_rtx_REG", "(", "value_mode", ",", "regno", ")", ";", "if", "(", "type_mode", "!=", "value_mode", ")", "{", "x", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "x", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_PARALLEL", "(", "type_mode", ",", "gen_rtvec", "(", "1", ",", "x", ")", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Return", "the", "representation", "of", "an", "argument", "passed", "or", "returned", "in", "an", "FPR", "when", "the", "value", "has", "mode", "VALUE_MODE", "and", "the", "type", "has", "TYPE_MODE", ".", "The", "two", "modes", "may", "be", "different", "for", "structures", "like", ":", "struct", "__attribute__", "(", "(", "packed", ")", ")", "foo", "{", "float", "f", ";", "}", "where", "the", "SFmode", "value", "``", "f", "''", "is", "passed", "in", "REGNO", "but", "the", "struct", "itself", "has", "mode", "BLKmode", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "void", "SparcTargetLowering", "::", "insertSSPDeclarations", "(", "Module", "&", "M", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "isTargetLinux", "(", ")", ")", "return", "TargetLowering", "::", "insertSSPDeclarations", "(", "M", ")", ";", "}", "</s>" ]

[ "Inserts", "necessary", "declarations", "for", "SSP", "(", "stack", "protection", ")", "purpose", "." ]

[ "Sparc", "Sparc", "SP", "SP" ]

[]

[ "<s>", "virtual", "const", "ARMSubtarget", "*", "getSubtarget", "(", ")", "{", "return", "Subtarget", ";", "}", "</s>" ]

[ "getSubtarget", "-", "Return", "the", "subtarget", "for", "which", "this", "machine", "code", "is", "being", "compiled", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "seh_emit_save", "(", "FILE", "*", "f", ",", "struct", "seh_frame_state", "*", "seh", ",", "rtx", "reg", ",", "HOST_WIDE_INT", "cfa_offset", ")", "{", "unsigned", "int", "regno", "=", "REGNO", "(", "reg", ")", ";", "HOST_WIDE_INT", "offset", ";", "gcc_assert", "(", "seh", "->", "sp_offset", ">=", "cfa_offset", ")", ";", "offset", "=", "seh", "->", "sp_offset", "-", "cfa_offset", ";", "fputs", "(", "(", "SSE_REGNO_P", "(", "regno", ")", "?", "\"\\t.seh_savexmm\\t\"", ":", "GENERAL_REGNO_P", "(", "regno", ")", "?", "\"\\t.seh_savereg\\t\"", ":", "(", "gcc_unreachable", "(", ")", ",", "\"\"", ")", ")", ",", "f", ")", ";", "print_reg", "(", "reg", ",", "0", ",", "f", ")", ";", "fprintf", "(", "f", ",", "\", \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "offset", ")", ";", "}", "</s>" ]

[ "Emit", "an", "assembler", "directive", "to", "save", "REG", "at", "CFA", "-", "CFA_OFFSET", "." ]

[ "i386", "\"\\t.seh_savexmm\\t\"", "\"\\t.seh_savereg\\t\"", "\"\"", "0", "\", \"", "\"\\n\"" ]

[]

[ "<s>", "static", "rtx", "rs6000_mask_atomic_subword", "(", "rtx", "oldval", ",", "rtx", "newval", ",", "rtx", "mask", ")", "{", "rtx", "x", ";", "x", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "x", ",", "gen_rtx_AND", "(", "SImode", ",", "gen_rtx_NOT", "(", "SImode", ",", "mask", ")", ",", "oldval", ")", ")", ")", ";", "x", "=", "expand_simple_binop", "(", "SImode", ",", "IOR", ",", "newval", ",", "x", ",", "x", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "various", "atomic", "expanders", ".", "For", "sub-word", "operands", ",", "combine", "OLDVAL", "and", "NEWVAL", "via", "MASK", ".", "Returns", "a", "new", "pseduo", "." ]

[ "powerpcspe", "1" ]

[]

[ "<s>", "Function", "*", "AMDGPULibFunc", "::", "getFunction", "(", "Module", "*", "M", ",", "const", "AMDGPULibFunc", "&", "fInfo", ")", "{", "std", "::", "string", "FuncName", "=", "fInfo", ".", "mangle", "(", ")", ";", "Function", "*", "F", "=", "dyn_cast_or_null", "<", "Function", ">", "(", "M", "->", "getValueSymbolTable", "(", ")", ".", "lookup", "(", "FuncName", ")", ")", ";", "if", "(", "F", "&&", "!", "F", "->", "isDeclaration", "(", ")", "&&", "!", "F", "->", "isVarArg", "(", ")", "&&", "F", "->", "arg_size", "(", ")", "==", "fInfo", ".", "getNumArgs", "(", ")", ")", "{", "return", "F", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "getFunction", "-", "Return", "this", "trace", "'s", "parent", "function", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "rtx_insn", "*", "visium_md_asm_adjust", "(", "vec", "<", "rtx", ">", "&", ",", "vec", "<", "rtx", ">", "&", ",", "vec", "<", "machine_mode", ">", "&", ",", "vec", "<", "const", "char", "*", ">", "&", ",", "vec", "<", "rtx", ">", "&", "clobbers", ",", "HARD_REG_SET", "&", "clobbered_regs", ",", "location_t", ")", "{", "clobbers", ".", "safe_push", "(", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REGNUM", ")", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "FLAGS_REGNUM", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Prepend", "to", "CLOBBERS", "hard", "registers", "that", "are", "automatically", "clobbered", "for", "an", "asm", "We", "do", "this", "for", "the", "FLAGS", "to", "maintain", "source", "compatibility", "with", "the", "original", "cc0-based", "compiler", "." ]

[ "visium" ]

[]

[ "<s>", "const", "SPScope", "*", "SPScope", "::", "getParent", "(", ")", "const", "{", "return", "Priv", "->", "Parent", ";", "}", "</s>" ]

[ "getParent", "-", "Return", "the", "last", "analyzed", "interval", "." ]

[ "Patmos" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Align", ",", "bool", "*", "IsFast", ")", "const", "{", "if", "(", "IsFast", ")", "*", "IsFast", "=", "false", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", "||", "VT", "==", "MVT", "::", "Other", ")", "return", "false", ";", "if", "(", "AddrSpace", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "{", "return", "Align", "%", "4", "==", "0", ";", "}", "if", "(", "IsFast", ")", "*", "IsFast", "=", "true", ";", "return", "VT", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "R600", "SI", "MVT::Other", "AMDGPUAS::LOCAL_ADDRESS", "4", "0", "MVT::i32" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "switch", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "{", "case", "VCCNZ", ":", "case", "VCCZ", ":", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ";", "assert", "(", "MRI", ".", "getRegClass", "(", "FalseReg", ")", "==", "RC", ")", ";", "int", "NumInsts", "=", "AMDGPU", "::", "getRegBitWidth", "(", "RC", "->", "getID", "(", ")", ")", "/", "32", ";", "CondCycles", "=", "TrueCycles", "=", "FalseCycles", "=", "NumInsts", ";", "return", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "NumInsts", "<=", "6", ";", "}", "case", "SCC_TRUE", ":", "case", "SCC_FALSE", ":", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ";", "assert", "(", "MRI", ".", "getRegClass", "(", "FalseReg", ")", "==", "RC", ")", ";", "int", "NumInsts", "=", "AMDGPU", "::", "getRegBitWidth", "(", "RC", "->", "getID", "(", ")", ")", "/", "32", ";", "if", "(", "NumInsts", "%", "2", "==", "0", ")", "NumInsts", "/=", "2", ";", "CondCycles", "=", "TrueCycles", "=", "FalseCycles", "=", "NumInsts", ";", "return", "RI", ".", "isSGPRClass", "(", "RC", ")", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "AMDGPU", "SI", "0", "AMDGPU::getRegBitWidth", "32", "6", "AMDGPU::getRegBitWidth", "32", "2", "0", "2" ]

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "MSP430", "::", "RET", ":", "case", "MSP430", "::", "RETI", ":", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "CSSize", "=", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "MSP430", "::", "FPW", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "MSP430", "::", "POP16r", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "break", ";", "--", "MBBI", ";", "}", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "FPW", ")", ";", "if", "(", "CSSize", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "CSSize", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "else", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430::RET", "MSP430::RETI", "\"Can only insert epilog into returning blocks\"", "MSP430", "0", "2", "MSP430::POP16r", "MSP430::FPW", "MSP430::POP16r", "MSP430::MOV16rr", "MSP430::SPW", "MSP430::FPW", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3", "MSP430::ADD16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "insn_info", "*", "extract_single_source", "(", "set_info", "*", "set", ")", "{", "if", "(", "!", "set", ")", "return", "nullptr", ";", "if", "(", "set", "->", "insn", "(", ")", "->", "is_real", "(", ")", ")", "return", "set", "->", "insn", "(", ")", ";", "if", "(", "!", "set", "->", "insn", "(", ")", "->", "is_phi", "(", ")", ")", "return", "nullptr", ";", "hash_set", "<", "set_info", "*", ">", "sets", "=", "get_all_sets", "(", "set", ",", "true", ",", "false", ",", "true", ")", ";", "insn_info", "*", "first_insn", "=", "(", "*", "sets", ".", "begin", "(", ")", ")", "->", "insn", "(", ")", ";", "if", "(", "first_insn", "->", "is_artificial", "(", ")", ")", "return", "nullptr", ";", "for", "(", "const", "set_info", "*", "set", ":", "sets", ")", "{", "if", "(", "set", "->", "insn", "(", ")", "->", "is_artificial", "(", ")", ")", "return", "nullptr", ";", "if", "(", "!", "source_equal_p", "(", "set", "->", "insn", "(", ")", ",", "first_insn", ")", ")", "return", "nullptr", ";", "}", "return", "first_insn", ";", "}", "</s>" ]

[ "Helper", "function", "to", "get", "single", "same", "real", "RTL", "source", ".", "return", "NULL", "if", "it", "is", "not", "a", "single", "real", "RTL", "source", "." ]

[ "riscv" ]

[]

[ "<s>", "virtual", "const", "MCSection", "*", "getSectionForConstant", "(", "SectionKind", "Kind", ")", "const", "{", "return", "ReadOnlySection", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "NVPTX" ]

[]

[ "<s>", "void", "Z80FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "0", ")", ";", "if", "(", "MFI", ".", "estimateStackSize", "(", "MF", ")", ">", "0x80", ")", "RS", "->", "addScavengingFrameIndex", "(", "MFI", ".", "CreateStackObject", "(", "SlotSize", ",", "1", ",", "false", ")", ")", ";", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "Z80", "Z80", "0", "0x80", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "ARM64TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "ARM64", "::", "GPR64commonRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "ARM64", "::", "GPR32commonRegClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "ARM64", "::", "FPR32RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "ARM64", "::", "FPR64RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "ARM64", "::", "FPR128RegClass", ")", ";", "break", ";", "case", "'x'", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "ARM64", "::", "FPR128_loRegClass", ")", ";", "break", ";", "}", "}", "if", "(", "StringRef", "(", "\"{cc}\"", ")", ".", "equals_lower", "(", "Constraint", ")", ")", "return", "std", "::", "make_pair", "(", "unsigned", "(", "ARM64", "::", "NZCV", ")", ",", "&", "ARM64", "::", "CCRRegClass", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "Res", ";", "Res", "=", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "!", "Res", ".", "second", ")", "{", "unsigned", "Size", "=", "Constraint", ".", "size", "(", ")", ";", "if", "(", "(", "Size", "==", "4", "||", "Size", "==", "5", ")", "&&", "Constraint", "[", "0", "]", "==", "'{'", "&&", "tolower", "(", "Constraint", "[", "1", "]", ")", "==", "'v'", "&&", "Constraint", "[", "Size", "-", "1", "]", "==", "'}'", ")", "{", "const", "std", "::", "string", "Reg", "=", "std", "::", "string", "(", "&", "Constraint", "[", "2", "]", ",", "&", "Constraint", "[", "Size", "-", "1", "]", ")", ";", "int", "RegNo", "=", "atoi", "(", "Reg", ".", "c_str", "(", ")", ")", ";", "if", "(", "RegNo", ">=", "0", "&&", "RegNo", "<=", "31", ")", "{", "Res", ".", "first", "=", "ARM64", "::", "FPR128RegClass", ".", "getRegister", "(", "RegNo", ")", ";", "Res", ".", "second", "=", "&", "ARM64", "::", "FPR128RegClass", ";", "}", "}", "}", "return", "Res", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "ARM64", "ARM64", "1", "0", "64", "0U", "ARM64::GPR64commonRegClass", "0U", "ARM64::GPR32commonRegClass", "MVT::f32", "0U", "ARM64::FPR32RegClass", "64", "0U", "ARM64::FPR64RegClass", "128", "0U", "ARM64::FPR128RegClass", "128", "0U", "ARM64::FPR128_loRegClass", "\"{cc}\"", "ARM64::NZCV", "ARM64::CCRRegClass", "4", "5", "0", "1", "1", "2", "1", "0", "31", "ARM64::FPR128RegClass", "ARM64::FPR128RegClass" ]

[]

[ "<s>", "static", "int", "ix86_simd_clone_usable", "(", "struct", "cgraph_node", "*", "node", ")", "{", "switch", "(", "node", "->", "simdclone", "->", "vecsize_mangle", ")", "{", "case", "'b'", ":", "if", "(", "!", "TARGET_SSE2", ")", "return", "-", "1", ";", "if", "(", "!", "TARGET_AVX", ")", "return", "0", ";", "return", "TARGET_AVX2", "?", "2", ":", "1", ";", "case", "'c'", ":", "if", "(", "!", "TARGET_AVX", ")", "return", "-", "1", ";", "return", "TARGET_AVX2", "?", "1", ":", "0", ";", "break", ";", "case", "'d'", ":", "if", "(", "!", "TARGET_AVX2", ")", "return", "-", "1", ";", "return", "0", ";", "case", "'e'", ":", "if", "(", "!", "TARGET_AVX512F", ")", "return", "-", "1", ";", "return", "0", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "If", "SIMD", "clone", "NODE", "ca", "n't", "be", "used", "in", "a", "vectorized", "loop", "in", "current", "function", ",", "return", "-1", ",", "otherwise", "return", "a", "badness", "of", "using", "it", "(", "0", "if", "it", "is", "most", "desirable", "from", "vecsize_mangle", "point", "of", "view", ",", "1", "slightly", "less", "desirable", ",", "etc", ".", ")", "." ]

[ "i386", "1", "0", "2", "1", "1", "1", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "HexagonAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "if", "(", "MBB", "->", "hasAddressTaken", "(", ")", ")", "{", "return", "false", ";", "}", "return", "AsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "MBB", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "ChangeStatus", "manifest", "(", "Attributor", "&", "A", ")", "override", "{", "SmallVector", "<", "Attribute", ",", "8", ">", "AttrList", ";", "Function", "*", "F", "=", "getAssociatedFunction", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "F", "->", "getContext", "(", ")", ";", "auto", "&", "InfoCache", "=", "static_cast", "<", "AMDGPUInformationCache", "&", ">", "(", "A", ".", "getInfoCache", "(", ")", ")", ";", "unsigned", "Min", ",", "Max", ";", "std", "::", "tie", "(", "Min", ",", "Max", ")", "=", "InfoCache", ".", "getMaximumFlatWorkGroupRange", "(", "*", "F", ")", ";", "if", "(", "getAssumed", "(", ")", ".", "getLower", "(", ")", "==", "Min", "&&", "getAssumed", "(", ")", ".", "getUpper", "(", ")", "-", "1", "==", "Max", ")", "return", "ChangeStatus", "::", "UNCHANGED", ";", "SmallString", "<", "10", ">", "Buffer", ";", "raw_svector_ostream", "OS", "(", "Buffer", ")", ";", "OS", "<<", "getAssumed", "(", ")", ".", "getLower", "(", ")", "<<", "','", "<<", "getAssumed", "(", ")", ".", "getUpper", "(", ")", "-", "1", ";", "AttrList", ".", "push_back", "(", "Attribute", "::", "get", "(", "Ctx", ",", "\"amdgpu-flat-work-group-size\"", ",", "OS", ".", "str", "(", ")", ")", ")", ";", "return", "IRAttributeManifest", "::", "manifestAttrs", "(", "A", ",", "getIRPosition", "(", ")", ",", "AttrList", ",", "true", ")", ";", "}", "</s>" ]

[ "See", "AbstractAttribute", ":", ":manifest", "(", "...", ")", "." ]

[ "AMDGPU", "8", "AMDGPU", "1", "10", "1", "\"amdgpu-flat-work-group-size\"" ]

[]