ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"void",
"pass_vsetvl",
"::",
"simple_vsetvl",
"(",
"void",
")",
"const",
"{",
"if",
"(",
"dump_file",
")",
"fprintf",
"(",
"dump_file",
",",
"\"\\nEntering Simple VSETVL PASS and Handling %d basic blocks for \"",
"\"function:%s\\n\"",
",",
"n_basic_blocks_for_fn",
"(",
"cfun",
")",
",",
"function_name",
"(",
"cfun",
")",
")",
";",
"basic_block",
"cfg_bb",
";",
"rtx_insn",
"*",
"rinsn",
";",
"FOR_ALL_BB_FN",
"(",
"cfg_bb",
",",
"cfun",
")",
"{",
"FOR_BB_INSNS",
"(",
"cfg_bb",
",",
"rinsn",
")",
"{",
"if",
"(",
"!",
"NONDEBUG_INSN_P",
"(",
"rinsn",
")",
")",
"continue",
";",
"if",
"(",
"has_vtype_op",
"(",
"rinsn",
")",
")",
"{",
"const",
"auto",
"info",
"=",
"m_vector_manager",
"->",
"vector_insn_infos",
"[",
"INSN_UID",
"(",
"rinsn",
")",
"]",
";",
"emit_vsetvl_insn",
"(",
"VSETVL_DISCARD_RESULT",
",",
"EMIT_BEFORE",
",",
"info",
",",
"NULL_RTX",
",",
"rinsn",
")",
";",
"}",
"}",
"}",
"}",
"</s>"
] | [
"Simple",
"m_vsetvl_insert",
"vsetvl",
"for",
"optimize",
"==",
"0",
"."
] | [
"riscv",
"\"\\nEntering Simple VSETVL PASS and Handling %d basic blocks for \"",
"\"function:%s\\n\""
] | riscv-vsetvl | simple_vsetvl | riscv | CPU | GCC | 17,400 | 101 | 1 | [] |
[
"<s>",
"unsigned",
"PPCAsmParser",
"::",
"validateTargetOperandClass",
"(",
"MCParsedAsmOperand",
"*",
"AsmOp",
",",
"unsigned",
"Kind",
")",
"{",
"int64_t",
"ImmVal",
";",
"switch",
"(",
"Kind",
")",
"{",
"case",
"MCK_0",
":",
"ImmVal",
"=",
"0",
";",
"break",
";",
"case",
"MCK_1",
":",
"ImmVal",
"=",
"1",
";",
"break",
";",
"default",
":",
"return",
"Match_InvalidOperand",
";",
"}",
"PPCOperand",
"*",
"Op",
"=",
"static_cast",
"<",
"PPCOperand",
"*",
">",
"(",
"AsmOp",
")",
";",
"if",
"(",
"Op",
"->",
"isImm",
"(",
")",
"&&",
"Op",
"->",
"getImm",
"(",
")",
"==",
"ImmVal",
")",
"return",
"Match_Success",
";",
"return",
"Match_InvalidOperand",
";",
"}",
"</s>"
] | [
"Allow",
"a",
"target",
"to",
"add",
"special",
"case",
"operand",
"matching",
"for",
"things",
"that",
"tblgen",
"doesn't/ca",
"n't",
"handle",
"effectively",
"."
] | [
"PowerPC",
"PPC",
"0",
"1",
"PPC",
"PPC"
] | PPCAsmParser14 | validateTargetOperandClass | PowerPC | CPU | LLVM | 17,401 | 81 | 1 | [] |
[
"<s>",
"void",
"ARMTargetLowering",
"::",
"AdjustInstrPostInstrSelection",
"(",
"MachineInstr",
"*",
"MI",
",",
"SDNode",
"*",
"Node",
")",
"const",
"{",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"MI",
"->",
"getDesc",
"(",
")",
";",
"if",
"(",
"!",
"MCID",
".",
"hasPostISelHook",
"(",
")",
")",
"{",
"assert",
"(",
"!",
"convertAddSubFlagsOpcode",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"\"Pseudo flag-setting opcodes must be marked with 'hasPostISelHook'\"",
")",
";",
"return",
";",
"}",
"unsigned",
"NewOpc",
"=",
"convertAddSubFlagsOpcode",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"NewOpc",
")",
"{",
"const",
"ARMBaseInstrInfo",
"*",
"TII",
"=",
"static_cast",
"<",
"const",
"ARMBaseInstrInfo",
"*",
">",
"(",
"getTargetMachine",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"MI",
"->",
"setDesc",
"(",
"TII",
"->",
"get",
"(",
"NewOpc",
")",
")",
";",
"}",
"unsigned",
"ccOutIdx",
"=",
"MCID",
".",
"getNumOperands",
"(",
")",
"-",
"1",
";",
"if",
"(",
"!",
"MCID",
".",
"hasOptionalDef",
"(",
")",
"||",
"!",
"MCID",
".",
"OpInfo",
"[",
"ccOutIdx",
"]",
".",
"isOptionalDef",
"(",
")",
")",
"{",
"assert",
"(",
"!",
"NewOpc",
"&&",
"\"Optional cc_out operand required\"",
")",
";",
"return",
";",
"}",
"bool",
"definesCPSR",
"=",
"false",
";",
"bool",
"deadCPSR",
"=",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"MCID",
".",
"getNumOperands",
"(",
")",
",",
"e",
"=",
"MI",
"->",
"getNumOperands",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"i",
")",
";",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
"&&",
"MO",
".",
"isDef",
"(",
")",
"&&",
"MO",
".",
"getReg",
"(",
")",
"==",
"ARM",
"::",
"CPSR",
")",
"{",
"definesCPSR",
"=",
"true",
";",
"if",
"(",
"MO",
".",
"isDead",
"(",
")",
")",
"deadCPSR",
"=",
"true",
";",
"MI",
"->",
"RemoveOperand",
"(",
"i",
")",
";",
"break",
";",
"}",
"}",
"if",
"(",
"!",
"definesCPSR",
")",
"{",
"assert",
"(",
"!",
"NewOpc",
"&&",
"\"Optional cc_out operand required\"",
")",
";",
"return",
";",
"}",
"assert",
"(",
"deadCPSR",
"==",
"!",
"Node",
"->",
"hasAnyUseOfValue",
"(",
"1",
")",
"&&",
"\"inconsistent dead flag\"",
")",
";",
"if",
"(",
"deadCPSR",
")",
"{",
"assert",
"(",
"!",
"MI",
"->",
"getOperand",
"(",
"ccOutIdx",
")",
".",
"getReg",
"(",
")",
"&&",
"\"expect uninitialized optional cc_out operand\"",
")",
";",
"return",
";",
"}",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"ccOutIdx",
")",
";",
"MO",
".",
"setReg",
"(",
"ARM",
"::",
"CPSR",
")",
";",
"MO",
".",
"setIsDef",
"(",
"true",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"should",
"be",
"implemented",
"by",
"targets",
"that",
"mark",
"instructions",
"with",
"the",
"'hasPostISelHook",
"'",
"flag",
"."
] | [
"ARM",
"ARM",
"\"Pseudo flag-setting opcodes must be marked with 'hasPostISelHook'\"",
"ARM",
"ARM",
"1",
"\"Optional cc_out operand required\"",
"ARM::CPSR",
"\"Optional cc_out operand required\"",
"1",
"\"inconsistent dead flag\"",
"\"expect uninitialized optional cc_out operand\"",
"ARM::CPSR"
] | ARMISelLowering152 | AdjustInstrPostInstrSelection | ARM | CPU | LLVM | 17,402 | 335 | 1 | [] |
[
"<s>",
"static",
"inline",
"unsigned",
"long",
"ia64_rse_slot_num",
"(",
"unsigned",
"long",
"*",
"addr",
")",
"{",
"return",
"(",
"(",
"(",
"unsigned",
"long",
")",
"addr",
")",
">>",
"3",
")",
"&",
"0x3f",
";",
"}",
"</s>"
] | [
"RSE",
"helper",
"functions",
"."
] | [
"ia64",
"3",
"0x3f"
] | unwind-ia64 | ia64_rse_slot_num | ia64 | CPU | GCC | 17,403 | 28 | 1 | [] |
[
"<s>",
"static",
"bool",
"microblaze_valid_index_register_p",
"(",
"rtx",
"x",
",",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"int",
"strict",
")",
"{",
"if",
"(",
"!",
"strict",
"&&",
"GET_CODE",
"(",
"x",
")",
"==",
"SUBREG",
")",
"x",
"=",
"SUBREG_REG",
"(",
"x",
")",
";",
"return",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"REG",
"&&",
"microblaze_regno_ok_for_base_p",
"(",
"REGNO",
"(",
"x",
")",
",",
"strict",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"X",
"is",
"a",
"valid",
"index",
"register",
"for",
"the",
"given",
"mode",
".",
"Allow",
"only",
"hard",
"registers",
"if",
"STRICT",
"."
] | [
"microblaze"
] | microblaze | microblaze_valid_index_register_p | microblaze | MPU | GCC | 17,404 | 55 | 1 | [] |
[
"<s>",
"void",
"m32r_expand_epilogue",
"(",
"void",
")",
"{",
"int",
"regno",
";",
"int",
"noepilogue",
"=",
"FALSE",
";",
"int",
"total_size",
";",
"gcc_assert",
"(",
"current_frame_info",
".",
"initialized",
")",
";",
"total_size",
"=",
"current_frame_info",
".",
"total_size",
";",
"if",
"(",
"total_size",
"==",
"0",
")",
"{",
"rtx",
"insn",
"=",
"get_last_insn",
"(",
")",
";",
"if",
"(",
"insn",
"&&",
"NOTE_P",
"(",
"insn",
")",
")",
"insn",
"=",
"prev_nonnote_insn",
"(",
"insn",
")",
";",
"if",
"(",
"insn",
"&&",
"BARRIER_P",
"(",
"insn",
")",
")",
"noepilogue",
"=",
"TRUE",
";",
"}",
"if",
"(",
"!",
"noepilogue",
")",
"{",
"unsigned",
"int",
"var_size",
"=",
"current_frame_info",
".",
"var_size",
";",
"unsigned",
"int",
"args_size",
"=",
"current_frame_info",
".",
"args_size",
";",
"unsigned",
"int",
"gmask",
"=",
"current_frame_info",
".",
"gmask",
";",
"int",
"can_trust_sp_p",
"=",
"!",
"cfun",
"->",
"calls_alloca",
";",
"if",
"(",
"flag_exceptions",
")",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"if",
"(",
"can_trust_sp_p",
")",
"{",
"unsigned",
"int",
"reg_offset",
"=",
"var_size",
"+",
"args_size",
";",
"if",
"(",
"reg_offset",
"==",
"0",
")",
";",
"else",
"if",
"(",
"reg_offset",
"<",
"32768",
")",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"reg_offset",
")",
")",
")",
";",
"else",
"{",
"rtx",
"tmp",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"PROLOGUE_TMP_REGNUM",
")",
";",
"emit_insn",
"(",
"gen_movsi",
"(",
"tmp",
",",
"GEN_INT",
"(",
"reg_offset",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"tmp",
")",
")",
";",
"}",
"}",
"else",
"if",
"(",
"frame_pointer_needed",
")",
"{",
"unsigned",
"int",
"reg_offset",
"=",
"var_size",
"+",
"args_size",
";",
"if",
"(",
"reg_offset",
"==",
"0",
")",
"emit_insn",
"(",
"gen_movsi",
"(",
"stack_pointer_rtx",
",",
"frame_pointer_rtx",
")",
")",
";",
"else",
"if",
"(",
"reg_offset",
"<",
"32768",
")",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"frame_pointer_rtx",
",",
"GEN_INT",
"(",
"reg_offset",
")",
")",
")",
";",
"else",
"{",
"rtx",
"tmp",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"PROLOGUE_TMP_REGNUM",
")",
";",
"emit_insn",
"(",
"gen_movsi",
"(",
"tmp",
",",
"GEN_INT",
"(",
"reg_offset",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_movsi",
"(",
"stack_pointer_rtx",
",",
"frame_pointer_rtx",
")",
")",
";",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"tmp",
")",
")",
";",
"}",
"}",
"else",
"gcc_unreachable",
"(",
")",
";",
"if",
"(",
"current_frame_info",
".",
"save_lr",
")",
"pop",
"(",
"RETURN_ADDR_REGNUM",
")",
";",
"gmask",
"&=",
"~",
"(",
"FRAME_POINTER_MASK",
"|",
"RETURN_ADDR_MASK",
")",
";",
"for",
"(",
"regno",
"=",
"M32R_MAX_INT_REGS",
"-",
"1",
";",
"regno",
">=",
"0",
";",
"--",
"regno",
")",
"{",
"if",
"(",
"(",
"gmask",
"&",
"(",
"1L",
"<<",
"regno",
")",
")",
"!=",
"0",
")",
"pop",
"(",
"regno",
")",
";",
"}",
"if",
"(",
"current_frame_info",
".",
"save_fp",
")",
"pop",
"(",
"FRAME_POINTER_REGNUM",
")",
";",
"if",
"(",
"current_frame_info",
".",
"pretend_size",
"!=",
"0",
")",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"current_frame_info",
".",
"pretend_size",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Expand",
"the",
"m32r",
"epilogue",
"as",
"a",
"series",
"of",
"insns",
"."
] | [
"m32r",
"0",
"0",
"32768",
"0",
"32768",
"1",
"0",
"1L",
"0",
"0"
] | m32r4 | m32r_expand_epilogue | m32r | MPU | GCC | 17,405 | 411 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyLateEHPrepare",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"********** Late EH Prepare **********\\n\"",
"\"********** Function: \"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
")",
";",
"if",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getMCAsmInfo",
"(",
")",
"->",
"getExceptionHandlingType",
"(",
")",
"!=",
"ExceptionHandling",
"::",
"Wasm",
")",
"return",
"false",
";",
"bool",
"Changed",
"=",
"false",
";",
"Changed",
"|=",
"removeUnnecessaryUnreachables",
"(",
"MF",
")",
";",
"if",
"(",
"!",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasPersonalityFn",
"(",
")",
")",
"return",
"Changed",
";",
"Changed",
"|=",
"replaceFuncletReturns",
"(",
"MF",
")",
";",
"Changed",
"|=",
"addCatches",
"(",
"MF",
")",
";",
"Changed",
"|=",
"addExceptionExtraction",
"(",
"MF",
")",
";",
"Changed",
"|=",
"restoreStackPointer",
"(",
"MF",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"********** Late EH Prepare **********\\n\"",
"\"********** Function: \""
] | WebAssemblyLateEHPrepare15 | runOnMachineFunction | WebAssembly | Virtual ISA | LLVM | 17,406 | 111 | 1 | [] |
[
"<s>",
"static",
"void",
"h8300_init_libfuncs",
"(",
"void",
")",
"{",
"set_optab_libfunc",
"(",
"smul_optab",
",",
"HImode",
",",
"\"__mulhi3\"",
")",
";",
"set_optab_libfunc",
"(",
"sdiv_optab",
",",
"HImode",
",",
"\"__divhi3\"",
")",
";",
"set_optab_libfunc",
"(",
"udiv_optab",
",",
"HImode",
",",
"\"__udivhi3\"",
")",
";",
"set_optab_libfunc",
"(",
"smod_optab",
",",
"HImode",
",",
"\"__modhi3\"",
")",
";",
"set_optab_libfunc",
"(",
"umod_optab",
",",
"HImode",
",",
"\"__umodhi3\"",
")",
";",
"}",
"</s>"
] | [
"Perform",
"target",
"dependent",
"optabs",
"initialization",
"."
] | [
"h8300",
"\"__mulhi3\"",
"\"__divhi3\"",
"\"__udivhi3\"",
"\"__modhi3\"",
"\"__umodhi3\""
] | h8300 | h8300_init_libfuncs | h8300 | MPU | GCC | 17,407 | 53 | 1 | [] |
[
"<s>",
"static",
"void",
"symbian_add_attribute",
"(",
"tree",
"node",
",",
"const",
"char",
"*",
"attr_name",
")",
"{",
"tree",
"attrs",
";",
"tree",
"attr",
";",
"attrs",
"=",
"DECL_P",
"(",
"node",
")",
"?",
"DECL_ATTRIBUTES",
"(",
"node",
")",
":",
"TYPE_ATTRIBUTES",
"(",
"node",
")",
";",
"if",
"(",
"lookup_attribute",
"(",
"attr_name",
",",
"attrs",
")",
"!=",
"NULL_TREE",
")",
"return",
";",
"attr",
"=",
"get_identifier",
"(",
"attr_name",
")",
";",
"if",
"(",
"DECL_P",
"(",
"node",
")",
")",
"DECL_ATTRIBUTES",
"(",
"node",
")",
"=",
"tree_cons",
"(",
"attr",
",",
"NULL_TREE",
",",
"attrs",
")",
";",
"else",
"TYPE_ATTRIBUTES",
"(",
"node",
")",
"=",
"tree_cons",
"(",
"attr",
",",
"NULL_TREE",
",",
"attrs",
")",
";",
"fprintf",
"(",
"stderr",
",",
"\"propogate %s attribute\"",
",",
"attr_name",
")",
";",
"print_node_brief",
"(",
"stderr",
",",
"\" to\"",
",",
"node",
",",
"0",
")",
";",
"fprintf",
"(",
"stderr",
",",
"\"\\n\"",
")",
";",
"}",
"</s>"
] | [
"Add",
"the",
"named",
"attribute",
"to",
"the",
"given",
"node",
".",
"Copes",
"with",
"both",
"DECLs",
"and",
"TYPEs",
".",
"Will",
"only",
"add",
"the",
"attribute",
"if",
"it",
"is",
"not",
"already",
"present",
"."
] | [
"sh",
"\"propogate %s attribute\"",
"\" to\"",
"0",
"\"\\n\""
] | symbian | symbian_add_attribute | sh | CPU | GCC | 17,408 | 120 | 1 | [] |
[
"<s>",
"const",
"CallLowering",
"*",
"MipsSubtarget",
"::",
"getCallLowering",
"(",
")",
"const",
"{",
"return",
"CallLoweringInfo",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Methods",
"used",
"by",
"Global",
"ISel",
"."
] | [
"Mips",
"Mips"
] | MipsSubtarget (2)2 | getCallLowering | Mips | CPU | LLVM | 17,409 | 18 | 1 | [] |
[
"<s>",
"static",
"void",
"microblaze_elf_asm_destructor",
"(",
"rtx",
"symbol",
",",
"int",
"priority",
")",
"{",
"microblaze_elf_asm_cdtor",
"(",
"symbol",
",",
"priority",
",",
"false",
")",
";",
"}",
"</s>"
] | [
"Add",
"a",
"function",
"to",
"the",
"list",
"of",
"static",
"destructors",
"."
] | [
"microblaze"
] | microblaze | microblaze_elf_asm_destructor | microblaze | MPU | GCC | 17,410 | 21 | 1 | [] |
[
"<s>",
"static",
"rtx",
"frv_legitimize_target",
"(",
"enum",
"insn_code",
"icode",
",",
"rtx",
"target",
")",
"{",
"machine_mode",
"mode",
"=",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"mode",
";",
"if",
"(",
"!",
"target",
"||",
"GET_MODE",
"(",
"target",
")",
"!=",
"mode",
"||",
"!",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"0",
"]",
".",
"predicate",
")",
"(",
"target",
",",
"mode",
")",
")",
"return",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"else",
"return",
"target",
";",
"}",
"</s>"
] | [
"Return",
"a",
"legitimate",
"rtx",
"for",
"instruction",
"ICODE",
"'s",
"return",
"value",
".",
"Use",
"TARGET",
"if",
"it",
"'s",
"not",
"null",
",",
"has",
"the",
"right",
"mode",
",",
"and",
"satisfies",
"operand",
"0",
"'s",
"predicate",
"."
] | [
"frv",
"0",
"0"
] | frv | frv_legitimize_target | frv | VLIW | GCC | 17,411 | 71 | 1 | [] |
[
"<s>",
"bool",
"X86RegisterInfo",
"::",
"hasReservedCallFrame",
"(",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"!",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"hasVarSizedObjects",
"(",
")",
";",
"}",
"</s>"
] | [
"hasReservedCallFrame",
"-",
"Under",
"normal",
"circumstances",
",",
"when",
"a",
"frame",
"pointer",
"is",
"not",
"required",
",",
"we",
"reserve",
"argument",
"space",
"for",
"call",
"sites",
"in",
"the",
"function",
"immediately",
"on",
"entry",
"to",
"the",
"current",
"function",
"."
] | [
"X86",
"X86"
] | X86RegisterInfo11 | hasReservedCallFrame | X86 | CPU | LLVM | 17,412 | 24 | 1 | [] |
[
"<s>",
"static",
"bool",
"xtensa_return_in_memory",
"(",
"const_tree",
"type",
",",
"const_tree",
"fntype",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"(",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"int_size_in_bytes",
"(",
"type",
")",
">",
"4",
"*",
"UNITS_PER_WORD",
")",
";",
"}",
"</s>"
] | [
"Worker",
"function",
"for",
"TARGET_RETURN_IN_MEMORY",
"."
] | [
"xtensa",
"4"
] | xtensa | xtensa_return_in_memory | xtensa | MPU | GCC | 17,413 | 29 | 1 | [] |
[
"<s>",
"TargetLowering",
"::",
"AtomicExpansionKind",
"ARMTargetLowering",
"::",
"shouldExpandAtomicLoadInIR",
"(",
"LoadInst",
"*",
"LI",
")",
"const",
"{",
"unsigned",
"Size",
"=",
"LI",
"->",
"getType",
"(",
")",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"return",
"(",
"(",
"Size",
"==",
"64",
")",
"&&",
"!",
"Subtarget",
"->",
"isMClass",
"(",
")",
")",
"?",
"AtomicExpansionKind",
"::",
"LLOnly",
":",
"AtomicExpansionKind",
"::",
"None",
";",
"}",
"</s>"
] | [
"Returns",
"how",
"the",
"given",
"(",
"atomic",
")",
"load",
"should",
"be",
"expanded",
"by",
"the",
"IR-level",
"AtomicExpand",
"pass",
"."
] | [
"ARM",
"ARM",
"64"
] | ARMISelLowering (2)2 | shouldExpandAtomicLoadInIR | ARM | CPU | LLVM | 17,414 | 51 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"WebAssembly Replace Physical Registers\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"WebAssembly",
"\"WebAssembly Replace Physical Registers\""
] | WebAssemblyReplacePhysRegs | getPassName | WebAssembly | Virtual ISA | LLVM | 17,415 | 11 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"long",
"get_csky_current_func_type",
"(",
"void",
")",
"{",
"if",
"(",
"CSKY_FUNCTION_TYPE",
"(",
"cfun",
"->",
"machine",
"->",
"func_type",
")",
"==",
"CSKY_FT_UNKNOWN",
")",
"{",
"unsigned",
"long",
"type",
"=",
"CSKY_FT_UNKNOWN",
";",
"tree",
"a",
";",
"tree",
"attr",
";",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"current_function_decl",
")",
"==",
"FUNCTION_DECL",
")",
";",
"attr",
"=",
"DECL_ATTRIBUTES",
"(",
"current_function_decl",
")",
";",
"a",
"=",
"lookup_attribute",
"(",
"\"naked\"",
",",
"attr",
")",
";",
"if",
"(",
"a",
"!=",
"NULL_TREE",
")",
"type",
"|=",
"CSKY_FT_NAKED",
";",
"a",
"=",
"lookup_attribute",
"(",
"\"isr\"",
",",
"attr",
")",
";",
"if",
"(",
"a",
"==",
"NULL_TREE",
")",
"a",
"=",
"lookup_attribute",
"(",
"\"interrupt\"",
",",
"attr",
")",
";",
"if",
"(",
"a",
"==",
"NULL_TREE",
")",
"type",
"|=",
"CSKY_FT_NORMAL",
";",
"else",
"type",
"|=",
"get_csky_isr_type",
"(",
"TREE_VALUE",
"(",
"a",
")",
")",
";",
"cfun",
"->",
"machine",
"->",
"func_type",
"=",
"type",
";",
"}",
"return",
"cfun",
"->",
"machine",
"->",
"func_type",
";",
"}",
"</s>"
] | [
"Classify",
"cfun",
"as",
"a",
"normal",
"function",
"or",
"some",
"sort",
"of",
"interrupt",
"handler",
",",
"and",
"set",
"the",
"corresponding",
"bits",
"in",
"cfun-",
">",
"machine-",
">",
"func_type",
"."
] | [
"csky",
"\"naked\"",
"\"isr\"",
"\"interrupt\""
] | csky | get_csky_current_func_type | csky | CPU | GCC | 17,416 | 132 | 1 | [] |
[
"<s>",
"bool",
"processBlock",
"(",
"MachineBasicBlock",
"&",
"MBB",
")",
"{",
"bool",
"Changed",
"=",
"false",
";",
"SmallVector",
"<",
"MachineInstr",
"*",
",",
"4",
">",
"ToDelete",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"begin",
"(",
")",
",",
"IE",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"I",
"!=",
"IE",
";",
"++",
"I",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"I",
";",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"PPC",
"::",
"XXLOR",
"&&",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
"==",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
"==",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
")",
"ToDelete",
".",
"push_back",
"(",
"MI",
")",
";",
"}",
"if",
"(",
"!",
"ToDelete",
".",
"empty",
"(",
")",
")",
"Changed",
"=",
"true",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"ie",
"=",
"ToDelete",
".",
"size",
"(",
")",
";",
"i",
"!=",
"ie",
";",
"++",
"i",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Removing VSX self-copy: \"",
"<<",
"*",
"ToDelete",
"[",
"i",
"]",
")",
";",
"ToDelete",
"[",
"i",
"]",
"->",
"eraseFromParent",
"(",
")",
";",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"processBlock",
"-",
"If",
"there",
"are",
"any",
"predecessors",
"whose",
"control",
"can",
"be",
"threaded",
"through",
"to",
"a",
"successor",
",",
"transform",
"them",
"now",
"."
] | [
"PowerPC",
"4",
"PPC::XXLOR",
"0",
"1",
"0",
"2",
"0",
"\"Removing VSX self-copy: \""
] | PPCInstrInfo1 | processBlock | PowerPC | CPU | LLVM | 17,417 | 186 | 1 | [] |
[
"<s>",
"void",
"GCNPassConfig",
"::",
"addPreRegAlloc",
"(",
")",
"{",
"if",
"(",
"LateCFGStructurize",
")",
"{",
"addPass",
"(",
"createAMDGPUMachineCFGStructurizerPass",
"(",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"register",
"allocation",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPUTargetMachine (2)1 | addPreRegAlloc | AMDGPU | GPU | LLVM | 17,418 | 21 | 1 | [] |
[
"<s>",
"void",
"ARMFrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"const",
"ARMBaseInstrInfo",
"&",
"TII",
"=",
"*",
"static_cast",
"<",
"const",
"ARMBaseInstrInfo",
"*",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"if",
"(",
"!",
"hasReservedCallFrame",
"(",
"MF",
")",
")",
"{",
"MachineInstr",
"*",
"Old",
"=",
"I",
";",
"DebugLoc",
"dl",
"=",
"Old",
"->",
"getDebugLoc",
"(",
")",
";",
"unsigned",
"Amount",
"=",
"Old",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Amount",
"!=",
"0",
")",
"{",
"unsigned",
"Align",
"=",
"getStackAlignment",
"(",
")",
";",
"Amount",
"=",
"(",
"Amount",
"+",
"Align",
"-",
"1",
")",
"/",
"Align",
"*",
"Align",
";",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"assert",
"(",
"!",
"AFI",
"->",
"isThumb1OnlyFunction",
"(",
")",
"&&",
"\"This eliminateCallFramePseudoInstr does not support Thumb1!\"",
")",
";",
"bool",
"isARM",
"=",
"!",
"AFI",
"->",
"isThumbFunction",
"(",
")",
";",
"unsigned",
"Opc",
"=",
"Old",
"->",
"getOpcode",
"(",
")",
";",
"int",
"PIdx",
"=",
"Old",
"->",
"findFirstPredOperandIdx",
"(",
")",
";",
"ARMCC",
"::",
"CondCodes",
"Pred",
"=",
"(",
"PIdx",
"==",
"-",
"1",
")",
"?",
"ARMCC",
"::",
"AL",
":",
"(",
"ARMCC",
"::",
"CondCodes",
")",
"Old",
"->",
"getOperand",
"(",
"PIdx",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Opc",
"==",
"ARM",
"::",
"ADJCALLSTACKDOWN",
"||",
"Opc",
"==",
"ARM",
"::",
"tADJCALLSTACKDOWN",
")",
"{",
"unsigned",
"PredReg",
"=",
"Old",
"->",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
";",
"emitSPUpdate",
"(",
"isARM",
",",
"MBB",
",",
"I",
",",
"dl",
",",
"TII",
",",
"-",
"Amount",
",",
"MachineInstr",
"::",
"NoFlags",
",",
"Pred",
",",
"PredReg",
")",
";",
"}",
"else",
"{",
"unsigned",
"PredReg",
"=",
"Old",
"->",
"getOperand",
"(",
"3",
")",
".",
"getReg",
"(",
")",
";",
"assert",
"(",
"Opc",
"==",
"ARM",
"::",
"ADJCALLSTACKUP",
"||",
"Opc",
"==",
"ARM",
"::",
"tADJCALLSTACKUP",
")",
";",
"emitSPUpdate",
"(",
"isARM",
",",
"MBB",
",",
"I",
",",
"dl",
",",
"TII",
",",
"Amount",
",",
"MachineInstr",
"::",
"NoFlags",
",",
"Pred",
",",
"PredReg",
")",
";",
"}",
"}",
"}",
"MBB",
".",
"erase",
"(",
"I",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"0",
"0",
"1",
"ARM",
"ARM",
"\"This eliminateCallFramePseudoInstr does not support Thumb1!\"",
"ARM",
"ARMCC::CondCodes",
"1",
"ARMCC::AL",
"ARMCC::CondCodes",
"ARM::ADJCALLSTACKDOWN",
"ARM::tADJCALLSTACKDOWN",
"2",
"ARM",
"3",
"ARM::ADJCALLSTACKUP",
"ARM::tADJCALLSTACKUP",
"ARM"
] | ARMFrameLowering26 | eliminateCallFramePseudoInstr | ARM | CPU | LLVM | 17,419 | 314 | 1 | [] |
[
"<s>",
"SDValue",
"MipsTargetLowering",
"::",
"LowerReturn",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"DebugLoc",
"DL",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"MF",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"MipsCC",
"MipsCCInfo",
"(",
"CallConv",
",",
"IsO32",
",",
"CCInfo",
")",
";",
"MipsCCInfo",
".",
"analyzeReturn",
"(",
"Outs",
",",
"getTargetMachine",
"(",
")",
".",
"Options",
".",
"UseSoftFloat",
",",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getReturnType",
"(",
")",
")",
";",
"SDValue",
"Flag",
";",
"SmallVector",
"<",
"SDValue",
",",
"4",
">",
"RetOps",
"(",
"1",
",",
"Chain",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"SDValue",
"Val",
"=",
"OutVals",
"[",
"i",
"]",
";",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Can only return in registers!\"",
")",
";",
"if",
"(",
"RVLocs",
"[",
"i",
"]",
".",
"getValVT",
"(",
")",
"!=",
"RVLocs",
"[",
"i",
"]",
".",
"getLocVT",
"(",
")",
")",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BITCAST",
",",
"DL",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getLocVT",
"(",
")",
",",
"Val",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"DL",
",",
"VA",
".",
"getLocReg",
"(",
")",
",",
"Val",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"VA",
".",
"getLocReg",
"(",
")",
",",
"VA",
".",
"getLocVT",
"(",
")",
")",
")",
";",
"}",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
"->",
"hasStructRetAttr",
"(",
")",
")",
"{",
"MipsFunctionInfo",
"*",
"MipsFI",
"=",
"MF",
".",
"getInfo",
"<",
"MipsFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"Reg",
"=",
"MipsFI",
"->",
"getSRetReturnReg",
"(",
")",
";",
"if",
"(",
"!",
"Reg",
")",
"llvm_unreachable",
"(",
"\"sret virtual register not created in the entry block\"",
")",
";",
"SDValue",
"Val",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"DL",
",",
"Reg",
",",
"getPointerTy",
"(",
")",
")",
";",
"unsigned",
"V0",
"=",
"IsN64",
"?",
"Mips",
"::",
"V0_64",
":",
"Mips",
"::",
"V0",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"DL",
",",
"V0",
",",
"Val",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"V0",
",",
"getPointerTy",
"(",
")",
")",
")",
";",
"}",
"RetOps",
"[",
"0",
"]",
"=",
"Chain",
";",
"if",
"(",
"Flag",
".",
"getNode",
"(",
")",
")",
"RetOps",
".",
"push_back",
"(",
"Flag",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"MipsISD",
"::",
"Ret",
",",
"DL",
",",
"MVT",
"::",
"Other",
",",
"&",
"RetOps",
"[",
"0",
"]",
",",
"RetOps",
".",
"size",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"outgoing",
"return",
"values",
",",
"described",
"by",
"the",
"Outs",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"Mips",
"Mips",
"ISD::OutputArg",
"16",
"Mips",
"Mips",
"Mips",
"4",
"1",
"0",
"\"Can only return in registers!\"",
"ISD::BITCAST",
"1",
"Mips",
"Mips",
"Mips",
"Mips",
"\"sret virtual register not created in the entry block\"",
"Mips::V0_64",
"Mips::V0",
"1",
"0",
"MipsISD::Ret",
"MVT::Other",
"0"
] | MipsISelLowering126 | LowerReturn | Mips | CPU | LLVM | 17,420 | 449 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"setPreservesAll",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"AU",
".",
"addRequired",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"AArch64"
] | AArch64CollectLOH | getAnalysisUsage | AArch64 | CPU | LLVM | 17,421 | 33 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"NOP insertion pass\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"X86",
"\"NOP insertion pass\""
] | NOPInsertion | getPassName | X86 | CPU | LLVM | 17,422 | 13 | 1 | [] |
[
"<s>",
"void",
"AMDGPURegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"int",
"SPAdj",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"assert",
"(",
"!",
"\"Subroutines not supported yet\"",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"R600",
"\"Subroutines not supported yet\""
] | AMDGPURegisterInfo9 | eliminateFrameIndex | R600 | GPU | LLVM | 17,423 | 26 | 1 | [] |
[
"<s>",
"static",
"bool",
"rs6000_output_addr_const_extra",
"(",
"FILE",
"*",
"file",
",",
"rtx",
"x",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"UNSPEC",
")",
"switch",
"(",
"XINT",
"(",
"x",
",",
"1",
")",
")",
"{",
"case",
"UNSPEC_TOCREL",
":",
"gcc_checking_assert",
"(",
"GET_CODE",
"(",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"0",
")",
")",
"==",
"SYMBOL_REF",
"&&",
"REG_P",
"(",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"1",
")",
")",
"&&",
"REGNO",
"(",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"1",
")",
")",
"==",
"TOC_REGISTER",
")",
";",
"output_addr_const",
"(",
"file",
",",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"0",
")",
")",
";",
"if",
"(",
"x",
"==",
"tocrel_base",
"&&",
"tocrel_offset",
"!=",
"const0_rtx",
")",
"{",
"if",
"(",
"INTVAL",
"(",
"tocrel_offset",
")",
">=",
"0",
")",
"fprintf",
"(",
"file",
",",
"\"+\"",
")",
";",
"output_addr_const",
"(",
"file",
",",
"CONST_CAST_RTX",
"(",
"tocrel_offset",
")",
")",
";",
"}",
"if",
"(",
"!",
"TARGET_AIX",
"||",
"(",
"TARGET_ELF",
"&&",
"TARGET_MINIMAL_TOC",
")",
")",
"{",
"putc",
"(",
"'-'",
",",
"file",
")",
";",
"assemble_name",
"(",
"file",
",",
"toc_label_name",
")",
";",
"need_toc_init",
"=",
"1",
";",
"}",
"else",
"if",
"(",
"TARGET_ELF",
")",
"fputs",
"(",
"\"@toc\"",
",",
"file",
")",
";",
"return",
"true",
";",
"case",
"UNSPEC_MACHOPIC_OFFSET",
":",
"output_addr_const",
"(",
"file",
",",
"XVECEXP",
"(",
"x",
",",
"0",
",",
"0",
")",
")",
";",
"putc",
"(",
"'-'",
",",
"file",
")",
";",
"machopic_output_function_base_name",
"(",
"file",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA",
"."
] | [
"powerpcspe",
"1",
"0",
"0",
"0",
"1",
"0",
"1",
"0",
"0",
"0",
"\"+\"",
"1",
"\"@toc\"",
"0",
"0"
] | powerpcspe | rs6000_output_addr_const_extra | powerpcspe | CPU | GCC | 17,424 | 212 | 1 | [] |
[
"<s>",
"static",
"void",
"emit_unlikely_jump",
"(",
"rtx",
"cond",
",",
"rtx",
"label",
")",
"{",
"rtx",
"very_unlikely",
"=",
"GEN_INT",
"(",
"REG_BR_PROB_BASE",
"/",
"100",
"-",
"1",
")",
";",
"rtx",
"x",
";",
"x",
"=",
"gen_rtx_IF_THEN_ELSE",
"(",
"VOIDmode",
",",
"cond",
",",
"label",
",",
"pc_rtx",
")",
";",
"x",
"=",
"emit_jump_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"pc_rtx",
",",
"x",
")",
")",
";",
"REG_NOTES",
"(",
"x",
")",
"=",
"gen_rtx_EXPR_LIST",
"(",
"REG_BR_PROB",
",",
"very_unlikely",
",",
"NULL_RTX",
")",
";",
"}",
"</s>"
] | [
"Mark",
"the",
"previous",
"jump",
"instruction",
"as",
"unlikely",
"."
] | [
"alpha",
"100",
"1"
] | alpha3 | emit_unlikely_jump | alpha | MPU | GCC | 17,425 | 68 | 1 | [] |
[
"<s>",
"SDValue",
"ARMTargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"ADD",
":",
"return",
"PerformADDCombine",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"SUB",
":",
"return",
"PerformSUBCombine",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"MUL",
":",
"return",
"PerformMULCombine",
"(",
"N",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"OR",
":",
"return",
"PerformORCombine",
"(",
"N",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ARMISD",
"::",
"VMOVRRD",
":",
"return",
"PerformVMOVRRDCombine",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ARMISD",
"::",
"VDUPLANE",
":",
"return",
"PerformVDUPLANECombine",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"PerformIntrinsicCombine",
"(",
"N",
",",
"DCI",
".",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SHL",
":",
"case",
"ISD",
"::",
"SRA",
":",
"case",
"ISD",
"::",
"SRL",
":",
"return",
"PerformShiftCombine",
"(",
"N",
",",
"DCI",
".",
"DAG",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND",
":",
"case",
"ISD",
"::",
"ZERO_EXTEND",
":",
"case",
"ISD",
"::",
"ANY_EXTEND",
":",
"return",
"PerformExtendCombine",
"(",
"N",
",",
"DCI",
".",
"DAG",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"SELECT_CC",
":",
"return",
"PerformSELECT_CCCombine",
"(",
"N",
",",
"DCI",
".",
"DAG",
",",
"Subtarget",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"will",
"be",
"invoked",
"for",
"all",
"target",
"nodes",
"and",
"for",
"any",
"target-independent",
"nodes",
"that",
"the",
"target",
"has",
"registered",
"with",
"invoke",
"it",
"for",
"."
] | [
"ARM",
"ARM",
"ISD::ADD",
"ISD::SUB",
"ISD::MUL",
"ISD::OR",
"ARMISD::VMOVRRD",
"ARMISD::VDUPLANE",
"ISD::INTRINSIC_WO_CHAIN",
"ISD::SHL",
"ISD::SRA",
"ISD::SRL",
"ISD::SIGN_EXTEND",
"ISD::ZERO_EXTEND",
"ISD::ANY_EXTEND",
"ISD::SELECT_CC"
] | ARMISelLowering54 | PerformDAGCombine | ARM | CPU | LLVM | 17,426 | 203 | 1 | [] |
[
"<s>",
"unsigned",
"SparcAsmParser",
"::",
"validateTargetOperandClass",
"(",
"MCParsedAsmOperand",
"&",
"GOp",
",",
"unsigned",
"Kind",
")",
"{",
"SparcOperand",
"&",
"Op",
"=",
"(",
"SparcOperand",
"&",
")",
"GOp",
";",
"if",
"(",
"Op",
".",
"isFloatOrDoubleReg",
"(",
")",
")",
"{",
"switch",
"(",
"Kind",
")",
"{",
"default",
":",
"break",
";",
"case",
"MCK_DFPRegs",
":",
"if",
"(",
"!",
"Op",
".",
"isFloatReg",
"(",
")",
"||",
"SparcOperand",
"::",
"MorphToDoubleReg",
"(",
"Op",
")",
")",
"return",
"MCTargetAsmParser",
"::",
"Match_Success",
";",
"break",
";",
"case",
"MCK_QFPRegs",
":",
"if",
"(",
"SparcOperand",
"::",
"MorphToQuadReg",
"(",
"Op",
")",
")",
"return",
"MCTargetAsmParser",
"::",
"Match_Success",
";",
"break",
";",
"}",
"}",
"return",
"Match_InvalidOperand",
";",
"}",
"</s>"
] | [
"Allow",
"a",
"target",
"to",
"add",
"special",
"case",
"operand",
"matching",
"for",
"things",
"that",
"tblgen",
"doesn't/ca",
"n't",
"handle",
"effectively",
"."
] | [
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"SparcOperand::MorphToDoubleReg",
"SparcOperand::MorphToQuadReg"
] | SparcAsmParser14 | validateTargetOperandClass | Sparc | CPU | LLVM | 17,427 | 92 | 1 | [] |
[
"<s>",
"void",
"MipsAsmPrinter",
"::",
"emitFrameDirective",
"(",
")",
"{",
"const",
"TargetRegisterInfo",
"&",
"RI",
"=",
"*",
"TM",
".",
"getSubtargetImpl",
"(",
")",
"->",
"getRegisterInfo",
"(",
")",
";",
"unsigned",
"stackReg",
"=",
"RI",
".",
"getFrameRegister",
"(",
"*",
"MF",
")",
";",
"unsigned",
"returnReg",
"=",
"RI",
".",
"getRARegister",
"(",
")",
";",
"unsigned",
"stackSize",
"=",
"MF",
"->",
"getFrameInfo",
"(",
")",
"->",
"getStackSize",
"(",
")",
";",
"getTargetStreamer",
"(",
")",
".",
"emitFrame",
"(",
"stackReg",
",",
"stackSize",
",",
"returnReg",
")",
";",
"}",
"</s>"
] | [
"Frame",
"Directive",
"."
] | [
"Mips",
"Mips"
] | MipsAsmPrinter20 | emitFrameDirective | Mips | CPU | LLVM | 17,428 | 70 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"getMemOperandWithOffsetWidth",
"(",
"const",
"MachineInstr",
"&",
"LdSt",
",",
"const",
"MachineOperand",
"*",
"&",
"BaseOp",
",",
"int64_t",
"&",
"Offset",
",",
"unsigned",
"&",
"Width",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"assert",
"(",
"LdSt",
".",
"mayLoadOrStore",
"(",
")",
"&&",
"\"Expected a memory operation.\"",
")",
";",
"if",
"(",
"LdSt",
".",
"getNumExplicitOperands",
"(",
")",
"==",
"3",
")",
"{",
"if",
"(",
"(",
"!",
"LdSt",
".",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
"&&",
"!",
"LdSt",
".",
"getOperand",
"(",
"1",
")",
".",
"isFI",
"(",
")",
")",
"||",
"!",
"LdSt",
".",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
")",
"return",
"false",
";",
"}",
"else",
"if",
"(",
"LdSt",
".",
"getNumExplicitOperands",
"(",
")",
"==",
"4",
")",
"{",
"if",
"(",
"!",
"LdSt",
".",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
"||",
"(",
"!",
"LdSt",
".",
"getOperand",
"(",
"2",
")",
".",
"isReg",
"(",
")",
"&&",
"!",
"LdSt",
".",
"getOperand",
"(",
"2",
")",
".",
"isFI",
"(",
")",
")",
"||",
"!",
"LdSt",
".",
"getOperand",
"(",
"3",
")",
".",
"isImm",
"(",
")",
")",
"return",
"false",
";",
"}",
"else",
"return",
"false",
";",
"unsigned",
"Scale",
"=",
"0",
";",
"int64_t",
"Dummy1",
",",
"Dummy2",
";",
"if",
"(",
"!",
"getMemOpInfo",
"(",
"LdSt",
".",
"getOpcode",
"(",
")",
",",
"Scale",
",",
"Width",
",",
"Dummy1",
",",
"Dummy2",
")",
")",
"return",
"false",
";",
"if",
"(",
"LdSt",
".",
"getNumExplicitOperands",
"(",
")",
"==",
"3",
")",
"{",
"BaseOp",
"=",
"&",
"LdSt",
".",
"getOperand",
"(",
"1",
")",
";",
"Offset",
"=",
"LdSt",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"*",
"Scale",
";",
"}",
"else",
"{",
"assert",
"(",
"LdSt",
".",
"getNumExplicitOperands",
"(",
")",
"==",
"4",
"&&",
"\"invalid number of operands\"",
")",
";",
"BaseOp",
"=",
"&",
"LdSt",
".",
"getOperand",
"(",
"2",
")",
";",
"Offset",
"=",
"LdSt",
".",
"getOperand",
"(",
"3",
")",
".",
"getImm",
"(",
")",
"*",
"Scale",
";",
"}",
"if",
"(",
"!",
"BaseOp",
"->",
"isReg",
"(",
")",
"&&",
"!",
"BaseOp",
"->",
"isFI",
"(",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"get",
"the",
"base",
"operand",
",",
"byte",
"offset",
"of",
"an",
"instruction",
"and",
"the",
"memory",
"width",
"."
] | [
"AArch64",
"AArch64",
"\"Expected a memory operation.\"",
"3",
"1",
"1",
"2",
"4",
"1",
"2",
"2",
"3",
"0",
"3",
"1",
"2",
"4",
"\"invalid number of operands\"",
"2",
"3"
] | AArch64InstrInfo120 | getMemOperandWithOffsetWidth | AArch64 | CPU | LLVM | 17,429 | 303 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"WebAssembly Late Prepare Exception\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"WebAssembly",
"\"WebAssembly Late Prepare Exception\""
] | WebAssemblyLateEHPrepare1 | getPassName | WebAssembly | Virtual ISA | LLVM | 17,430 | 11 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"get_trap_mode_suffix",
"(",
")",
"{",
"enum",
"attr_trap_suffix",
"s",
"=",
"get_attr_trap_suffix",
"(",
"current_output_insn",
")",
";",
"switch",
"(",
"s",
")",
"{",
"case",
"TRAP_SUFFIX_NONE",
":",
"return",
"NULL",
";",
"case",
"TRAP_SUFFIX_SU",
":",
"if",
"(",
"alpha_fptm",
">=",
"ALPHA_FPTM_SU",
")",
"return",
"\"su\"",
";",
"return",
"NULL",
";",
"case",
"TRAP_SUFFIX_SUI",
":",
"if",
"(",
"alpha_fptm",
">=",
"ALPHA_FPTM_SUI",
")",
"return",
"\"sui\"",
";",
"return",
"NULL",
";",
"case",
"TRAP_SUFFIX_V_SV",
":",
"switch",
"(",
"alpha_fptm",
")",
"{",
"case",
"ALPHA_FPTM_N",
":",
"return",
"NULL",
";",
"case",
"ALPHA_FPTM_U",
":",
"return",
"\"v\"",
";",
"case",
"ALPHA_FPTM_SU",
":",
"case",
"ALPHA_FPTM_SUI",
":",
"return",
"\"sv\"",
";",
"}",
"break",
";",
"case",
"TRAP_SUFFIX_V_SV_SVI",
":",
"switch",
"(",
"alpha_fptm",
")",
"{",
"case",
"ALPHA_FPTM_N",
":",
"return",
"NULL",
";",
"case",
"ALPHA_FPTM_U",
":",
"return",
"\"v\"",
";",
"case",
"ALPHA_FPTM_SU",
":",
"return",
"\"sv\"",
";",
"case",
"ALPHA_FPTM_SUI",
":",
"return",
"\"svi\"",
";",
"}",
"break",
";",
"case",
"TRAP_SUFFIX_U_SU_SUI",
":",
"switch",
"(",
"alpha_fptm",
")",
"{",
"case",
"ALPHA_FPTM_N",
":",
"return",
"NULL",
";",
"case",
"ALPHA_FPTM_U",
":",
"return",
"\"u\"",
";",
"case",
"ALPHA_FPTM_SU",
":",
"return",
"\"su\"",
";",
"case",
"ALPHA_FPTM_SUI",
":",
"return",
"\"sui\"",
";",
"}",
"break",
";",
"}",
"abort",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"trap",
"mode",
"suffix",
"applicable",
"to",
"the",
"current",
"instruction",
",",
"or",
"NULL",
"."
] | [
"alpha",
"\"su\"",
"\"sui\"",
"\"v\"",
"\"sv\"",
"\"v\"",
"\"sv\"",
"\"svi\"",
"\"u\"",
"\"su\"",
"\"sui\""
] | alpha2 | get_trap_mode_suffix | alpha | MPU | GCC | 17,431 | 166 | 1 | [] |
[
"<s>",
"int",
"X86FrameLowering",
"::",
"mergeSPUpdates",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"MBBI",
",",
"bool",
"doMergeWithPrevious",
")",
"const",
"{",
"if",
"(",
"(",
"doMergeWithPrevious",
"&&",
"MBBI",
"==",
"MBB",
".",
"begin",
"(",
")",
")",
"||",
"(",
"!",
"doMergeWithPrevious",
"&&",
"MBBI",
"==",
"MBB",
".",
"end",
"(",
")",
")",
")",
"return",
"0",
";",
"MachineBasicBlock",
"::",
"iterator",
"PI",
"=",
"doMergeWithPrevious",
"?",
"std",
"::",
"prev",
"(",
"MBBI",
")",
":",
"MBBI",
";",
"MachineBasicBlock",
"::",
"iterator",
"NI",
"=",
"doMergeWithPrevious",
"?",
"nullptr",
":",
"std",
"::",
"next",
"(",
"MBBI",
")",
";",
"unsigned",
"Opc",
"=",
"PI",
"->",
"getOpcode",
"(",
")",
";",
"int",
"Offset",
"=",
"0",
";",
"if",
"(",
"(",
"Opc",
"==",
"X86",
"::",
"ADD64ri32",
"||",
"Opc",
"==",
"X86",
"::",
"ADD64ri8",
"||",
"Opc",
"==",
"X86",
"::",
"ADD32ri",
"||",
"Opc",
"==",
"X86",
"::",
"ADD32ri8",
"||",
"Opc",
"==",
"X86",
"::",
"LEA32r",
"||",
"Opc",
"==",
"X86",
"::",
"LEA64_32r",
")",
"&&",
"PI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
"==",
"StackPtr",
")",
"{",
"Offset",
"+=",
"PI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"MBB",
".",
"erase",
"(",
"PI",
")",
";",
"if",
"(",
"!",
"doMergeWithPrevious",
")",
"MBBI",
"=",
"NI",
";",
"}",
"else",
"if",
"(",
"(",
"Opc",
"==",
"X86",
"::",
"SUB64ri32",
"||",
"Opc",
"==",
"X86",
"::",
"SUB64ri8",
"||",
"Opc",
"==",
"X86",
"::",
"SUB32ri",
"||",
"Opc",
"==",
"X86",
"::",
"SUB32ri8",
")",
"&&",
"PI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
"==",
"StackPtr",
")",
"{",
"Offset",
"-=",
"PI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"MBB",
".",
"erase",
"(",
"PI",
")",
";",
"if",
"(",
"!",
"doMergeWithPrevious",
")",
"MBBI",
"=",
"NI",
";",
"}",
"return",
"Offset",
";",
"}",
"</s>"
] | [
"Check",
"the",
"instruction",
"before/after",
"the",
"passed",
"instruction",
"."
] | [
"X86",
"X86",
"0",
"0",
"X86::ADD64ri32",
"X86::ADD64ri8",
"X86::ADD32ri",
"X86::ADD32ri8",
"X86::LEA32r",
"X86::LEA64_32r",
"0",
"2",
"X86::SUB64ri32",
"X86::SUB64ri8",
"X86::SUB32ri",
"X86::SUB32ri8",
"0",
"2"
] | X86FrameLowering (2)4 | mergeSPUpdates | X86 | CPU | LLVM | 17,432 | 257 | 1 | [] |
[
"<s>",
"static",
"machine_mode",
"mode_from_flags",
"(",
"unsigned",
"int",
"f",
")",
"{",
"if",
"(",
"f",
"&",
"CC_FLAG_FP",
")",
"return",
"CC_Fmode",
";",
"if",
"(",
"f",
"&",
"CC_FLAG_O",
")",
"{",
"if",
"(",
"f",
"&",
"CC_FLAG_C",
")",
"return",
"CCmode",
";",
"else",
"return",
"CC_ZSOmode",
";",
"}",
"else",
"if",
"(",
"f",
"&",
"CC_FLAG_C",
")",
"return",
"CC_ZSCmode",
";",
"else",
"return",
"CC_ZSmode",
";",
"}",
"</s>"
] | [
"Convert",
"a",
"set",
"of",
"flags",
"to",
"a",
"CC_MODE",
"that",
"can",
"implement",
"it",
"."
] | [
"rx"
] | rx | mode_from_flags | rx | CPU | GCC | 17,433 | 54 | 1 | [] |
[
"<s>",
"tree",
"arm_valid_target_attribute_tree",
"(",
"tree",
"args",
",",
"struct",
"gcc_options",
"*",
"opts",
",",
"struct",
"gcc_options",
"*",
"opts_set",
")",
"{",
"struct",
"cl_target_option",
"cl_opts",
";",
"if",
"(",
"!",
"arm_valid_target_attribute_rec",
"(",
"args",
",",
"opts",
")",
")",
"return",
"NULL_TREE",
";",
"cl_target_option_save",
"(",
"&",
"cl_opts",
",",
"opts",
")",
";",
"arm_configure_build_target",
"(",
"&",
"arm_active_target",
",",
"&",
"cl_opts",
",",
"opts_set",
",",
"false",
")",
";",
"arm_option_check_internal",
"(",
"opts",
")",
";",
"arm_option_override_internal",
"(",
"opts",
",",
"opts_set",
")",
";",
"return",
"build_target_option_node",
"(",
"opts",
")",
";",
"}",
"</s>"
] | [
"Return",
"a",
"TARGET_OPTION_NODE",
"tree",
"of",
"the",
"target",
"options",
"listed",
"or",
"NULL",
"."
] | [
"arm"
] | arm6 | arm_valid_target_attribute_tree | arm | CPU | GCC | 17,434 | 74 | 1 | [] |
[
"<s>",
"void",
"SystemZPostRASchedStrategy",
"::",
"advanceTo",
"(",
"MachineBasicBlock",
"::",
"iterator",
"NextBegin",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"LastEmittedMI",
"=",
"HazardRec",
"->",
"getLastEmittedMI",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"(",
"(",
"LastEmittedMI",
"!=",
"nullptr",
"&&",
"LastEmittedMI",
"->",
"getParent",
"(",
")",
"==",
"MBB",
")",
"?",
"std",
"::",
"next",
"(",
"LastEmittedMI",
")",
":",
"MBB",
"->",
"begin",
"(",
")",
")",
";",
"for",
"(",
";",
"I",
"!=",
"NextBegin",
";",
"++",
"I",
")",
"{",
"if",
"(",
"I",
"->",
"isPosition",
"(",
")",
"||",
"I",
"->",
"isDebugInstr",
"(",
")",
")",
"continue",
";",
"HazardRec",
"->",
"emitInstruction",
"(",
"&",
"*",
"I",
")",
";",
"}",
"}",
"</s>"
] | [
"advanceTo",
"-",
"Advance",
"the",
"specified",
"iterator",
"to",
"point",
"to",
"the",
"Segment",
"containing",
"the",
"specified",
"position",
",",
"or",
"end",
"(",
")",
"if",
"the",
"position",
"is",
"past",
"the",
"end",
"of",
"the",
"range",
"."
] | [
"SystemZ",
"SystemZ"
] | SystemZMachineScheduler | advanceTo | SystemZ | CPU | LLVM | 17,435 | 94 | 1 | [] |
[
"<s>",
"TargetTransformInfo",
"NyuziTargetMachine",
"::",
"getTargetTransformInfo",
"(",
"const",
"Function",
"&",
"F",
")",
"{",
"return",
"TargetTransformInfo",
"(",
"NyuziTTIImpl",
"(",
"this",
",",
"F",
")",
")",
";",
"}",
"</s>"
] | [
"Get",
"a",
"TargetTransformInfo",
"implementation",
"for",
"the",
"target",
"."
] | [
"Nyuzi",
"Nyuzi",
"Nyuzi"
] | NyuziTargetMachine | getTargetTransformInfo | Nyuzi | GPU | LLVM | 17,436 | 23 | 1 | [] |
[
"<s>",
"unsigned",
"AMDGPUSubtarget",
"::",
"getMaxLocalMemSizeWithWaveCount",
"(",
"unsigned",
"NWaves",
")",
"const",
"{",
"switch",
"(",
"NWaves",
")",
"{",
"case",
"10",
":",
"return",
"1638",
";",
"case",
"9",
":",
"return",
"1820",
";",
"case",
"8",
":",
"return",
"2048",
";",
"case",
"7",
":",
"return",
"2340",
";",
"case",
"6",
":",
"return",
"2730",
";",
"case",
"5",
":",
"return",
"3276",
";",
"case",
"4",
":",
"return",
"4096",
";",
"case",
"3",
":",
"return",
"5461",
";",
"case",
"2",
":",
"return",
"8192",
";",
"default",
":",
"return",
"getLocalMemorySize",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"amount",
"of",
"LDS",
"that",
"can",
"be",
"used",
"that",
"will",
"not",
"restrict",
"the",
"occupancy",
"lower",
"than",
"WaveCount",
"."
] | [
"AMDGPU",
"AMDGPU",
"10",
"1638",
"9",
"1820",
"8",
"2048",
"7",
"2340",
"6",
"2730",
"5",
"3276",
"4",
"4096",
"3",
"5461",
"2",
"8192"
] | AMDGPUSubtarget109 | getMaxLocalMemSizeWithWaveCount | AMDGPU | GPU | LLVM | 17,437 | 78 | 1 | [] |
[
"<s>",
"bool",
"ARM64InstrInfo",
"::",
"analyzeCompare",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"&",
"SrcReg",
",",
"unsigned",
"&",
"SrcReg2",
",",
"int",
"&",
"CmpMask",
",",
"int",
"&",
"CmpValue",
")",
"const",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ARM64",
"::",
"SUBSWrr",
":",
"case",
"ARM64",
"::",
"SUBSWrs",
":",
"case",
"ARM64",
"::",
"SUBSWrx",
":",
"case",
"ARM64",
"::",
"SUBSXrr",
":",
"case",
"ARM64",
"::",
"SUBSXrs",
":",
"case",
"ARM64",
"::",
"SUBSXrx",
":",
"case",
"ARM64",
"::",
"ADDSWrr",
":",
"case",
"ARM64",
"::",
"ADDSWrs",
":",
"case",
"ARM64",
"::",
"ADDSWrx",
":",
"case",
"ARM64",
"::",
"ADDSXrr",
":",
"case",
"ARM64",
"::",
"ADDSXrs",
":",
"case",
"ARM64",
"::",
"ADDSXrx",
":",
"SrcReg",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"SrcReg2",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
";",
"CmpMask",
"=",
"~",
"0",
";",
"CmpValue",
"=",
"0",
";",
"return",
"true",
";",
"case",
"ARM64",
"::",
"SUBSWri",
":",
"case",
"ARM64",
"::",
"ADDSWri",
":",
"case",
"ARM64",
"::",
"SUBSXri",
":",
"case",
"ARM64",
"::",
"ADDSXri",
":",
"SrcReg",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"SrcReg2",
"=",
"0",
";",
"CmpMask",
"=",
"~",
"0",
";",
"CmpValue",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"return",
"true",
";",
"case",
"ARM64",
"::",
"ANDSWri",
":",
"case",
"ARM64",
"::",
"ANDSXri",
":",
"SrcReg",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"SrcReg2",
"=",
"0",
";",
"CmpMask",
"=",
"~",
"0",
";",
"CmpValue",
"=",
"ARM64_AM",
"::",
"decodeLogicalImmediate",
"(",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
",",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"ARM64",
"::",
"ANDSWri",
"?",
"32",
":",
"64",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"analyzeCompare",
"-",
"For",
"a",
"comparison",
"instruction",
",",
"return",
"the",
"source",
"registers",
"in",
"SrcReg",
"and",
"SrcReg2",
"if",
"having",
"two",
"register",
"operands",
",",
"and",
"the",
"value",
"it",
"compares",
"against",
"in",
"CmpValue",
"."
] | [
"ARM64",
"ARM64",
"ARM64::SUBSWrr",
"ARM64::SUBSWrs",
"ARM64::SUBSWrx",
"ARM64::SUBSXrr",
"ARM64::SUBSXrs",
"ARM64::SUBSXrx",
"ARM64::ADDSWrr",
"ARM64::ADDSWrs",
"ARM64::ADDSWrx",
"ARM64::ADDSXrr",
"ARM64::ADDSXrs",
"ARM64::ADDSXrx",
"1",
"2",
"0",
"0",
"ARM64::SUBSWri",
"ARM64::ADDSWri",
"ARM64::SUBSXri",
"ARM64::ADDSXri",
"1",
"0",
"0",
"2",
"ARM64::ANDSWri",
"ARM64::ANDSXri",
"1",
"0",
"0",
"ARM64_AM::decodeLogicalImmediate",
"2",
"ARM64::ANDSWri",
"32",
"64"
] | ARM64InstrInfo | analyzeCompare | ARM64 | CPU | LLVM | 17,438 | 269 | 1 | [] |
[
"<s>",
"bool",
"R600InstrInfo",
"::",
"isLegalToSplitMBBAt",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
")",
"const",
"{",
"for",
"(",
"MachineInstr",
"::",
"const_mop_iterator",
"I",
"=",
"MBBI",
"->",
"operands_begin",
"(",
")",
",",
"E",
"=",
"MBBI",
"->",
"operands_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"I",
"->",
"isReg",
"(",
")",
"&&",
"!",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"I",
"->",
"getReg",
"(",
")",
")",
"&&",
"I",
"->",
"isUse",
"(",
")",
"&&",
"RI",
".",
"isPhysRegLiveAcrossClauses",
"(",
"I",
"->",
"getReg",
"(",
")",
")",
")",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"'s",
"legal",
"to",
"split",
"the",
"given",
"basic",
"block",
"at",
"the",
"specified",
"instruction",
"(",
"i.e",
"."
] | [
"R600"
] | R600InstrInfo11 | isLegalToSplitMBBAt | R600 | GPU | LLVM | 17,439 | 90 | 1 | [] |
[
"<s>",
"static",
"bool",
"avr_pgm_check_var_decl",
"(",
"tree",
"node",
")",
"{",
"const",
"char",
"*",
"reason",
"=",
"NULL",
";",
"addr_space_t",
"as",
"=",
"ADDR_SPACE_GENERIC",
";",
"gcc_assert",
"(",
"as",
"==",
"0",
")",
";",
"if",
"(",
"avr_log",
".",
"progmem",
")",
"avr_edump",
"(",
"\"%?: %t\\n\"",
",",
"node",
")",
";",
"switch",
"(",
"TREE_CODE",
"(",
"node",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"VAR_DECL",
":",
"if",
"(",
"as",
"=",
"avr_nonconst_pointer_addrspace",
"(",
"TREE_TYPE",
"(",
"node",
")",
")",
",",
"as",
")",
"reason",
"=",
"\"variable\"",
";",
"break",
";",
"case",
"PARM_DECL",
":",
"if",
"(",
"as",
"=",
"avr_nonconst_pointer_addrspace",
"(",
"TREE_TYPE",
"(",
"node",
")",
")",
",",
"as",
")",
"reason",
"=",
"\"function parameter\"",
";",
"break",
";",
"case",
"FIELD_DECL",
":",
"if",
"(",
"as",
"=",
"avr_nonconst_pointer_addrspace",
"(",
"TREE_TYPE",
"(",
"node",
")",
")",
",",
"as",
")",
"reason",
"=",
"\"structure field\"",
";",
"break",
";",
"case",
"FUNCTION_DECL",
":",
"if",
"(",
"as",
"=",
"avr_nonconst_pointer_addrspace",
"(",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"node",
")",
")",
")",
",",
"as",
")",
"reason",
"=",
"\"return type of function\"",
";",
"break",
";",
"case",
"POINTER_TYPE",
":",
"if",
"(",
"as",
"=",
"avr_nonconst_pointer_addrspace",
"(",
"node",
")",
",",
"as",
")",
"reason",
"=",
"\"pointer\"",
";",
"break",
";",
"}",
"if",
"(",
"reason",
")",
"{",
"if",
"(",
"avr_addrspace",
"[",
"as",
"]",
".",
"segment",
">=",
"avr_n_flash",
")",
"{",
"if",
"(",
"TYPE_P",
"(",
"node",
")",
")",
"error",
"(",
"\"%qT uses address space %qs beyond flash of %d KiB\"",
",",
"node",
",",
"avr_addrspace",
"[",
"as",
"]",
".",
"name",
",",
"64",
"*",
"avr_n_flash",
")",
";",
"else",
"error",
"(",
"\"%s %q+D uses address space %qs beyond flash of %d KiB\"",
",",
"reason",
",",
"node",
",",
"avr_addrspace",
"[",
"as",
"]",
".",
"name",
",",
"64",
"*",
"avr_n_flash",
")",
";",
"}",
"else",
"{",
"if",
"(",
"TYPE_P",
"(",
"node",
")",
")",
"error",
"(",
"\"pointer targeting address space %qs must be const in %qT\"",
",",
"avr_addrspace",
"[",
"as",
"]",
".",
"name",
",",
"node",
")",
";",
"else",
"error",
"(",
"\"pointer targeting address space %qs must be const\"",
"\" in %s %q+D\"",
",",
"avr_addrspace",
"[",
"as",
"]",
".",
"name",
",",
"reason",
",",
"node",
")",
";",
"}",
"}",
"return",
"reason",
"==",
"NULL",
";",
"}",
"</s>"
] | [
"Sanity",
"check",
"NODE",
"so",
"that",
"all",
"pointers",
"targeting",
"non-generic",
"address",
"spaces",
"go",
"along",
"with",
"CONST",
"qualifier",
".",
"Writing",
"to",
"these",
"address",
"spaces",
"should",
"be",
"detected",
"and",
"complained",
"about",
"as",
"early",
"as",
"possible",
"."
] | [
"avr",
"0",
"\"%?: %t\\n\"",
"\"variable\"",
"\"function parameter\"",
"\"structure field\"",
"\"return type of function\"",
"\"pointer\"",
"\"%qT uses address space %qs beyond flash of %d KiB\"",
"64",
"\"%s %q+D uses address space %qs beyond flash of %d KiB\"",
"64",
"\"pointer targeting address space %qs must be const in %qT\"",
"\"pointer targeting address space %qs must be const\"",
"\" in %s %q+D\""
] | avr5 | avr_pgm_check_var_decl | avr | MPU | GCC | 17,440 | 281 | 1 | [] |
[
"<s>",
"bool",
"X86FrameLowering",
"::",
"assignCalleeSavedSpillSlots",
"(",
"MachineFunction",
"&",
"MF",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
")",
"const",
"{",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"X86RegisterInfo",
"*",
"RegInfo",
"=",
"static_cast",
"<",
"const",
"X86RegisterInfo",
"*",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
")",
";",
"unsigned",
"SlotSize",
"=",
"RegInfo",
"->",
"getSlotSize",
"(",
")",
";",
"X86MachineFunctionInfo",
"*",
"X86FI",
"=",
"MF",
".",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"CalleeSavedFrameSize",
"=",
"0",
";",
"int",
"SpillSlotOffset",
"=",
"getOffsetOfLocalArea",
"(",
")",
"+",
"X86FI",
"->",
"getTCReturnAddrDelta",
"(",
")",
";",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"{",
"SpillSlotOffset",
"-=",
"SlotSize",
";",
"MFI",
"->",
"CreateFixedSpillStackObject",
"(",
"SlotSize",
",",
"SpillSlotOffset",
")",
";",
"unsigned",
"FPReg",
"=",
"RegInfo",
"->",
"getFrameRegister",
"(",
"MF",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"CSI",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"if",
"(",
"TRI",
"->",
"regsOverlap",
"(",
"CSI",
"[",
"i",
"]",
".",
"getReg",
"(",
")",
",",
"FPReg",
")",
")",
"{",
"CSI",
".",
"erase",
"(",
"CSI",
".",
"begin",
"(",
")",
"+",
"i",
")",
";",
"break",
";",
"}",
"}",
"}",
"for",
"(",
"unsigned",
"i",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"0",
";",
"--",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"-",
"1",
"]",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"!",
"X86",
"::",
"GR64RegClass",
".",
"contains",
"(",
"Reg",
")",
"&&",
"!",
"X86",
"::",
"GR32RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"continue",
";",
"SpillSlotOffset",
"-=",
"SlotSize",
";",
"CalleeSavedFrameSize",
"+=",
"SlotSize",
";",
"int",
"SlotIndex",
"=",
"MFI",
"->",
"CreateFixedSpillStackObject",
"(",
"SlotSize",
",",
"SpillSlotOffset",
")",
";",
"CSI",
"[",
"i",
"-",
"1",
"]",
".",
"setFrameIdx",
"(",
"SlotIndex",
")",
";",
"}",
"X86FI",
"->",
"setCalleeSavedFrameSize",
"(",
"CalleeSavedFrameSize",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"0",
";",
"--",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"-",
"1",
"]",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"X86",
"::",
"GR64RegClass",
".",
"contains",
"(",
"Reg",
")",
"||",
"X86",
"::",
"GR32RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"continue",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"RegInfo",
"->",
"getMinimalPhysRegClass",
"(",
"Reg",
")",
";",
"SpillSlotOffset",
"-=",
"abs",
"(",
"SpillSlotOffset",
")",
"%",
"RC",
"->",
"getAlignment",
"(",
")",
";",
"SpillSlotOffset",
"-=",
"RC",
"->",
"getSize",
"(",
")",
";",
"int",
"SlotIndex",
"=",
"MFI",
"->",
"CreateFixedSpillStackObject",
"(",
"RC",
"->",
"getSize",
"(",
")",
",",
"SpillSlotOffset",
")",
";",
"CSI",
"[",
"i",
"-",
"1",
"]",
".",
"setFrameIdx",
"(",
"SlotIndex",
")",
";",
"MFI",
"->",
"ensureMaxAlignment",
"(",
"RC",
"->",
"getAlignment",
"(",
")",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"function",
"will",
"assign",
"callee",
"saved",
"gprs",
"to",
"volatile",
"vector",
"registers",
"for",
"prologue",
"spills",
"when",
"applicable",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"0",
"X86",
"0",
"0",
"1",
"X86::GR64RegClass",
"X86::GR32RegClass",
"1",
"X86",
"0",
"1",
"X86::GR64RegClass",
"X86::GR32RegClass",
"1"
] | X86FrameLowering120 | assignCalleeSavedSpillSlots | X86 | CPU | LLVM | 17,441 | 414 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isUsedByReturnOnly",
"(",
"SDNode",
"*",
"N",
",",
"SDValue",
"&",
"Chain",
")",
"const",
"{",
"if",
"(",
"N",
"->",
"getNumValues",
"(",
")",
"!=",
"1",
"||",
"!",
"N",
"->",
"hasNUsesOfValue",
"(",
"1",
",",
"0",
")",
")",
"return",
"false",
";",
"SDValue",
"TCChain",
"=",
"Chain",
";",
"SDNode",
"*",
"Copy",
"=",
"*",
"N",
"->",
"use_begin",
"(",
")",
";",
"if",
"(",
"Copy",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"CopyToReg",
")",
"{",
"if",
"(",
"Copy",
"->",
"getOperand",
"(",
"Copy",
"->",
"getNumOperands",
"(",
")",
"-",
"1",
")",
".",
"getValueType",
"(",
")",
"==",
"MVT",
"::",
"Glue",
")",
"return",
"false",
";",
"TCChain",
"=",
"Copy",
"->",
"getOperand",
"(",
"0",
")",
";",
"}",
"else",
"if",
"(",
"Copy",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"FP_EXTEND",
")",
"return",
"false",
";",
"bool",
"HasRet",
"=",
"false",
";",
"for",
"(",
"const",
"SDNode",
"*",
"U",
":",
"Copy",
"->",
"uses",
"(",
")",
")",
"{",
"if",
"(",
"U",
"->",
"getOpcode",
"(",
")",
"!=",
"X86ISD",
"::",
"RET_FLAG",
")",
"return",
"false",
";",
"if",
"(",
"U",
"->",
"getNumOperands",
"(",
")",
">",
"4",
")",
"return",
"false",
";",
"if",
"(",
"U",
"->",
"getNumOperands",
"(",
")",
"==",
"4",
"&&",
"U",
"->",
"getOperand",
"(",
"U",
"->",
"getNumOperands",
"(",
")",
"-",
"1",
")",
".",
"getValueType",
"(",
")",
"!=",
"MVT",
"::",
"Glue",
")",
"return",
"false",
";",
"HasRet",
"=",
"true",
";",
"}",
"if",
"(",
"!",
"HasRet",
")",
"return",
"false",
";",
"Chain",
"=",
"TCChain",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"result",
"of",
"the",
"specified",
"node",
"is",
"used",
"by",
"a",
"return",
"node",
"only",
"."
] | [
"X86",
"X86",
"1",
"1",
"0",
"ISD::CopyToReg",
"1",
"MVT::Glue",
"0",
"ISD::FP_EXTEND",
"X86ISD::RET_FLAG",
"4",
"4",
"1",
"MVT::Glue"
] | X86ISelLowering100 | isUsedByReturnOnly | X86 | CPU | LLVM | 17,442 | 221 | 1 | [] |
[
"<s>",
"bool",
"LanaiInstrInfo",
"::",
"reverseBranchCondition",
"(",
"SmallVectorImpl",
"<",
"llvm",
"::",
"MachineOperand",
">",
"&",
"Condition",
")",
"const",
"{",
"assert",
"(",
"(",
"Condition",
".",
"size",
"(",
")",
"==",
"1",
")",
"&&",
"\"Lanai branch conditions should have one component.\"",
")",
";",
"LPCC",
"::",
"CondCode",
"BranchCond",
"=",
"static_cast",
"<",
"LPCC",
"::",
"CondCode",
">",
"(",
"Condition",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
")",
";",
"Condition",
"[",
"0",
"]",
".",
"setImm",
"(",
"getOppositeCondition",
"(",
"BranchCond",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Reverses",
"the",
"branch",
"condition",
"of",
"the",
"specified",
"condition",
"list",
",",
"returning",
"false",
"on",
"success",
"and",
"true",
"if",
"it",
"can",
"not",
"be",
"reversed",
"."
] | [
"Lanai",
"Lanai",
"1",
"\"Lanai branch conditions should have one component.\"",
"0",
"0"
] | LanaiInstrInfo (2) | reverseBranchCondition | Lanai | CPU | LLVM | 17,443 | 70 | 1 | [] |
[
"<s>",
"static",
"void",
"mmix_reorg",
"(",
"void",
")",
"{",
"int",
"regno",
";",
"for",
"(",
"regno",
"=",
"MMIX_LAST_STACK_REGISTER_REGNUM",
";",
"regno",
">=",
"0",
";",
"regno",
"--",
")",
"if",
"(",
"(",
"regs_ever_live",
"[",
"regno",
"]",
"&&",
"!",
"call_used_regs",
"[",
"regno",
"]",
")",
"||",
"(",
"regno",
"==",
"MMIX_FRAME_POINTER_REGNUM",
"&&",
"frame_pointer_needed",
")",
")",
"break",
";",
"if",
"(",
"!",
"TARGET_ABI_GNU",
"&&",
"regno",
"<",
"current_function_args_info",
".",
"regs",
"-",
"1",
")",
"{",
"regno",
"=",
"current_function_args_info",
".",
"regs",
"-",
"1",
";",
"if",
"(",
"regno",
">",
"MMIX_RETURN_VALUE_REGNUM",
"-",
"1",
")",
"regno",
"=",
"MMIX_RETURN_VALUE_REGNUM",
"-",
"1",
";",
"}",
"cfun",
"->",
"machine",
"->",
"highest_saved_stack_register",
"=",
"regno",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_MACHINE_DEPENDENT_REORG",
".",
"No",
"actual",
"rearrangements",
"done",
"here",
";",
"just",
"virtually",
"by",
"calculating",
"the",
"highest",
"saved",
"stack",
"register",
"number",
"used",
"to",
"modify",
"the",
"register",
"numbers",
"at",
"output",
"time",
"."
] | [
"mmix",
"0",
"1",
"1",
"1",
"1"
] | mmix3 | mmix_reorg | mmix | CPU | GCC | 17,444 | 94 | 1 | [] |
[
"<s>",
"void",
"AArch64PassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"addPass",
"(",
"createAtomicExpandPass",
"(",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"EnableAtomicTidy",
")",
"addPass",
"(",
"createCFGSimplificationPass",
"(",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"EnableLoopDataPrefetch",
")",
"addPass",
"(",
"createLoopDataPrefetchPass",
"(",
")",
")",
";",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createInterleavedAccessPass",
"(",
")",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"==",
"CodeGenOpt",
"::",
"Aggressive",
"&&",
"EnableGEPOpt",
")",
"{",
"addPass",
"(",
"createSeparateConstOffsetFromGEPPass",
"(",
"TM",
",",
"true",
")",
")",
";",
"addPass",
"(",
"createEarlyCSEPass",
"(",
")",
")",
";",
"addPass",
"(",
"createLICMPass",
"(",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"AArch64",
"AArch64"
] | AArch64TargetMachine20 | addIRPasses | AArch64 | CPU | LLVM | 17,445 | 122 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isLegalAddImmediate",
"(",
"int64_t",
"Imm",
")",
"const",
"{",
"return",
"isInt",
"<",
"32",
">",
"(",
"Imm",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"specified",
"immediate",
"is",
"legal",
"add",
"immediate",
",",
"that",
"is",
"the",
"target",
"has",
"add",
"instructions",
"which",
"can",
"add",
"a",
"register",
"and",
"the",
"immediate",
"without",
"having",
"to",
"materialize",
"the",
"immediate",
"into",
"a",
"register",
"."
] | [
"X86",
"X86",
"32"
] | X86ISelLowering (2) | isLegalAddImmediate | X86 | CPU | LLVM | 17,446 | 20 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"i386_nlm_strip_name_encoding",
"(",
"const",
"char",
"*",
"str",
")",
"{",
"const",
"char",
"*",
"name",
"=",
"default_strip_name_encoding",
"(",
"str",
")",
";",
"if",
"(",
"*",
"str",
"!=",
"'*'",
"&&",
"(",
"*",
"name",
"==",
"'_'",
"||",
"*",
"name",
"==",
"'@'",
")",
")",
"{",
"const",
"char",
"*",
"p",
"=",
"strchr",
"(",
"name",
"+",
"1",
",",
"'@'",
")",
";",
"if",
"(",
"p",
")",
"{",
"++",
"name",
";",
"if",
"(",
"ISDIGIT",
"(",
"p",
"[",
"1",
"]",
")",
")",
"name",
"=",
"ggc_alloc_string",
"(",
"name",
",",
"p",
"-",
"name",
")",
";",
"else",
"{",
"gcc_assert",
"(",
"ISDIGIT",
"(",
"*",
"name",
")",
")",
";",
"name",
"++",
";",
"gcc_assert",
"(",
"name",
"==",
"p",
")",
";",
"}",
"}",
"}",
"return",
"name",
";",
"}",
"</s>"
] | [
"Strip",
"the",
"stdcall/fastcall/regparm",
"pre-/suffix",
"."
] | [
"i386",
"1",
"1"
] | netware | i386_nlm_strip_name_encoding | i386 | CPU | GCC | 17,447 | 112 | 1 | [] |
[
"<s>",
"int",
"GBZ80InstrInfo",
"::",
"getSPAdjust",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"GB",
"::",
"PUSH",
":",
"return",
"-",
"2",
";",
"case",
"GB",
"::",
"POP",
":",
"return",
"2",
";",
"case",
"GB",
"::",
"ADD_SP_e",
":",
"return",
"(",
"int8_t",
")",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"}",
"return",
"TargetInstrInfo",
"::",
"getSPAdjust",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"getSPAdjust",
"-",
"This",
"returns",
"the",
"stack",
"pointer",
"adjustment",
"made",
"by",
"this",
"instruction",
"."
] | [
"GBZ80",
"GB",
"GB::PUSH",
"2",
"GB::POP",
"2",
"GB::ADD_SP_e",
"0"
] | GBZ80InstrInfo | getSPAdjust | GBZ80 | MPU | LLVM | 17,448 | 68 | 1 | [] |
[
"<s>",
"int64_t",
"SIRegisterInfo",
"::",
"getFrameIndexInstrOffset",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"Idx",
")",
"const",
"{",
"if",
"(",
"!",
"SIInstrInfo",
"::",
"isMUBUF",
"(",
"*",
"MI",
")",
"&&",
"!",
"SIInstrInfo",
"::",
"isFLATScratch",
"(",
"*",
"MI",
")",
")",
"return",
"0",
";",
"assert",
"(",
"(",
"Idx",
"==",
"AMDGPU",
"::",
"getNamedOperandIdx",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
",",
"AMDGPU",
"::",
"OpName",
"::",
"vaddr",
")",
"||",
"(",
"Idx",
"==",
"AMDGPU",
"::",
"getNamedOperandIdx",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
",",
"AMDGPU",
"::",
"OpName",
"::",
"saddr",
")",
")",
")",
"&&",
"\"Should never see frame index on non-address operand\"",
")",
";",
"return",
"getScratchInstrOffset",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"Get",
"the",
"offset",
"from",
"the",
"referenced",
"frame",
"index",
"in",
"the",
"instruction",
",",
"if",
"there",
"is",
"one",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"0",
"AMDGPU::getNamedOperandIdx",
"AMDGPU::OpName",
"AMDGPU::getNamedOperandIdx",
"AMDGPU::OpName",
"\"Should never see frame index on non-address operand\""
] | SIRegisterInfo (3) | getFrameIndexInstrOffset | AMDGPU | GPU | LLVM | 17,449 | 92 | 1 | [] |
[
"<s>",
"unsigned",
"AMDGPUSubtarget",
"::",
"getOccupancyWithLocalMemSize",
"(",
"uint32_t",
"Bytes",
",",
"const",
"Function",
"&",
"F",
")",
"const",
"{",
"unsigned",
"WorkGroupSize",
"=",
"getFlatWorkGroupSizes",
"(",
"F",
")",
".",
"second",
";",
"unsigned",
"WorkGroupsPerCu",
"=",
"getMaxWorkGroupsPerCU",
"(",
"WorkGroupSize",
")",
";",
"if",
"(",
"!",
"WorkGroupsPerCu",
")",
"return",
"0",
";",
"unsigned",
"MaxWaves",
"=",
"getMaxWavesPerEU",
"(",
")",
";",
"unsigned",
"Limit",
"=",
"getLocalMemorySize",
"(",
")",
"*",
"MaxWaves",
"/",
"WorkGroupsPerCu",
";",
"unsigned",
"NumWaves",
"=",
"Limit",
"/",
"(",
"Bytes",
"?",
"Bytes",
":",
"1u",
")",
";",
"NumWaves",
"=",
"std",
"::",
"min",
"(",
"NumWaves",
",",
"MaxWaves",
")",
";",
"NumWaves",
"=",
"std",
"::",
"max",
"(",
"NumWaves",
",",
"1u",
")",
";",
"return",
"NumWaves",
";",
"}",
"</s>"
] | [
"Inverse",
"of",
"getMaxLocalMemWithWaveCount",
"."
] | [
"AMDGPU",
"AMDGPU",
"0",
"1u",
"1u"
] | AMDGPUSubtarget106 | getOccupancyWithLocalMemSize | AMDGPU | GPU | LLVM | 17,450 | 98 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"addRequired",
"<",
"MemorySSAWrapperPass",
">",
"(",
")",
";",
"AU",
".",
"setPreservesAll",
"(",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"AMDGPU"
] | AMDGPUPromoteKernelArguments1 | getAnalysisUsage | AMDGPU | GPU | LLVM | 17,451 | 26 | 1 | [] |
[
"<s>",
"int",
"mcore_dllimport_name_p",
"(",
"const",
"char",
"*",
"symbol",
")",
"{",
"return",
"symbol",
"[",
"0",
"]",
"==",
"'@'",
"&&",
"symbol",
"[",
"1",
"]",
"==",
"'i'",
"&&",
"symbol",
"[",
"2",
"]",
"==",
"'.'",
";",
"}",
"</s>"
] | [
"Return",
"non-zero",
"if",
"SYMBOL",
"is",
"marked",
"as",
"being",
"dllimport",
"'d",
"."
] | [
"mcore",
"0",
"1",
"2"
] | mcore | mcore_dllimport_name_p | mcore | MPU | GCC | 17,452 | 32 | 1 | [] |
[
"<s>",
"static",
"int",
"match_const_restriction",
"(",
"typeinfo",
"*",
"typedata",
")",
"{",
"int",
"oldpos",
"=",
"pos",
";",
"if",
"(",
"linebuf",
"[",
"pos",
"]",
"==",
"'<'",
")",
"{",
"safe_inc_pos",
"(",
")",
";",
"oldpos",
"=",
"pos",
";",
"char",
"*",
"x",
"=",
"match_integer",
"(",
")",
";",
"if",
"(",
"x",
"==",
"NULL",
")",
"{",
"diag",
"(",
"oldpos",
",",
"\"malformed integer.\\n\"",
")",
";",
"return",
"0",
";",
"}",
"consume_whitespace",
"(",
")",
";",
"if",
"(",
"linebuf",
"[",
"pos",
"]",
"==",
"'>'",
")",
"{",
"typedata",
"->",
"restr",
"=",
"RES_BITS",
";",
"typedata",
"->",
"val1",
"=",
"x",
";",
"safe_inc_pos",
"(",
")",
";",
"return",
"1",
";",
"}",
"else",
"if",
"(",
"linebuf",
"[",
"pos",
"]",
"!=",
"','",
")",
"{",
"diag",
"(",
"pos",
",",
"\"malformed restriction.\\n\"",
")",
";",
"return",
"0",
";",
"}",
"safe_inc_pos",
"(",
")",
";",
"oldpos",
"=",
"pos",
";",
"char",
"*",
"y",
"=",
"match_integer",
"(",
")",
";",
"if",
"(",
"y",
"==",
"NULL",
")",
"{",
"diag",
"(",
"oldpos",
",",
"\"malformed integer.\\n\"",
")",
";",
"return",
"0",
";",
"}",
"typedata",
"->",
"restr",
"=",
"RES_RANGE",
";",
"typedata",
"->",
"val1",
"=",
"x",
";",
"typedata",
"->",
"val2",
"=",
"y",
";",
"consume_whitespace",
"(",
")",
";",
"if",
"(",
"linebuf",
"[",
"pos",
"]",
"!=",
"'>'",
")",
"{",
"diag",
"(",
"pos",
",",
"\"malformed restriction.\\n\"",
")",
";",
"return",
"0",
";",
"}",
"safe_inc_pos",
"(",
")",
";",
"return",
"1",
";",
"}",
"else",
"if",
"(",
"match_bracketed_pair",
"(",
"typedata",
",",
"'{'",
",",
"'}'",
",",
"RES_VALUES",
")",
"||",
"match_bracketed_pair",
"(",
"typedata",
",",
"'['",
",",
"']'",
",",
"RES_VAR_RANGE",
")",
")",
"return",
"1",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"A",
"const",
"int",
"argument",
"may",
"be",
"restricted",
"to",
"certain",
"values",
".",
"This",
"is",
"indicated",
"by",
"one",
"of",
"the",
"following",
"occurring",
"after",
"the",
"``",
"int",
"'",
"token",
":",
"<",
"x",
">",
"restricts",
"the",
"constant",
"to",
"x",
"bits",
",",
"interpreted",
"as",
"unsigned",
"<",
"x",
",",
"y",
">",
"restricts",
"the",
"constant",
"to",
"the",
"inclusive",
"range",
"[",
"x",
",",
"y",
"]",
"[",
"x",
",",
"y",
"]",
"restricts",
"the",
"constant",
"to",
"the",
"inclusive",
"range",
"[",
"x",
",",
"y",
"]",
",",
"but",
"only",
"applies",
"if",
"the",
"argument",
"is",
"constant",
".",
"{",
"x",
",",
"y",
"}",
"restricts",
"the",
"constant",
"to",
"one",
"of",
"two",
"values",
",",
"x",
"or",
"y",
".",
"Here",
"x",
"and",
"y",
"are",
"integer",
"tokens",
".",
"Note",
"that",
"the",
"``",
"const",
"''",
"token",
"is",
"a",
"lie",
"when",
"the",
"restriction",
"is",
"[",
"x",
",",
"y",
"]",
",",
"but",
"this",
"simplifies",
"the",
"parsing",
"significantly",
"and",
"is",
"hopefully",
"forgivable",
".",
"Return",
"1",
"for",
"success",
",",
"else",
"0",
"."
] | [
"rs6000",
"\"malformed integer.\\n\"",
"0",
"1",
"\"malformed restriction.\\n\"",
"0",
"\"malformed integer.\\n\"",
"0",
"\"malformed restriction.\\n\"",
"0",
"1",
"1",
"0"
] | rs6000-gen-builtins | match_const_restriction | rs6000 | CPU | GCC | 17,453 | 231 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"arm_identify_fpu_from_isa",
"(",
"sbitmap",
"isa",
")",
"{",
"auto_sbitmap",
"fpubits",
"(",
"isa_num_bits",
")",
";",
"auto_sbitmap",
"cand_fpubits",
"(",
"isa_num_bits",
")",
";",
"bitmap_and",
"(",
"fpubits",
",",
"isa",
",",
"isa_all_fpubits",
")",
";",
"if",
"(",
"bitmap_empty_p",
"(",
"fpubits",
")",
")",
"return",
"\"softvfp\"",
";",
"for",
"(",
"unsigned",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"all_fpus",
")",
";",
"i",
"++",
")",
"{",
"arm_initialize_isa",
"(",
"cand_fpubits",
",",
"all_fpus",
"[",
"i",
"]",
".",
"isa_bits",
")",
";",
"if",
"(",
"bitmap_equal_p",
"(",
"fpubits",
",",
"cand_fpubits",
")",
")",
"return",
"all_fpus",
"[",
"i",
"]",
".",
"name",
";",
"}",
"gcc_unreachable",
"(",
")",
";",
"}",
"</s>"
] | [
"Match",
"an",
"ISA",
"feature",
"bitmap",
"to",
"a",
"named",
"FPU",
".",
"We",
"always",
"use",
"the",
"first",
"entry",
"that",
"exactly",
"matches",
"the",
"feature",
"set",
",",
"so",
"that",
"we",
"effectively",
"canonicalize",
"the",
"FPU",
"name",
"for",
"the",
"assembler",
"."
] | [
"arm",
"\"softvfp\"",
"0"
] | arm6 | arm_identify_fpu_from_isa | arm | CPU | GCC | 17,454 | 95 | 1 | [] |
[
"<s>",
"unsigned",
"ARMConstantIslands",
"::",
"getOffsetOf",
"(",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"MachineBasicBlock",
"*",
"MBB",
"=",
"MI",
"->",
"getParent",
"(",
")",
";",
"unsigned",
"Offset",
"=",
"BBInfo",
"[",
"MBB",
"->",
"getNumber",
"(",
")",
"]",
".",
"Offset",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
"->",
"begin",
"(",
")",
";",
"&",
"*",
"I",
"!=",
"MI",
";",
"++",
"I",
")",
"{",
"assert",
"(",
"I",
"!=",
"MBB",
"->",
"end",
"(",
")",
"&&",
"\"Didn't find MI in its own basic block?\"",
")",
";",
"Offset",
"+=",
"TII",
"->",
"GetInstSizeInBytes",
"(",
"*",
"I",
")",
";",
"}",
"return",
"Offset",
";",
"}",
"</s>"
] | [
"getOffsetOf",
"-",
"Return",
"the",
"current",
"offset",
"of",
"the",
"specified",
"machine",
"instruction",
"from",
"the",
"start",
"of",
"the",
"function",
"."
] | [
"ARM",
"ARM",
"\"Didn't find MI in its own basic block?\""
] | ARMConstantIslandPass44 | getOffsetOf | ARM | CPU | LLVM | 17,455 | 86 | 1 | [] |
[
"<s>",
"const",
"MipsSubtarget",
"*",
"MipsTargetMachine",
"::",
"getSubtargetImpl",
"(",
"const",
"Function",
"&",
"F",
")",
"const",
"{",
"Attribute",
"CPUAttr",
"=",
"F",
".",
"getFnAttribute",
"(",
"\"target-cpu\"",
")",
";",
"Attribute",
"FSAttr",
"=",
"F",
".",
"getFnAttribute",
"(",
"\"target-features\"",
")",
";",
"std",
"::",
"string",
"CPU",
"=",
"CPUAttr",
".",
"isValid",
"(",
")",
"?",
"CPUAttr",
".",
"getValueAsString",
"(",
")",
".",
"str",
"(",
")",
":",
"TargetCPU",
";",
"std",
"::",
"string",
"FS",
"=",
"FSAttr",
".",
"isValid",
"(",
")",
"?",
"FSAttr",
".",
"getValueAsString",
"(",
")",
".",
"str",
"(",
")",
":",
"TargetFS",
";",
"bool",
"hasMips16Attr",
"=",
"F",
".",
"getFnAttribute",
"(",
"\"mips16\"",
")",
".",
"isValid",
"(",
")",
";",
"bool",
"hasNoMips16Attr",
"=",
"F",
".",
"getFnAttribute",
"(",
"\"nomips16\"",
")",
".",
"isValid",
"(",
")",
";",
"bool",
"HasMicroMipsAttr",
"=",
"F",
".",
"getFnAttribute",
"(",
"\"micromips\"",
")",
".",
"isValid",
"(",
")",
";",
"bool",
"HasNoMicroMipsAttr",
"=",
"F",
".",
"getFnAttribute",
"(",
"\"nomicromips\"",
")",
".",
"isValid",
"(",
")",
";",
"bool",
"softFloat",
"=",
"F",
".",
"getFnAttribute",
"(",
"\"use-soft-float\"",
")",
".",
"getValueAsBool",
"(",
")",
";",
"if",
"(",
"hasMips16Attr",
")",
"FS",
"+=",
"FS",
".",
"empty",
"(",
")",
"?",
"\"+mips16\"",
":",
"\",+mips16\"",
";",
"else",
"if",
"(",
"hasNoMips16Attr",
")",
"FS",
"+=",
"FS",
".",
"empty",
"(",
")",
"?",
"\"-mips16\"",
":",
"\",-mips16\"",
";",
"if",
"(",
"HasMicroMipsAttr",
")",
"FS",
"+=",
"FS",
".",
"empty",
"(",
")",
"?",
"\"+micromips\"",
":",
"\",+micromips\"",
";",
"else",
"if",
"(",
"HasNoMicroMipsAttr",
")",
"FS",
"+=",
"FS",
".",
"empty",
"(",
")",
"?",
"\"-micromips\"",
":",
"\",-micromips\"",
";",
"if",
"(",
"softFloat",
")",
"FS",
"+=",
"FS",
".",
"empty",
"(",
")",
"?",
"\"+soft-float\"",
":",
"\",+soft-float\"",
";",
"auto",
"&",
"I",
"=",
"SubtargetMap",
"[",
"CPU",
"+",
"FS",
"]",
";",
"if",
"(",
"!",
"I",
")",
"{",
"resetTargetOptions",
"(",
"F",
")",
";",
"I",
"=",
"std",
"::",
"make_unique",
"<",
"MipsSubtarget",
">",
"(",
"TargetTriple",
",",
"CPU",
",",
"FS",
",",
"isLittle",
",",
"*",
"this",
",",
"MaybeAlign",
"(",
"Options",
".",
"StackAlignmentOverride",
")",
")",
";",
"}",
"return",
"I",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"Mips",
"Mips",
"Mips",
"\"target-cpu\"",
"\"target-features\"",
"Mips",
"\"mips16\"",
"Mips",
"\"nomips16\"",
"Mips",
"\"micromips\"",
"Mips",
"\"nomicromips\"",
"\"use-soft-float\"",
"Mips",
"\"+mips16\"",
"\",+mips16\"",
"Mips",
"\"-mips16\"",
"\",-mips16\"",
"Mips",
"\"+micromips\"",
"\",+micromips\"",
"Mips",
"\"-micromips\"",
"\",-micromips\"",
"\"+soft-float\"",
"\",+soft-float\"",
"Mips"
] | MipsTargetMachine41 | getSubtargetImpl | Mips | CPU | LLVM | 17,456 | 291 | 1 | [] |
[
"<s>",
"void",
"SIFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"const",
"SIMachineFunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"FuncInfo",
"->",
"isEntryFunction",
"(",
")",
")",
"return",
";",
"const",
"SISubtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"SISubtarget",
">",
"(",
")",
";",
"const",
"SIInstrInfo",
"*",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"getFirstTerminator",
"(",
")",
";",
"for",
"(",
"const",
"SIMachineFunctionInfo",
"::",
"SGPRSpillVGPRCSR",
"&",
"Reg",
":",
"FuncInfo",
"->",
"getSGPRSpillVGPRs",
"(",
")",
")",
"{",
"if",
"(",
"!",
"Reg",
".",
"FI",
".",
"hasValue",
"(",
")",
")",
"continue",
";",
"TII",
"->",
"loadRegFromStackSlot",
"(",
"MBB",
",",
"MBBI",
",",
"Reg",
".",
"VGPR",
",",
"Reg",
".",
"FI",
".",
"getValue",
"(",
")",
",",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
",",
"&",
"TII",
"->",
"getRegisterInfo",
"(",
")",
")",
";",
"}",
"unsigned",
"StackPtrReg",
"=",
"FuncInfo",
"->",
"getStackPtrOffsetReg",
"(",
")",
";",
"if",
"(",
"StackPtrReg",
"==",
"AMDGPU",
"::",
"NoRegister",
")",
"return",
";",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"uint32_t",
"NumBytes",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"NumBytes",
"!=",
"0",
"&&",
"hasSP",
"(",
"MF",
")",
")",
"{",
"uint32_t",
"RoundedSize",
"=",
"FuncInfo",
"->",
"isStackRealigned",
"(",
")",
"?",
"NumBytes",
"+",
"MFI",
".",
"getMaxAlignment",
"(",
")",
":",
"NumBytes",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_SUB_U32",
")",
",",
"StackPtrReg",
")",
".",
"addReg",
"(",
"StackPtrReg",
")",
".",
"addImm",
"(",
"RoundedSize",
"*",
"ST",
".",
"getWavefrontSize",
"(",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"SI",
"SI",
"SI",
"AMDGPU::VGPR_32RegClass",
"AMDGPU::NoRegister",
"0",
"AMDGPU::S_SUB_U32"
] | SIFrameLowering15 | emitEpilogue | AMDGPU | GPU | LLVM | 17,457 | 249 | 1 | [] |
[
"<s>",
"bool",
"AlphaTargetMachine",
"::",
"addPreEmitPass",
"(",
"PassManagerBase",
"&",
"PM",
",",
"bool",
"Fast",
")",
"{",
"PM",
".",
"add",
"(",
"createAlphaBranchSelectionPass",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"Alpha",
"Alpha",
"Alpha"
] | AlphaTargetMachine6 | addPreEmitPass | Alpha | MPU | LLVM | 17,458 | 26 | 1 | [] |
[
"<s>",
"static",
"rtx",
"avr_find_unused_d_reg",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"exclude",
")",
"{",
"bool",
"isr_p",
"=",
"(",
"avr_interrupt_function_p",
"(",
"current_function_decl",
")",
"||",
"avr_signal_function_p",
"(",
"current_function_decl",
")",
")",
";",
"for",
"(",
"int",
"regno",
"=",
"16",
";",
"regno",
"<",
"32",
";",
"regno",
"++",
")",
"{",
"rtx",
"reg",
"=",
"all_regs_rtx",
"[",
"regno",
"]",
";",
"if",
"(",
"(",
"exclude",
"&&",
"reg_overlap_mentioned_p",
"(",
"exclude",
",",
"reg",
")",
")",
"||",
"fixed_regs",
"[",
"regno",
"]",
")",
"{",
"continue",
";",
"}",
"if",
"(",
"!",
"df_regs_ever_live_p",
"(",
"regno",
")",
"&&",
"(",
"TREE_THIS_VOLATILE",
"(",
"current_function_decl",
")",
"||",
"cfun",
"->",
"machine",
"->",
"is_OS_task",
"||",
"cfun",
"->",
"machine",
"->",
"is_OS_main",
"||",
"(",
"!",
"isr_p",
"&&",
"call_used_regs",
"[",
"regno",
"]",
")",
")",
")",
"{",
"return",
"reg",
";",
"}",
"if",
"(",
"df_regs_ever_live_p",
"(",
"regno",
")",
"&&",
"reg_unused_after",
"(",
"insn",
",",
"reg",
")",
")",
"{",
"return",
"reg",
";",
"}",
"}",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Fixme",
":",
"This",
"is",
"a",
"hack",
"because",
"secondary",
"reloads",
"do",
"n't",
"works",
"as",
"expected",
".",
"Find",
"an",
"unused",
"d-register",
"to",
"be",
"used",
"as",
"scratch",
"in",
"INSN",
".",
"EXCLUDE",
"is",
"either",
"NULL_RTX",
"or",
"some",
"register",
".",
"In",
"the",
"case",
"where",
"EXCLUDE",
"is",
"a",
"register",
",",
"skip",
"all",
"possible",
"return",
"values",
"that",
"overlap",
"EXCLUDE",
".",
"The",
"policy",
"for",
"the",
"returned",
"register",
"is",
"similar",
"to",
"that",
"of",
"`",
"reg_unused_after",
"'",
",",
"i.e",
".",
"the",
"returned",
"register",
"may",
"overlap",
"the",
"SET_DEST",
"of",
"INSN",
".",
"Return",
"a",
"QImode",
"d-register",
"or",
"NULL_RTX",
"if",
"nothing",
"found",
"."
] | [
"avr",
"16",
"32"
] | avr6 | avr_find_unused_d_reg | avr | MPU | GCC | 17,459 | 138 | 1 | [] |
[
"<s>",
"bool",
"aarch64_sve_ldff1_operand_p",
"(",
"rtx",
"op",
")",
"{",
"if",
"(",
"!",
"MEM_P",
"(",
"op",
")",
")",
"return",
"false",
";",
"struct",
"aarch64_address_info",
"addr",
";",
"if",
"(",
"!",
"aarch64_classify_address",
"(",
"&",
"addr",
",",
"XEXP",
"(",
"op",
",",
"0",
")",
",",
"GET_MODE",
"(",
"op",
")",
",",
"false",
")",
")",
"return",
"false",
";",
"if",
"(",
"addr",
".",
"type",
"==",
"ADDRESS_REG_IMM",
")",
"return",
"known_eq",
"(",
"addr",
".",
"const_offset",
",",
"0",
")",
";",
"return",
"addr",
".",
"type",
"==",
"ADDRESS_REG_REG",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"OP",
"is",
"a",
"valid",
"MEM",
"operand",
"for",
"an",
"SVE",
"LDFF1",
"instruction",
"."
] | [
"aarch64",
"0",
"0"
] | aarch64 | aarch64_sve_ldff1_operand_p | aarch64 | CPU | GCC | 17,460 | 74 | 1 | [] |
[
"<s>",
"void",
"ia64_expand_unpack",
"(",
"rtx",
"operands",
"[",
"3",
"]",
",",
"bool",
"unsignedp",
",",
"bool",
"highp",
")",
"{",
"rtx",
"sign",
"=",
"ia64_unpack_sign",
"(",
"operands",
"[",
"1",
"]",
",",
"unsignedp",
")",
";",
"ia64_unpack_assemble",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"1",
"]",
",",
"sign",
",",
"highp",
")",
";",
"}",
"</s>"
] | [
"Emit",
"an",
"integral",
"vector",
"unpack",
"operation",
"."
] | [
"ia64",
"3",
"1",
"0",
"1"
] | ia64 | ia64_expand_unpack | ia64 | CPU | GCC | 17,461 | 47 | 1 | [] |
[
"<s>",
"static",
"void",
"*",
"rs6000_init_cost",
"(",
"struct",
"loop",
"*",
"loop_info",
")",
"{",
"rs6000_cost_data",
"*",
"data",
"=",
"XNEW",
"(",
"struct",
"_rs6000_cost_data",
")",
";",
"data",
"->",
"loop_info",
"=",
"loop_info",
";",
"data",
"->",
"cost",
"[",
"vect_prologue",
"]",
"=",
"0",
";",
"data",
"->",
"cost",
"[",
"vect_body",
"]",
"=",
"0",
";",
"data",
"->",
"cost",
"[",
"vect_epilogue",
"]",
"=",
"0",
";",
"rs6000_vect_nonmem",
"=",
"false",
";",
"return",
"data",
";",
"}",
"</s>"
] | [
"Implement",
"targetm.vectorize.init_cost",
"."
] | [
"rs6000",
"0",
"0",
"0"
] | rs6000 | rs6000_init_cost | rs6000 | CPU | GCC | 17,462 | 62 | 1 | [] |
[
"<s>",
"uint64_t",
"R600MCCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"const",
"MCOperand",
"&",
"MO",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixup",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"{",
"if",
"(",
"HAS_NATIVE_OPERANDS",
"(",
"MCII",
".",
"get",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
".",
"TSFlags",
")",
")",
"return",
"MRI",
".",
"getEncodingValue",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"return",
"getHWReg",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"}",
"assert",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
";",
"return",
"MO",
".",
"getImm",
"(",
")",
";",
"}",
"</s>"
] | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"AMDGPU",
"R600"
] | R600MCCodeEmitter21 | getMachineOpValue | AMDGPU | GPU | LLVM | 17,463 | 96 | 1 | [] |
[
"<s>",
"unsigned",
"RISCVAsmParser",
"::",
"validateTargetOperandClass",
"(",
"MCParsedAsmOperand",
"&",
"AsmOp",
",",
"unsigned",
"Kind",
")",
"{",
"RISCVOperand",
"&",
"Op",
"=",
"static_cast",
"<",
"RISCVOperand",
"&",
">",
"(",
"AsmOp",
")",
";",
"if",
"(",
"!",
"Op",
".",
"isReg",
"(",
")",
")",
"return",
"Match_InvalidOperand",
";",
"Register",
"Reg",
"=",
"Op",
".",
"getReg",
"(",
")",
";",
"bool",
"IsRegFPR32",
"=",
"RISCVMCRegisterClasses",
"[",
"RISCV",
"::",
"FPR32RegClassID",
"]",
".",
"contains",
"(",
"Reg",
")",
";",
"bool",
"IsRegFPR32C",
"=",
"RISCVMCRegisterClasses",
"[",
"RISCV",
"::",
"FPR32CRegClassID",
"]",
".",
"contains",
"(",
"Reg",
")",
";",
"if",
"(",
"(",
"IsRegFPR32",
"&&",
"Kind",
"==",
"MCK_FPR64",
")",
"||",
"(",
"IsRegFPR32C",
"&&",
"Kind",
"==",
"MCK_FPR64C",
")",
")",
"{",
"Op",
".",
"Reg",
".",
"RegNum",
"=",
"convertFPR32ToFPR64",
"(",
"Reg",
")",
";",
"return",
"Match_Success",
";",
"}",
"return",
"Match_InvalidOperand",
";",
"}",
"</s>"
] | [
"Allow",
"a",
"target",
"to",
"add",
"special",
"case",
"operand",
"matching",
"for",
"things",
"that",
"tblgen",
"doesn't/ca",
"n't",
"handle",
"effectively",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"RISCV",
"RISCV",
"RISCV::FPR32RegClassID",
"RISCV",
"RISCV::FPR32CRegClassID"
] | RISCVAsmParser46 | validateTargetOperandClass | RISCV | CPU | LLVM | 17,464 | 115 | 1 | [] |
[
"<s>",
"bool",
"isImm",
"(",
")",
"const",
"override",
"{",
"return",
"Kind",
"==",
"KindTy",
"::",
"Immediate",
";",
"}",
"</s>"
] | [
"isImm",
"-",
"Is",
"this",
"an",
"immediate",
"operand",
"?"
] | [
"RISCV"
] | RISCVAsmParser (2) | isImm | RISCV | CPU | LLVM | 17,465 | 15 | 1 | [] |
[
"<s>",
"static",
"bool",
"rs6000_debug_mode_dependent_address",
"(",
"const_rtx",
"addr",
")",
"{",
"bool",
"ret",
"=",
"rs6000_mode_dependent_address",
"(",
"addr",
")",
";",
"fprintf",
"(",
"stderr",
",",
"\"\\nrs6000_mode_dependent_address: ret = %s\\n\"",
",",
"ret",
"?",
"\"true\"",
":",
"\"false\"",
")",
";",
"debug_rtx",
"(",
"addr",
")",
";",
"return",
"ret",
";",
"}",
"</s>"
] | [
"Debug",
"version",
"of",
"rs6000_mode_dependent_address",
"."
] | [
"powerpcspe",
"\"\\nrs6000_mode_dependent_address: ret = %s\\n\"",
"\"true\"",
"\"false\""
] | powerpcspe | rs6000_debug_mode_dependent_address | powerpcspe | CPU | GCC | 17,466 | 38 | 1 | [] |
[
"<s>",
"static",
"rtx_insn",
"*",
"rs6000_emit_savres_rtx",
"(",
"rs6000_stack_t",
"*",
"info",
",",
"rtx",
"frame_reg_rtx",
",",
"int",
"save_area_offset",
",",
"int",
"lr_offset",
",",
"machine_mode",
"reg_mode",
",",
"int",
"sel",
")",
"{",
"int",
"i",
";",
"int",
"offset",
",",
"start_reg",
",",
"end_reg",
",",
"n_regs",
",",
"use_reg",
";",
"int",
"reg_size",
"=",
"GET_MODE_SIZE",
"(",
"reg_mode",
")",
";",
"rtx",
"sym",
";",
"rtvec",
"p",
";",
"rtx",
"par",
";",
"rtx_insn",
"*",
"insn",
";",
"offset",
"=",
"0",
";",
"start_reg",
"=",
"(",
"(",
"sel",
"&",
"SAVRES_REG",
")",
"==",
"SAVRES_GPR",
"?",
"info",
"->",
"first_gp_reg_save",
":",
"(",
"sel",
"&",
"SAVRES_REG",
")",
"==",
"SAVRES_FPR",
"?",
"info",
"->",
"first_fp_reg_save",
":",
"(",
"sel",
"&",
"SAVRES_REG",
")",
"==",
"SAVRES_VR",
"?",
"info",
"->",
"first_altivec_reg_save",
":",
"-",
"1",
")",
";",
"end_reg",
"=",
"(",
"(",
"sel",
"&",
"SAVRES_REG",
")",
"==",
"SAVRES_GPR",
"?",
"32",
":",
"(",
"sel",
"&",
"SAVRES_REG",
")",
"==",
"SAVRES_FPR",
"?",
"64",
":",
"(",
"sel",
"&",
"SAVRES_REG",
")",
"==",
"SAVRES_VR",
"?",
"LAST_ALTIVEC_REGNO",
"+",
"1",
":",
"-",
"1",
")",
";",
"n_regs",
"=",
"end_reg",
"-",
"start_reg",
";",
"p",
"=",
"rtvec_alloc",
"(",
"3",
"+",
"(",
"(",
"sel",
"&",
"SAVRES_LR",
")",
"?",
"1",
":",
"0",
")",
"+",
"(",
"(",
"sel",
"&",
"SAVRES_REG",
")",
"==",
"SAVRES_VR",
"?",
"1",
":",
"0",
")",
"+",
"n_regs",
")",
";",
"if",
"(",
"!",
"(",
"sel",
"&",
"SAVRES_SAVE",
")",
"&&",
"(",
"sel",
"&",
"SAVRES_LR",
")",
")",
"RTVEC_ELT",
"(",
"p",
",",
"offset",
"++",
")",
"=",
"ret_rtx",
";",
"RTVEC_ELT",
"(",
"p",
",",
"offset",
"++",
")",
"=",
"gen_rtx_CLOBBER",
"(",
"VOIDmode",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"LR_REGNO",
")",
")",
";",
"sym",
"=",
"rs6000_savres_routine_sym",
"(",
"info",
",",
"sel",
")",
";",
"RTVEC_ELT",
"(",
"p",
",",
"offset",
"++",
")",
"=",
"gen_rtx_USE",
"(",
"VOIDmode",
",",
"sym",
")",
";",
"use_reg",
"=",
"ptr_regno_for_savres",
"(",
"sel",
")",
";",
"if",
"(",
"(",
"sel",
"&",
"SAVRES_REG",
")",
"==",
"SAVRES_VR",
")",
"{",
"RTVEC_ELT",
"(",
"p",
",",
"offset",
"++",
")",
"=",
"gen_rtx_CLOBBER",
"(",
"VOIDmode",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"use_reg",
")",
")",
";",
"RTVEC_ELT",
"(",
"p",
",",
"offset",
"++",
")",
"=",
"gen_rtx_USE",
"(",
"VOIDmode",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"0",
")",
")",
";",
"}",
"else",
"RTVEC_ELT",
"(",
"p",
",",
"offset",
"++",
")",
"=",
"gen_rtx_USE",
"(",
"VOIDmode",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"use_reg",
")",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"end_reg",
"-",
"start_reg",
";",
"i",
"++",
")",
"RTVEC_ELT",
"(",
"p",
",",
"i",
"+",
"offset",
")",
"=",
"gen_frame_set",
"(",
"gen_rtx_REG",
"(",
"reg_mode",
",",
"start_reg",
"+",
"i",
")",
",",
"frame_reg_rtx",
",",
"save_area_offset",
"+",
"reg_size",
"*",
"i",
",",
"(",
"sel",
"&",
"SAVRES_SAVE",
")",
"!=",
"0",
")",
";",
"if",
"(",
"(",
"sel",
"&",
"SAVRES_SAVE",
")",
"&&",
"(",
"sel",
"&",
"SAVRES_LR",
")",
")",
"RTVEC_ELT",
"(",
"p",
",",
"i",
"+",
"offset",
")",
"=",
"gen_frame_store",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"0",
")",
",",
"frame_reg_rtx",
",",
"lr_offset",
")",
";",
"par",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"p",
")",
";",
"if",
"(",
"!",
"(",
"sel",
"&",
"SAVRES_SAVE",
")",
"&&",
"(",
"sel",
"&",
"SAVRES_LR",
")",
")",
"{",
"insn",
"=",
"emit_jump_insn",
"(",
"par",
")",
";",
"JUMP_LABEL",
"(",
"insn",
")",
"=",
"ret_rtx",
";",
"}",
"else",
"insn",
"=",
"emit_insn",
"(",
"par",
")",
";",
"return",
"insn",
";",
"}",
"</s>"
] | [
"Construct",
"a",
"parallel",
"rtx",
"describing",
"the",
"effect",
"of",
"a",
"call",
"to",
"an",
"out-of-line",
"register",
"save/restore",
"routine",
",",
"and",
"emit",
"the",
"insn",
"or",
"jump_insn",
"as",
"appropriate",
"."
] | [
"rs6000",
"0",
"1",
"32",
"64",
"1",
"1",
"3",
"1",
"0",
"1",
"0",
"0",
"0",
"0",
"0"
] | rs60006 | rs6000_emit_savres_rtx | rs6000 | CPU | GCC | 17,467 | 477 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"ix86_output_indirect_function_return",
"(",
"rtx",
"ret_op",
")",
"{",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"function_return_type",
"!=",
"indirect_branch_keep",
")",
"{",
"char",
"thunk_name",
"[",
"32",
"]",
";",
"enum",
"indirect_thunk_prefix",
"need_prefix",
"=",
"indirect_thunk_need_prefix",
"(",
"current_output_insn",
")",
";",
"unsigned",
"int",
"regno",
"=",
"REGNO",
"(",
"ret_op",
")",
";",
"gcc_assert",
"(",
"regno",
"==",
"CX_REG",
")",
";",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"function_return_type",
"!=",
"indirect_branch_thunk_inline",
")",
"{",
"bool",
"need_thunk",
"=",
"(",
"cfun",
"->",
"machine",
"->",
"function_return_type",
"==",
"indirect_branch_thunk",
")",
";",
"indirect_thunk_name",
"(",
"thunk_name",
",",
"regno",
",",
"need_prefix",
",",
"true",
")",
";",
"if",
"(",
"need_thunk",
")",
"{",
"indirect_return_via_cx",
"=",
"true",
";",
"indirect_thunks_used",
"|=",
"1",
"<<",
"CX_REG",
";",
"}",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\tjmp\\t%s\\n\"",
",",
"thunk_name",
")",
";",
"}",
"else",
"output_indirect_thunk",
"(",
"regno",
")",
";",
"return",
"\"\"",
";",
"}",
"else",
"return",
"\"%!jmp\\t%A0\"",
";",
"}",
"</s>"
] | [
"Output",
"indirect",
"function",
"return",
".",
"RET_OP",
"is",
"the",
"function",
"return",
"target",
"."
] | [
"i386",
"32",
"1",
"\"\\tjmp\\t%s\\n\"",
"\"\"",
"\"%!jmp\\t%A0\""
] | i3868 | ix86_output_indirect_function_return | i386 | CPU | GCC | 17,468 | 127 | 1 | [] |
[
"<s>",
"static",
"std",
"::",
"string",
"getNodeLabel",
"(",
"const",
"SUnit",
"*",
"SU",
",",
"const",
"ScheduleDAG",
"*",
"G",
")",
"{",
"std",
"::",
"string",
"Str",
";",
"raw_string_ostream",
"SS",
"(",
"Str",
")",
";",
"SS",
"<<",
"\"SU(\"",
"<<",
"SU",
"->",
"NodeNum",
"<<",
"\")[\"",
"<<",
"SU",
"->",
"Latency",
"<<",
"\"]\"",
";",
"return",
"SS",
".",
"str",
"(",
")",
";",
"}",
"</s>"
] | [
"Print",
"a",
"DDG",
"node",
"either",
"in",
"concise",
"form",
"(",
"-ddg-dot-only",
")",
"or",
"verbose",
"mode",
"(",
"-ddg-dot",
")",
"."
] | [
"Patmos",
"\"SU(\"",
"\")[\"",
"\"]\""
] | PatmosPostRAScheduler | getNodeLabel | Patmos | VLIW | LLVM | 17,469 | 52 | 1 | [] |
[
"<s>",
"unsigned",
"SIRegisterInfo",
"::",
"getRegPressureLimit",
"(",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"Occupancy",
"=",
"ST",
".",
"getOccupancyWithLocalMemSize",
"(",
"MFI",
"->",
"getLDSSize",
"(",
")",
",",
"MF",
".",
"getFunction",
"(",
")",
")",
";",
"switch",
"(",
"RC",
"->",
"getID",
"(",
")",
")",
"{",
"default",
":",
"return",
"AMDGPUGenRegisterInfo",
"::",
"getRegPressureLimit",
"(",
"RC",
",",
"MF",
")",
";",
"case",
"AMDGPU",
"::",
"VGPR_32RegClassID",
":",
"case",
"AMDGPU",
"::",
"VGPR_LO16RegClassID",
":",
"case",
"AMDGPU",
"::",
"VGPR_HI16RegClassID",
":",
"return",
"std",
"::",
"min",
"(",
"ST",
".",
"getMaxNumVGPRs",
"(",
"Occupancy",
")",
",",
"ST",
".",
"getMaxNumVGPRs",
"(",
"MF",
")",
")",
";",
"case",
"AMDGPU",
"::",
"SGPR_32RegClassID",
":",
"return",
"std",
"::",
"min",
"(",
"ST",
".",
"getMaxNumSGPRs",
"(",
"Occupancy",
",",
"true",
")",
",",
"ST",
".",
"getMaxNumSGPRs",
"(",
"MF",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"register",
"pressure",
"``",
"high",
"water",
"mark",
"''",
"for",
"the",
"specific",
"register",
"class",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"AMDGPU",
"AMDGPU::VGPR_32RegClassID",
"AMDGPU::VGPR_LO16RegClassID",
"AMDGPU::VGPR_HI16RegClassID",
"AMDGPU::SGPR_32RegClassID"
] | SIRegisterInfo17 | getRegPressureLimit | AMDGPU | GPU | LLVM | 17,470 | 135 | 1 | [] |
[
"<s>",
"const",
"MCExpr",
"*",
"getSubExpr",
"(",
")",
"const",
"{",
"return",
"Expr",
";",
"}",
"</s>"
] | [
"getSubExpr",
"-",
"Get",
"the",
"child",
"of",
"this",
"expression",
"."
] | [
"ARM"
] | ARMMCExpr | getSubExpr | ARM | CPU | LLVM | 17,471 | 12 | 1 | [] |
[
"<s>",
"TargetFrameLowering",
"::",
"DwarfFrameBase",
"WebAssemblyFrameLowering",
"::",
"getDwarfFrameBase",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"DwarfFrameBase",
"Loc",
";",
"Loc",
".",
"Kind",
"=",
"DwarfFrameBase",
"::",
"WasmFrameBase",
";",
"const",
"WebAssemblyFunctionInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getInfo",
"<",
"WebAssemblyFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"needsSP",
"(",
"MF",
")",
")",
"{",
"unsigned",
"LocalNum",
"=",
"MFI",
".",
"getFrameBaseLocal",
"(",
")",
";",
"Loc",
".",
"Location",
".",
"WasmLoc",
"=",
"{",
"WebAssembly",
"::",
"TI_LOCAL_START",
",",
"LocalNum",
"}",
";",
"}",
"else",
"{",
"Loc",
".",
"Location",
".",
"WasmLoc",
"=",
"{",
"WebAssembly",
"::",
"TI_GLOBAL_START",
",",
"0",
"}",
";",
"}",
"return",
"Loc",
";",
"}",
"</s>"
] | [
"Return",
"the",
"frame",
"base",
"information",
"to",
"be",
"encoded",
"in",
"the",
"DWARF",
"subprogram",
"debug",
"info",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly",
"WebAssembly",
"WebAssembly::TI_LOCAL_START",
"WebAssembly::TI_GLOBAL_START",
"0"
] | WebAssemblyFrameLowering5 | getDwarfFrameBase | WebAssembly | Virtual ISA | LLVM | 17,472 | 93 | 1 | [] |
[
"<s>",
"bool",
"X86CallLowering",
"::",
"lowerReturn",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Value",
"*",
"Val",
",",
"unsigned",
"VReg",
")",
"const",
"{",
"assert",
"(",
"(",
"(",
"Val",
"&&",
"VReg",
")",
"||",
"(",
"!",
"Val",
"&&",
"!",
"VReg",
")",
")",
"&&",
"\"Return value without a vreg\"",
")",
";",
"auto",
"MIB",
"=",
"MIRBuilder",
".",
"buildInstrNoInsert",
"(",
"X86",
"::",
"RET",
")",
".",
"addImm",
"(",
"0",
")",
";",
"if",
"(",
"VReg",
")",
"{",
"MachineFunction",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"auto",
"&",
"DL",
"=",
"MF",
".",
"getDataLayout",
"(",
")",
";",
"const",
"Function",
"&",
"F",
"=",
"*",
"MF",
".",
"getFunction",
"(",
")",
";",
"ArgInfo",
"OrigArg",
"{",
"VReg",
",",
"Val",
"->",
"getType",
"(",
")",
"}",
";",
"setArgFlags",
"(",
"OrigArg",
",",
"AttributeList",
"::",
"ReturnIndex",
",",
"DL",
",",
"F",
")",
";",
"SmallVector",
"<",
"ArgInfo",
",",
"8",
">",
"SplitArgs",
";",
"splitToValueTypes",
"(",
"OrigArg",
",",
"SplitArgs",
",",
"DL",
",",
"MRI",
",",
"[",
"&",
"]",
"(",
"ArrayRef",
"<",
"unsigned",
">",
"Regs",
")",
"{",
"MIRBuilder",
".",
"buildUnmerge",
"(",
"Regs",
",",
"VReg",
")",
";",
"}",
")",
";",
"FuncReturnHandler",
"Handler",
"(",
"MIRBuilder",
",",
"MRI",
",",
"MIB",
",",
"RetCC_X86",
")",
";",
"if",
"(",
"!",
"handleAssignments",
"(",
"MIRBuilder",
",",
"SplitArgs",
",",
"Handler",
")",
")",
"return",
"false",
";",
"}",
"MIRBuilder",
".",
"insertInstr",
"(",
"MIB",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"hook",
"behaves",
"as",
"the",
"extended",
"lowerReturn",
"function",
",",
"but",
"for",
"targets",
"that",
"do",
"not",
"support",
"swifterror",
"value",
"promotion",
"."
] | [
"X86",
"X86",
"\"Return value without a vreg\"",
"X86::RET",
"0",
"8",
"X86"
] | X86CallLowering6 | lowerReturn | X86 | CPU | LLVM | 17,473 | 209 | 1 | [] |
[
"<s>",
"SDValue",
"X86TargetLowering",
"::",
"getSqrtEstimate",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
",",
"int",
"Enabled",
",",
"int",
"&",
"RefinementSteps",
",",
"bool",
"&",
"UseOneConstNR",
",",
"bool",
"Reciprocal",
")",
"const",
"{",
"SDLoc",
"DL",
"(",
"Op",
")",
";",
"EVT",
"VT",
"=",
"Op",
".",
"getValueType",
"(",
")",
";",
"if",
"(",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
"&&",
"Subtarget",
".",
"hasSSE1",
"(",
")",
")",
"||",
"(",
"VT",
"==",
"MVT",
"::",
"v4f32",
"&&",
"Subtarget",
".",
"hasSSE1",
"(",
")",
"&&",
"Reciprocal",
")",
"||",
"(",
"VT",
"==",
"MVT",
"::",
"v4f32",
"&&",
"Subtarget",
".",
"hasSSE2",
"(",
")",
"&&",
"!",
"Reciprocal",
")",
"||",
"(",
"VT",
"==",
"MVT",
"::",
"v8f32",
"&&",
"Subtarget",
".",
"hasAVX",
"(",
")",
")",
"||",
"(",
"VT",
"==",
"MVT",
"::",
"v16f32",
"&&",
"Subtarget",
".",
"useAVX512Regs",
"(",
")",
")",
")",
"{",
"if",
"(",
"RefinementSteps",
"==",
"ReciprocalEstimate",
"::",
"Unspecified",
")",
"RefinementSteps",
"=",
"1",
";",
"UseOneConstNR",
"=",
"false",
";",
"unsigned",
"Opcode",
"=",
"VT",
"==",
"MVT",
"::",
"v16f32",
"?",
"X86ISD",
"::",
"RSQRT14",
":",
"X86ISD",
"::",
"FRSQRT",
";",
"return",
"DAG",
".",
"getNode",
"(",
"Opcode",
",",
"DL",
",",
"VT",
",",
"Op",
")",
";",
"}",
"if",
"(",
"VT",
".",
"getScalarType",
"(",
")",
"==",
"MVT",
"::",
"f16",
"&&",
"isTypeLegal",
"(",
"VT",
")",
"&&",
"Subtarget",
".",
"hasFP16",
"(",
")",
")",
"{",
"if",
"(",
"RefinementSteps",
"==",
"ReciprocalEstimate",
"::",
"Unspecified",
")",
"RefinementSteps",
"=",
"0",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f16",
")",
"{",
"SDValue",
"Zero",
"=",
"DAG",
".",
"getIntPtrConstant",
"(",
"0",
",",
"DL",
")",
";",
"SDValue",
"Undef",
"=",
"DAG",
".",
"getUNDEF",
"(",
"MVT",
"::",
"v8f16",
")",
";",
"Op",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SCALAR_TO_VECTOR",
",",
"DL",
",",
"MVT",
"::",
"v8f16",
",",
"Op",
")",
";",
"Op",
"=",
"DAG",
".",
"getNode",
"(",
"X86ISD",
"::",
"RSQRT14S",
",",
"DL",
",",
"MVT",
"::",
"v8f16",
",",
"Undef",
",",
"Op",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
",",
"DL",
",",
"MVT",
"::",
"f16",
",",
"Op",
",",
"Zero",
")",
";",
"}",
"return",
"DAG",
".",
"getNode",
"(",
"X86ISD",
"::",
"RSQRT14",
",",
"DL",
",",
"VT",
",",
"Op",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"Hooks",
"for",
"building",
"estimates",
"in",
"place",
"of",
"slower",
"divisions",
"and",
"square",
"roots",
"."
] | [
"X86",
"X86",
"MVT::f32",
"MVT::v4f32",
"MVT::v4f32",
"MVT::v8f32",
"MVT::v16f32",
"1",
"MVT::v16f32",
"X86ISD::RSQRT14",
"X86ISD::FRSQRT",
"MVT::f16",
"0",
"MVT::f16",
"0",
"MVT::v8f16",
"ISD::SCALAR_TO_VECTOR",
"MVT::v8f16",
"X86ISD::RSQRT14S",
"MVT::v8f16",
"ISD::EXTRACT_VECTOR_ELT",
"MVT::f16",
"X86ISD::RSQRT14"
] | X86ISelLowering (2)5 | getSqrtEstimate | X86 | CPU | LLVM | 17,474 | 322 | 1 | [] |
[
"<s>",
"unsigned",
"MBlazeMCCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"const",
"MCOperand",
"&",
"MO",
")",
"const",
"{",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"return",
"MBlazeRegisterInfo",
"::",
"getRegisterNumbering",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"else",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"static_cast",
"<",
"unsigned",
">",
"(",
"MO",
".",
"getImm",
"(",
")",
")",
";",
"else",
"if",
"(",
"MO",
".",
"isExpr",
"(",
")",
")",
"return",
"0",
";",
"else",
"{",
"errs",
"(",
")",
"<<",
"MO",
";",
"llvm_unreachable",
"(",
"0",
")",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"MBlaze",
"MBlaze",
"MBlaze",
"0",
"0",
"0"
] | MBlazeMCCodeEmitter | getMachineOpValue | MBlaze | MPU | LLVM | 17,475 | 89 | 1 | [] |
[
"<s>",
"SDValue",
"MipsTargetLowering",
"::",
"LowerCallResult",
"(",
"SDValue",
"Chain",
",",
"SDValue",
"InFlag",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"const",
"SDLoc",
"&",
"DL",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
",",
"TargetLowering",
"::",
"CallLoweringInfo",
"&",
"CLI",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"MipsCCState",
"CCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeCallResult",
"(",
"Ins",
",",
"RetCC_Mips",
",",
"CLI",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Can only return in registers!\"",
")",
";",
"SDValue",
"Val",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"DL",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getLocReg",
"(",
")",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getLocVT",
"(",
")",
",",
"InFlag",
")",
";",
"Chain",
"=",
"Val",
".",
"getValue",
"(",
"1",
")",
";",
"InFlag",
"=",
"Val",
".",
"getValue",
"(",
"2",
")",
";",
"if",
"(",
"VA",
".",
"isUpperBitsInLoc",
"(",
")",
")",
"{",
"unsigned",
"ValSizeInBits",
"=",
"Ins",
"[",
"i",
"]",
".",
"ArgVT",
".",
"getSizeInBits",
"(",
")",
";",
"unsigned",
"LocSizeInBits",
"=",
"VA",
".",
"getLocVT",
"(",
")",
".",
"getSizeInBits",
"(",
")",
";",
"unsigned",
"Shift",
"=",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"ZExtUpper",
"?",
"ISD",
"::",
"SRL",
":",
"ISD",
"::",
"SRA",
";",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"Shift",
",",
"DL",
",",
"VA",
".",
"getLocVT",
"(",
")",
",",
"Val",
",",
"DAG",
".",
"getConstant",
"(",
"LocSizeInBits",
"-",
"ValSizeInBits",
",",
"DL",
",",
"VA",
".",
"getLocVT",
"(",
")",
")",
")",
";",
"}",
"switch",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unknown loc info!\"",
")",
";",
"case",
"CCValAssign",
"::",
"Full",
":",
"break",
";",
"case",
"CCValAssign",
"::",
"BCvt",
":",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BITCAST",
",",
"DL",
",",
"VA",
".",
"getValVT",
"(",
")",
",",
"Val",
")",
";",
"break",
";",
"case",
"CCValAssign",
"::",
"AExt",
":",
"case",
"CCValAssign",
"::",
"AExtUpper",
":",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TRUNCATE",
",",
"DL",
",",
"VA",
".",
"getValVT",
"(",
")",
",",
"Val",
")",
";",
"break",
";",
"case",
"CCValAssign",
"::",
"ZExt",
":",
"case",
"CCValAssign",
"::",
"ZExtUpper",
":",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AssertZext",
",",
"DL",
",",
"VA",
".",
"getLocVT",
"(",
")",
",",
"Val",
",",
"DAG",
".",
"getValueType",
"(",
"VA",
".",
"getValVT",
"(",
")",
")",
")",
";",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TRUNCATE",
",",
"DL",
",",
"VA",
".",
"getValVT",
"(",
")",
",",
"Val",
")",
";",
"break",
";",
"case",
"CCValAssign",
"::",
"SExt",
":",
"case",
"CCValAssign",
"::",
"SExtUpper",
":",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AssertSext",
",",
"DL",
",",
"VA",
".",
"getLocVT",
"(",
")",
",",
"Val",
",",
"DAG",
".",
"getValueType",
"(",
"VA",
".",
"getValVT",
"(",
")",
")",
")",
";",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TRUNCATE",
",",
"DL",
",",
"VA",
".",
"getValVT",
"(",
")",
",",
"Val",
")",
";",
"break",
";",
"}",
"InVals",
".",
"push_back",
"(",
"Val",
")",
";",
"}",
"return",
"Chain",
";",
"}",
"</s>"
] | [
"LowerCallResult",
"-",
"Lower",
"the",
"result",
"values",
"of",
"an",
"ISD",
":",
":CALL",
"into",
"the",
"appropriate",
"copies",
"out",
"of",
"appropriate",
"physical",
"registers",
"."
] | [
"Mips",
"Mips",
"ISD::InputArg",
"16",
"Mips",
"Mips",
"0",
"\"Can only return in registers!\"",
"1",
"2",
"ISD::SRL",
"ISD::SRA",
"\"Unknown loc info!\"",
"ISD::BITCAST",
"ISD::TRUNCATE",
"ISD::AssertZext",
"ISD::TRUNCATE",
"ISD::AssertSext",
"ISD::TRUNCATE"
] | MipsISelLowering102 | LowerCallResult | Mips | CPU | LLVM | 17,476 | 505 | 1 | [] |
[
"<s>",
"LLVM_DUMP_METHOD",
"void",
"Coloring",
"::",
"dump",
"(",
")",
"const",
"{",
"dbgs",
"(",
")",
"<<",
"\"{ Order: {\"",
";",
"for",
"(",
"unsigned",
"I",
"=",
"0",
";",
"I",
"!=",
"Order",
".",
"size",
"(",
")",
";",
"++",
"I",
")",
"{",
"Node",
"P",
"=",
"Order",
"[",
"I",
"]",
";",
"if",
"(",
"P",
"!=",
"Ignore",
")",
"dbgs",
"(",
")",
"<<",
"' '",
"<<",
"P",
";",
"else",
"dbgs",
"(",
")",
"<<",
"\" -\"",
";",
"}",
"dbgs",
"(",
")",
"<<",
"\" }\\n\"",
";",
"dbgs",
"(",
")",
"<<",
"\" Needed: {\"",
";",
"for",
"(",
"Node",
"N",
":",
"Needed",
")",
"dbgs",
"(",
")",
"<<",
"' '",
"<<",
"N",
";",
"dbgs",
"(",
")",
"<<",
"\" }\\n\"",
";",
"dbgs",
"(",
")",
"<<",
"\" Edges: {\\n\"",
";",
"for",
"(",
"auto",
"E",
":",
"Edges",
")",
"{",
"dbgs",
"(",
")",
"<<",
"\" \"",
"<<",
"E",
".",
"first",
"<<",
"\" -> {\"",
";",
"for",
"(",
"auto",
"N",
":",
"E",
".",
"second",
")",
"dbgs",
"(",
")",
"<<",
"' '",
"<<",
"N",
";",
"dbgs",
"(",
")",
"<<",
"\" }\\n\"",
";",
"}",
"dbgs",
"(",
")",
"<<",
"\" }\\n\"",
";",
"auto",
"ColorKindToName",
"=",
"[",
"]",
"(",
"ColorKind",
"C",
")",
"{",
"switch",
"(",
"C",
")",
"{",
"case",
"ColorKind",
"::",
"None",
":",
"return",
"\"None\"",
";",
"case",
"ColorKind",
"::",
"Red",
":",
"return",
"\"Red\"",
";",
"case",
"ColorKind",
"::",
"Black",
":",
"return",
"\"Black\"",
";",
"}",
"llvm_unreachable",
"(",
"\"all ColorKinds should be handled by the switch above\"",
")",
";",
"}",
";",
"dbgs",
"(",
")",
"<<",
"\" Colors: {\\n\"",
";",
"for",
"(",
"auto",
"C",
":",
"Colors",
")",
"dbgs",
"(",
")",
"<<",
"\" \"",
"<<",
"C",
".",
"first",
"<<",
"\" -> \"",
"<<",
"ColorKindToName",
"(",
"C",
".",
"second",
")",
"<<",
"\"\\n\"",
";",
"dbgs",
"(",
")",
"<<",
"\" }\\n}\\n\"",
";",
"}",
"</s>"
] | [
"Dump",
"the",
"plan",
"to",
"stderr",
"(",
"for",
"debugging",
")",
"."
] | [
"Hexagon",
"\"{ Order: {\"",
"0",
"\" -\"",
"\" }\\n\"",
"\" Needed: {\"",
"\" }\\n\"",
"\" Edges: {\\n\"",
"\" \"",
"\" -> {\"",
"\" }\\n\"",
"\" }\\n\"",
"\"None\"",
"\"Red\"",
"\"Black\"",
"\"all ColorKinds should be handled by the switch above\"",
"\" Colors: {\\n\"",
"\" \"",
"\" -> \"",
"\"\\n\"",
"\" }\\n}\\n\""
] | HexagonISelDAGToDAGHVX | dump | Hexagon | DSP | LLVM | 17,477 | 241 | 1 | [] |
[
"<s>",
"llvm",
"::",
"FastISel",
"*",
"X86",
"::",
"createFastISel",
"(",
"MachineFunction",
"&",
"mf",
",",
"MachineModuleInfo",
"*",
"mmi",
",",
"DwarfWriter",
"*",
"dw",
",",
"DenseMap",
"<",
"const",
"Value",
"*",
",",
"unsigned",
">",
"&",
"vm",
",",
"DenseMap",
"<",
"const",
"BasicBlock",
"*",
",",
"MachineBasicBlock",
"*",
">",
"&",
"bm",
",",
"DenseMap",
"<",
"const",
"AllocaInst",
"*",
",",
"int",
">",
"&",
"am",
",",
"SmallSet",
"<",
"Instruction",
"*",
",",
"8",
">",
"&",
"cil",
")",
"{",
"return",
"new",
"X86FastISel",
"(",
"mf",
",",
"mmi",
",",
"dw",
",",
"vm",
",",
"bm",
",",
"am",
",",
"cil",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"returns",
"a",
"target",
"specific",
"FastISel",
"object",
",",
"or",
"null",
"if",
"the",
"target",
"does",
"not",
"support",
"``",
"fast",
"''",
"ISel",
"."
] | [
"X86",
"X86::createFastISel",
"8",
"X86"
] | X86FastISel117 | createFastISel | X86 | CPU | LLVM | 17,478 | 85 | 1 | [] |
[
"<s>",
"bool",
"convertSelectOfConstantsToMath",
"(",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"a",
"select",
"of",
"constants",
"(",
"select",
"Cond",
",",
"C1",
",",
"C2",
")",
"should",
"be",
"transformed",
"into",
"simple",
"math",
"ops",
"with",
"the",
"condition",
"value",
"."
] | [
"PowerPC"
] | PPCISelLowering108 | convertSelectOfConstantsToMath | PowerPC | CPU | LLVM | 17,479 | 11 | 1 | [] |
[
"<s>",
"void",
"X86InstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIdx",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"const",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"assert",
"(",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"getObjectSize",
"(",
"FrameIdx",
")",
">=",
"RC",
"->",
"getSize",
"(",
")",
"&&",
"\"Stack slot too small for store\"",
")",
";",
"unsigned",
"Alignment",
"=",
"std",
"::",
"max",
"<",
"uint32_t",
">",
"(",
"RC",
"->",
"getSize",
"(",
")",
",",
"16",
")",
";",
"bool",
"isAligned",
"=",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
"->",
"getStackAlignment",
"(",
")",
">=",
"Alignment",
")",
"||",
"RI",
".",
"canRealignStack",
"(",
"MF",
")",
";",
"unsigned",
"Opc",
"=",
"getStoreRegOpcode",
"(",
"SrcReg",
",",
"RC",
",",
"isAligned",
",",
"Subtarget",
")",
";",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
")",
",",
"FrameIdx",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"X86",
"X86",
"\"Stack slot too small for store\"",
"16"
] | X86InstrInfo142 | storeRegToStackSlot | X86 | CPU | LLVM | 17,480 | 170 | 1 | [] |
[
"<s>",
"void",
"LEGFrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"?",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
":",
"DebugLoc",
"(",
")",
";",
"uint64_t",
"StackSize",
"=",
"computeStackSize",
"(",
"MF",
")",
";",
"if",
"(",
"!",
"StackSize",
")",
"{",
"return",
";",
"}",
"unsigned",
"StackReg",
"=",
"LEG",
"::",
"SP",
";",
"unsigned",
"OffsetReg",
"=",
"materializeOffset",
"(",
"MF",
",",
"MBB",
",",
"MBBI",
",",
"(",
"unsigned",
")",
"StackSize",
")",
";",
"if",
"(",
"OffsetReg",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"LEG",
"::",
"SUBrr",
")",
",",
"StackReg",
")",
".",
"addReg",
"(",
"StackReg",
")",
".",
"addReg",
"(",
"OffsetReg",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"}",
"else",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"LEG",
"::",
"SUBri",
")",
",",
"StackReg",
")",
".",
"addReg",
"(",
"StackReg",
")",
".",
"addImm",
"(",
"StackSize",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"}",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"LEG",
"LEG",
"LEG::SP",
"LEG::SUBrr",
"LEG::SUBri"
] | LEGFrameLowering | emitPrologue | LEG | CPU | LLVM | 17,481 | 188 | 1 | [] |
[
"<s>",
"MCInstrDesc",
"const",
"&",
"HexagonMCInstrInfo",
"::",
"getDesc",
"(",
"MCInstrInfo",
"const",
"&",
"MCII",
",",
"MCInst",
"const",
"&",
"MCI",
")",
"{",
"return",
"(",
"MCII",
".",
"get",
"(",
"MCI",
".",
"getOpcode",
"(",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"target",
"instruction",
"descriptor",
"of",
"this",
"MachineInstr",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonMCInstrInfo | getDesc | Hexagon | DSP | LLVM | 17,482 | 33 | 1 | [] |
[
"<s>",
"void",
"SystemZInstrInfo",
"::",
"copyPhysReg",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"DebugLoc",
"DL",
",",
"unsigned",
"DestReg",
",",
"unsigned",
"SrcReg",
",",
"bool",
"KillSrc",
")",
"const",
"{",
"unsigned",
"Opc",
";",
"if",
"(",
"SystemZ",
"::",
"GR64RegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opc",
"=",
"SystemZ",
"::",
"MOV64rr",
";",
"else",
"if",
"(",
"SystemZ",
"::",
"GR32RegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opc",
"=",
"SystemZ",
"::",
"MOV32rr",
";",
"else",
"if",
"(",
"SystemZ",
"::",
"GR64PRegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opc",
"=",
"SystemZ",
"::",
"MOV64rrP",
";",
"else",
"if",
"(",
"SystemZ",
"::",
"GR128RegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opc",
"=",
"SystemZ",
"::",
"MOV128rr",
";",
"else",
"if",
"(",
"SystemZ",
"::",
"FP32RegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opc",
"=",
"SystemZ",
"::",
"FMOV32rr",
";",
"else",
"if",
"(",
"SystemZ",
"::",
"FP64RegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opc",
"=",
"SystemZ",
"::",
"FMOV64rr",
";",
"else",
"llvm_unreachable",
"(",
"\"Impossible reg-to-reg copy\"",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"}",
"</s>"
] | [
"}",
"Branch",
"Analysis",
"&",
"Modification"
] | [
"SystemZ",
"SystemZ",
"SystemZ::GR64RegClass",
"SystemZ::MOV64rr",
"SystemZ::GR32RegClass",
"SystemZ::MOV32rr",
"SystemZ::GR64PRegClass",
"SystemZ::MOV64rrP",
"SystemZ::GR128RegClass",
"SystemZ::MOV128rr",
"SystemZ::FP32RegClass",
"SystemZ::FMOV32rr",
"SystemZ::FP64RegClass",
"SystemZ::FMOV64rr",
"\"Impossible reg-to-reg copy\""
] | SystemZInstrInfo25 | copyPhysReg | SystemZ | CPU | LLVM | 17,483 | 183 | 1 | [] |
[
"<s>",
"bool",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"override",
"{",
"Casts",
".",
"clear",
"(",
")",
";",
"ConstantCasts",
".",
"clear",
"(",
")",
";",
"visit",
"(",
"F",
")",
";",
"if",
"(",
"!",
"(",
"Casts",
".",
"empty",
"(",
")",
"&&",
"ConstantCasts",
".",
"empty",
"(",
")",
")",
")",
"{",
"Intrinsic",
"::",
"ID",
"SetLength",
"=",
"Intrinsic",
"::",
"cheri_cap_bounds_set",
";",
"SetLengthFn",
"=",
"Intrinsic",
"::",
"getDeclaration",
"(",
"M",
",",
"SetLength",
",",
"SizeTy",
")",
";",
"Value",
"*",
"BitCast",
"=",
"0",
";",
"for",
"(",
"auto",
"*",
"i",
"=",
"Casts",
".",
"begin",
"(",
")",
",",
"*",
"e",
"=",
"Casts",
".",
"end",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"Instruction",
"*",
"I2P",
"=",
"i",
"->",
"second",
";",
"auto",
"InsertPt",
"=",
"I2P",
"->",
"getParent",
"(",
")",
"->",
"begin",
"(",
")",
";",
"while",
"(",
"&",
"(",
"*",
"InsertPt",
")",
"!=",
"I2P",
")",
"{",
"++",
"InsertPt",
";",
"}",
"++",
"InsertPt",
";",
"Value",
"*",
"New",
"=",
"RangeCheckedValue",
"(",
"&",
"*",
"InsertPt",
",",
"i",
"->",
"first",
",",
"I2P",
",",
"BitCast",
")",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Replacing \"",
";",
"I2P",
"->",
"dump",
"(",
")",
";",
"dbgs",
"(",
")",
"<<",
"\" with \"",
";",
"New",
"->",
"dump",
"(",
")",
")",
";",
"I2P",
"->",
"replaceAllUsesWith",
"(",
"New",
")",
";",
"RecursivelyDeleteTriviallyDeadInstructions",
"(",
"I2P",
")",
";",
"}",
"for",
"(",
"pair",
"<",
"AllocOperands",
",",
"ConstantCast",
">",
"*",
"i",
"=",
"ConstantCasts",
".",
"begin",
"(",
")",
",",
"*",
"e",
"=",
"ConstantCasts",
".",
"end",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"Value",
"*",
"I2P",
"=",
"i",
"->",
"second",
".",
"Instr",
"->",
"getOperand",
"(",
"i",
"->",
"second",
".",
"OpNo",
")",
";",
"Value",
"*",
"New",
"=",
"RangeCheckedValue",
"(",
"i",
"->",
"second",
".",
"Instr",
",",
"i",
"->",
"first",
",",
"I2P",
",",
"BitCast",
")",
";",
"i",
"->",
"second",
".",
"Instr",
"->",
"setOperand",
"(",
"i",
"->",
"second",
".",
"OpNo",
",",
"New",
")",
";",
"}",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"Mips",
"Intrinsic::ID",
"Intrinsic::cheri_cap_bounds_set",
"Intrinsic::getDeclaration",
"0",
"\"Replacing \"",
"\" with \""
] | CheriRangeChecker | runOnFunction | Mips | CPU | LLVM | 17,484 | 299 | 1 | [] |
[
"<s>",
"static",
"inline",
"unsigned",
"getFormat",
"(",
"uint64_t",
"TSFlags",
")",
"{",
"return",
"(",
"TSFlags",
"&",
"InstFormatMask",
")",
">>",
"InstFormatShift",
";",
"}",
"</s>"
] | [
"Return",
"the",
"DWARF",
"format",
"of",
"this",
"table",
"."
] | [
"RISCV"
] | RISCVBaseInfo | getFormat | RISCV | CPU | LLVM | 17,485 | 19 | 1 | [] |
[
"<s>",
"ARMBaseTargetMachine",
"::",
"ARMBaseTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"StringRef",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Reloc",
"::",
"Model",
"RM",
",",
"CodeModel",
"::",
"Model",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"RM",
",",
"CM",
",",
"OL",
")",
",",
"Subtarget",
"(",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
")",
",",
"JITInfo",
"(",
")",
",",
"InstrItins",
"(",
"Subtarget",
".",
"getInstrItineraryData",
"(",
")",
")",
"{",
"if",
"(",
"Options",
".",
"FloatABIType",
"==",
"FloatABI",
"::",
"Default",
")",
"this",
"->",
"Options",
".",
"FloatABIType",
"=",
"FloatABI",
"::",
"Soft",
";",
"}",
"</s>"
] | [
"Create",
"an",
"ARM",
"architecture",
"model",
"."
] | [
"ARM",
"ARM",
"ARM"
] | ARMTargetMachine106 | ARMBaseTargetMachine | ARM | CPU | LLVM | 17,486 | 103 | 1 | [] |
[
"<s>",
"bool",
"loongarch_expand_block_move",
"(",
"rtx",
"dest",
",",
"rtx",
"src",
",",
"rtx",
"length",
")",
"{",
"int",
"max_move_bytes",
"=",
"LARCH_MAX_MOVE_BYTES_STRAIGHT",
";",
"if",
"(",
"CONST_INT_P",
"(",
"length",
")",
"&&",
"INTVAL",
"(",
"length",
")",
"<=",
"loongarch_max_inline_memcpy_size",
")",
"{",
"if",
"(",
"INTVAL",
"(",
"length",
")",
"<=",
"max_move_bytes",
")",
"{",
"loongarch_block_move_straight",
"(",
"dest",
",",
"src",
",",
"INTVAL",
"(",
"length",
")",
")",
";",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"optimize",
")",
"{",
"loongarch_block_move_loop",
"(",
"dest",
",",
"src",
",",
"INTVAL",
"(",
"length",
")",
",",
"LARCH_MAX_MOVE_BYTES_PER_LOOP_ITER",
")",
";",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"cpymemsi",
"instruction",
",",
"which",
"copies",
"LENGTH",
"bytes",
"from",
"memory",
"reference",
"SRC",
"to",
"memory",
"reference",
"DEST",
"."
] | [
"loongarch"
] | loongarch | loongarch_expand_block_move | loongarch | CPU | GCC | 17,487 | 88 | 1 | [] |
[
"<s>",
"static",
"void",
"sparc_output_dwarf_dtprel",
"(",
"FILE",
"*",
"file",
",",
"int",
"size",
",",
"rtx",
"x",
")",
"{",
"switch",
"(",
"size",
")",
"{",
"case",
"4",
":",
"fputs",
"(",
"\"\\t.word\\t%r_tls_dtpoff32(\"",
",",
"file",
")",
";",
"break",
";",
"case",
"8",
":",
"fputs",
"(",
"\"\\t.xword\\t%r_tls_dtpoff64(\"",
",",
"file",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"output_addr_const",
"(",
"file",
",",
"x",
")",
";",
"fputs",
"(",
"\")\"",
",",
"file",
")",
";",
"}",
"</s>"
] | [
"This",
"is",
"called",
"from",
"dwarf2out.cc",
"via",
"TARGET_ASM_OUTPUT_DWARF_DTPREL",
".",
"We",
"need",
"to",
"emit",
"DTP-relative",
"relocations",
"."
] | [
"sparc",
"4",
"\"\\t.word\\t%r_tls_dtpoff32(\"",
"8",
"\"\\t.xword\\t%r_tls_dtpoff64(\"",
"\")\""
] | sparc | sparc_output_dwarf_dtprel | sparc | CPU | GCC | 17,488 | 66 | 1 | [] |
[
"<s>",
"PreservedAnalyses",
"AMDGPULowerModuleLDSPass",
"::",
"run",
"(",
"Module",
"&",
"M",
",",
"ModuleAnalysisManager",
"&",
")",
"{",
"return",
"AMDGPULowerModuleLDS",
"(",
")",
".",
"runOnModule",
"(",
"M",
")",
"?",
"PreservedAnalyses",
"::",
"none",
"(",
")",
":",
"PreservedAnalyses",
"::",
"all",
"(",
")",
";",
"}",
"</s>"
] | [
"Run",
"the",
"analysis",
"pass",
"over",
"a",
"function",
"and",
"produce",
"a",
"dominator",
"tree",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | AMDGPULowerModuleLDSPass | run | AMDGPU | GPU | LLVM | 17,489 | 36 | 1 | [] |
[
"<s>",
"void",
"Z80RegisterInfo",
"::",
"resolveFrameIndex",
"(",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"BaseReg",
",",
"int64_t",
"Offset",
")",
"const",
"{",
"unsigned",
"FIOperandNum",
"=",
"0",
";",
"while",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"isFI",
"(",
")",
")",
"{",
"FIOperandNum",
"++",
";",
"assert",
"(",
"FIOperandNum",
"<",
"MI",
".",
"getNumOperands",
"(",
")",
"&&",
"\"Expected a frame index\"",
")",
";",
"}",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"ChangeToRegister",
"(",
"BaseReg",
",",
"false",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"ChangeToImmediate",
"(",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"getImm",
"(",
")",
"+",
"Offset",
")",
";",
"}",
"</s>"
] | [
"Resolve",
"a",
"frame",
"index",
"operand",
"of",
"an",
"instruction",
"to",
"reference",
"the",
"indicated",
"base",
"register",
"plus",
"offset",
"instead",
"."
] | [
"Z80",
"Z80",
"0",
"\"Expected a frame index\"",
"1",
"1"
] | Z80RegisterInfo2 | resolveFrameIndex | Z80 | MPU | LLVM | 17,490 | 96 | 1 | [] |
[
"<s>",
"const",
"WebAssemblyTargetLowering",
"*",
"getTLI",
"(",
")",
"const",
"{",
"return",
"TLI",
";",
"}",
"</s>"
] | [
"Getter",
"for",
"generic",
"TargetLowering",
"class",
"."
] | [
"WebAssembly",
"WebAssembly"
] | WebAssemblyTargetTransformInfo | getTLI | WebAssembly | Virtual ISA | LLVM | 17,491 | 12 | 1 | [] |
[
"<s>",
"static",
"void",
"predicate_insn",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"pred",
")",
"{",
"rtx",
"pat",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"pred",
"=",
"gen_rtx_NE",
"(",
"BImode",
",",
"pred",
",",
"const0_rtx",
")",
";",
"pat",
"=",
"gen_rtx_COND_EXEC",
"(",
"VOIDmode",
",",
"pred",
",",
"pat",
")",
";",
"bool",
"changed_p",
"=",
"validate_change",
"(",
"insn",
",",
"&",
"PATTERN",
"(",
"insn",
")",
",",
"pat",
",",
"false",
")",
";",
"gcc_assert",
"(",
"changed_p",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"we",
"can",
"add",
"a",
"predicate",
"COND",
"to",
"INSN",
",",
"or",
"if",
"INSN",
"already",
"has",
"that",
"predicate",
".",
"If",
"DOIT",
"is",
"true",
",",
"also",
"perform",
"the",
"modification",
"."
] | [
"nvptx"
] | nvptx | predicate_insn | nvptx | GPU | GCC | 17,492 | 66 | 1 | [] |
[
"<s>",
"bool",
"WebAssembly",
"::",
"mayThrow",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"WebAssembly",
"::",
"THROW_I32",
":",
"case",
"WebAssembly",
"::",
"THROW_I32_S",
":",
"case",
"WebAssembly",
"::",
"THROW_I64",
":",
"case",
"WebAssembly",
"::",
"THROW_I64_S",
":",
"case",
"WebAssembly",
"::",
"RETHROW",
":",
"case",
"WebAssembly",
"::",
"RETHROW_S",
":",
"return",
"true",
";",
"}",
"if",
"(",
"isCallIndirect",
"(",
"MI",
")",
")",
"return",
"true",
";",
"if",
"(",
"!",
"MI",
".",
"isCall",
"(",
")",
")",
"return",
"false",
";",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"getCalleeOpNo",
"(",
"MI",
")",
")",
";",
"assert",
"(",
"MO",
".",
"isGlobal",
"(",
")",
")",
";",
"const",
"auto",
"*",
"F",
"=",
"dyn_cast",
"<",
"Function",
">",
"(",
"MO",
".",
"getGlobal",
"(",
")",
")",
";",
"if",
"(",
"!",
"F",
")",
"return",
"true",
";",
"if",
"(",
"F",
"->",
"doesNotThrow",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"F",
"->",
"getName",
"(",
")",
"==",
"CxaBeginCatchFn",
"||",
"F",
"->",
"getName",
"(",
")",
"==",
"PersonalityWrapperFn",
"||",
"F",
"->",
"getName",
"(",
")",
"==",
"ClangCallTerminateFn",
"||",
"F",
"->",
"getName",
"(",
")",
"==",
"StdTerminateFn",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"instruction",
"may",
"throw",
"an",
"exception",
"."
] | [
"WebAssembly",
"WebAssembly::mayThrow",
"WebAssembly::THROW_I32",
"WebAssembly::THROW_I32_S",
"WebAssembly::THROW_I64",
"WebAssembly::THROW_I64_S",
"WebAssembly::RETHROW",
"WebAssembly::RETHROW_S"
] | WebAssemblyUtilities | mayThrow | WebAssembly | Virtual ISA | LLVM | 17,493 | 177 | 1 | [] |
[
"<s>",
"void",
"visium_expand_epilogue",
"(",
"void",
")",
"{",
"const",
"int",
"save_area_size",
"=",
"current_frame_info",
".",
"save_area_size",
";",
"const",
"int",
"reg_size1",
"=",
"current_frame_info",
".",
"reg_size1",
";",
"const",
"int",
"max_reg1",
"=",
"current_frame_info",
".",
"max_reg1",
";",
"const",
"int",
"reg_size2",
"=",
"current_frame_info",
".",
"reg_size2",
";",
"const",
"int",
"var_size",
"=",
"current_frame_info",
".",
"var_size",
";",
"const",
"int",
"restore_fp",
"=",
"current_frame_info",
".",
"save_fp",
";",
"const",
"int",
"restore_lr",
"=",
"current_frame_info",
".",
"save_lr",
";",
"const",
"int",
"lr_slot",
"=",
"current_frame_info",
".",
"lr_slot",
";",
"const",
"int",
"local_frame_offset",
"=",
"(",
"restore_fp",
"+",
"restore_lr",
"+",
"lr_slot",
")",
"*",
"UNITS_PER_WORD",
";",
"const",
"int",
"combine",
"=",
"current_frame_info",
".",
"combine",
";",
"int",
"reg_size",
";",
"int",
"last_reg",
";",
"int",
"fsize",
";",
"if",
"(",
"!",
"crtl",
"->",
"sp_is_unchanging",
")",
"emit_insn",
"(",
"gen_stack_restore",
"(",
")",
")",
";",
"if",
"(",
"restore_fp",
")",
"{",
"rtx",
"src",
";",
"if",
"(",
"TARGET_MCM",
"&&",
"!",
"crtl",
"->",
"sp_is_unchanging",
")",
"src",
"=",
"gen_frame_mem",
"(",
"SImode",
",",
"hard_frame_pointer_rtx",
")",
";",
"else",
"src",
"=",
"gen_frame_mem",
"(",
"SImode",
",",
"stack_pointer_rtx",
")",
";",
"rtx",
"insn",
"=",
"emit_frame_insn",
"(",
"gen_movsi",
"(",
"hard_frame_pointer_rtx",
",",
"src",
")",
")",
";",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_ADJUST_CFA",
",",
"gen_rtx_SET",
"(",
"stack_pointer_rtx",
",",
"hard_frame_pointer_rtx",
")",
")",
";",
"visium_add_cfa_restore_note",
"(",
"hard_frame_pointer_rtx",
")",
";",
"}",
"if",
"(",
"restore_lr",
")",
"{",
"rtx",
"mem",
"=",
"gen_frame_mem",
"(",
"SImode",
",",
"plus_constant",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"restore_fp",
"*",
"UNITS_PER_WORD",
")",
")",
";",
"rtx",
"reg",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"LINK_REGNUM",
")",
";",
"emit_insn",
"(",
"gen_movsi",
"(",
"reg",
",",
"mem",
")",
")",
";",
"visium_add_cfa_restore_note",
"(",
"reg",
")",
";",
"}",
"if",
"(",
"reg_size2",
")",
"{",
"reg_size",
"=",
"reg_size2",
";",
"last_reg",
"=",
"max_reg1",
"+",
"1",
";",
"fsize",
"=",
"local_frame_offset",
"+",
"var_size",
"+",
"reg_size2",
";",
"}",
"else",
"{",
"reg_size",
"=",
"reg_size1",
";",
"last_reg",
"=",
"0",
";",
"fsize",
"=",
"local_frame_offset",
"+",
"var_size",
"+",
"reg_size1",
"+",
"save_area_size",
";",
"}",
"if",
"(",
"reg_size",
"&&",
"combine",
")",
"visium_restore_regs",
"(",
"fsize",
",",
"local_frame_offset",
"+",
"var_size",
",",
"FIRST_PSEUDO_REGISTER",
"-",
"1",
",",
"last_reg",
")",
";",
"else",
"if",
"(",
"fsize",
")",
"{",
"const",
"int",
"pop_size",
"=",
"reg_size",
"?",
"local_frame_offset",
"+",
"var_size",
":",
"fsize",
";",
"rtx",
"insn",
";",
"if",
"(",
"pop_size",
">",
"65535",
")",
"{",
"rtx",
"tmp",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"PROLOGUE_TMP_REGNUM",
")",
";",
"emit_move_insn",
"(",
"tmp",
",",
"GEN_INT",
"(",
"pop_size",
")",
")",
";",
"insn",
"=",
"emit_frame_insn",
"(",
"gen_stack_pop",
"(",
"tmp",
")",
")",
";",
"}",
"else",
"insn",
"=",
"emit_frame_insn",
"(",
"gen_stack_pop",
"(",
"GEN_INT",
"(",
"pop_size",
")",
")",
")",
";",
"add_reg_note",
"(",
"insn",
",",
"REG_FRAME_RELATED_EXPR",
",",
"gen_rtx_SET",
"(",
"stack_pointer_rtx",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"pop_size",
")",
")",
")",
")",
";",
"visium_add_queued_cfa_restore_notes",
"(",
"insn",
")",
";",
"}",
"if",
"(",
"reg_size",
"&&",
"!",
"combine",
")",
"visium_restore_regs",
"(",
"fsize",
"-",
"local_frame_offset",
"-",
"var_size",
",",
"0",
",",
"FIRST_PSEUDO_REGISTER",
"-",
"1",
",",
"last_reg",
")",
";",
"if",
"(",
"reg_size2",
")",
"visium_restore_regs",
"(",
"reg_size1",
"+",
"save_area_size",
",",
"0",
",",
"max_reg1",
",",
"0",
")",
";",
"if",
"(",
"crtl",
"->",
"calls_eh_return",
")",
"emit_insn",
"(",
"gen_stack_pop",
"(",
"EH_RETURN_STACKADJ_RTX",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"function",
"generates",
"the",
"code",
"for",
"function",
"exit",
"."
] | [
"visium",
"1",
"0",
"1",
"65535",
"0",
"1",
"0",
"0"
] | visium | visium_expand_epilogue | visium | Virtual ISA | GCC | 17,494 | 459 | 1 | [] |
[
"<s>",
"DecodeStatus",
"AArch64Disassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"MI",
",",
"uint64_t",
"&",
"Size",
",",
"const",
"MemoryObject",
"&",
"Region",
",",
"uint64_t",
"Address",
",",
"raw_ostream",
"&",
"os",
",",
"raw_ostream",
"&",
"cs",
")",
"const",
"{",
"CommentStream",
"=",
"&",
"cs",
";",
"uint8_t",
"bytes",
"[",
"4",
"]",
";",
"Size",
"=",
"0",
";",
"if",
"(",
"Region",
".",
"readBytes",
"(",
"Address",
",",
"4",
",",
"(",
"uint8_t",
"*",
")",
"bytes",
")",
"==",
"-",
"1",
")",
"return",
"Fail",
";",
"Size",
"=",
"4",
";",
"uint32_t",
"insn",
"=",
"(",
"bytes",
"[",
"3",
"]",
"<<",
"24",
")",
"|",
"(",
"bytes",
"[",
"2",
"]",
"<<",
"16",
")",
"|",
"(",
"bytes",
"[",
"1",
"]",
"<<",
"8",
")",
"|",
"(",
"bytes",
"[",
"0",
"]",
"<<",
"0",
")",
";",
"return",
"decodeInstruction",
"(",
"DecoderTable32",
",",
"MI",
",",
"insn",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"AArch64",
"AArch64",
"4",
"0",
"4",
"1",
"4",
"3",
"24",
"2",
"16",
"1",
"8",
"0",
"0"
] | AArch64Disassembler55 | getInstruction | AArch64 | CPU | LLVM | 17,495 | 129 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUPerfHintAnalysis",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"auto",
"*",
"TPC",
"=",
"getAnalysisIfAvailable",
"<",
"TargetPassConfig",
">",
"(",
")",
";",
"if",
"(",
"!",
"TPC",
")",
"return",
"false",
";",
"const",
"TargetMachine",
"&",
"TM",
"=",
"TPC",
"->",
"getTM",
"<",
"TargetMachine",
">",
"(",
")",
";",
"const",
"TargetSubtargetInfo",
"*",
"ST",
"=",
"TM",
".",
"getSubtargetImpl",
"(",
"F",
")",
";",
"AMDGPUPerfHint",
"Analyzer",
"(",
"FIM",
",",
"ST",
"->",
"getTargetLowering",
"(",
")",
")",
";",
"Analyzer",
".",
"runOnFunction",
"(",
"F",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | AMDGPUPerfHintAnalysis | runOnFunction | AMDGPU | GPU | LLVM | 17,496 | 78 | 1 | [] |
[
"<s>",
"bool",
"XCoreFrameLowering",
"::",
"restoreCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"MutableArrayRef",
"<",
"CalleeSavedInfo",
">",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"MF",
"->",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"bool",
"AtStart",
"=",
"MI",
"==",
"MBB",
".",
"begin",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"BeforeI",
"=",
"MI",
";",
"if",
"(",
"!",
"AtStart",
")",
"--",
"BeforeI",
";",
"for",
"(",
"const",
"CalleeSavedInfo",
"&",
"CSR",
":",
"CSI",
")",
"{",
"Register",
"Reg",
"=",
"CSR",
".",
"getReg",
"(",
")",
";",
"assert",
"(",
"Reg",
"!=",
"XCore",
"::",
"LR",
"&&",
"!",
"(",
"Reg",
"==",
"XCore",
"::",
"R10",
"&&",
"hasFP",
"(",
"*",
"MF",
")",
")",
"&&",
"\"LR & FP are always handled in emitEpilogue\"",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TRI",
"->",
"getMinimalPhysRegClass",
"(",
"Reg",
")",
";",
"TII",
".",
"loadRegFromStackSlot",
"(",
"MBB",
",",
"MI",
",",
"Reg",
",",
"CSR",
".",
"getFrameIdx",
"(",
")",
",",
"RC",
",",
"TRI",
")",
";",
"assert",
"(",
"MI",
"!=",
"MBB",
".",
"begin",
"(",
")",
"&&",
"\"loadRegFromStackSlot didn't insert any code!\"",
")",
";",
"if",
"(",
"AtStart",
")",
"MI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"else",
"{",
"MI",
"=",
"BeforeI",
";",
"++",
"MI",
";",
"}",
"}",
"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",
"(",
")",
"."
] | [
"XCore",
"XCore",
"XCore::LR",
"XCore::R10",
"\"LR & FP are always handled in emitEpilogue\"",
"\"loadRegFromStackSlot didn't insert any code!\""
] | XCoreFrameLowering21 | restoreCalleeSavedRegisters | XCore | MPU | LLVM | 17,497 | 197 | 1 | [] |
[
"<s>",
"void",
"AlphaRegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"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",
")",
";",
"DOUT",
"(",
"llvm",
"::",
"dbgs",
"(",
")",
"<<",
"\"FI: \"",
"<<",
"FrameIndex",
"<<",
"\" Offset: \"",
"<<",
"Offset",
"<<",
"\"\\n\"",
";",
"Offset",
"+=",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"getStackSize",
"(",
")",
";",
"DOUT",
"(",
"llvm",
"::",
"dbgs",
"(",
")",
"<<",
"\"Corrected Offset \"",
"<<",
"Offset",
"<<",
"\" for stack size: \"",
"<<",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"getStackSize",
"(",
")",
"<<",
"\"\\n\"",
";",
"if",
"(",
"Offset",
">",
"IMM_HIGH",
"||",
"Offset",
"<",
"IMM_LOW",
")",
"{",
"DOUT",
"(",
"llvm",
"::",
"dbgs",
"(",
")",
"<<",
"\"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",
")",
";",
"}",
"}",
"</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"
] | AlphaRegisterInfo6 | eliminateFrameIndex | Alpha | MPU | LLVM | 17,498 | 343 | 1 | [] |
[
"<s>",
"SDValue",
"MipsTargetLowering",
"::",
"LowerReturn",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeReturn",
"(",
"Outs",
",",
"RetCC_Mips",
")",
";",
"if",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_empty",
"(",
")",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"if",
"(",
"RVLocs",
"[",
"i",
"]",
".",
"isRegLoc",
"(",
")",
")",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"addLiveOut",
"(",
"RVLocs",
"[",
"i",
"]",
".",
"getLocReg",
"(",
")",
")",
";",
"}",
"SDValue",
"Flag",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Can only return in registers!\"",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"VA",
".",
"getLocReg",
"(",
")",
",",
"OutVals",
"[",
"i",
"]",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"}",
"if",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getFunction",
"(",
")",
"->",
"hasStructRetAttr",
"(",
")",
")",
"{",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"MipsFunctionInfo",
"*",
"MipsFI",
"=",
"MF",
".",
"getInfo",
"<",
"MipsFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"Reg",
"=",
"MipsFI",
"->",
"getSRetReturnReg",
"(",
")",
";",
"if",
"(",
"!",
"Reg",
")",
"llvm_unreachable",
"(",
"\"sret virtual register not created in the entry block\"",
")",
";",
"SDValue",
"Val",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"dl",
",",
"Reg",
",",
"getPointerTy",
"(",
")",
")",
";",
"unsigned",
"V0",
"=",
"IsN64",
"?",
"Mips",
"::",
"V0_64",
":",
"Mips",
"::",
"V0",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"V0",
",",
"Val",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"addLiveOut",
"(",
"V0",
")",
";",
"}",
"if",
"(",
"Flag",
".",
"getNode",
"(",
")",
")",
"return",
"DAG",
".",
"getNode",
"(",
"MipsISD",
"::",
"Ret",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"Chain",
",",
"Flag",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"MipsISD",
"::",
"Ret",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"Chain",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"outgoing",
"return",
"values",
",",
"described",
"by",
"the",
"Outs",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"Mips",
"Mips",
"ISD::OutputArg",
"16",
"Mips",
"0",
"0",
"\"Can only return in registers!\"",
"1",
"Mips",
"Mips",
"Mips",
"Mips",
"\"sret virtual register not created in the entry block\"",
"Mips::V0_64",
"Mips::V0",
"1",
"MipsISD::Ret",
"MVT::Other",
"MipsISD::Ret",
"MVT::Other"
] | MipsISelLowering101 | LowerReturn | Mips | CPU | LLVM | 17,499 | 407 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.