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",
"fpscr_set_from_mem",
"(",
"int",
"mode",
",",
"HARD_REG_SET",
"regs_live",
")",
"{",
"enum",
"attr_fp_mode",
"fp_mode",
"=",
"(",
"enum",
"attr_fp_mode",
")",
"mode",
";",
"enum",
"attr_fp_mode",
"norm_mode",
"=",
"ACTUAL_NORMAL_MODE",
"(",
"FP_MODE",
")",
";",
"rtx",
"addr_reg",
";",
"addr_reg",
"=",
"!",
"can_create_pseudo_p",
"(",
")",
"?",
"get_free_reg",
"(",
"regs_live",
")",
":",
"NULL_RTX",
";",
"emit_fpu_switch",
"(",
"addr_reg",
",",
"fp_mode",
"==",
"norm_mode",
")",
";",
"}",
"</s>"
] | [
"This",
"function",
"will",
"set",
"the",
"fpscr",
"from",
"memory",
".",
"MODE",
"is",
"the",
"mode",
"we",
"are",
"setting",
"it",
"to",
"."
] | [
"sh"
] | sh4 | fpscr_set_from_mem | sh | CPU | GCC | 16,100 | 56 | 1 | [] |
[
"<s>",
"void",
"BTFDebug",
"::",
"beginFunctionImpl",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"{",
"auto",
"*",
"SP",
"=",
"MF",
"->",
"getFunction",
"(",
")",
".",
"getSubprogram",
"(",
")",
";",
"auto",
"*",
"Unit",
"=",
"SP",
"->",
"getUnit",
"(",
")",
";",
"if",
"(",
"Unit",
"->",
"getEmissionKind",
"(",
")",
"==",
"DICompileUnit",
"::",
"NoDebug",
")",
"{",
"SkipInstruction",
"=",
"true",
";",
"return",
";",
"}",
"SkipInstruction",
"=",
"false",
";",
"if",
"(",
"MapDefNotCollected",
")",
"{",
"processGlobals",
"(",
"true",
")",
";",
"MapDefNotCollected",
"=",
"false",
";",
"}",
"std",
"::",
"unordered_map",
"<",
"uint32_t",
",",
"StringRef",
">",
"FuncArgNames",
";",
"for",
"(",
"const",
"DINode",
"*",
"DN",
":",
"SP",
"->",
"getRetainedNodes",
"(",
")",
")",
"{",
"if",
"(",
"const",
"auto",
"*",
"DV",
"=",
"dyn_cast",
"<",
"DILocalVariable",
">",
"(",
"DN",
")",
")",
"{",
"uint32_t",
"Arg",
"=",
"DV",
"->",
"getArg",
"(",
")",
";",
"if",
"(",
"Arg",
")",
"{",
"visitTypeEntry",
"(",
"DV",
"->",
"getType",
"(",
")",
")",
";",
"FuncArgNames",
"[",
"Arg",
"]",
"=",
"DV",
"->",
"getName",
"(",
")",
";",
"}",
"}",
"}",
"uint32_t",
"ProtoTypeId",
";",
"visitSubroutineType",
"(",
"SP",
"->",
"getType",
"(",
")",
",",
"true",
",",
"FuncArgNames",
",",
"ProtoTypeId",
")",
";",
"uint8_t",
"Scope",
"=",
"SP",
"->",
"isLocalToUnit",
"(",
")",
"?",
"BTF",
"::",
"FUNC_STATIC",
":",
"BTF",
"::",
"FUNC_GLOBAL",
";",
"auto",
"FuncTypeEntry",
"=",
"std",
"::",
"make_unique",
"<",
"BTFTypeFunc",
">",
"(",
"SP",
"->",
"getName",
"(",
")",
",",
"ProtoTypeId",
",",
"Scope",
")",
";",
"uint32_t",
"FuncTypeId",
"=",
"addType",
"(",
"std",
"::",
"move",
"(",
"FuncTypeEntry",
")",
")",
";",
"for",
"(",
"const",
"auto",
"&",
"TypeEntry",
":",
"TypeEntries",
")",
"TypeEntry",
"->",
"completeType",
"(",
"*",
"this",
")",
";",
"MCSymbol",
"*",
"FuncLabel",
"=",
"Asm",
"->",
"getFunctionBegin",
"(",
")",
";",
"BTFFuncInfo",
"FuncInfo",
";",
"FuncInfo",
".",
"Label",
"=",
"FuncLabel",
";",
"FuncInfo",
".",
"TypeId",
"=",
"FuncTypeId",
";",
"if",
"(",
"FuncLabel",
"->",
"isInSection",
"(",
")",
")",
"{",
"MCSection",
"&",
"Section",
"=",
"FuncLabel",
"->",
"getSection",
"(",
")",
";",
"const",
"MCSectionELF",
"*",
"SectionELF",
"=",
"dyn_cast",
"<",
"MCSectionELF",
">",
"(",
"&",
"Section",
")",
";",
"assert",
"(",
"SectionELF",
"&&",
"\"Null section for Function Label\"",
")",
";",
"SecNameOff",
"=",
"addString",
"(",
"SectionELF",
"->",
"getName",
"(",
")",
")",
";",
"}",
"else",
"{",
"SecNameOff",
"=",
"addString",
"(",
"\".text\"",
")",
";",
"}",
"FuncInfoTable",
"[",
"SecNameOff",
"]",
".",
"push_back",
"(",
"FuncInfo",
")",
";",
"}",
"</s>"
] | [
"Gather",
"pre-function",
"debug",
"information",
"."
] | [
"BPF",
"BTF::FUNC_STATIC",
"BTF::FUNC_GLOBAL",
"\"Null section for Function Label\"",
"\".text\""
] | BTFDebug10 | beginFunctionImpl | BPF | Virtual ISA | LLVM | 16,101 | 335 | 1 | [] |
[
"<s>",
"SDValue",
"VETargetLowering",
"::",
"withTargetFlags",
"(",
"SDValue",
"Op",
",",
"unsigned",
"TF",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"const",
"GlobalAddressSDNode",
"*",
"GA",
"=",
"dyn_cast",
"<",
"GlobalAddressSDNode",
">",
"(",
"Op",
")",
")",
"return",
"DAG",
".",
"getTargetGlobalAddress",
"(",
"GA",
"->",
"getGlobal",
"(",
")",
",",
"SDLoc",
"(",
"GA",
")",
",",
"GA",
"->",
"getValueType",
"(",
"0",
")",
",",
"GA",
"->",
"getOffset",
"(",
")",
",",
"TF",
")",
";",
"if",
"(",
"const",
"BlockAddressSDNode",
"*",
"BA",
"=",
"dyn_cast",
"<",
"BlockAddressSDNode",
">",
"(",
"Op",
")",
")",
"return",
"DAG",
".",
"getTargetBlockAddress",
"(",
"BA",
"->",
"getBlockAddress",
"(",
")",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"0",
",",
"TF",
")",
";",
"if",
"(",
"const",
"ExternalSymbolSDNode",
"*",
"ES",
"=",
"dyn_cast",
"<",
"ExternalSymbolSDNode",
">",
"(",
"Op",
")",
")",
"return",
"DAG",
".",
"getTargetExternalSymbol",
"(",
"ES",
"->",
"getSymbol",
"(",
")",
",",
"ES",
"->",
"getValueType",
"(",
"0",
")",
",",
"TF",
")",
";",
"llvm_unreachable",
"(",
"\"Unhandled address SDNode\"",
")",
";",
"}",
"</s>"
] | [
"}",
"Custom",
"DAGCombine"
] | [
"VE",
"VE",
"0",
"0",
"0",
"\"Unhandled address SDNode\""
] | VEISelLowering | withTargetFlags | VE | CPU | LLVM | 16,102 | 143 | 1 | [] |
[
"<s>",
"bool",
"r0rel_constant_p",
"(",
"rtx",
"op",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"SYMBOL_REF",
"&&",
"nios2_symbol_ref_in_r0rel_data_p",
"(",
"op",
")",
")",
"return",
"true",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"CONST",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
")",
"==",
"PLUS",
")",
"return",
"r0rel_constant_p",
"(",
"XEXP",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
",",
"0",
")",
")",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"CONST_INT",
"&&",
"SMALL_INT",
"(",
"INTVAL",
"(",
"op",
")",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Likewise",
"if",
"this",
"is",
"a",
"zero-relative",
"accessible",
"reference",
"."
] | [
"nios2",
"0",
"0",
"0"
] | nios2 | r0rel_constant_p | nios2 | MPU | GCC | 16,103 | 87 | 1 | [] |
[
"<s>",
"TargetLoweringBase",
"::",
"LegalizeTypeAction",
"X86TargetLowering",
"::",
"getPreferredVectorAction",
"(",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"v32i1",
"&&",
"Subtarget",
".",
"hasAVX512",
"(",
")",
"&&",
"!",
"Subtarget",
".",
"hasBWI",
"(",
")",
")",
"return",
"TypeSplitVector",
";",
"if",
"(",
"ExperimentalVectorWideningLegalization",
"&&",
"VT",
".",
"getVectorNumElements",
"(",
")",
"!=",
"1",
"&&",
"VT",
".",
"getVectorElementType",
"(",
")",
".",
"getSimpleVT",
"(",
")",
"!=",
"MVT",
"::",
"i1",
")",
"return",
"TypeWidenVector",
";",
"return",
"TargetLoweringBase",
"::",
"getPreferredVectorAction",
"(",
"VT",
")",
";",
"}",
"</s>"
] | [
"Customize",
"the",
"preferred",
"legalization",
"strategy",
"for",
"certain",
"types",
"."
] | [
"X86",
"X86",
"MVT::v32i1",
"1",
"MVT::i1"
] | X86ISelLowering | getPreferredVectorAction | X86 | CPU | LLVM | 16,104 | 74 | 1 | [] |
[
"<s>",
"static",
"void",
"expand_block_set_1",
"(",
"rtx",
"dst_reg",
",",
"rtx",
"value_rtx",
",",
"rtx",
"bytes_rtx",
")",
"{",
"value_rtx",
"=",
"convert_to_mode",
"(",
"Pmode",
",",
"value_rtx",
",",
"1",
")",
";",
"emit_library_call",
"(",
"byt_memset_libfunc",
",",
"LCT_NORMAL",
",",
"VOIDmode",
",",
"3",
",",
"dst_reg",
",",
"Pmode",
",",
"value_rtx",
",",
"Pmode",
",",
"convert_to_mode",
"(",
"TYPE_MODE",
"(",
"sizetype",
")",
",",
"bytes_rtx",
",",
"TYPE_UNSIGNED",
"(",
"sizetype",
")",
")",
",",
"TYPE_MODE",
"(",
"sizetype",
")",
")",
";",
"}",
"</s>"
] | [
"Generate",
"a",
"call",
"to",
"a",
"library",
"function",
"to",
"set",
"BYTES_RTX",
"bytes",
"at",
"address",
"DST_REG",
"to",
"VALUE_RTX",
"in",
"1-byte",
"chunks",
"."
] | [
"visium",
"1",
"3"
] | visium3 | expand_block_set_1 | visium | Virtual ISA | GCC | 16,105 | 65 | 1 | [] |
[
"<s>",
"FastISel",
"*",
"PPCTargetLowering",
"::",
"createFastISel",
"(",
"FunctionLoweringInfo",
"&",
"FuncInfo",
",",
"const",
"TargetLibraryInfo",
"*",
"LibInfo",
")",
"const",
"{",
"return",
"PPC",
"::",
"createFastISel",
"(",
"FuncInfo",
",",
"LibInfo",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"returns",
"a",
"target",
"specific",
"FastISel",
"object",
",",
"or",
"null",
"if",
"the",
"target",
"does",
"not",
"support",
"``",
"fast",
"''",
"ISel",
"."
] | [
"PowerPC",
"PPC",
"PPC::createFastISel"
] | PPCISelLowering (2) | createFastISel | PowerPC | CPU | LLVM | 16,106 | 28 | 1 | [] |
[
"<s>",
"static",
"void",
"sparc_function_arg_advance",
"(",
"cumulative_args_t",
"cum_v",
",",
"machine_mode",
"mode",
",",
"const_tree",
"type",
",",
"bool",
"named",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"cum",
"=",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"int",
"regno",
",",
"padding",
";",
"function_arg_slotno",
"(",
"cum",
",",
"mode",
",",
"type",
",",
"named",
",",
"false",
",",
"&",
"regno",
",",
"&",
"padding",
")",
";",
"cum",
"->",
"words",
"+=",
"padding",
";",
"if",
"(",
"TARGET_ARCH32",
")",
"{",
"cum",
"->",
"words",
"+=",
"(",
"mode",
"!=",
"BLKmode",
"?",
"ROUND_ADVANCE",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
")",
":",
"ROUND_ADVANCE",
"(",
"int_size_in_bytes",
"(",
"type",
")",
")",
")",
";",
"}",
"else",
"{",
"if",
"(",
"type",
"&&",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
"{",
"int",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"if",
"(",
"size",
"<=",
"8",
")",
"++",
"cum",
"->",
"words",
";",
"else",
"if",
"(",
"size",
"<=",
"16",
")",
"cum",
"->",
"words",
"+=",
"2",
";",
"else",
"++",
"cum",
"->",
"words",
";",
"}",
"else",
"{",
"cum",
"->",
"words",
"+=",
"(",
"mode",
"!=",
"BLKmode",
"?",
"ROUND_ADVANCE",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
")",
":",
"ROUND_ADVANCE",
"(",
"int_size_in_bytes",
"(",
"type",
")",
")",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Handle",
"the",
"TARGET_FUNCTION_ARG_ADVANCE",
"hook",
".",
"Update",
"the",
"data",
"in",
"CUM",
"to",
"advance",
"over",
"an",
"argument",
"of",
"mode",
"MODE",
"and",
"data",
"type",
"TYPE",
".",
"TYPE",
"is",
"null",
"for",
"libcalls",
"where",
"that",
"information",
"may",
"not",
"be",
"available",
"."
] | [
"sparc",
"8",
"16",
"2"
] | sparc4 | sparc_function_arg_advance | sparc | CPU | GCC | 16,107 | 170 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isFMAFasterThanFMulAndFAdd",
"(",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"!",
"(",
"Subtarget",
"->",
"hasFMA",
"(",
")",
"||",
"Subtarget",
"->",
"hasFMA4",
"(",
")",
")",
")",
"return",
"false",
";",
"VT",
"=",
"VT",
".",
"getScalarType",
"(",
")",
";",
"if",
"(",
"!",
"VT",
".",
"isSimple",
"(",
")",
")",
"return",
"false",
";",
"switch",
"(",
"VT",
".",
"getSimpleVT",
"(",
")",
".",
"SimpleTy",
")",
"{",
"case",
"MVT",
"::",
"f32",
":",
"case",
"MVT",
"::",
"f64",
":",
"return",
"true",
";",
"default",
":",
"break",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"an",
"FMA",
"operation",
"is",
"faster",
"than",
"a",
"pair",
"of",
"fmul",
"and",
"fadd",
"instructions",
"."
] | [
"X86",
"X86",
"MVT::f32",
"MVT::f64"
] | X86ISelLowering (2) | isFMAFasterThanFMulAndFAdd | X86 | CPU | LLVM | 16,108 | 83 | 1 | [] |
[
"<s>",
"void",
"HexagonInstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"DestReg",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"I",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"unsigned",
"Align",
"=",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"(",
"PseudoSourceValue",
"::",
"getFixedStack",
"(",
"FI",
")",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"MFI",
".",
"getObjectSize",
"(",
"FI",
")",
",",
"Align",
")",
";",
"if",
"(",
"RC",
"==",
"Hexagon",
"::",
"IntRegsRegisterClass",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Hexagon",
"::",
"LDriw",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"else",
"if",
"(",
"RC",
"==",
"Hexagon",
"::",
"DoubleRegsRegisterClass",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Hexagon",
"::",
"LDrid",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"else",
"if",
"(",
"RC",
"==",
"Hexagon",
"::",
"PredRegsRegisterClass",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Hexagon",
"::",
"LDriw_pred",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"else",
"{",
"llvm_unreachable",
"(",
"\"Can't store this register to stack slot\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon::IntRegsRegisterClass",
"Hexagon::LDriw",
"0",
"Hexagon::DoubleRegsRegisterClass",
"Hexagon::LDrid",
"0",
"Hexagon::PredRegsRegisterClass",
"Hexagon::LDriw_pred",
"0",
"\"Can't store this register to stack slot\""
] | HexagonInstrInfo25 | loadRegFromStackSlot | Hexagon | DSP | LLVM | 16,109 | 246 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseInstrInfo",
"::",
"isCopyInstrImpl",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"MachineOperand",
"*",
"&",
"Src",
",",
"const",
"MachineOperand",
"*",
"&",
"Dest",
")",
"const",
"{",
"if",
"(",
"!",
"MI",
".",
"isMoveReg",
"(",
")",
"||",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"VORRq",
"&&",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
"!=",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
")",
")",
"return",
"false",
";",
"Dest",
"=",
"&",
"MI",
".",
"getOperand",
"(",
"0",
")",
";",
"Src",
"=",
"&",
"MI",
".",
"getOperand",
"(",
"1",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"If",
"the",
"specific",
"machine",
"instruction",
"is",
"a",
"instruction",
"that",
"moves/copies",
"value",
"from",
"one",
"register",
"to",
"another",
"register",
"return",
"destination",
"and",
"source",
"registers",
"as",
"machine",
"operands",
"."
] | [
"ARM",
"ARM",
"ARM::VORRq",
"1",
"2",
"0",
"1"
] | ARMBaseInstrInfo1 | isCopyInstrImpl | ARM | CPU | LLVM | 16,110 | 94 | 1 | [] |
[
"<s>",
"static",
"inline",
"int",
"arm_arm_address_cost",
"(",
"rtx",
"x",
")",
"{",
"enum",
"rtx_code",
"c",
"=",
"GET_CODE",
"(",
"x",
")",
";",
"if",
"(",
"c",
"==",
"PRE_INC",
"||",
"c",
"==",
"PRE_DEC",
"||",
"c",
"==",
"POST_INC",
"||",
"c",
"==",
"POST_DEC",
")",
"return",
"0",
";",
"if",
"(",
"c",
"==",
"MEM",
"||",
"c",
"==",
"LABEL_REF",
"||",
"c",
"==",
"SYMBOL_REF",
")",
"return",
"10",
";",
"if",
"(",
"c",
"==",
"PLUS",
"||",
"c",
"==",
"MINUS",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"==",
"CONST_INT",
")",
"return",
"2",
";",
"if",
"(",
"ARITHMETIC_P",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"||",
"ARITHMETIC_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
")",
"return",
"3",
";",
"return",
"4",
";",
"}",
"return",
"6",
";",
"}",
"</s>"
] | [
"All",
"address",
"computations",
"that",
"can",
"be",
"done",
"are",
"free",
",",
"but",
"rtx",
"cost",
"returns",
"the",
"same",
"for",
"practically",
"all",
"of",
"them",
".",
"So",
"we",
"weight",
"the",
"different",
"types",
"of",
"address",
"here",
"in",
"the",
"order",
"(",
"most",
"pref",
"first",
")",
":",
"PRE/POST_INC/DEC",
",",
"SHIFT",
"or",
"NON-INT",
"sum",
",",
"INT",
"sum",
",",
"REG",
",",
"MEM",
"or",
"LABEL",
"."
] | [
"arm",
"0",
"10",
"0",
"2",
"0",
"1",
"3",
"4",
"6"
] | arm3 | arm_arm_address_cost | arm | CPU | GCC | 16,111 | 117 | 1 | [] |
[
"<s>",
"static",
"rtx",
"gen_frame_mem_offset",
"(",
"machine_mode",
"mode",
",",
"rtx",
"reg",
",",
"int",
"offset",
")",
"{",
"rtx",
"int_rtx",
",",
"offset_rtx",
";",
"int_rtx",
"=",
"GEN_INT",
"(",
"offset",
")",
";",
"if",
"(",
"(",
"TARGET_SPE_ABI",
"&&",
"SPE_VECTOR_MODE",
"(",
"mode",
")",
"&&",
"!",
"SPE_CONST_OFFSET_OK",
"(",
"offset",
")",
")",
"||",
"(",
"TARGET_E500_DOUBLE",
"&&",
"mode",
"==",
"DFmode",
")",
")",
"{",
"offset_rtx",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"FIXED_SCRATCH",
")",
";",
"emit_move_insn",
"(",
"offset_rtx",
",",
"int_rtx",
")",
";",
"}",
"else",
"offset_rtx",
"=",
"int_rtx",
";",
"return",
"gen_frame_mem",
"(",
"mode",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"reg",
",",
"offset_rtx",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"an",
"offset",
"memory",
"reference",
"suitable",
"for",
"a",
"frame",
"store",
",",
"while",
"converting",
"to",
"a",
"valid",
"addressing",
"mode",
"."
] | [
"powerpcspe"
] | powerpcspe | gen_frame_mem_offset | powerpcspe | CPU | GCC | 16,112 | 90 | 1 | [] |
[
"<s>",
"bool",
"MipsDAGToDAGISel",
"::",
"SelectInlineAsmMemoryOperand",
"(",
"const",
"SDValue",
"&",
"Op",
",",
"unsigned",
"ConstraintID",
",",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"&",
"OutOps",
")",
"{",
"switch",
"(",
"ConstraintID",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unexpected asm memory constraint\"",
")",
";",
"case",
"InlineAsm",
"::",
"Constraint_m",
":",
"case",
"InlineAsm",
"::",
"Constraint_R",
":",
"case",
"InlineAsm",
"::",
"Constraint_ZC",
":",
"OutOps",
".",
"push_back",
"(",
"Op",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"SelectInlineAsmMemoryOperand",
"-",
"Select",
"the",
"specified",
"address",
"as",
"a",
"target",
"addressing",
"mode",
",",
"according",
"to",
"the",
"specified",
"constraint",
"."
] | [
"Mips",
"Mips",
"\"Unexpected asm memory constraint\""
] | MipsISelDAGToDAG27 | SelectInlineAsmMemoryOperand | Mips | CPU | LLVM | 16,113 | 65 | 1 | [] |
[
"<s>",
"unsigned",
"getExceptionPointerRegister",
"(",
"const",
"Constant",
"*",
"PersonalityFn",
")",
"const",
"override",
"{",
"return",
"SP",
"::",
"I0",
";",
"}",
"</s>"
] | [
"If",
"a",
"physical",
"register",
",",
"this",
"returns",
"the",
"register",
"that",
"receives",
"the",
"exception",
"address",
"on",
"entry",
"to",
"an",
"EH",
"pad",
"."
] | [
"Sparc",
"SP::I0"
] | SparcISelLowering (2)2 | getExceptionPointerRegister | Sparc | CPU | LLVM | 16,114 | 17 | 1 | [] |
[
"<s>",
"bool",
"sh_vector_mode_supported_p",
"(",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Implements",
"target",
"hook",
"vector_mode_supported_p",
"."
] | [
"sh"
] | sh | sh_vector_mode_supported_p | sh | CPU | GCC | 16,115 | 12 | 1 | [] |
[
"<s>",
"void",
"microblaze_expand_epilogue",
"(",
"void",
")",
"{",
"HOST_WIDE_INT",
"fsiz",
"=",
"current_frame_info",
".",
"total_size",
";",
"rtx",
"fsiz_rtx",
"=",
"GEN_INT",
"(",
"fsiz",
")",
";",
"rtx",
"reg_rtx",
";",
"rtx",
"mem_rtx",
";",
"if",
"(",
"microblaze_can_use_return_insn",
"(",
")",
")",
"{",
"emit_jump_insn",
"(",
"gen_return_internal",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"GP_REG_FIRST",
"+",
"MB_ABI_SUB_RETURN_ADDR_REGNUM",
")",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"fsiz",
">",
"0",
")",
"{",
"if",
"(",
"!",
"crtl",
"->",
"is_leaf",
"||",
"interrupt_handler",
")",
"{",
"mem_rtx",
"=",
"gen_rtx_MEM",
"(",
"SImode",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"const0_rtx",
")",
")",
";",
"if",
"(",
"interrupt_handler",
")",
"MEM_VOLATILE_P",
"(",
"mem_rtx",
")",
"=",
"1",
";",
"reg_rtx",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"MB_ABI_SUB_RETURN_ADDR_REGNUM",
")",
";",
"emit_move_insn",
"(",
"reg_rtx",
",",
"mem_rtx",
")",
";",
"}",
"if",
"(",
"frame_pointer_needed",
")",
"emit_insn",
"(",
"gen_movsi",
"(",
"stack_pointer_rtx",
",",
"hard_frame_pointer_rtx",
")",
")",
";",
"save_restore_insns",
"(",
"0",
")",
";",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"fsiz_rtx",
")",
")",
";",
"}",
"if",
"(",
"crtl",
"->",
"calls_eh_return",
")",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"gen_raw_REG",
"(",
"SImode",
",",
"MB_EH_STACKADJ_REGNUM",
")",
")",
")",
";",
"emit_jump_insn",
"(",
"gen_return_internal",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"GP_REG_FIRST",
"+",
"MB_ABI_SUB_RETURN_ADDR_REGNUM",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"the",
"epilogue",
"into",
"a",
"bunch",
"of",
"separate",
"insns",
"."
] | [
"microblaze",
"0",
"1",
"0"
] | microblaze | microblaze_expand_epilogue | microblaze | MPU | GCC | 16,116 | 191 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_darwin64_record_arg_flush",
"(",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"HOST_WIDE_INT",
"bitpos",
",",
"rtx",
"rvec",
"[",
"]",
",",
"int",
"*",
"k",
")",
"{",
"machine_mode",
"mode",
";",
"unsigned",
"int",
"regno",
";",
"unsigned",
"int",
"startbit",
",",
"endbit",
";",
"int",
"this_regno",
",",
"intregs",
",",
"intoffset",
";",
"rtx",
"reg",
";",
"if",
"(",
"cum",
"->",
"intoffset",
"==",
"-",
"1",
")",
"return",
";",
"intoffset",
"=",
"cum",
"->",
"intoffset",
";",
"cum",
"->",
"intoffset",
"=",
"-",
"1",
";",
"if",
"(",
"intoffset",
"%",
"BITS_PER_WORD",
"!=",
"0",
")",
"{",
"mode",
"=",
"mode_for_size",
"(",
"BITS_PER_WORD",
"-",
"intoffset",
"%",
"BITS_PER_WORD",
",",
"MODE_INT",
",",
"0",
")",
";",
"if",
"(",
"mode",
"==",
"BLKmode",
")",
"{",
"intoffset",
"=",
"ROUND_DOWN",
"(",
"intoffset",
",",
"BITS_PER_WORD",
")",
";",
"mode",
"=",
"word_mode",
";",
"}",
"}",
"else",
"mode",
"=",
"word_mode",
";",
"startbit",
"=",
"ROUND_DOWN",
"(",
"intoffset",
",",
"BITS_PER_WORD",
")",
";",
"endbit",
"=",
"ROUND_UP",
"(",
"bitpos",
",",
"BITS_PER_WORD",
")",
";",
"intregs",
"=",
"(",
"endbit",
"-",
"startbit",
")",
"/",
"BITS_PER_WORD",
";",
"this_regno",
"=",
"cum",
"->",
"words",
"+",
"intoffset",
"/",
"BITS_PER_WORD",
";",
"if",
"(",
"intregs",
">",
"0",
"&&",
"intregs",
">",
"GP_ARG_NUM_REG",
"-",
"this_regno",
")",
"cum",
"->",
"use_stack",
"=",
"1",
";",
"intregs",
"=",
"MIN",
"(",
"intregs",
",",
"GP_ARG_NUM_REG",
"-",
"this_regno",
")",
";",
"if",
"(",
"intregs",
"<=",
"0",
")",
"return",
";",
"intoffset",
"/=",
"BITS_PER_UNIT",
";",
"do",
"{",
"regno",
"=",
"GP_ARG_MIN_REG",
"+",
"this_regno",
";",
"reg",
"=",
"gen_rtx_REG",
"(",
"mode",
",",
"regno",
")",
";",
"rvec",
"[",
"(",
"*",
"k",
")",
"++",
"]",
"=",
"gen_rtx_EXPR_LIST",
"(",
"VOIDmode",
",",
"reg",
",",
"GEN_INT",
"(",
"intoffset",
")",
")",
";",
"this_regno",
"+=",
"1",
";",
"intoffset",
"=",
"(",
"intoffset",
"|",
"(",
"UNITS_PER_WORD",
"-",
"1",
")",
")",
"+",
"1",
";",
"mode",
"=",
"word_mode",
";",
"intregs",
"-=",
"1",
";",
"}",
"while",
"(",
"intregs",
">",
"0",
")",
";",
"}",
"</s>"
] | [
"A",
"subroutine",
"of",
"rs6000_darwin64_record_arg",
".",
"Assign",
"the",
"bits",
"of",
"the",
"structure",
"between",
"cum-",
">",
"intoffset",
"and",
"bitpos",
"to",
"integer",
"registers",
"."
] | [
"rs6000",
"1",
"1",
"0",
"0",
"0",
"1",
"0",
"1",
"1",
"1",
"1",
"0"
] | rs60005 | rs6000_darwin64_record_arg_flush | rs6000 | CPU | GCC | 16,117 | 271 | 1 | [] |
[
"<s>",
"static",
"rtx",
"arc_dwarf_register_span",
"(",
"rtx",
"rtl",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"rtl",
")",
";",
"unsigned",
"regno",
";",
"rtx",
"p",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"!=",
"8",
")",
"return",
"NULL_RTX",
";",
"p",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"rtvec_alloc",
"(",
"2",
")",
")",
";",
"regno",
"=",
"REGNO",
"(",
"rtl",
")",
";",
"XVECEXP",
"(",
"p",
",",
"0",
",",
"0",
")",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"regno",
")",
";",
"XVECEXP",
"(",
"p",
",",
"0",
",",
"1",
")",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"regno",
"+",
"1",
")",
";",
"return",
"p",
";",
"}",
"</s>"
] | [
"Return",
"a",
"parallel",
"of",
"registers",
"to",
"represent",
"where",
"to",
"find",
"the",
"register",
"pieces",
"if",
"required",
",",
"otherwise",
"NULL_RTX",
"."
] | [
"arc",
"8",
"2",
"0",
"0",
"0",
"1",
"1"
] | arc | arc_dwarf_register_span | arc | MPU | GCC | 16,118 | 91 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"optimizeCompareInstr",
"(",
"MachineInstr",
"&",
"CmpInstr",
",",
"Register",
"SrcReg",
",",
"Register",
"SrcReg2",
",",
"int",
"CmpMask",
",",
"int",
"CmpValue",
",",
"const",
"MachineRegisterInfo",
"*",
"MRI",
")",
"const",
"{",
"assert",
"(",
"CmpInstr",
".",
"getParent",
"(",
")",
")",
";",
"assert",
"(",
"MRI",
")",
";",
"int",
"DeadNZCVIdx",
"=",
"CmpInstr",
".",
"findRegisterDefOperandIdx",
"(",
"AArch64",
"::",
"NZCV",
",",
"true",
")",
";",
"if",
"(",
"DeadNZCVIdx",
"!=",
"-",
"1",
")",
"{",
"if",
"(",
"CmpInstr",
".",
"definesRegister",
"(",
"AArch64",
"::",
"WZR",
")",
"||",
"CmpInstr",
".",
"definesRegister",
"(",
"AArch64",
"::",
"XZR",
")",
")",
"{",
"CmpInstr",
".",
"eraseFromParent",
"(",
")",
";",
"return",
"true",
";",
"}",
"unsigned",
"Opc",
"=",
"CmpInstr",
".",
"getOpcode",
"(",
")",
";",
"unsigned",
"NewOpc",
"=",
"convertToNonFlagSettingOpc",
"(",
"CmpInstr",
")",
";",
"if",
"(",
"NewOpc",
"==",
"Opc",
")",
"return",
"false",
";",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"get",
"(",
"NewOpc",
")",
";",
"CmpInstr",
".",
"setDesc",
"(",
"MCID",
")",
";",
"CmpInstr",
".",
"RemoveOperand",
"(",
"DeadNZCVIdx",
")",
";",
"bool",
"succeeded",
"=",
"UpdateOperandRegClass",
"(",
"CmpInstr",
")",
";",
"(",
"void",
")",
"succeeded",
";",
"assert",
"(",
"succeeded",
"&&",
"\"Some operands reg class are incompatible!\"",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"CmpInstr",
".",
"getOpcode",
"(",
")",
"==",
"AArch64",
"::",
"PTEST_PP",
")",
"return",
"optimizePTestInstr",
"(",
"&",
"CmpInstr",
",",
"SrcReg",
",",
"SrcReg2",
",",
"MRI",
")",
";",
"assert",
"(",
"(",
"CmpValue",
"==",
"0",
"||",
"CmpValue",
"==",
"1",
")",
"&&",
"\"CmpValue must be 0 or 1!\"",
")",
";",
"if",
"(",
"CmpValue",
"!=",
"0",
"||",
"SrcReg2",
"!=",
"0",
")",
"return",
"false",
";",
"if",
"(",
"!",
"MRI",
"->",
"use_nodbg_empty",
"(",
"CmpInstr",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
")",
"return",
"false",
";",
"return",
"substituteCmpToZero",
"(",
"CmpInstr",
",",
"SrcReg",
",",
"MRI",
")",
";",
"}",
"</s>"
] | [
"optimizeCompareInstr",
"-",
"Check",
"if",
"there",
"exists",
"an",
"earlier",
"instruction",
"that",
"operates",
"on",
"the",
"same",
"source",
"operands",
"and",
"sets",
"flags",
"in",
"the",
"same",
"way",
"as",
"Compare",
";",
"remove",
"Compare",
"if",
"possible",
"."
] | [
"AArch64",
"AArch64",
"AArch64::NZCV",
"1",
"AArch64::WZR",
"AArch64::XZR",
"\"Some operands reg class are incompatible!\"",
"AArch64::PTEST_PP",
"0",
"1",
"\"CmpValue must be 0 or 1!\"",
"0",
"0",
"0"
] | AArch64InstrInfo107 | optimizeCompareInstr | AArch64 | CPU | LLVM | 16,119 | 255 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"SHUXITargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"(",
"SHUXIISD",
"::",
"NodeType",
")",
"Opcode",
")",
"{",
"case",
"SHUXIISD",
"::",
"FIRST_NUMBER",
":",
"break",
";",
"case",
"SHUXIISD",
"::",
"CMP",
":",
"return",
"\"SHUXIISD::CMP\"",
";",
"case",
"SHUXIISD",
"::",
"RET_FLAG",
":",
"return",
"\"SHUXIISD::RET_FLAG\"",
";",
"case",
"SHUXIISD",
"::",
"BR_CC",
":",
"return",
"\"SHUXIISD::BR_CC\"",
";",
"case",
"SHUXIISD",
"::",
"SELECT_CC",
":",
"return",
"\"SHUXIISD::SELECT_CC\"",
";",
"case",
"SHUXIISD",
"::",
"Wrapper",
":",
"return",
"\"SHUXIISD::Wrapper\"",
";",
"case",
"SHUXIISD",
"::",
"CALL",
":",
"return",
"\"SHUXIISD::CALL\"",
";",
"}",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"SHUXI",
"SHUXI",
"SHUXIISD::NodeType",
"SHUXIISD::FIRST_NUMBER",
"SHUXIISD::CMP",
"\"SHUXIISD::CMP\"",
"SHUXIISD::RET_FLAG",
"\"SHUXIISD::RET_FLAG\"",
"SHUXIISD::BR_CC",
"\"SHUXIISD::BR_CC\"",
"SHUXIISD::SELECT_CC",
"\"SHUXIISD::SELECT_CC\"",
"SHUXIISD::Wrapper",
"\"SHUXIISD::Wrapper\"",
"SHUXIISD::CALL",
"\"SHUXIISD::CALL\""
] | SHUXIISelLowering | getTargetNodeName | SHUXI | CPU | LLVM | 16,120 | 82 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyCFGStackify",
"::",
"releaseMemory",
"(",
")",
"{",
"ScopeTops",
".",
"clear",
"(",
")",
";",
"BeginToEnd",
".",
"clear",
"(",
")",
";",
"EndToBegin",
".",
"clear",
"(",
")",
";",
"TryToEHPad",
".",
"clear",
"(",
")",
";",
"EHPadToTry",
".",
"clear",
"(",
")",
";",
"BeginToBottom",
".",
"clear",
"(",
")",
";",
"}",
"</s>"
] | [
"releaseMemory",
"(",
")",
"-",
"This",
"member",
"can",
"be",
"implemented",
"by",
"a",
"pass",
"if",
"it",
"wants",
"to",
"be",
"able",
"to",
"release",
"its",
"memory",
"when",
"it",
"is",
"no",
"longer",
"needed",
"."
] | [
"WebAssembly",
"WebAssembly"
] | WebAssemblyCFGStackify1 | releaseMemory | WebAssembly | Virtual ISA | LLVM | 16,121 | 44 | 1 | [] |
[
"<s>",
"int",
"ia64_direct_return",
"(",
")",
"{",
"if",
"(",
"reload_completed",
"&&",
"!",
"frame_pointer_needed",
")",
"{",
"ia64_compute_frame_size",
"(",
"get_frame_size",
"(",
")",
")",
";",
"return",
"(",
"current_frame_info",
".",
"total_size",
"==",
"0",
"&&",
"current_frame_info",
".",
"n_spilled",
"==",
"0",
"&&",
"current_frame_info",
".",
"reg_save_b0",
"==",
"0",
"&&",
"current_frame_info",
".",
"reg_save_pr",
"==",
"0",
"&&",
"current_frame_info",
".",
"reg_save_ar_pfs",
"==",
"0",
"&&",
"current_frame_info",
".",
"reg_save_ar_unat",
"==",
"0",
"&&",
"current_frame_info",
".",
"reg_save_ar_lc",
"==",
"0",
")",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"1",
"if",
"br.ret",
"can",
"do",
"all",
"the",
"work",
"required",
"to",
"return",
"from",
"a",
"function",
"."
] | [
"ia64",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0"
] | ia642 | ia64_direct_return | ia64 | CPU | GCC | 16,122 | 70 | 1 | [] |
[
"<s>",
"virtual",
"const",
"TargetSubtargetInfo",
"*",
"getSubtargetImpl",
"(",
"const",
"Function",
"&",
")",
"const",
"override",
"{",
"return",
"&",
"Subtarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"CJG"
] | CJGTargetMachine | getSubtargetImpl | CJG | CPU | LLVM | 16,123 | 18 | 1 | [] |
[
"<s>",
"static",
"void",
"spu_emit_branch_hint",
"(",
"rtx_insn",
"*",
"before",
",",
"rtx_insn",
"*",
"branch",
",",
"rtx",
"target",
",",
"int",
"distance",
",",
"sbitmap",
"blocks",
")",
"{",
"rtx_insn",
"*",
"hint",
";",
"rtx_insn",
"*",
"insn",
";",
"rtx_jump_table_data",
"*",
"table",
";",
"if",
"(",
"before",
"==",
"0",
"||",
"branch",
"==",
"0",
"||",
"target",
"==",
"0",
")",
"return",
";",
"if",
"(",
"distance",
">",
"600",
")",
"return",
";",
"if",
"(",
"NOTE_INSN_BASIC_BLOCK_P",
"(",
"before",
")",
")",
"before",
"=",
"NEXT_INSN",
"(",
"before",
")",
";",
"rtx_code_label",
"*",
"branch_label",
"=",
"gen_label_rtx",
"(",
")",
";",
"LABEL_NUSES",
"(",
"branch_label",
")",
"++",
";",
"LABEL_PRESERVE_P",
"(",
"branch_label",
")",
"=",
"1",
";",
"insn",
"=",
"emit_label_before",
"(",
"branch_label",
",",
"branch",
")",
";",
"rtx",
"branch_label_ref",
"=",
"gen_rtx_LABEL_REF",
"(",
"VOIDmode",
",",
"branch_label",
")",
";",
"bitmap_set_bit",
"(",
"blocks",
",",
"BLOCK_FOR_INSN",
"(",
"branch",
")",
"->",
"index",
")",
";",
"hint",
"=",
"emit_insn_before",
"(",
"gen_hbr",
"(",
"branch_label_ref",
",",
"target",
")",
",",
"before",
")",
";",
"recog_memoized",
"(",
"hint",
")",
";",
"INSN_LOCATION",
"(",
"hint",
")",
"=",
"INSN_LOCATION",
"(",
"branch",
")",
";",
"HINTED_P",
"(",
"branch",
")",
"=",
"1",
";",
"if",
"(",
"GET_CODE",
"(",
"target",
")",
"==",
"LABEL_REF",
")",
"HINTED_P",
"(",
"XEXP",
"(",
"target",
",",
"0",
")",
")",
"=",
"1",
";",
"else",
"if",
"(",
"tablejump_p",
"(",
"branch",
",",
"0",
",",
"&",
"table",
")",
")",
"{",
"rtvec",
"vec",
";",
"int",
"j",
";",
"if",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"table",
")",
")",
"==",
"ADDR_VEC",
")",
"vec",
"=",
"XVEC",
"(",
"PATTERN",
"(",
"table",
")",
",",
"0",
")",
";",
"else",
"vec",
"=",
"XVEC",
"(",
"PATTERN",
"(",
"table",
")",
",",
"1",
")",
";",
"for",
"(",
"j",
"=",
"GET_NUM_ELEM",
"(",
"vec",
")",
"-",
"1",
";",
"j",
">=",
"0",
";",
"--",
"j",
")",
"HINTED_P",
"(",
"XEXP",
"(",
"RTVEC_ELT",
"(",
"vec",
",",
"j",
")",
",",
"0",
")",
")",
"=",
"1",
";",
"}",
"if",
"(",
"distance",
">=",
"588",
")",
"{",
"insn",
"=",
"emit_insn_before",
"(",
"gen_blockage",
"(",
")",
",",
"hint",
")",
";",
"recog_memoized",
"(",
"insn",
")",
";",
"INSN_LOCATION",
"(",
"insn",
")",
"=",
"INSN_LOCATION",
"(",
"hint",
")",
";",
"}",
"else",
"if",
"(",
"distance",
"<=",
"8",
"*",
"4",
")",
"{",
"int",
"d",
";",
"for",
"(",
"d",
"=",
"distance",
";",
"d",
"<",
"8",
"*",
"4",
";",
"d",
"+=",
"4",
")",
"{",
"insn",
"=",
"emit_insn_after",
"(",
"gen_nopn_nv",
"(",
"gen_rtx_REG",
"(",
"SImode",
",",
"127",
")",
")",
",",
"hint",
")",
";",
"recog_memoized",
"(",
"insn",
")",
";",
"INSN_LOCATION",
"(",
"insn",
")",
"=",
"INSN_LOCATION",
"(",
"hint",
")",
";",
"}",
"insn",
"=",
"emit_insn_after",
"(",
"gen_blockage",
"(",
")",
",",
"hint",
")",
";",
"recog_memoized",
"(",
"insn",
")",
";",
"INSN_LOCATION",
"(",
"insn",
")",
"=",
"INSN_LOCATION",
"(",
"hint",
")",
";",
"if",
"(",
"CALL_P",
"(",
"branch",
")",
"&&",
"distance",
"<",
"8",
"*",
"4",
")",
"{",
"insn",
"=",
"emit_insn_before",
"(",
"gen_blockage",
"(",
")",
",",
"branch",
")",
";",
"recog_memoized",
"(",
"insn",
")",
";",
"INSN_LOCATION",
"(",
"insn",
")",
"=",
"INSN_LOCATION",
"(",
"branch",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Routines",
"for",
"branch",
"hints",
"."
] | [
"spu",
"0",
"0",
"0",
"600",
"1",
"1",
"0",
"1",
"0",
"0",
"1",
"1",
"0",
"0",
"1",
"588",
"8",
"4",
"8",
"4",
"4",
"127",
"8",
"4"
] | spu2 | spu_emit_branch_hint | spu | MPU | GCC | 16,124 | 440 | 1 | [] |
[
"<s>",
"const",
"uint16_t",
"*",
"MipsRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"if",
"(",
"Subtarget",
".",
"isSingleFloat",
"(",
")",
")",
"return",
"CSR_SingleFloatOnly_SaveList",
";",
"if",
"(",
"Subtarget",
".",
"isABI_N64",
"(",
")",
")",
"return",
"CSR_N64_SaveList",
";",
"if",
"(",
"Subtarget",
".",
"isABI_N32",
"(",
")",
")",
"return",
"CSR_N32_SaveList",
";",
"if",
"(",
"Subtarget",
".",
"isFP64bit",
"(",
")",
")",
"return",
"CSR_O32_FP64_SaveList",
";",
"return",
"CSR_O32_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"Mips",
"Mips"
] | MipsRegisterInfo19 | getCalleeSavedRegs | Mips | CPU | LLVM | 16,125 | 62 | 1 | [] |
[
"<s>",
"void",
"PPCAIXAsmPrinter",
"::",
"emitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"PPC",
"::",
"BL8",
":",
"case",
"PPC",
"::",
"BL",
":",
"case",
"PPC",
"::",
"BL8_NOP",
":",
"case",
"PPC",
"::",
"BL_NOP",
":",
"{",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
";",
"if",
"(",
"MO",
".",
"isSymbol",
"(",
")",
")",
"{",
"MCSymbolXCOFF",
"*",
"S",
"=",
"cast",
"<",
"MCSymbolXCOFF",
">",
"(",
"OutContext",
".",
"getOrCreateSymbol",
"(",
"MO",
".",
"getSymbolName",
"(",
")",
")",
")",
";",
"ExtSymSDNodeSymbols",
".",
"insert",
"(",
"S",
")",
";",
"}",
"}",
"break",
";",
"case",
"PPC",
"::",
"BL_TLS",
":",
"case",
"PPC",
"::",
"BL8_TLS",
":",
"case",
"PPC",
"::",
"BL8_TLS_",
":",
"case",
"PPC",
"::",
"BL8_NOP_TLS",
":",
"report_fatal_error",
"(",
"\"TLS call not yet implemented\"",
")",
";",
"case",
"PPC",
"::",
"TAILB",
":",
"case",
"PPC",
"::",
"TAILB8",
":",
"case",
"PPC",
"::",
"TAILBA",
":",
"case",
"PPC",
"::",
"TAILBA8",
":",
"case",
"PPC",
"::",
"TAILBCTR",
":",
"case",
"PPC",
"::",
"TAILBCTR8",
":",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"isSymbol",
"(",
")",
")",
"report_fatal_error",
"(",
"\"Tail call for extern symbol not yet supported.\"",
")",
";",
"break",
";",
"}",
"return",
"PPCAsmPrinter",
"::",
"emitInstruction",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"Targets",
"should",
"implement",
"this",
"to",
"emit",
"instructions",
"."
] | [
"PowerPC",
"PPC",
"PPC::BL8",
"PPC::BL",
"PPC::BL8_NOP",
"PPC::BL_NOP",
"0",
"PPC::BL_TLS",
"PPC::BL8_TLS",
"PPC::BL8_TLS_",
"PPC::BL8_NOP_TLS",
"\"TLS call not yet implemented\"",
"PPC::TAILB",
"PPC::TAILB8",
"PPC::TAILBA",
"PPC::TAILBA8",
"PPC::TAILBCTR",
"PPC::TAILBCTR8",
"0",
"\"Tail call for extern symbol not yet supported.\"",
"PPC"
] | PPCAsmPrinter10 | emitInstruction | PowerPC | CPU | LLVM | 16,126 | 183 | 1 | [] |
[
"<s>",
"rtx_insn",
"*",
"s390_emit_jump",
"(",
"rtx",
"target",
",",
"rtx",
"cond",
")",
"{",
"rtx",
"insn",
";",
"target",
"=",
"gen_rtx_LABEL_REF",
"(",
"VOIDmode",
",",
"target",
")",
";",
"if",
"(",
"cond",
")",
"target",
"=",
"gen_rtx_IF_THEN_ELSE",
"(",
"VOIDmode",
",",
"cond",
",",
"target",
",",
"pc_rtx",
")",
";",
"insn",
"=",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"pc_rtx",
",",
"target",
")",
";",
"return",
"emit_jump_insn",
"(",
"insn",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"jump",
"instruction",
"to",
"TARGET",
".",
"If",
"COND",
"is",
"NULL_RTX",
",",
"emit",
"an",
"unconditional",
"jump",
",",
"else",
"a",
"conditional",
"jump",
"under",
"condition",
"COND",
"."
] | [
"s390"
] | s3904 | s390_emit_jump | s390 | MPU | GCC | 16,127 | 58 | 1 | [] |
[
"<s>",
"static",
"struct",
"mips_multi_member",
"*",
"mips_multi_add",
"(",
"void",
")",
"{",
"mips_multi_member",
"empty",
";",
"memset",
"(",
"&",
"empty",
",",
"0",
",",
"sizeof",
"(",
"empty",
")",
")",
";",
"return",
"mips_multi_members",
".",
"safe_push",
"(",
"empty",
")",
";",
"}",
"</s>"
] | [
"Add",
"a",
"new",
",",
"uninitialized",
"member",
"to",
"the",
"current",
"multi-insn",
"sequence",
"."
] | [
"mips",
"0"
] | mips | mips_multi_add | mips | CPU | GCC | 16,128 | 34 | 1 | [] |
[
"<s>",
"void",
"AnalyzeCallResult",
"(",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"CCAssignFn",
"Fn",
",",
"const",
"TargetLowering",
"::",
"CallLoweringInfo",
"&",
"CLI",
")",
"{",
"PreAnalyzeCallResultForF128",
"(",
"Ins",
",",
"CLI",
")",
";",
"CCState",
"::",
"AnalyzeCallResult",
"(",
"Ins",
",",
"Fn",
")",
";",
"OriginalArgWasFloat",
".",
"clear",
"(",
")",
";",
"OriginalArgWasF128",
".",
"clear",
"(",
")",
";",
"}",
"</s>"
] | [
"AnalyzeCallResult",
"-",
"Same",
"as",
"above",
"except",
"it",
"'s",
"specialized",
"for",
"calls",
"which",
"produce",
"a",
"single",
"value",
"."
] | [
"Mips",
"ISD::InputArg"
] | MipsCCState | AnalyzeCallResult | Mips | CPU | LLVM | 16,129 | 53 | 1 | [] |
[
"<s>",
"static",
"void",
"add_to_reg",
"(",
"rtx",
"reg",
",",
"HOST_WIDE_INT",
"value",
",",
"int",
"frame",
",",
"int",
"epilogue_p",
")",
"{",
"if",
"(",
"value",
"==",
"0",
")",
"return",
";",
"if",
"(",
"value",
">",
"120",
"||",
"value",
"<",
"-",
"120",
")",
"{",
"rtx",
"tmpreg",
";",
"rtx",
"tmpreg2",
";",
"rtx_insn",
"*",
"insn",
";",
"tmpreg2",
"=",
"NULL_RTX",
";",
"if",
"(",
"epilogue_p",
">=",
"0",
")",
"tmpreg",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"REG_P1",
")",
";",
"else",
"{",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"REG_P0",
";",
"i",
"<=",
"REG_P5",
";",
"i",
"++",
")",
"if",
"(",
"(",
"df_regs_ever_live_p",
"(",
"i",
")",
"&&",
"!",
"call_used_regs",
"[",
"i",
"]",
")",
"||",
"(",
"!",
"TARGET_FDPIC",
"&&",
"i",
"==",
"PIC_OFFSET_TABLE_REGNUM",
"&&",
"(",
"crtl",
"->",
"uses_pic_offset_table",
"||",
"(",
"TARGET_ID_SHARED_LIBRARY",
"&&",
"!",
"crtl",
"->",
"is_leaf",
")",
")",
")",
")",
"break",
";",
"if",
"(",
"i",
"<=",
"REG_P5",
")",
"tmpreg",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"i",
")",
";",
"else",
"{",
"tmpreg",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"REG_P1",
")",
";",
"tmpreg2",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"REG_I0",
")",
";",
"emit_move_insn",
"(",
"tmpreg2",
",",
"tmpreg",
")",
";",
"}",
"}",
"if",
"(",
"frame",
")",
"frame_related_constant_load",
"(",
"tmpreg",
",",
"value",
",",
"TRUE",
")",
";",
"else",
"insn",
"=",
"emit_move_insn",
"(",
"tmpreg",
",",
"GEN_INT",
"(",
"value",
")",
")",
";",
"insn",
"=",
"emit_insn",
"(",
"gen_addsi3",
"(",
"reg",
",",
"reg",
",",
"tmpreg",
")",
")",
";",
"if",
"(",
"frame",
")",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"if",
"(",
"tmpreg2",
"!=",
"NULL_RTX",
")",
"emit_move_insn",
"(",
"tmpreg",
",",
"tmpreg2",
")",
";",
"}",
"else",
"do",
"{",
"int",
"size",
"=",
"value",
";",
"rtx_insn",
"*",
"insn",
";",
"if",
"(",
"size",
">",
"60",
")",
"size",
"=",
"60",
";",
"else",
"if",
"(",
"size",
"<",
"-",
"60",
")",
"size",
"=",
"-",
"60",
";",
"insn",
"=",
"emit_insn",
"(",
"gen_addsi3",
"(",
"reg",
",",
"reg",
",",
"GEN_INT",
"(",
"size",
")",
")",
")",
";",
"if",
"(",
"frame",
")",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"value",
"-=",
"size",
";",
"}",
"while",
"(",
"value",
"!=",
"0",
")",
";",
"}",
"</s>"
] | [
"Generate",
"efficient",
"code",
"to",
"add",
"a",
"value",
"to",
"a",
"P",
"register",
".",
"Set",
"RTX_FRAME_RELATED_P",
"on",
"the",
"generated",
"insns",
"if",
"FRAME",
"is",
"nonzero",
".",
"EPILOGUE_P",
"is",
"zero",
"if",
"this",
"function",
"is",
"called",
"for",
"prologue",
",",
"otherwise",
"it",
"'s",
"nonzero",
".",
"And",
"it",
"'s",
"less",
"than",
"zero",
"if",
"this",
"is",
"for",
"sibcall",
"epilogue",
"."
] | [
"bfin",
"0",
"120",
"120",
"0",
"1",
"60",
"60",
"60",
"60",
"1",
"0"
] | bfin3 | add_to_reg | bfin | DSP | GCC | 16,130 | 310 | 1 | [] |
[
"<s>",
"Optional",
"<",
"bool",
">",
"isSyncScopeInclusion",
"(",
"SyncScope",
"::",
"ID",
"A",
",",
"SyncScope",
"::",
"ID",
"B",
")",
"const",
"{",
"const",
"auto",
"&",
"AIO",
"=",
"getSyncScopeInclusionOrdering",
"(",
"A",
")",
";",
"const",
"auto",
"&",
"BIO",
"=",
"getSyncScopeInclusionOrdering",
"(",
"B",
")",
";",
"if",
"(",
"!",
"AIO",
"||",
"!",
"BIO",
")",
"return",
"None",
";",
"return",
"AIO",
".",
"getValue",
"(",
")",
">",
"BIO",
".",
"getValue",
"(",
")",
";",
"}",
"</s>"
] | [
"In",
"AMDGPU",
"target",
"synchronization",
"scopes",
"are",
"inclusive",
",",
"meaning",
"a",
"larger",
"synchronization",
"scope",
"is",
"inclusive",
"of",
"a",
"smaller",
"synchronization",
"scope",
"."
] | [
"AMDGPU"
] | AMDGPUMachineModuleInfo | isSyncScopeInclusion | AMDGPU | GPU | LLVM | 16,131 | 63 | 1 | [] |
[
"<s>",
"int",
"X86FrameLowering",
"::",
"getFrameIndexReference",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"int",
"FI",
",",
"Register",
"&",
"FrameReg",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"bool",
"IsFixed",
"=",
"MFI",
".",
"isFixedObjectIndex",
"(",
"FI",
")",
";",
"if",
"(",
"TRI",
"->",
"hasBasePointer",
"(",
"MF",
")",
")",
"FrameReg",
"=",
"IsFixed",
"?",
"TRI",
"->",
"getFramePtr",
"(",
")",
":",
"TRI",
"->",
"getBaseRegister",
"(",
")",
";",
"else",
"if",
"(",
"TRI",
"->",
"needsStackRealignment",
"(",
"MF",
")",
")",
"FrameReg",
"=",
"IsFixed",
"?",
"TRI",
"->",
"getFramePtr",
"(",
")",
":",
"TRI",
"->",
"getStackRegister",
"(",
")",
";",
"else",
"FrameReg",
"=",
"TRI",
"->",
"getFrameRegister",
"(",
"MF",
")",
";",
"int",
"Offset",
"=",
"MFI",
".",
"getObjectOffset",
"(",
"FI",
")",
"-",
"getOffsetOfLocalArea",
"(",
")",
";",
"const",
"X86MachineFunctionInfo",
"*",
"X86FI",
"=",
"MF",
".",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"CSSize",
"=",
"X86FI",
"->",
"getCalleeSavedFrameSize",
"(",
")",
";",
"uint64_t",
"StackSize",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"bool",
"HasFP",
"=",
"hasFP",
"(",
"MF",
")",
";",
"bool",
"IsWin64Prologue",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getMCAsmInfo",
"(",
")",
"->",
"usesWindowsCFI",
"(",
")",
";",
"int64_t",
"FPDelta",
"=",
"0",
";",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
".",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"X86_INTR",
"&&",
"Offset",
">=",
"0",
")",
"{",
"Offset",
"+=",
"getOffsetOfLocalArea",
"(",
")",
";",
"}",
"if",
"(",
"IsWin64Prologue",
")",
"{",
"assert",
"(",
"!",
"MFI",
".",
"hasCalls",
"(",
")",
"||",
"(",
"StackSize",
"%",
"16",
")",
"==",
"8",
")",
";",
"uint64_t",
"FrameSize",
"=",
"StackSize",
"-",
"SlotSize",
";",
"if",
"(",
"X86FI",
"->",
"getRestoreBasePointer",
"(",
")",
")",
"FrameSize",
"+=",
"SlotSize",
";",
"uint64_t",
"NumBytes",
"=",
"FrameSize",
"-",
"CSSize",
";",
"uint64_t",
"SEHFrameOffset",
"=",
"calculateSetFPREG",
"(",
"NumBytes",
")",
";",
"if",
"(",
"FI",
"&&",
"FI",
"==",
"X86FI",
"->",
"getFAIndex",
"(",
")",
")",
"return",
"-",
"SEHFrameOffset",
";",
"FPDelta",
"=",
"FrameSize",
"-",
"SEHFrameOffset",
";",
"assert",
"(",
"(",
"!",
"MFI",
".",
"hasCalls",
"(",
")",
"||",
"(",
"FPDelta",
"%",
"16",
")",
"==",
"0",
")",
"&&",
"\"FPDelta isn't aligned per the Win64 ABI!\"",
")",
";",
"}",
"if",
"(",
"TRI",
"->",
"hasBasePointer",
"(",
"MF",
")",
")",
"{",
"assert",
"(",
"HasFP",
"&&",
"\"VLAs and dynamic stack realign, but no FP?!\"",
")",
";",
"if",
"(",
"FI",
"<",
"0",
")",
"{",
"return",
"Offset",
"+",
"SlotSize",
"+",
"FPDelta",
";",
"}",
"else",
"{",
"assert",
"(",
"isAligned",
"(",
"MFI",
".",
"getObjectAlign",
"(",
"FI",
")",
",",
"-",
"(",
"Offset",
"+",
"StackSize",
")",
")",
")",
";",
"return",
"Offset",
"+",
"StackSize",
";",
"}",
"}",
"else",
"if",
"(",
"TRI",
"->",
"needsStackRealignment",
"(",
"MF",
")",
")",
"{",
"if",
"(",
"FI",
"<",
"0",
")",
"{",
"return",
"Offset",
"+",
"SlotSize",
"+",
"FPDelta",
";",
"}",
"else",
"{",
"assert",
"(",
"isAligned",
"(",
"MFI",
".",
"getObjectAlign",
"(",
"FI",
")",
",",
"-",
"(",
"Offset",
"+",
"StackSize",
")",
")",
")",
";",
"return",
"Offset",
"+",
"StackSize",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"!",
"HasFP",
")",
"return",
"Offset",
"+",
"StackSize",
";",
"Offset",
"+=",
"SlotSize",
";",
"int",
"TailCallReturnAddrDelta",
"=",
"X86FI",
"->",
"getTCReturnAddrDelta",
"(",
")",
";",
"if",
"(",
"TailCallReturnAddrDelta",
"<",
"0",
")",
"Offset",
"-=",
"TailCallReturnAddrDelta",
";",
"}",
"return",
"Offset",
"+",
"FPDelta",
";",
"}",
"</s>"
] | [
"getFrameIndexReference",
"-",
"This",
"method",
"should",
"return",
"the",
"base",
"register",
"and",
"offset",
"used",
"to",
"reference",
"a",
"frame",
"index",
"location",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"0",
"X86",
"0",
"16",
"8",
"X86",
"X86",
"16",
"0",
"\"FPDelta isn't aligned per the Win64 ABI!\"",
"\"VLAs and dynamic stack realign, but no FP?!\"",
"0",
"0",
"X86",
"0"
] | X86FrameLowering101 | getFrameIndexReference | X86 | CPU | LLVM | 16,132 | 465 | 1 | [] |
[
"<s>",
"bool",
"MipsCodeEmitter",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"JTI",
"=",
"(",
"(",
"MipsTargetMachine",
"&",
")",
"MF",
".",
"getTarget",
"(",
")",
")",
".",
"getJITInfo",
"(",
")",
";",
"II",
"=",
"(",
"(",
"const",
"MipsTargetMachine",
"&",
")",
"MF",
".",
"getTarget",
"(",
")",
")",
".",
"getInstrInfo",
"(",
")",
";",
"TD",
"=",
"(",
"(",
"const",
"MipsTargetMachine",
"&",
")",
"MF",
".",
"getTarget",
"(",
")",
")",
".",
"getDataLayout",
"(",
")",
";",
"Subtarget",
"=",
"&",
"TM",
".",
"getSubtarget",
"<",
"MipsSubtarget",
">",
"(",
")",
";",
"MCPEs",
"=",
"&",
"MF",
".",
"getConstantPool",
"(",
")",
"->",
"getConstants",
"(",
")",
";",
"MJTEs",
"=",
"0",
";",
"if",
"(",
"MF",
".",
"getJumpTableInfo",
"(",
")",
")",
"MJTEs",
"=",
"&",
"MF",
".",
"getJumpTableInfo",
"(",
")",
"->",
"getJumpTables",
"(",
")",
";",
"JTI",
"->",
"Initialize",
"(",
"MF",
",",
"IsPIC",
",",
"Subtarget",
"->",
"isLittle",
"(",
")",
")",
";",
"MCE",
".",
"setModuleInfo",
"(",
"&",
"getAnalysis",
"<",
"MachineModuleInfo",
">",
"(",
")",
")",
";",
"do",
"{",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"JITTing function '\"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"\"'\\n\"",
")",
";",
"MCE",
".",
"startFunction",
"(",
"MF",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MBB",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"MBB",
"!=",
"E",
";",
"++",
"MBB",
")",
"{",
"MCE",
".",
"StartMachineBasicBlock",
"(",
"MBB",
")",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"instr_iterator",
"I",
"=",
"MBB",
"->",
"instr_begin",
"(",
")",
",",
"E",
"=",
"MBB",
"->",
"instr_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"emitInstruction",
"(",
"*",
"I",
")",
";",
"}",
"}",
"while",
"(",
"MCE",
".",
"finishFunction",
"(",
"MF",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"Mips",
"0",
"\"JITTing function '\"",
"\"'\\n\""
] | MipsCodeEmitter10 | runOnMachineFunction | Mips | CPU | LLVM | 16,133 | 256 | 1 | [] |
[
"<s>",
"void",
"MSP430InstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIdx",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
")",
"const",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"PseudoSourceValue",
"::",
"getFixedStack",
"(",
"FrameIdx",
")",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"0",
",",
"MFI",
".",
"getObjectSize",
"(",
"FrameIdx",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FrameIdx",
")",
")",
";",
"if",
"(",
"RC",
"==",
"&",
"MSP430",
"::",
"GR16RegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"MSP430",
"::",
"MOV16mr",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"MSP430",
"::",
"GR8RegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"MSP430",
"::",
"MOV8mr",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"llvm_unreachable",
"(",
"\"Cannot store this register to stack slot!\"",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"MSP430",
"MSP430",
"0",
"MSP430::GR16RegClass",
"MSP430::MOV16mr",
"0",
"MSP430::GR8RegClass",
"MSP430::MOV8mr",
"0",
"\"Cannot store this register to stack slot!\""
] | MSP430InstrInfo2 | storeRegToStackSlot | MSP430 | MPU | LLVM | 16,134 | 217 | 1 | [] |
[
"<s>",
"bool",
"PPCInstrInfo",
"::",
"getMachineCombinerPatterns",
"(",
"MachineInstr",
"&",
"Root",
",",
"SmallVectorImpl",
"<",
"MachineCombinerPattern",
">",
"&",
"Patterns",
",",
"bool",
"DoRegPressureReduce",
")",
"const",
"{",
"if",
"(",
"Subtarget",
".",
"getTargetMachine",
"(",
")",
".",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"Aggressive",
")",
"return",
"false",
";",
"if",
"(",
"getFMAPatterns",
"(",
"Root",
",",
"Patterns",
",",
"DoRegPressureReduce",
")",
")",
"return",
"true",
";",
"return",
"TargetInstrInfo",
"::",
"getMachineCombinerPatterns",
"(",
"Root",
",",
"Patterns",
",",
"DoRegPressureReduce",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"when",
"there",
"is",
"potentially",
"a",
"faster",
"code",
"sequence",
"for",
"an",
"instruction",
"chain",
"ending",
"in",
"Root",
"."
] | [
"PowerPC",
"PPC"
] | PPCInstrInfo | getMachineCombinerPatterns | PowerPC | CPU | LLVM | 16,135 | 67 | 1 | [] |
[
"<s>",
"static",
"void",
"sparc_handle_vis_mul8x16",
"(",
"tree",
"*",
"n_elts",
",",
"enum",
"sparc_builtins",
"fncode",
",",
"tree",
"inner_type",
",",
"tree",
"cst0",
",",
"tree",
"cst1",
")",
"{",
"unsigned",
"i",
",",
"num",
"=",
"VECTOR_CST_NELTS",
"(",
"cst0",
")",
";",
"int",
"scale",
";",
"switch",
"(",
"fncode",
")",
"{",
"case",
"SPARC_BUILTIN_FMUL8X16",
":",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"num",
";",
"++",
"i",
")",
"{",
"int",
"val",
"=",
"sparc_vis_mul8x16",
"(",
"TREE_INT_CST_LOW",
"(",
"VECTOR_CST_ELT",
"(",
"cst0",
",",
"i",
")",
")",
",",
"TREE_INT_CST_LOW",
"(",
"VECTOR_CST_ELT",
"(",
"cst1",
",",
"i",
")",
")",
")",
";",
"n_elts",
"[",
"i",
"]",
"=",
"build_int_cst",
"(",
"inner_type",
",",
"val",
")",
";",
"}",
"break",
";",
"case",
"SPARC_BUILTIN_FMUL8X16AU",
":",
"scale",
"=",
"TREE_INT_CST_LOW",
"(",
"VECTOR_CST_ELT",
"(",
"cst1",
",",
"0",
")",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"num",
";",
"++",
"i",
")",
"{",
"int",
"val",
"=",
"sparc_vis_mul8x16",
"(",
"TREE_INT_CST_LOW",
"(",
"VECTOR_CST_ELT",
"(",
"cst0",
",",
"i",
")",
")",
",",
"scale",
")",
";",
"n_elts",
"[",
"i",
"]",
"=",
"build_int_cst",
"(",
"inner_type",
",",
"val",
")",
";",
"}",
"break",
";",
"case",
"SPARC_BUILTIN_FMUL8X16AL",
":",
"scale",
"=",
"TREE_INT_CST_LOW",
"(",
"VECTOR_CST_ELT",
"(",
"cst1",
",",
"1",
")",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"num",
";",
"++",
"i",
")",
"{",
"int",
"val",
"=",
"sparc_vis_mul8x16",
"(",
"TREE_INT_CST_LOW",
"(",
"VECTOR_CST_ELT",
"(",
"cst0",
",",
"i",
")",
")",
",",
"scale",
")",
";",
"n_elts",
"[",
"i",
"]",
"=",
"build_int_cst",
"(",
"inner_type",
",",
"val",
")",
";",
"}",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Multiply",
"the",
"vector",
"elements",
"in",
"ELTS0",
"to",
"the",
"elements",
"in",
"ELTS1",
"as",
"specified",
"by",
"FNCODE",
".",
"All",
"of",
"the",
"elements",
"in",
"ELTS0",
"and",
"ELTS1",
"lists",
"must",
"be",
"integer",
"constants",
".",
"A",
"tree",
"list",
"with",
"the",
"results",
"of",
"the",
"multiplications",
"is",
"returned",
",",
"and",
"each",
"element",
"in",
"the",
"list",
"is",
"of",
"INNER_TYPE",
"."
] | [
"sparc",
"0",
"0",
"0",
"1",
"0"
] | sparc4 | sparc_handle_vis_mul8x16 | sparc | CPU | GCC | 16,136 | 230 | 1 | [] |
[
"<s>",
"int",
"AArch64LoadStoreOpt",
"::",
"getMemSize",
"(",
"MachineInstr",
"*",
"MemMI",
")",
"{",
"switch",
"(",
"MemMI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Opcode has has unknown size!\"",
")",
";",
"case",
"AArch64",
"::",
"STRSui",
":",
"case",
"AArch64",
"::",
"STURSi",
":",
"return",
"4",
";",
"case",
"AArch64",
"::",
"STRDui",
":",
"case",
"AArch64",
"::",
"STURDi",
":",
"return",
"8",
";",
"case",
"AArch64",
"::",
"STRQui",
":",
"case",
"AArch64",
"::",
"STURQi",
":",
"return",
"16",
";",
"case",
"AArch64",
"::",
"STRWui",
":",
"case",
"AArch64",
"::",
"STURWi",
":",
"return",
"4",
";",
"case",
"AArch64",
"::",
"STRXui",
":",
"case",
"AArch64",
"::",
"STURXi",
":",
"return",
"8",
";",
"case",
"AArch64",
"::",
"LDRSui",
":",
"case",
"AArch64",
"::",
"LDURSi",
":",
"return",
"4",
";",
"case",
"AArch64",
"::",
"LDRDui",
":",
"case",
"AArch64",
"::",
"LDURDi",
":",
"return",
"8",
";",
"case",
"AArch64",
"::",
"LDRQui",
":",
"case",
"AArch64",
"::",
"LDURQi",
":",
"return",
"16",
";",
"case",
"AArch64",
"::",
"LDRWui",
":",
"case",
"AArch64",
"::",
"LDURWi",
":",
"return",
"4",
";",
"case",
"AArch64",
"::",
"LDRXui",
":",
"case",
"AArch64",
"::",
"LDURXi",
":",
"return",
"8",
";",
"}",
"}",
"</s>"
] | [
"Returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"memory",
"access",
"."
] | [
"AArch64",
"AArch64",
"\"Opcode has has unknown size!\"",
"AArch64::STRSui",
"AArch64::STURSi",
"4",
"AArch64::STRDui",
"AArch64::STURDi",
"8",
"AArch64::STRQui",
"AArch64::STURQi",
"16",
"AArch64::STRWui",
"AArch64::STURWi",
"4",
"AArch64::STRXui",
"AArch64::STURXi",
"8",
"AArch64::LDRSui",
"AArch64::LDURSi",
"4",
"AArch64::LDRDui",
"AArch64::LDURDi",
"8",
"AArch64::LDRQui",
"AArch64::LDURQi",
"16",
"AArch64::LDRWui",
"AArch64::LDURWi",
"4",
"AArch64::LDRXui",
"AArch64::LDURXi",
"8"
] | AArch64LoadStoreOptimizer24 | getMemSize | AArch64 | CPU | LLVM | 16,137 | 158 | 1 | [] |
[
"<s>",
"bool",
"X86FastISel",
"::",
"tryToFoldLoadIntoMI",
"(",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"const",
"LoadInst",
"*",
"LI",
")",
"{",
"const",
"Value",
"*",
"Ptr",
"=",
"LI",
"->",
"getPointerOperand",
"(",
")",
";",
"X86AddressMode",
"AM",
";",
"if",
"(",
"!",
"X86SelectAddress",
"(",
"Ptr",
",",
"AM",
")",
")",
"return",
"false",
";",
"const",
"X86InstrInfo",
"&",
"XII",
"=",
"(",
"const",
"X86InstrInfo",
"&",
")",
"TII",
";",
"unsigned",
"Size",
"=",
"DL",
".",
"getTypeAllocSize",
"(",
"LI",
"->",
"getType",
"(",
")",
")",
";",
"unsigned",
"Alignment",
"=",
"LI",
"->",
"getAlignment",
"(",
")",
";",
"if",
"(",
"Alignment",
"==",
"0",
")",
"Alignment",
"=",
"DL",
".",
"getABITypeAlignment",
"(",
"LI",
"->",
"getType",
"(",
")",
")",
";",
"SmallVector",
"<",
"MachineOperand",
",",
"8",
">",
"AddrOps",
";",
"AM",
".",
"getFullAddress",
"(",
"AddrOps",
")",
";",
"MachineInstr",
"*",
"Result",
"=",
"XII",
".",
"foldMemoryOperandImpl",
"(",
"*",
"FuncInfo",
".",
"MF",
",",
"MI",
",",
"OpNo",
",",
"AddrOps",
",",
"FuncInfo",
".",
"InsertPt",
",",
"Size",
",",
"Alignment",
",",
"true",
")",
";",
"if",
"(",
"!",
"Result",
")",
"return",
"false",
";",
"unsigned",
"OperandNo",
"=",
"0",
";",
"for",
"(",
"MachineInstr",
"::",
"mop_iterator",
"I",
"=",
"Result",
"->",
"operands_begin",
"(",
")",
",",
"E",
"=",
"Result",
"->",
"operands_end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
",",
"++",
"OperandNo",
")",
"{",
"MachineOperand",
"&",
"MO",
"=",
"*",
"I",
";",
"if",
"(",
"!",
"MO",
".",
"isReg",
"(",
")",
"||",
"MO",
".",
"isDef",
"(",
")",
"||",
"MO",
".",
"getReg",
"(",
")",
"!=",
"AM",
".",
"IndexReg",
")",
"continue",
";",
"unsigned",
"IndexReg",
"=",
"constrainOperandRegClass",
"(",
"Result",
"->",
"getDesc",
"(",
")",
",",
"MO",
".",
"getReg",
"(",
")",
",",
"OperandNo",
")",
";",
"if",
"(",
"IndexReg",
"==",
"MO",
".",
"getReg",
"(",
")",
")",
"continue",
";",
"MO",
".",
"setReg",
"(",
"IndexReg",
")",
";",
"}",
"Result",
"->",
"addMemOperand",
"(",
"*",
"FuncInfo",
".",
"MF",
",",
"createMachineMemOperandFor",
"(",
"LI",
")",
")",
";",
"MI",
"->",
"eraseFromParent",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"The",
"specified",
"machine",
"instr",
"operand",
"is",
"a",
"vreg",
",",
"and",
"that",
"vreg",
"is",
"being",
"provided",
"by",
"the",
"specified",
"load",
"instruction",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"0",
"8",
"0"
] | X86FastISel (2)6 | tryToFoldLoadIntoMI | X86 | CPU | LLVM | 16,138 | 288 | 1 | [] |
[
"<s>",
"static",
"sbitmap",
"aarch64_get_separate_components",
"(",
"void",
")",
"{",
"aarch64_layout_frame",
"(",
")",
";",
"sbitmap",
"components",
"=",
"sbitmap_alloc",
"(",
"LAST_SAVED_REGNUM",
"+",
"1",
")",
";",
"bitmap_clear",
"(",
"components",
")",
";",
"for",
"(",
"unsigned",
"regno",
"=",
"0",
";",
"regno",
"<=",
"LAST_SAVED_REGNUM",
";",
"regno",
"++",
")",
"if",
"(",
"aarch64_register_saved_on_entry",
"(",
"regno",
")",
")",
"{",
"poly_int64",
"offset",
"=",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"reg_offset",
"[",
"regno",
"]",
";",
"if",
"(",
"!",
"frame_pointer_needed",
")",
"offset",
"+=",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"frame_size",
"-",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"hard_fp_offset",
";",
"if",
"(",
"offset_12bit_unsigned_scaled_p",
"(",
"DImode",
",",
"offset",
")",
")",
"bitmap_set_bit",
"(",
"components",
",",
"regno",
")",
";",
"}",
"if",
"(",
"frame_pointer_needed",
")",
"bitmap_clear_bit",
"(",
"components",
",",
"HARD_FRAME_POINTER_REGNUM",
")",
";",
"unsigned",
"reg1",
"=",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"wb_candidate1",
";",
"unsigned",
"reg2",
"=",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"wb_candidate2",
";",
"if",
"(",
"reg2",
"!=",
"INVALID_REGNUM",
")",
"bitmap_clear_bit",
"(",
"components",
",",
"reg2",
")",
";",
"if",
"(",
"reg1",
"!=",
"INVALID_REGNUM",
")",
"bitmap_clear_bit",
"(",
"components",
",",
"reg1",
")",
";",
"bitmap_clear_bit",
"(",
"components",
",",
"LR_REGNUM",
")",
";",
"bitmap_clear_bit",
"(",
"components",
",",
"SP_REGNUM",
")",
";",
"return",
"components",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS",
"."
] | [
"aarch64",
"1",
"0"
] | aarch645 | aarch64_get_separate_components | aarch64 | CPU | GCC | 16,139 | 179 | 1 | [] |
[
"<s>",
"SDValue",
"AlphaTargetLowering",
"::",
"LowerReturn",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
")",
"{",
"SDValue",
"Copy",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"Alpha",
"::",
"R26",
",",
"DAG",
".",
"getNode",
"(",
"AlphaISD",
"::",
"GlobalRetAddr",
",",
"DebugLoc",
"::",
"getUnknownLoc",
"(",
")",
",",
"MVT",
"::",
"i64",
")",
",",
"SDValue",
"(",
")",
")",
";",
"switch",
"(",
"Outs",
".",
"size",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Do not know how to return this many arguments!\"",
")",
";",
"case",
"0",
":",
"break",
";",
"case",
"1",
":",
"{",
"EVT",
"ArgVT",
"=",
"Outs",
"[",
"0",
"]",
".",
"Val",
".",
"getValueType",
"(",
")",
";",
"unsigned",
"ArgReg",
";",
"if",
"(",
"ArgVT",
".",
"isInteger",
"(",
")",
")",
"ArgReg",
"=",
"Alpha",
"::",
"R0",
";",
"else",
"{",
"assert",
"(",
"ArgVT",
".",
"isFloatingPoint",
"(",
")",
")",
";",
"ArgReg",
"=",
"Alpha",
"::",
"F0",
";",
"}",
"Copy",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Copy",
",",
"dl",
",",
"ArgReg",
",",
"Outs",
"[",
"0",
"]",
".",
"Val",
",",
"Copy",
".",
"getValue",
"(",
"1",
")",
")",
";",
"if",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_empty",
"(",
")",
")",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"addLiveOut",
"(",
"ArgReg",
")",
";",
"break",
";",
"}",
"case",
"2",
":",
"{",
"EVT",
"ArgVT",
"=",
"Outs",
"[",
"0",
"]",
".",
"Val",
".",
"getValueType",
"(",
")",
";",
"unsigned",
"ArgReg1",
",",
"ArgReg2",
";",
"if",
"(",
"ArgVT",
".",
"isInteger",
"(",
")",
")",
"{",
"ArgReg1",
"=",
"Alpha",
"::",
"R0",
";",
"ArgReg2",
"=",
"Alpha",
"::",
"R1",
";",
"}",
"else",
"{",
"assert",
"(",
"ArgVT",
".",
"isFloatingPoint",
"(",
")",
")",
";",
"ArgReg1",
"=",
"Alpha",
"::",
"F0",
";",
"ArgReg2",
"=",
"Alpha",
"::",
"F1",
";",
"}",
"Copy",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Copy",
",",
"dl",
",",
"ArgReg1",
",",
"Outs",
"[",
"0",
"]",
".",
"Val",
",",
"Copy",
".",
"getValue",
"(",
"1",
")",
")",
";",
"if",
"(",
"std",
"::",
"find",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_begin",
"(",
")",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_end",
"(",
")",
",",
"ArgReg1",
")",
"==",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_end",
"(",
")",
")",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"addLiveOut",
"(",
"ArgReg1",
")",
";",
"Copy",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Copy",
",",
"dl",
",",
"ArgReg2",
",",
"Outs",
"[",
"1",
"]",
".",
"Val",
",",
"Copy",
".",
"getValue",
"(",
"1",
")",
")",
";",
"if",
"(",
"std",
"::",
"find",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_begin",
"(",
")",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_end",
"(",
")",
",",
"ArgReg2",
")",
"==",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_end",
"(",
")",
")",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"addLiveOut",
"(",
"ArgReg2",
")",
";",
"break",
";",
"}",
"}",
"return",
"DAG",
".",
"getNode",
"(",
"AlphaISD",
"::",
"RET_FLAG",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"Copy",
",",
"Copy",
".",
"getValue",
"(",
"1",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"outgoing",
"return",
"values",
",",
"described",
"by",
"the",
"Outs",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"Alpha",
"Alpha",
"ISD::OutputArg",
"Alpha::R26",
"AlphaISD::GlobalRetAddr",
"MVT::i64",
"\"Do not know how to return this many arguments!\"",
"0",
"1",
"0",
"Alpha::R0",
"Alpha::F0",
"0",
"1",
"2",
"0",
"Alpha::R0",
"Alpha::R1",
"Alpha::F0",
"Alpha::F1",
"0",
"1",
"1",
"1",
"AlphaISD::RET_FLAG",
"MVT::Other",
"1"
] | AlphaISelLowering7 | LowerReturn | Alpha | MPU | LLVM | 16,140 | 493 | 1 | [] |
[
"<s>",
"unsigned",
"AMDGPURegisterBankInfo",
"::",
"copyCost",
"(",
"const",
"RegisterBank",
"&",
"Dst",
",",
"const",
"RegisterBank",
"&",
"Src",
",",
"unsigned",
"Size",
")",
"const",
"{",
"if",
"(",
"Dst",
".",
"getID",
"(",
")",
"==",
"AMDGPU",
"::",
"SGPRRegBankID",
"&&",
"isVectorRegisterBank",
"(",
"Src",
")",
")",
"{",
"return",
"std",
"::",
"numeric_limits",
"<",
"unsigned",
">",
"::",
"max",
"(",
")",
";",
"}",
"if",
"(",
"Size",
"==",
"1",
"&&",
"(",
"Dst",
".",
"getID",
"(",
")",
"==",
"AMDGPU",
"::",
"SCCRegBankID",
"||",
"Dst",
".",
"getID",
"(",
")",
"==",
"AMDGPU",
"::",
"SGPRRegBankID",
")",
"&&",
"(",
"isVectorRegisterBank",
"(",
"Src",
")",
"||",
"Src",
".",
"getID",
"(",
")",
"==",
"AMDGPU",
"::",
"SGPRRegBankID",
"||",
"Src",
".",
"getID",
"(",
")",
"==",
"AMDGPU",
"::",
"VCCRegBankID",
")",
")",
"return",
"std",
"::",
"numeric_limits",
"<",
"unsigned",
">",
"::",
"max",
"(",
")",
";",
"if",
"(",
"Dst",
".",
"getID",
"(",
")",
"==",
"AMDGPU",
"::",
"SCCRegBankID",
"&&",
"Src",
".",
"getID",
"(",
")",
"==",
"AMDGPU",
"::",
"VCCRegBankID",
")",
"return",
"std",
"::",
"numeric_limits",
"<",
"unsigned",
">",
"::",
"max",
"(",
")",
";",
"if",
"(",
"Dst",
".",
"getID",
"(",
")",
"==",
"AMDGPU",
"::",
"AGPRRegBankID",
"&&",
"Src",
".",
"getID",
"(",
")",
"==",
"AMDGPU",
"::",
"AGPRRegBankID",
")",
"return",
"4",
";",
"return",
"RegisterBankInfo",
"::",
"copyCost",
"(",
"Dst",
",",
"Src",
",",
"Size",
")",
";",
"}",
"</s>"
] | [
"Get",
"the",
"cost",
"of",
"a",
"copy",
"from",
"B",
"to",
"A",
",",
"or",
"put",
"differently",
",",
"get",
"the",
"cost",
"of",
"A",
"=",
"COPY",
"B",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU::SGPRRegBankID",
"1",
"AMDGPU::SCCRegBankID",
"AMDGPU::SGPRRegBankID",
"AMDGPU::SGPRRegBankID",
"AMDGPU::VCCRegBankID",
"AMDGPU::SCCRegBankID",
"AMDGPU::VCCRegBankID",
"AMDGPU::AGPRRegBankID",
"AMDGPU::AGPRRegBankID",
"4"
] | AMDGPURegisterBankInfo30 | copyCost | AMDGPU | GPU | LLVM | 16,141 | 190 | 1 | [] |
[
"<s>",
"bool",
"PPCPassConfig",
"::",
"addILPOpts",
"(",
")",
"{",
"addPass",
"(",
"&",
"EarlyIfConverterID",
")",
";",
"if",
"(",
"EnableMachineCombinerPass",
")",
"addPass",
"(",
"&",
"MachineCombinerID",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Add",
"passes",
"that",
"optimize",
"instruction",
"level",
"parallelism",
"for",
"out-of-order",
"targets",
"."
] | [
"PowerPC",
"PPC"
] | PPCTargetMachine1 | addILPOpts | PowerPC | CPU | LLVM | 16,142 | 27 | 1 | [] |
[
"<s>",
"virtual",
"const",
"NVPTXSubtarget",
"*",
"getSubtargetImpl",
"(",
")",
"const",
"{",
"return",
"&",
"Subtarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"NVPTX",
"NVPTX"
] | NVPTXTargetMachine13 | getSubtargetImpl | NVPTX | GPU | LLVM | 16,143 | 14 | 1 | [] |
[
"<s>",
"bool",
"ARMTTIImpl",
"::",
"areInlineCompatible",
"(",
"const",
"Function",
"*",
"Caller",
",",
"const",
"Function",
"*",
"Callee",
")",
"const",
"{",
"const",
"TargetMachine",
"&",
"TM",
"=",
"getTLI",
"(",
")",
"->",
"getTargetMachine",
"(",
")",
";",
"const",
"FeatureBitset",
"&",
"CallerBits",
"=",
"TM",
".",
"getSubtargetImpl",
"(",
"*",
"Caller",
")",
"->",
"getFeatureBits",
"(",
")",
";",
"const",
"FeatureBitset",
"&",
"CalleeBits",
"=",
"TM",
".",
"getSubtargetImpl",
"(",
"*",
"Callee",
")",
"->",
"getFeatureBits",
"(",
")",
";",
"bool",
"MatchExact",
"=",
"(",
"CallerBits",
"&",
"~",
"InlineFeaturesAllowed",
")",
"==",
"(",
"CalleeBits",
"&",
"~",
"InlineFeaturesAllowed",
")",
";",
"bool",
"MatchSubset",
"=",
"(",
"(",
"CallerBits",
"&",
"CalleeBits",
")",
"&",
"InlineFeaturesAllowed",
")",
"==",
"(",
"CalleeBits",
"&",
"InlineFeaturesAllowed",
")",
";",
"return",
"MatchExact",
"&&",
"MatchSubset",
";",
"}",
"</s>"
] | [
"Determine",
"whether",
"a",
"callee",
"with",
"the",
"given",
"TLI",
"can",
"be",
"inlined",
"into",
"caller",
"with",
"this",
"TLI",
",",
"based",
"on",
"'nobuiltin",
"'",
"attributes",
"."
] | [
"ARM",
"ARM"
] | ARMTargetTransformInfo1 | areInlineCompatible | ARM | CPU | LLVM | 16,144 | 106 | 1 | [] |
[
"<s>",
"bool",
"MipsCallLowering",
"::",
"lowerFormalArguments",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Function",
"&",
"F",
",",
"ArrayRef",
"<",
"unsigned",
">",
"VRegs",
")",
"const",
"{",
"if",
"(",
"F",
".",
"arg_empty",
"(",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"VRegs",
",",
"for",
"GlobalISel",
"."
] | [
"Mips",
"Mips"
] | MipsCallLowering32 | lowerFormalArguments | Mips | CPU | LLVM | 16,145 | 37 | 1 | [] |
[
"<s>",
"bool",
"HexagonInstrInfo",
"::",
"isSchedulingBoundary",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"const",
"MachineBasicBlock",
"*",
"MBB",
",",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"if",
"(",
"MI",
"->",
"isDebugValue",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"MI",
"->",
"getDesc",
"(",
")",
".",
"isTerminator",
"(",
")",
"||",
"MI",
"->",
"isPosition",
"(",
")",
"||",
"MI",
"->",
"isInlineAsm",
"(",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"isSchedulingBoundary",
"-",
"Overrides",
"the",
"isSchedulingBoundary",
"from",
"Codegen/TargetInstrInfo.cpp",
"to",
"make",
"it",
"capable",
"of",
"identifying",
"ENDBR",
"intructions",
"and",
"prevent",
"it",
"from",
"being",
"re-scheduled",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonInstrInfo | isSchedulingBoundary | Hexagon | DSP | LLVM | 16,146 | 64 | 1 | [] |
[
"<s>",
"unsigned",
"getSlotSize",
"(",
")",
"const",
"{",
"return",
"SlotSize",
";",
"}",
"</s>"
] | [
"getSlotSize",
"-",
"Stack",
"slot",
"size",
"in",
"bytes",
"."
] | [
"X86"
] | X86RegisterInfo (2) | getSlotSize | X86 | CPU | LLVM | 16,147 | 10 | 1 | [] |
[
"<s>",
"static",
"int",
"available_regs",
"(",
")",
"{",
"static",
"int",
"n",
"=",
"-",
"1",
";",
"int",
"i",
";",
"if",
"(",
"n",
">=",
"0",
")",
"return",
"n",
";",
"for",
"(",
"i",
"=",
"n",
"=",
"0",
";",
"i",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"i",
"++",
",",
"n",
"++",
")",
"if",
"(",
"(",
"fixed_regs",
"[",
"i",
"]",
"&&",
"n",
"!=",
"0",
")",
"||",
"i",
"==",
"HARD_FRAME_POINTER_REGNUM",
"||",
"i",
"==",
"PIC_SOMETHING_REGNUM",
"||",
"i",
"==",
"STATIC_CHAIN_REGNUM",
")",
"break",
";",
"return",
"n",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"registers",
"available",
"for",
"-mregparm",
",",
"-mreturn-regs",
",",
"and",
"-mcall-clobbered",
"."
] | [
"pdp10",
"1",
"0",
"0",
"0"
] | pdp10 | available_regs | pdp10 | MPU | GCC | 16,148 | 74 | 1 | [] |
[
"<s>",
"static",
"void",
"tilepro_print_operand_address",
"(",
"FILE",
"*",
"file",
",",
"machine_mode",
"mode",
",",
"rtx",
"addr",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"POST_DEC",
"||",
"GET_CODE",
"(",
"addr",
")",
"==",
"POST_INC",
")",
"{",
"int",
"offset",
"=",
"GET_MODE_SIZE",
"(",
"mode",
")",
";",
"gcc_assert",
"(",
"mode",
"!=",
"VOIDmode",
")",
";",
"if",
"(",
"output_memory_autoinc_first",
")",
"fprintf",
"(",
"file",
",",
"\"%s\"",
",",
"reg_names",
"[",
"REGNO",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
"]",
")",
";",
"else",
"fprintf",
"(",
"file",
",",
"\"%d\"",
",",
"GET_CODE",
"(",
"addr",
")",
"==",
"POST_DEC",
"?",
"-",
"offset",
":",
"offset",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"POST_MODIFY",
")",
"{",
"gcc_assert",
"(",
"mode",
"!=",
"VOIDmode",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
"==",
"PLUS",
")",
";",
"if",
"(",
"output_memory_autoinc_first",
")",
"fprintf",
"(",
"file",
",",
"\"%s\"",
",",
"reg_names",
"[",
"REGNO",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
"]",
")",
";",
"else",
"fprintf",
"(",
"file",
",",
"HOST_WIDE_INT_PRINT_DEC",
",",
"INTVAL",
"(",
"XEXP",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
",",
"1",
")",
")",
")",
";",
"}",
"else",
"tilepro_print_operand",
"(",
"file",
",",
"addr",
",",
"'r'",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_PRINT_OPERAND_ADDRESS",
"."
] | [
"tilepro",
"\"%s\"",
"0",
"\"%d\"",
"1",
"\"%s\"",
"0",
"1",
"1"
] | tilepro | tilepro_print_operand_address | tilepro | VLIW | GCC | 16,149 | 184 | 1 | [] |
[
"<s>",
"bool",
"writeNopData",
"(",
"raw_ostream",
"&",
"OS",
",",
"uint64_t",
"Count",
")",
"const",
"override",
"{",
"if",
"(",
"Count",
"%",
"4",
"!=",
"0",
")",
"return",
"false",
";",
"uint64_t",
"NumNops",
"=",
"Count",
"/",
"4",
";",
"for",
"(",
"uint64_t",
"i",
"=",
"0",
";",
"i",
"!=",
"NumNops",
";",
"++",
"i",
")",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint32_t",
">",
"(",
"OS",
",",
"0x01000000",
",",
"Endian",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Write",
"an",
"(",
"optimal",
")",
"nop",
"sequence",
"of",
"Count",
"bytes",
"to",
"the",
"given",
"output",
"."
] | [
"Sparc",
"4",
"0",
"4",
"0",
"support::endian",
"0x01000000"
] | SparcAsmBackend11 | writeNopData | Sparc | CPU | LLVM | 16,150 | 65 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"HOST_WIDE_INT",
"aarch64_replicate_bitmask_imm",
"(",
"unsigned",
"HOST_WIDE_INT",
"val",
",",
"machine_mode",
"mode",
")",
"{",
"unsigned",
"int",
"size",
"=",
"GET_MODE_UNIT_PRECISION",
"(",
"mode",
")",
";",
"while",
"(",
"size",
"<",
"64",
")",
"{",
"val",
"&=",
"(",
"HOST_WIDE_INT_1U",
"<<",
"size",
")",
"-",
"1",
";",
"val",
"|=",
"val",
"<<",
"size",
";",
"size",
"*=",
"2",
";",
"}",
"return",
"val",
";",
"}",
"</s>"
] | [
"VAL",
"is",
"a",
"value",
"with",
"the",
"inner",
"mode",
"of",
"MODE",
".",
"Replicate",
"it",
"to",
"fill",
"a",
"64-bit",
"(",
"DImode",
")",
"integer",
"."
] | [
"aarch64",
"64",
"1",
"2"
] | aarch64 | aarch64_replicate_bitmask_imm | aarch64 | CPU | GCC | 16,151 | 54 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"getPreIndexedAddressParts",
"(",
"SDNode",
"*",
"N",
",",
"SDValue",
"&",
"Base",
",",
"SDValue",
"&",
"Offset",
",",
"ISD",
"::",
"MemIndexedMode",
"&",
"AM",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"Subtarget",
"->",
"isThumb1Only",
"(",
")",
")",
"return",
"false",
";",
"EVT",
"VT",
";",
"SDValue",
"Ptr",
";",
"Align",
"Alignment",
";",
"bool",
"isSEXTLoad",
"=",
"false",
";",
"bool",
"IsMasked",
"=",
"false",
";",
"if",
"(",
"LoadSDNode",
"*",
"LD",
"=",
"dyn_cast",
"<",
"LoadSDNode",
">",
"(",
"N",
")",
")",
"{",
"Ptr",
"=",
"LD",
"->",
"getBasePtr",
"(",
")",
";",
"VT",
"=",
"LD",
"->",
"getMemoryVT",
"(",
")",
";",
"Alignment",
"=",
"LD",
"->",
"getAlign",
"(",
")",
";",
"isSEXTLoad",
"=",
"LD",
"->",
"getExtensionType",
"(",
")",
"==",
"ISD",
"::",
"SEXTLOAD",
";",
"}",
"else",
"if",
"(",
"StoreSDNode",
"*",
"ST",
"=",
"dyn_cast",
"<",
"StoreSDNode",
">",
"(",
"N",
")",
")",
"{",
"Ptr",
"=",
"ST",
"->",
"getBasePtr",
"(",
")",
";",
"VT",
"=",
"ST",
"->",
"getMemoryVT",
"(",
")",
";",
"Alignment",
"=",
"ST",
"->",
"getAlign",
"(",
")",
";",
"}",
"else",
"if",
"(",
"MaskedLoadSDNode",
"*",
"LD",
"=",
"dyn_cast",
"<",
"MaskedLoadSDNode",
">",
"(",
"N",
")",
")",
"{",
"Ptr",
"=",
"LD",
"->",
"getBasePtr",
"(",
")",
";",
"VT",
"=",
"LD",
"->",
"getMemoryVT",
"(",
")",
";",
"Alignment",
"=",
"LD",
"->",
"getAlign",
"(",
")",
";",
"isSEXTLoad",
"=",
"LD",
"->",
"getExtensionType",
"(",
")",
"==",
"ISD",
"::",
"SEXTLOAD",
";",
"IsMasked",
"=",
"true",
";",
"}",
"else",
"if",
"(",
"MaskedStoreSDNode",
"*",
"ST",
"=",
"dyn_cast",
"<",
"MaskedStoreSDNode",
">",
"(",
"N",
")",
")",
"{",
"Ptr",
"=",
"ST",
"->",
"getBasePtr",
"(",
")",
";",
"VT",
"=",
"ST",
"->",
"getMemoryVT",
"(",
")",
";",
"Alignment",
"=",
"ST",
"->",
"getAlign",
"(",
")",
";",
"IsMasked",
"=",
"true",
";",
"}",
"else",
"return",
"false",
";",
"bool",
"isInc",
";",
"bool",
"isLegal",
"=",
"false",
";",
"if",
"(",
"VT",
".",
"isVector",
"(",
")",
")",
"isLegal",
"=",
"Subtarget",
"->",
"hasMVEIntegerOps",
"(",
")",
"&&",
"getMVEIndexedAddressParts",
"(",
"Ptr",
".",
"getNode",
"(",
")",
",",
"VT",
",",
"Alignment",
",",
"isSEXTLoad",
",",
"IsMasked",
",",
"Subtarget",
"->",
"isLittle",
"(",
")",
",",
"Base",
",",
"Offset",
",",
"isInc",
",",
"DAG",
")",
";",
"else",
"{",
"if",
"(",
"Subtarget",
"->",
"isThumb2",
"(",
")",
")",
"isLegal",
"=",
"getT2IndexedAddressParts",
"(",
"Ptr",
".",
"getNode",
"(",
")",
",",
"VT",
",",
"isSEXTLoad",
",",
"Base",
",",
"Offset",
",",
"isInc",
",",
"DAG",
")",
";",
"else",
"isLegal",
"=",
"getARMIndexedAddressParts",
"(",
"Ptr",
".",
"getNode",
"(",
")",
",",
"VT",
",",
"isSEXTLoad",
",",
"Base",
",",
"Offset",
",",
"isInc",
",",
"DAG",
")",
";",
"}",
"if",
"(",
"!",
"isLegal",
")",
"return",
"false",
";",
"AM",
"=",
"isInc",
"?",
"ISD",
"::",
"PRE_INC",
":",
"ISD",
"::",
"PRE_DEC",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"by",
"value",
",",
"base",
"pointer",
"and",
"offset",
"pointer",
"and",
"addressing",
"mode",
"by",
"reference",
"if",
"the",
"node",
"'s",
"address",
"can",
"be",
"legally",
"represented",
"as",
"pre-indexed",
"load",
"/",
"store",
"address",
"."
] | [
"ARM",
"ARM",
"ISD::MemIndexedMode",
"ISD::SEXTLOAD",
"ISD::SEXTLOAD",
"ARM",
"ISD::PRE_INC",
"ISD::PRE_DEC"
] | ARMISelLowering (2)5 | getPreIndexedAddressParts | ARM | CPU | LLVM | 16,152 | 395 | 1 | [] |
[
"<s>",
"void",
"SITypeRewriter",
"::",
"visitCallInst",
"(",
"CallInst",
"&",
"I",
")",
"{",
"IRBuilder",
"<",
">",
"Builder",
"(",
"&",
"I",
")",
";",
"SmallVector",
"<",
"Value",
"*",
",",
"8",
">",
"Args",
";",
"SmallVector",
"<",
"Type",
"*",
",",
"8",
">",
"Types",
";",
"bool",
"NeedToReplace",
"=",
"false",
";",
"Function",
"*",
"F",
"=",
"I",
".",
"getCalledFunction",
"(",
")",
";",
"std",
"::",
"string",
"Name",
"=",
"F",
"->",
"getName",
"(",
")",
".",
"str",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"I",
".",
"getNumArgOperands",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"Value",
"*",
"Arg",
"=",
"I",
".",
"getArgOperand",
"(",
"i",
")",
";",
"if",
"(",
"Arg",
"->",
"getType",
"(",
")",
"==",
"v16i8",
")",
"{",
"Args",
".",
"push_back",
"(",
"Builder",
".",
"CreateBitCast",
"(",
"Arg",
",",
"v4i32",
")",
")",
";",
"Types",
".",
"push_back",
"(",
"v4i32",
")",
";",
"NeedToReplace",
"=",
"true",
";",
"Name",
"=",
"Name",
"+",
"\".v4i32\"",
";",
"}",
"else",
"if",
"(",
"Arg",
"->",
"getType",
"(",
")",
"->",
"isVectorTy",
"(",
")",
"&&",
"Arg",
"->",
"getType",
"(",
")",
"->",
"getVectorNumElements",
"(",
")",
"==",
"1",
"&&",
"Arg",
"->",
"getType",
"(",
")",
"->",
"getVectorElementType",
"(",
")",
"==",
"Type",
"::",
"getInt32Ty",
"(",
"I",
".",
"getContext",
"(",
")",
")",
")",
"{",
"Type",
"*",
"ElementTy",
"=",
"Arg",
"->",
"getType",
"(",
")",
"->",
"getVectorElementType",
"(",
")",
";",
"std",
"::",
"string",
"TypeName",
"=",
"\"i32\"",
";",
"InsertElementInst",
"*",
"Def",
"=",
"cast",
"<",
"InsertElementInst",
">",
"(",
"Arg",
")",
";",
"Args",
".",
"push_back",
"(",
"Def",
"->",
"getOperand",
"(",
"1",
")",
")",
";",
"Types",
".",
"push_back",
"(",
"ElementTy",
")",
";",
"std",
"::",
"string",
"VecTypeName",
"=",
"\"v1\"",
"+",
"TypeName",
";",
"Name",
"=",
"Name",
".",
"replace",
"(",
"Name",
".",
"find",
"(",
"VecTypeName",
")",
",",
"VecTypeName",
".",
"length",
"(",
")",
",",
"TypeName",
")",
";",
"NeedToReplace",
"=",
"true",
";",
"}",
"else",
"{",
"Args",
".",
"push_back",
"(",
"Arg",
")",
";",
"Types",
".",
"push_back",
"(",
"Arg",
"->",
"getType",
"(",
")",
")",
";",
"}",
"}",
"if",
"(",
"!",
"NeedToReplace",
")",
"{",
"return",
";",
"}",
"Function",
"*",
"NewF",
"=",
"Mod",
"->",
"getFunction",
"(",
"Name",
")",
";",
"if",
"(",
"!",
"NewF",
")",
"{",
"NewF",
"=",
"Function",
"::",
"Create",
"(",
"FunctionType",
"::",
"get",
"(",
"F",
"->",
"getReturnType",
"(",
")",
",",
"Types",
",",
"false",
")",
",",
"GlobalValue",
"::",
"ExternalLinkage",
",",
"Name",
",",
"Mod",
")",
";",
"NewF",
"->",
"setAttributes",
"(",
"F",
"->",
"getAttributes",
"(",
")",
")",
";",
"}",
"I",
".",
"replaceAllUsesWith",
"(",
"Builder",
".",
"CreateCall",
"(",
"NewF",
",",
"Args",
")",
")",
";",
"I",
".",
"eraseFromParent",
"(",
")",
";",
"}",
"</s>"
] | [
"CallInst",
"simplification",
"."
] | [
"R600",
"SI",
"8",
"8",
"0",
"\".v4i32\"",
"1",
"\"i32\"",
"1",
"\"v1\""
] | SITypeRewriter | visitCallInst | R600 | GPU | LLVM | 16,153 | 390 | 1 | [] |
[
"<s>",
"static",
"inline",
"bool",
"is_brk_interrupt_func",
"(",
"const_tree",
"decl",
")",
"{",
"return",
"has_func_attr",
"(",
"decl",
",",
"\"brk_interrupt\"",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"provided",
"function",
"has",
"the",
"``",
"brk_interrupt",
"''",
"attribute",
"."
] | [
"rl78",
"\"brk_interrupt\""
] | rl78 | is_brk_interrupt_func | rl78 | MPU | GCC | 16,154 | 18 | 1 | [] |
[
"<s>",
"SMLoc",
"getLoc",
"(",
")",
"const",
"{",
"return",
"getParser",
"(",
")",
".",
"getTok",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"}",
"</s>"
] | [
"Get",
"the",
"source",
"location",
"of",
"the",
"point",
"where",
"the",
"field",
"was",
"defined",
"."
] | [
"MMIX"
] | MMIXAsmParser | getLoc | MMIX | CPU | LLVM | 16,155 | 20 | 1 | [] |
[
"<s>",
"unsigned",
"ARMBaseRegisterInfo",
"::",
"getFrameRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"ARMSubtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"const",
"ARMFrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
")",
"return",
"getFramePointerReg",
"(",
"STI",
")",
";",
"return",
"ARM",
"::",
"SP",
";",
"}",
"</s>"
] | [
"Debug",
"information",
"queries",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM::SP"
] | ARMBaseRegisterInfo10 | getFrameRegister | ARM | CPU | LLVM | 16,156 | 57 | 1 | [] |
[
"<s>",
"static",
"SDValue",
"getTruncateOrZeroExtend",
"(",
"SDValue",
"V",
",",
"SelectionDAG",
"&",
"DAG",
",",
"MVT",
"ToVT",
")",
"{",
"SDNodeTreeBuilder",
"b",
"(",
"V",
",",
"&",
"DAG",
")",
";",
"MVT",
"VT",
"=",
"V",
".",
"getSimpleValueType",
"(",
")",
";",
"if",
"(",
"VT",
".",
"bitsLT",
"(",
"ToVT",
")",
")",
"return",
"b",
".",
"ZERO_EXTEND",
"(",
"V",
",",
"ToVT",
")",
";",
"else",
"if",
"(",
"VT",
".",
"bitsGT",
"(",
"ToVT",
")",
")",
"return",
"b",
".",
"TRUNCATE",
"(",
"V",
",",
"ToVT",
")",
";",
"return",
"V",
";",
"}",
"</s>"
] | [
"Return",
"a",
"SCEV",
"corresponding",
"to",
"a",
"conversion",
"of",
"the",
"input",
"value",
"to",
"the",
"specified",
"type",
"."
] | [
"X86"
] | X86ParabixISelLowering | getTruncateOrZeroExtend | X86 | CPU | LLVM | 16,157 | 76 | 1 | [] |
[
"<s>",
"static",
"tree",
"handle_nodirect_extern_access_attribute",
"(",
"tree",
"*",
"pnode",
",",
"tree",
"name",
",",
"tree",
"ARG_UNUSED",
"(",
"args",
")",
",",
"int",
"ARG_UNUSED",
"(",
"flags",
")",
",",
"bool",
"*",
"no_add_attrs",
")",
"{",
"tree",
"node",
"=",
"*",
"pnode",
";",
"if",
"(",
"VAR_OR_FUNCTION_DECL_P",
"(",
"node",
")",
")",
"{",
"if",
"(",
"(",
"!",
"TREE_STATIC",
"(",
"node",
")",
"&&",
"TREE_CODE",
"(",
"node",
")",
"!=",
"FUNCTION_DECL",
"&&",
"!",
"DECL_EXTERNAL",
"(",
"node",
")",
")",
"||",
"!",
"TREE_PUBLIC",
"(",
"node",
")",
")",
"{",
"warning",
"(",
"OPT_Wattributes",
",",
"\"%qE attribute have effect only on public objects\"",
",",
"name",
")",
";",
"*",
"no_add_attrs",
"=",
"true",
";",
"}",
"}",
"else",
"{",
"warning",
"(",
"OPT_Wattributes",
",",
"\"%qE attribute ignored\"",
",",
"name",
")",
";",
"*",
"no_add_attrs",
"=",
"true",
";",
"}",
"return",
"NULL_TREE",
";",
"}",
"</s>"
] | [
"Handle",
"a",
"``",
"nodirect_extern_access",
"''",
"attribute",
";",
"arguments",
"as",
"in",
"struct",
"attribute_spec.handler",
"."
] | [
"i386",
"\"%qE attribute have effect only on public objects\"",
"\"%qE attribute ignored\""
] | i386-options | handle_nodirect_extern_access_attribute | i386 | CPU | GCC | 16,158 | 109 | 1 | [] |
[
"<s>",
"bool",
"HexagonTargetLowering",
"::",
"isShuffleMaskLegal",
"(",
"ArrayRef",
"<",
"int",
">",
"Mask",
",",
"EVT",
"VT",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Targets",
"can",
"use",
"this",
"to",
"indicate",
"that",
"they",
"only",
"support",
"some",
"VECTOR_SHUFFLE",
"operations",
",",
"those",
"with",
"specific",
"masks",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonISelLowering (2)1 | isShuffleMaskLegal | Hexagon | DSP | LLVM | 16,159 | 20 | 1 | [] |
[
"<s>",
"static",
"int",
"ix86_flags_dependant",
"(",
"rtx",
"insn",
",",
"rtx",
"dep_insn",
",",
"enum",
"attr_type",
"insn_type",
")",
"{",
"rtx",
"set",
",",
"set2",
";",
"if",
"(",
"insn_type",
"!=",
"TYPE_SETCC",
"&&",
"insn_type",
"!=",
"TYPE_ICMOV",
"&&",
"insn_type",
"!=",
"TYPE_FCMOV",
"&&",
"insn_type",
"!=",
"TYPE_IBR",
")",
"return",
"0",
";",
"if",
"(",
"(",
"set",
"=",
"single_set",
"(",
"dep_insn",
")",
")",
"!=",
"0",
")",
"{",
"set",
"=",
"SET_DEST",
"(",
"set",
")",
";",
"set2",
"=",
"NULL_RTX",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"dep_insn",
")",
")",
"==",
"PARALLEL",
"&&",
"XVECLEN",
"(",
"PATTERN",
"(",
"dep_insn",
")",
",",
"0",
")",
"==",
"2",
"&&",
"GET_CODE",
"(",
"XVECEXP",
"(",
"PATTERN",
"(",
"dep_insn",
")",
",",
"0",
",",
"0",
")",
")",
"==",
"SET",
"&&",
"GET_CODE",
"(",
"XVECEXP",
"(",
"PATTERN",
"(",
"dep_insn",
")",
",",
"0",
",",
"1",
")",
")",
"==",
"SET",
")",
"{",
"set",
"=",
"SET_DEST",
"(",
"XVECEXP",
"(",
"PATTERN",
"(",
"dep_insn",
")",
",",
"0",
",",
"0",
")",
")",
";",
"set2",
"=",
"SET_DEST",
"(",
"XVECEXP",
"(",
"PATTERN",
"(",
"dep_insn",
")",
",",
"0",
",",
"0",
")",
")",
";",
"}",
"else",
"return",
"0",
";",
"if",
"(",
"GET_CODE",
"(",
"set",
")",
"!=",
"REG",
"||",
"REGNO",
"(",
"set",
")",
"!=",
"FLAGS_REG",
")",
"return",
"0",
";",
"if",
"(",
"!",
"reg_overlap_mentioned_p",
"(",
"set",
",",
"PATTERN",
"(",
"insn",
")",
")",
")",
"return",
"0",
";",
"if",
"(",
"set2",
"&&",
"reg_overlap_mentioned_p",
"(",
"set2",
",",
"PATTERN",
"(",
"insn",
")",
")",
")",
"return",
"0",
";",
"return",
"1",
";",
"}",
"</s>"
] | [
"A",
"subroutine",
"of",
"ix86_adjust_cost",
"--",
"return",
"true",
"iff",
"INSN",
"reads",
"flags",
"set",
"by",
"DEP_INSN",
"and",
"nothing",
"set",
"by",
"DEP_INSN",
"."
] | [
"i386",
"0",
"0",
"0",
"2",
"0",
"0",
"0",
"1",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1"
] | i3863 | ix86_flags_dependant | i386 | CPU | GCC | 16,160 | 222 | 1 | [] |
[
"<s>",
"bool",
"PTXAsmPrinter",
"::",
"doFinalization",
"(",
"Module",
"&",
"M",
")",
"{",
"Module",
"::",
"GlobalListType",
"&",
"global_list",
"=",
"M",
".",
"getGlobalList",
"(",
")",
";",
"int",
"i",
",",
"n",
"=",
"global_list",
".",
"size",
"(",
")",
";",
"GlobalVariable",
"*",
"*",
"gv_array",
"=",
"new",
"GlobalVariable",
"*",
"[",
"n",
"]",
";",
"i",
"=",
"0",
";",
"for",
"(",
"Module",
"::",
"global_iterator",
"I",
"=",
"global_list",
".",
"begin",
"(",
")",
",",
"E",
"=",
"global_list",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"gv_array",
"[",
"i",
"++",
"]",
"=",
"&",
"*",
"I",
";",
"while",
"(",
"!",
"global_list",
".",
"empty",
"(",
")",
")",
"global_list",
".",
"remove",
"(",
"global_list",
".",
"begin",
"(",
")",
")",
";",
"bool",
"ret",
"=",
"AsmPrinter",
"::",
"doFinalization",
"(",
"M",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
")",
"global_list",
".",
"insert",
"(",
"global_list",
".",
"end",
"(",
")",
",",
"gv_array",
"[",
"i",
"]",
")",
";",
"delete",
"[",
"]",
"gv_array",
";",
"return",
"ret",
";",
"}",
"</s>"
] | [
"doFinalization",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"any",
"necessary",
"clean",
"up",
"after",
"all",
"passes",
"have",
"run",
"."
] | [
"PTX",
"PTX",
"0",
"0"
] | PTXAsmPrinter | doFinalization | PTX | GPU | LLVM | 16,161 | 155 | 1 | [] |
[
"<s>",
"SDValue",
"X86TargetLowering",
"::",
"BuildSDIVPow2",
"(",
"SDNode",
"*",
"N",
",",
"const",
"APInt",
"&",
"Divisor",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDNode",
"*",
">",
"&",
"Created",
")",
"const",
"{",
"AttributeList",
"Attr",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getFunction",
"(",
")",
".",
"getAttributes",
"(",
")",
";",
"if",
"(",
"isIntDivCheap",
"(",
"N",
"->",
"getValueType",
"(",
"0",
")",
",",
"Attr",
")",
")",
"return",
"SDValue",
"(",
"N",
",",
"0",
")",
";",
"assert",
"(",
"(",
"Divisor",
".",
"isPowerOf2",
"(",
")",
"||",
"(",
"-",
"Divisor",
")",
".",
"isPowerOf2",
"(",
")",
")",
"&&",
"\"Unexpected divisor!\"",
")",
";",
"if",
"(",
"!",
"Subtarget",
".",
"hasCMov",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"EVT",
"VT",
"=",
"N",
"->",
"getValueType",
"(",
"0",
")",
";",
"if",
"(",
"VT",
"!=",
"MVT",
"::",
"i16",
"&&",
"VT",
"!=",
"MVT",
"::",
"i32",
"&&",
"!",
"(",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"VT",
"==",
"MVT",
"::",
"i64",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"unsigned",
"Lg2",
"=",
"Divisor",
".",
"countTrailingZeros",
"(",
")",
";",
"if",
"(",
"Lg2",
"==",
"1",
")",
"return",
"SDValue",
"(",
")",
";",
"SDLoc",
"DL",
"(",
"N",
")",
";",
"SDValue",
"N0",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"Zero",
"=",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"DL",
",",
"VT",
")",
";",
"APInt",
"Lg2Mask",
"=",
"APInt",
"::",
"getLowBitsSet",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
",",
"Lg2",
")",
";",
"SDValue",
"Pow2MinusOne",
"=",
"DAG",
".",
"getConstant",
"(",
"Lg2Mask",
",",
"DL",
",",
"VT",
")",
";",
"SDValue",
"Cmp",
"=",
"DAG",
".",
"getSetCC",
"(",
"DL",
",",
"MVT",
"::",
"i8",
",",
"N0",
",",
"Zero",
",",
"ISD",
"::",
"SETLT",
")",
";",
"SDValue",
"Add",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"VT",
",",
"N0",
",",
"Pow2MinusOne",
")",
";",
"SDValue",
"CMov",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SELECT",
",",
"DL",
",",
"VT",
",",
"Cmp",
",",
"Add",
",",
"N0",
")",
";",
"Created",
".",
"push_back",
"(",
"Cmp",
".",
"getNode",
"(",
")",
")",
";",
"Created",
".",
"push_back",
"(",
"Add",
".",
"getNode",
"(",
")",
")",
";",
"Created",
".",
"push_back",
"(",
"CMov",
".",
"getNode",
"(",
")",
")",
";",
"SDValue",
"SRA",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SRA",
",",
"DL",
",",
"VT",
",",
"CMov",
",",
"DAG",
".",
"getConstant",
"(",
"Lg2",
",",
"DL",
",",
"MVT",
"::",
"i64",
")",
")",
";",
"if",
"(",
"Divisor",
".",
"isNonNegative",
"(",
")",
")",
"return",
"SRA",
";",
"Created",
".",
"push_back",
"(",
"SRA",
".",
"getNode",
"(",
")",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SUB",
",",
"DL",
",",
"VT",
",",
"Zero",
",",
"SRA",
")",
";",
"}",
"</s>"
] | [
"Targets",
"may",
"override",
"this",
"function",
"to",
"provide",
"custom",
"SDIV",
"lowering",
"for",
"power-of-2",
"denominators",
"."
] | [
"X86",
"X86",
"0",
"0",
"\"Unexpected divisor!\"",
"0",
"MVT::i16",
"MVT::i32",
"MVT::i64",
"1",
"0",
"0",
"MVT::i8",
"ISD::SETLT",
"ISD::ADD",
"ISD::SELECT",
"ISD::SRA",
"MVT::i64",
"ISD::SUB"
] | X86ISelLowering (2)6 | BuildSDIVPow2 | X86 | CPU | LLVM | 16,162 | 396 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"isShuffleMaskLegal",
"(",
"ArrayRef",
"<",
"int",
">",
"M",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"ShuffleVectorSDNode",
"::",
"isSplatMask",
"(",
"M",
".",
"data",
"(",
")",
",",
"VT",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Targets",
"can",
"use",
"this",
"to",
"indicate",
"that",
"they",
"only",
"support",
"some",
"VECTOR_SHUFFLE",
"operations",
",",
"those",
"with",
"specific",
"masks",
"."
] | [
"RISCV",
"RISCV"
] | RISCVISelLowering1 | isShuffleMaskLegal | RISCV | CPU | LLVM | 16,163 | 38 | 1 | [] |
[
"<s>",
"TargetTransformInfo",
"HexagonTargetMachine",
"::",
"getTargetTransformInfo",
"(",
"const",
"Function",
"&",
"F",
")",
"const",
"{",
"return",
"TargetTransformInfo",
"(",
"HexagonTTIImpl",
"(",
"this",
",",
"F",
")",
")",
";",
"}",
"</s>"
] | [
"Get",
"a",
"TargetTransformInfo",
"implementation",
"for",
"the",
"target",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon"
] | HexagonTargetMachine26 | getTargetTransformInfo | Hexagon | DSP | LLVM | 16,164 | 24 | 1 | [] |
[
"<s>",
"bool",
"invalid_e500_subreg",
"(",
"rtx",
"op",
",",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"TARGET_E500_DOUBLE",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"SUBREG",
"&&",
"(",
"mode",
"==",
"SImode",
"||",
"mode",
"==",
"DImode",
"||",
"mode",
"==",
"TImode",
"||",
"mode",
"==",
"DDmode",
"||",
"mode",
"==",
"TDmode",
"||",
"mode",
"==",
"PTImode",
")",
"&&",
"REG_P",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"&&",
"(",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"==",
"DFmode",
"||",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"==",
"TFmode",
"||",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"==",
"IFmode",
"||",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"==",
"KFmode",
")",
")",
"return",
"true",
";",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"SUBREG",
"&&",
"(",
"mode",
"==",
"DFmode",
"||",
"mode",
"==",
"TFmode",
"||",
"mode",
"==",
"IFmode",
"||",
"mode",
"==",
"KFmode",
")",
"&&",
"REG_P",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"&&",
"(",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"==",
"DImode",
"||",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"==",
"TImode",
"||",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"==",
"PTImode",
"||",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"==",
"DDmode",
"||",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"==",
"TDmode",
")",
")",
"return",
"true",
";",
"}",
"if",
"(",
"TARGET_SPE",
"&&",
"GET_CODE",
"(",
"op",
")",
"==",
"SUBREG",
"&&",
"mode",
"==",
"SImode",
"&&",
"REG_P",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"&&",
"SPE_VECTOR_MODE",
"(",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"TRUE",
"if",
"OP",
"is",
"an",
"invalid",
"SUBREG",
"operation",
"on",
"the",
"e500",
"."
] | [
"powerpcspe"
] | powerpcspe | invalid_e500_subreg | powerpcspe | CPU | GCC | 16,165 | 235 | 1 | [] |
[
"<s>",
"bool",
"FISCPassConfig",
"::",
"addPreISel",
"(",
")",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"{",
"{",
"@",
"For",
"GlobalISel"
] | [
"FISC",
"FISC"
] | FISCTargetMachine | addPreISel | FISC | CPU | LLVM | 16,166 | 11 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"XCoreInstrInfo",
"::",
"loadImmediate",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"Reg",
",",
"uint64_t",
"Value",
")",
"const",
"{",
"DebugLoc",
"dl",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
"&&",
"!",
"MI",
"->",
"isDebugValue",
"(",
")",
")",
"dl",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"isImmMskBitp",
"(",
"Value",
")",
")",
"{",
"int",
"N",
"=",
"Log2_32",
"(",
"Value",
")",
"+",
"1",
";",
"return",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"dl",
",",
"get",
"(",
"XCore",
"::",
"MKMSK_rus",
")",
",",
"Reg",
")",
".",
"addImm",
"(",
"N",
")",
".",
"getInstr",
"(",
")",
";",
"}",
"if",
"(",
"isImmU16",
"(",
"Value",
")",
")",
"{",
"int",
"Opcode",
"=",
"isImmU6",
"(",
"Value",
")",
"?",
"XCore",
"::",
"LDC_ru6",
":",
"XCore",
"::",
"LDC_lru6",
";",
"return",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"dl",
",",
"get",
"(",
"Opcode",
")",
",",
"Reg",
")",
".",
"addImm",
"(",
"Value",
")",
".",
"getInstr",
"(",
")",
";",
"}",
"MachineConstantPool",
"*",
"ConstantPool",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getConstantPool",
"(",
")",
";",
"const",
"Constant",
"*",
"C",
"=",
"ConstantInt",
"::",
"get",
"(",
"Type",
"::",
"getInt32Ty",
"(",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getFunction",
"(",
")",
".",
"getContext",
"(",
")",
")",
",",
"Value",
")",
";",
"unsigned",
"Idx",
"=",
"ConstantPool",
"->",
"getConstantPoolIndex",
"(",
"C",
",",
"4",
")",
";",
"return",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"dl",
",",
"get",
"(",
"XCore",
"::",
"LDWCP_lru6",
")",
",",
"Reg",
")",
".",
"addConstantPoolIndex",
"(",
"Idx",
")",
".",
"getInstr",
"(",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"series",
"of",
"instructions",
"to",
"load",
"an",
"immediate",
"."
] | [
"XCore",
"XCore",
"1",
"XCore::MKMSK_rus",
"XCore::LDC_ru6",
"XCore::LDC_lru6",
"4",
"XCore::LDWCP_lru6"
] | XCoreInstrInfo34 | loadImmediate | XCore | MPU | LLVM | 16,167 | 236 | 1 | [] |
[
"<s>",
"void",
"ix86_expand_vector_logical_operator",
"(",
"enum",
"rtx_code",
"code",
",",
"machine_mode",
"mode",
",",
"rtx",
"operands",
"[",
"]",
")",
"{",
"rtx",
"op1",
"=",
"NULL_RTX",
",",
"op2",
"=",
"NULL_RTX",
";",
"if",
"(",
"SUBREG_P",
"(",
"operands",
"[",
"1",
"]",
")",
")",
"{",
"op1",
"=",
"operands",
"[",
"1",
"]",
";",
"op2",
"=",
"operands",
"[",
"2",
"]",
";",
"}",
"else",
"if",
"(",
"SUBREG_P",
"(",
"operands",
"[",
"2",
"]",
")",
")",
"{",
"op1",
"=",
"operands",
"[",
"2",
"]",
";",
"op2",
"=",
"operands",
"[",
"1",
"]",
";",
"}",
"if",
"(",
"op1",
"&&",
"!",
"TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL",
"&&",
"(",
"SUBREG_P",
"(",
"op2",
")",
"||",
"GET_CODE",
"(",
"op2",
")",
"==",
"CONST_VECTOR",
")",
"&&",
"GET_MODE_CLASS",
"(",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op1",
")",
")",
")",
"==",
"MODE_VECTOR_FLOAT",
"&&",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op1",
")",
")",
")",
"==",
"GET_MODE_SIZE",
"(",
"mode",
")",
"&&",
"SUBREG_BYTE",
"(",
"op1",
")",
"==",
"0",
"&&",
"(",
"GET_CODE",
"(",
"op2",
")",
"==",
"CONST_VECTOR",
"||",
"(",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op1",
")",
")",
"==",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op2",
")",
")",
"&&",
"SUBREG_BYTE",
"(",
"op2",
")",
"==",
"0",
")",
")",
"&&",
"can_create_pseudo_p",
"(",
")",
")",
"{",
"rtx",
"dst",
";",
"switch",
"(",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op1",
")",
")",
")",
"{",
"case",
"V4SFmode",
":",
"case",
"V8SFmode",
":",
"case",
"V16SFmode",
":",
"case",
"V2DFmode",
":",
"case",
"V4DFmode",
":",
"case",
"V8DFmode",
":",
"dst",
"=",
"gen_reg_rtx",
"(",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op1",
")",
")",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"op2",
")",
"==",
"CONST_VECTOR",
")",
"{",
"op2",
"=",
"gen_lowpart",
"(",
"GET_MODE",
"(",
"dst",
")",
",",
"op2",
")",
";",
"op2",
"=",
"force_reg",
"(",
"GET_MODE",
"(",
"dst",
")",
",",
"op2",
")",
";",
"}",
"else",
"{",
"op1",
"=",
"operands",
"[",
"1",
"]",
";",
"op2",
"=",
"SUBREG_REG",
"(",
"operands",
"[",
"2",
"]",
")",
";",
"if",
"(",
"!",
"vector_operand",
"(",
"op2",
",",
"GET_MODE",
"(",
"dst",
")",
")",
")",
"op2",
"=",
"force_reg",
"(",
"GET_MODE",
"(",
"dst",
")",
",",
"op2",
")",
";",
"}",
"op1",
"=",
"SUBREG_REG",
"(",
"op1",
")",
";",
"if",
"(",
"!",
"vector_operand",
"(",
"op1",
",",
"GET_MODE",
"(",
"dst",
")",
")",
")",
"op1",
"=",
"force_reg",
"(",
"GET_MODE",
"(",
"dst",
")",
",",
"op1",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"dst",
",",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"GET_MODE",
"(",
"dst",
")",
",",
"op1",
",",
"op2",
")",
")",
")",
";",
"emit_move_insn",
"(",
"operands",
"[",
"0",
"]",
",",
"gen_lowpart",
"(",
"mode",
",",
"dst",
")",
")",
";",
"return",
";",
"default",
":",
"break",
";",
"}",
"}",
"if",
"(",
"!",
"vector_operand",
"(",
"operands",
"[",
"1",
"]",
",",
"mode",
")",
")",
"operands",
"[",
"1",
"]",
"=",
"force_reg",
"(",
"mode",
",",
"operands",
"[",
"1",
"]",
")",
";",
"if",
"(",
"!",
"vector_operand",
"(",
"operands",
"[",
"2",
"]",
",",
"mode",
")",
")",
"operands",
"[",
"2",
"]",
"=",
"force_reg",
"(",
"mode",
",",
"operands",
"[",
"2",
"]",
")",
";",
"ix86_fixup_binary_operands_no_copy",
"(",
"code",
",",
"mode",
",",
"operands",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"operands",
"[",
"0",
"]",
",",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"mode",
",",
"operands",
"[",
"1",
"]",
",",
"operands",
"[",
"2",
"]",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"vector",
"logical",
"operation",
"CODE",
"(",
"AND",
",",
"IOR",
",",
"XOR",
")",
"in",
"MODE",
"with",
"the",
"given",
"OPERANDS",
"."
] | [
"i386",
"1",
"1",
"2",
"2",
"2",
"1",
"0",
"0",
"1",
"2",
"0",
"1",
"1",
"1",
"2",
"2",
"2",
"0",
"1",
"2"
] | i3865 | ix86_expand_vector_logical_operator | i386 | CPU | GCC | 16,168 | 470 | 1 | [] |
[
"<s>",
"unsigned",
"MipsCodeEmitter",
"::",
"getBranchTargetOpValueMM",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"OpNo",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"Unimplemented function.\"",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getBranchTargetOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"the",
"microMIPS",
"branch",
"target",
"operand",
"."
] | [
"Mips",
"Mips",
"\"Unimplemented function.\"",
"0"
] | MipsCodeEmitter11 | getBranchTargetOpValueMM | Mips | CPU | LLVM | 16,169 | 24 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"X86RegisterInfo",
"::",
"getLargestLegalSuperClass",
"(",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"if",
"(",
"RC",
"==",
"&",
"X86",
"::",
"GR8_NOREXRegClass",
")",
"return",
"RC",
";",
"const",
"X86Subtarget",
"&",
"Subtarget",
"=",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"Super",
"=",
"RC",
";",
"TargetRegisterClass",
"::",
"sc_iterator",
"I",
"=",
"RC",
"->",
"getSuperClasses",
"(",
")",
";",
"do",
"{",
"switch",
"(",
"Super",
"->",
"getID",
"(",
")",
")",
"{",
"case",
"X86",
"::",
"FR32RegClassID",
":",
"case",
"X86",
"::",
"FR64RegClassID",
":",
"if",
"(",
"!",
"Subtarget",
".",
"hasAVX512",
"(",
")",
"&&",
"getRegSizeInBits",
"(",
"*",
"Super",
")",
"==",
"getRegSizeInBits",
"(",
"*",
"RC",
")",
")",
"return",
"Super",
";",
"break",
";",
"case",
"X86",
"::",
"VR128RegClassID",
":",
"case",
"X86",
"::",
"VR256RegClassID",
":",
"if",
"(",
"!",
"Subtarget",
".",
"hasVLX",
"(",
")",
"&&",
"getRegSizeInBits",
"(",
"*",
"Super",
")",
"==",
"getRegSizeInBits",
"(",
"*",
"RC",
")",
")",
"return",
"Super",
";",
"break",
";",
"case",
"X86",
"::",
"VR128XRegClassID",
":",
"case",
"X86",
"::",
"VR256XRegClassID",
":",
"if",
"(",
"Subtarget",
".",
"hasVLX",
"(",
")",
"&&",
"getRegSizeInBits",
"(",
"*",
"Super",
")",
"==",
"getRegSizeInBits",
"(",
"*",
"RC",
")",
")",
"return",
"Super",
";",
"break",
";",
"case",
"X86",
"::",
"FR32XRegClassID",
":",
"case",
"X86",
"::",
"FR64XRegClassID",
":",
"if",
"(",
"Subtarget",
".",
"hasAVX512",
"(",
")",
"&&",
"getRegSizeInBits",
"(",
"*",
"Super",
")",
"==",
"getRegSizeInBits",
"(",
"*",
"RC",
")",
")",
"return",
"Super",
";",
"break",
";",
"case",
"X86",
"::",
"GR8RegClassID",
":",
"case",
"X86",
"::",
"GR16RegClassID",
":",
"case",
"X86",
"::",
"GR32RegClassID",
":",
"case",
"X86",
"::",
"GR64RegClassID",
":",
"case",
"X86",
"::",
"RFP32RegClassID",
":",
"case",
"X86",
"::",
"RFP64RegClassID",
":",
"case",
"X86",
"::",
"RFP80RegClassID",
":",
"case",
"X86",
"::",
"VR512_0_15RegClassID",
":",
"case",
"X86",
"::",
"VR512RegClassID",
":",
"if",
"(",
"getRegSizeInBits",
"(",
"*",
"Super",
")",
"==",
"getRegSizeInBits",
"(",
"*",
"RC",
")",
")",
"return",
"Super",
";",
"}",
"Super",
"=",
"*",
"I",
"++",
";",
"}",
"while",
"(",
"Super",
")",
";",
"return",
"RC",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"largest",
"super",
"class",
"of",
"RC",
"that",
"is",
"legal",
"to",
"use",
"in",
"the",
"current",
"sub-target",
"and",
"has",
"the",
"same",
"spill",
"size",
"."
] | [
"X86",
"X86",
"X86::GR8_NOREXRegClass",
"X86",
"X86",
"X86::FR32RegClassID",
"X86::FR64RegClassID",
"X86::VR128RegClassID",
"X86::VR256RegClassID",
"X86::VR128XRegClassID",
"X86::VR256XRegClassID",
"X86::FR32XRegClassID",
"X86::FR64XRegClassID",
"X86::GR8RegClassID",
"X86::GR16RegClassID",
"X86::GR32RegClassID",
"X86::GR64RegClassID",
"X86::RFP32RegClassID",
"X86::RFP64RegClassID",
"X86::RFP80RegClassID",
"X86::VR512_0_15RegClassID",
"X86::VR512RegClassID"
] | X86RegisterInfo (2)1 | getLargestLegalSuperClass | X86 | CPU | LLVM | 16,170 | 295 | 1 | [] |
[
"<s>",
"void",
"dimode_scalar_chain",
"::",
"convert_op",
"(",
"rtx",
"*",
"op",
",",
"rtx_insn",
"*",
"insn",
")",
"{",
"*",
"op",
"=",
"copy_rtx_if_shared",
"(",
"*",
"op",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"*",
"op",
")",
"==",
"NOT",
")",
"{",
"convert_op",
"(",
"&",
"XEXP",
"(",
"*",
"op",
",",
"0",
")",
",",
"insn",
")",
";",
"PUT_MODE",
"(",
"*",
"op",
",",
"V2DImode",
")",
";",
"}",
"else",
"if",
"(",
"MEM_P",
"(",
"*",
"op",
")",
")",
"{",
"rtx",
"tmp",
"=",
"gen_reg_rtx",
"(",
"DImode",
")",
";",
"emit_insn_before",
"(",
"gen_move_insn",
"(",
"tmp",
",",
"*",
"op",
")",
",",
"insn",
")",
";",
"*",
"op",
"=",
"gen_rtx_SUBREG",
"(",
"V2DImode",
",",
"tmp",
",",
"0",
")",
";",
"if",
"(",
"dump_file",
")",
"fprintf",
"(",
"dump_file",
",",
"\" Preloading operand for insn %d into r%d\\n\"",
",",
"INSN_UID",
"(",
"insn",
")",
",",
"REGNO",
"(",
"tmp",
")",
")",
";",
"}",
"else",
"if",
"(",
"REG_P",
"(",
"*",
"op",
")",
")",
"{",
"df_ref",
"ref",
";",
"FOR_EACH_INSN_USE",
"(",
"ref",
",",
"insn",
")",
"if",
"(",
"DF_REF_REGNO",
"(",
"ref",
")",
"==",
"REGNO",
"(",
"*",
"op",
")",
")",
"{",
"gcc_assert",
"(",
"!",
"DF_REF_CHAIN",
"(",
"ref",
")",
")",
";",
"break",
";",
"}",
"*",
"op",
"=",
"gen_rtx_SUBREG",
"(",
"V2DImode",
",",
"*",
"op",
",",
"0",
")",
";",
"}",
"else",
"if",
"(",
"CONST_INT_P",
"(",
"*",
"op",
")",
")",
"{",
"rtx",
"vec_cst",
";",
"rtx",
"tmp",
"=",
"gen_rtx_SUBREG",
"(",
"V2DImode",
",",
"gen_reg_rtx",
"(",
"DImode",
")",
",",
"0",
")",
";",
"if",
"(",
"constm1_operand",
"(",
"*",
"op",
",",
"GET_MODE",
"(",
"*",
"op",
")",
")",
")",
"vec_cst",
"=",
"CONSTM1_RTX",
"(",
"V2DImode",
")",
";",
"else",
"vec_cst",
"=",
"gen_rtx_CONST_VECTOR",
"(",
"V2DImode",
",",
"gen_rtvec",
"(",
"2",
",",
"*",
"op",
",",
"const0_rtx",
")",
")",
";",
"if",
"(",
"!",
"standard_sse_constant_p",
"(",
"vec_cst",
",",
"V2DImode",
")",
")",
"{",
"start_sequence",
"(",
")",
";",
"vec_cst",
"=",
"validize_mem",
"(",
"force_const_mem",
"(",
"V2DImode",
",",
"vec_cst",
")",
")",
";",
"rtx_insn",
"*",
"seq",
"=",
"get_insns",
"(",
")",
";",
"end_sequence",
"(",
")",
";",
"emit_insn_before",
"(",
"seq",
",",
"insn",
")",
";",
"}",
"emit_insn_before",
"(",
"gen_move_insn",
"(",
"copy_rtx",
"(",
"tmp",
")",
",",
"vec_cst",
")",
",",
"insn",
")",
";",
"*",
"op",
"=",
"tmp",
";",
"}",
"else",
"{",
"gcc_assert",
"(",
"SUBREG_P",
"(",
"*",
"op",
")",
")",
";",
"gcc_assert",
"(",
"GET_MODE",
"(",
"*",
"op",
")",
"==",
"V2DImode",
")",
";",
"}",
"}",
"</s>"
] | [
"Convert",
"operand",
"OP",
"in",
"INSN",
".",
"We",
"should",
"handle",
"memory",
"operands",
"and",
"uninitialized",
"registers",
".",
"All",
"other",
"register",
"uses",
"are",
"converted",
"during",
"registers",
"conversion",
"."
] | [
"i386",
"0",
"0",
"\" Preloading operand for insn %d into r%d\\n\"",
"0",
"0",
"2"
] | i3866 | convert_op | i386 | CPU | GCC | 16,171 | 340 | 1 | [] |
[
"<s>",
"int",
"emit_cbcond_nop",
"(",
"rtx",
"insn",
")",
"{",
"rtx",
"next",
"=",
"next_active_insn",
"(",
"insn",
")",
";",
"if",
"(",
"!",
"next",
")",
"return",
"1",
";",
"if",
"(",
"NONJUMP_INSN_P",
"(",
"next",
")",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"next",
")",
")",
"==",
"SEQUENCE",
")",
"next",
"=",
"XVECEXP",
"(",
"PATTERN",
"(",
"next",
")",
",",
"0",
",",
"0",
")",
";",
"else",
"if",
"(",
"CALL_P",
"(",
"next",
")",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"next",
")",
")",
"==",
"PARALLEL",
")",
"{",
"rtx",
"delay",
"=",
"XVECEXP",
"(",
"PATTERN",
"(",
"next",
")",
",",
"0",
",",
"1",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"delay",
")",
"==",
"RETURN",
")",
"{",
"if",
"(",
"sparc_leaf_function_p",
"||",
"TARGET_FLAT",
")",
"return",
"0",
";",
"}",
"}",
"if",
"(",
"NONJUMP_INSN_P",
"(",
"next",
")",
")",
"return",
"0",
";",
"return",
"1",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"we",
"should",
"emit",
"a",
"nop",
"after",
"a",
"cbcond",
"instruction",
".",
"The",
"cbcond",
"instruction",
"does",
"not",
"have",
"a",
"delay",
"slot",
",",
"however",
"there",
"is",
"a",
"severe",
"performance",
"penalty",
"if",
"a",
"control",
"transfer",
"appears",
"right",
"after",
"a",
"cbcond",
".",
"Therefore",
"we",
"emit",
"a",
"nop",
"when",
"we",
"detect",
"this",
"situation",
"."
] | [
"sparc",
"1",
"0",
"0",
"0",
"1",
"0",
"0",
"1"
] | sparc4 | emit_cbcond_nop | sparc | CPU | GCC | 16,172 | 123 | 1 | [] |
[
"<s>",
"unsigned",
"MipsSEInstrInfo",
"::",
"getOppositeBranchOpc",
"(",
"unsigned",
"Opc",
")",
"const",
"{",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Illegal opcode!\"",
")",
";",
"case",
"Mips",
"::",
"BEQ",
":",
"return",
"Mips",
"::",
"BNE",
";",
"case",
"Mips",
"::",
"BNE",
":",
"return",
"Mips",
"::",
"BEQ",
";",
"case",
"Mips",
"::",
"BGTZ",
":",
"return",
"Mips",
"::",
"BLEZ",
";",
"case",
"Mips",
"::",
"BGEZ",
":",
"return",
"Mips",
"::",
"BLTZ",
";",
"case",
"Mips",
"::",
"BLTZ",
":",
"return",
"Mips",
"::",
"BGEZ",
";",
"case",
"Mips",
"::",
"BLEZ",
":",
"return",
"Mips",
"::",
"BGTZ",
";",
"case",
"Mips",
"::",
"BEQ64",
":",
"return",
"Mips",
"::",
"BNE64",
";",
"case",
"Mips",
"::",
"BNE64",
":",
"return",
"Mips",
"::",
"BEQ64",
";",
"case",
"Mips",
"::",
"BGTZ64",
":",
"return",
"Mips",
"::",
"BLEZ64",
";",
"case",
"Mips",
"::",
"BGEZ64",
":",
"return",
"Mips",
"::",
"BLTZ64",
";",
"case",
"Mips",
"::",
"BLTZ64",
":",
"return",
"Mips",
"::",
"BGEZ64",
";",
"case",
"Mips",
"::",
"BLEZ64",
":",
"return",
"Mips",
"::",
"BGTZ64",
";",
"case",
"Mips",
"::",
"BC1T",
":",
"return",
"Mips",
"::",
"BC1F",
";",
"case",
"Mips",
"::",
"BC1F",
":",
"return",
"Mips",
"::",
"BC1T",
";",
"case",
"Mips",
"::",
"BEQZC_MM",
":",
"return",
"Mips",
"::",
"BNEZC_MM",
";",
"case",
"Mips",
"::",
"BNEZC_MM",
":",
"return",
"Mips",
"::",
"BEQZC_MM",
";",
"}",
"}",
"</s>"
] | [
"getOppositeBranchOpc",
"-",
"Return",
"the",
"inverse",
"of",
"the",
"specified",
"opcode",
",",
"e.g",
"."
] | [
"Mips",
"Mips",
"\"Illegal opcode!\"",
"Mips::BEQ",
"Mips::BNE",
"Mips::BNE",
"Mips::BEQ",
"Mips::BGTZ",
"Mips::BLEZ",
"Mips::BGEZ",
"Mips::BLTZ",
"Mips::BLTZ",
"Mips::BGEZ",
"Mips::BLEZ",
"Mips::BGTZ",
"Mips::BEQ64",
"Mips::BNE64",
"Mips::BNE64",
"Mips::BEQ64",
"Mips::BGTZ64",
"Mips::BLEZ64",
"Mips::BGEZ64",
"Mips::BLTZ64",
"Mips::BLTZ64",
"Mips::BGEZ64",
"Mips::BLEZ64",
"Mips::BGTZ64",
"Mips::BC1T",
"Mips::BC1F",
"Mips::BC1F",
"Mips::BC1T",
"Mips::BEQZC_MM",
"Mips::BNEZC_MM",
"Mips::BNEZC_MM",
"Mips::BEQZC_MM"
] | MipsSEInstrInfo | getOppositeBranchOpc | Mips | CPU | LLVM | 16,173 | 184 | 1 | [] |
[
"<s>",
"unsigned",
"MipsMCCodeEmitter",
"::",
"getJumpTargetOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"unsigned",
"OpNo",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
")",
"const",
"{",
"const",
"MCOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OpNo",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
";",
"assert",
"(",
"MO",
".",
"isExpr",
"(",
")",
"&&",
"\"getJumpTargetOpValue expects only expressions or an immediate\"",
")",
";",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MO",
".",
"getExpr",
"(",
")",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"Create",
"(",
"0",
",",
"Expr",
",",
"MCFixupKind",
"(",
"Mips",
"::",
"fixup_Mips_26",
")",
")",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getJumpTargetOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"the",
"jump",
"target",
"operand",
"."
] | [
"Mips",
"Mips",
"\"getJumpTargetOpValue expects only expressions or an immediate\"",
"0",
"Mips::fixup_Mips_26",
"0"
] | MipsMCCodeEmitter13 | getJumpTargetOpValue | Mips | CPU | LLVM | 16,174 | 96 | 1 | [] |
[
"<s>",
"bool",
"isMem",
"(",
")",
"const",
"override",
"{",
"return",
"Kind",
"==",
"k_Memory",
";",
"}",
"</s>"
] | [
"isMem",
"-",
"Is",
"this",
"a",
"memory",
"operand",
"?"
] | [
"Cpu0"
] | Cpu0AsmParser | isMem | Cpu0 | CPU | LLVM | 16,175 | 13 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"const",
"TargetRegisterClass",
"*",
",",
"uint8_t",
">",
"ARMTargetLowering",
"::",
"findRepresentativeClass",
"(",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"MVT",
"VT",
")",
"const",
"{",
"const",
"TargetRegisterClass",
"*",
"RRC",
"=",
"nullptr",
";",
"uint8_t",
"Cost",
"=",
"1",
";",
"switch",
"(",
"VT",
".",
"SimpleTy",
")",
"{",
"default",
":",
"return",
"TargetLowering",
"::",
"findRepresentativeClass",
"(",
"TRI",
",",
"VT",
")",
";",
"case",
"MVT",
"::",
"f32",
":",
"case",
"MVT",
"::",
"f64",
":",
"case",
"MVT",
"::",
"v8i8",
":",
"case",
"MVT",
"::",
"v4i16",
":",
"case",
"MVT",
"::",
"v2i32",
":",
"case",
"MVT",
"::",
"v1i64",
":",
"case",
"MVT",
"::",
"v2f32",
":",
"RRC",
"=",
"&",
"ARM",
"::",
"DPRRegClass",
";",
"if",
"(",
"Subtarget",
"->",
"useNEONForSinglePrecisionFP",
"(",
")",
")",
"Cost",
"=",
"2",
";",
"break",
";",
"case",
"MVT",
"::",
"v16i8",
":",
"case",
"MVT",
"::",
"v8i16",
":",
"case",
"MVT",
"::",
"v4i32",
":",
"case",
"MVT",
"::",
"v2i64",
":",
"case",
"MVT",
"::",
"v4f32",
":",
"case",
"MVT",
"::",
"v2f64",
":",
"RRC",
"=",
"&",
"ARM",
"::",
"DPRRegClass",
";",
"Cost",
"=",
"2",
";",
"break",
";",
"case",
"MVT",
"::",
"v4i64",
":",
"RRC",
"=",
"&",
"ARM",
"::",
"DPRRegClass",
";",
"Cost",
"=",
"4",
";",
"break",
";",
"case",
"MVT",
"::",
"v8i64",
":",
"RRC",
"=",
"&",
"ARM",
"::",
"DPRRegClass",
";",
"Cost",
"=",
"8",
";",
"break",
";",
"}",
"return",
"std",
"::",
"make_pair",
"(",
"RRC",
",",
"Cost",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"largest",
"legal",
"super-reg",
"register",
"class",
"of",
"the",
"register",
"class",
"for",
"the",
"specified",
"type",
"and",
"its",
"associated",
"``",
"cost",
"''",
"."
] | [
"ARM",
"ARM",
"1",
"MVT::f32",
"MVT::f64",
"MVT::v8i8",
"MVT::v4i16",
"MVT::v2i32",
"MVT::v1i64",
"MVT::v2f32",
"ARM::DPRRegClass",
"2",
"MVT::v16i8",
"MVT::v8i16",
"MVT::v4i32",
"MVT::v2i64",
"MVT::v4f32",
"MVT::v2f64",
"ARM::DPRRegClass",
"2",
"MVT::v4i64",
"ARM::DPRRegClass",
"4",
"MVT::v8i64",
"ARM::DPRRegClass",
"8"
] | ARMISelLowering (2)2 | findRepresentativeClass | ARM | CPU | LLVM | 16,176 | 202 | 1 | [] |
[
"<s>",
"unsigned",
"OR1KMachineFunctionInfo",
"::",
"getGlobalBaseReg",
"(",
")",
"{",
"if",
"(",
"GlobalBaseReg",
")",
"return",
"GlobalBaseReg",
";",
"return",
"GlobalBaseReg",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"&",
"OR1K",
"::",
"GPRRegClass",
")",
";",
"}",
"</s>"
] | [
"getGlobalBaseReg",
"-",
"Return",
"a",
"virtual",
"register",
"initialized",
"with",
"the",
"the",
"global",
"base",
"register",
"value",
"."
] | [
"OR1K",
"OR1K",
"OR1K::GPRRegClass"
] | OR1KMachineFunctionInfo | getGlobalBaseReg | OR1K | CPU | LLVM | 16,177 | 32 | 1 | [] |
[
"<s>",
"static",
"rtx_insn",
"*",
"thumb1_emit_multi_reg_push",
"(",
"unsigned",
"long",
"mask",
",",
"unsigned",
"long",
"real_regs",
")",
"{",
"unsigned",
"long",
"regno",
";",
"rtx",
"par",
"[",
"10",
"]",
",",
"tmp",
",",
"reg",
";",
"rtx_insn",
"*",
"insn",
";",
"int",
"i",
",",
"j",
";",
"for",
"(",
"i",
"=",
"0",
";",
"mask",
";",
"++",
"i",
",",
"mask",
"&=",
"mask",
"-",
"1",
")",
"{",
"regno",
"=",
"ctz_hwi",
"(",
"mask",
")",
";",
"reg",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"regno",
")",
";",
"if",
"(",
"i",
"==",
"0",
")",
"tmp",
"=",
"gen_rtx_UNSPEC",
"(",
"BLKmode",
",",
"gen_rtvec",
"(",
"1",
",",
"reg",
")",
",",
"UNSPEC_PUSH_MULT",
")",
";",
"else",
"tmp",
"=",
"gen_rtx_USE",
"(",
"VOIDmode",
",",
"reg",
")",
";",
"par",
"[",
"i",
"]",
"=",
"tmp",
";",
"}",
"tmp",
"=",
"plus_constant",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"-",
"4",
"*",
"i",
")",
";",
"tmp",
"=",
"gen_rtx_PRE_MODIFY",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"tmp",
")",
";",
"tmp",
"=",
"gen_frame_mem",
"(",
"BLKmode",
",",
"tmp",
")",
";",
"tmp",
"=",
"gen_rtx_SET",
"(",
"tmp",
",",
"par",
"[",
"0",
"]",
")",
";",
"par",
"[",
"0",
"]",
"=",
"tmp",
";",
"tmp",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"gen_rtvec_v",
"(",
"i",
",",
"par",
")",
")",
";",
"insn",
"=",
"emit_insn",
"(",
"tmp",
")",
";",
"tmp",
"=",
"plus_constant",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"-",
"4",
"*",
"i",
")",
";",
"tmp",
"=",
"gen_rtx_SET",
"(",
"stack_pointer_rtx",
",",
"tmp",
")",
";",
"par",
"[",
"0",
"]",
"=",
"tmp",
";",
"for",
"(",
"j",
"=",
"0",
";",
"real_regs",
";",
"++",
"j",
",",
"real_regs",
"&=",
"real_regs",
"-",
"1",
")",
"{",
"regno",
"=",
"ctz_hwi",
"(",
"real_regs",
")",
";",
"reg",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"regno",
")",
";",
"tmp",
"=",
"plus_constant",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"j",
"*",
"4",
")",
";",
"tmp",
"=",
"gen_frame_mem",
"(",
"SImode",
",",
"tmp",
")",
";",
"tmp",
"=",
"gen_rtx_SET",
"(",
"tmp",
",",
"reg",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"tmp",
")",
"=",
"1",
";",
"par",
"[",
"j",
"+",
"1",
"]",
"=",
"tmp",
";",
"}",
"if",
"(",
"j",
"==",
"0",
")",
"tmp",
"=",
"par",
"[",
"0",
"]",
";",
"else",
"{",
"RTX_FRAME_RELATED_P",
"(",
"par",
"[",
"0",
"]",
")",
"=",
"1",
";",
"tmp",
"=",
"gen_rtx_SEQUENCE",
"(",
"VOIDmode",
",",
"gen_rtvec_v",
"(",
"j",
"+",
"1",
",",
"par",
")",
")",
";",
"}",
"add_reg_note",
"(",
"insn",
",",
"REG_FRAME_RELATED_EXPR",
",",
"tmp",
")",
";",
"return",
"insn",
";",
"}",
"</s>"
] | [
"Like",
"emit_multi_reg_push",
",",
"but",
"allowing",
"for",
"a",
"different",
"set",
"of",
"registers",
"to",
"be",
"described",
"as",
"saved",
".",
"MASK",
"is",
"the",
"set",
"of",
"registers",
"to",
"be",
"saved",
";",
"REAL_REGS",
"is",
"the",
"set",
"of",
"registers",
"to",
"be",
"described",
"as",
"saved",
".",
"If",
"REAL_REGS",
"is",
"0",
",",
"only",
"describe",
"the",
"stack",
"adjustment",
"."
] | [
"arm",
"10",
"0",
"1",
"0",
"1",
"4",
"0",
"0",
"4",
"0",
"0",
"1",
"4",
"1",
"1",
"0",
"0",
"0",
"1",
"1"
] | arm | thumb1_emit_multi_reg_push | arm | CPU | GCC | 16,178 | 352 | 1 | [] |
[
"<s>",
"static",
"rtx",
"create_temp_reg_if_possible",
"(",
"machine_mode",
"mode",
",",
"rtx",
"default_reg",
")",
"{",
"return",
"can_create_pseudo_p",
"(",
")",
"?",
"gen_reg_rtx",
"(",
"mode",
")",
":",
"default_reg",
";",
"}",
"</s>"
] | [
"Create",
"a",
"temporary",
"variable",
"to",
"hold",
"a",
"partial",
"result",
",",
"to",
"enable",
"CSE",
"."
] | [
"tilegx"
] | tilegx | create_temp_reg_if_possible | tilegx | VLIW | GCC | 16,179 | 24 | 1 | [] |
[
"<s>",
"void",
"LanaiFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MachineFunction",
"&",
"MF",
",",
"BitVector",
"&",
"SavedRegs",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"TargetFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MF",
",",
"SavedRegs",
",",
"RS",
")",
";",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"LanaiRegisterInfo",
"*",
"LRI",
"=",
"static_cast",
"<",
"const",
"LanaiRegisterInfo",
"*",
">",
"(",
"STI",
".",
"getRegisterInfo",
"(",
")",
")",
";",
"int",
"Offset",
"=",
"-",
"4",
";",
"MFI",
"->",
"CreateFixedObject",
"(",
"4",
",",
"Offset",
",",
"true",
")",
";",
"Offset",
"-=",
"4",
";",
"MFI",
"->",
"CreateFixedObject",
"(",
"4",
",",
"Offset",
",",
"true",
")",
";",
"Offset",
"-=",
"4",
";",
"if",
"(",
"LRI",
"->",
"hasBasePointer",
"(",
"MF",
")",
")",
"{",
"MFI",
"->",
"CreateFixedObject",
"(",
"4",
",",
"Offset",
",",
"true",
")",
";",
"SavedRegs",
".",
"reset",
"(",
"LRI",
"->",
"getBaseRegister",
"(",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"determines",
"which",
"of",
"the",
"registers",
"reported",
"by",
"TargetRegisterInfo",
":",
":getCalleeSavedRegs",
"(",
")",
"should",
"actually",
"get",
"saved",
"."
] | [
"Lanai",
"Lanai",
"Lanai",
"Lanai",
"4",
"4",
"4",
"4",
"4",
"4"
] | LanaiFrameLowering | determineCalleeSaves | Lanai | CPU | LLVM | 16,180 | 129 | 1 | [] |
[
"<s>",
"const",
"M68kSubtarget",
"*",
"getSubtargetImpl",
"(",
")",
"const",
"{",
"return",
"&",
"Subtarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"M68k",
"M68k"
] | M68kTargetMachine | getSubtargetImpl | M68k | MPU | LLVM | 16,181 | 13 | 1 | [] |
[
"<s>",
"static",
"rtx",
"function_arg_union_value",
"(",
"int",
"size",
",",
"machine_mode",
"mode",
",",
"int",
"slotno",
",",
"int",
"regno",
")",
"{",
"int",
"nwords",
"=",
"ROUND_ADVANCE",
"(",
"size",
")",
",",
"i",
";",
"rtx",
"regs",
";",
"if",
"(",
"nwords",
"==",
"0",
")",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"regno",
")",
";",
"if",
"(",
"slotno",
"==",
"SPARC_INT_ARG_MAX",
"-",
"1",
")",
"nwords",
"=",
"1",
";",
"regs",
"=",
"gen_rtx_PARALLEL",
"(",
"mode",
",",
"rtvec_alloc",
"(",
"nwords",
")",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"nwords",
";",
"i",
"++",
")",
"{",
"XVECEXP",
"(",
"regs",
",",
"0",
",",
"i",
")",
"=",
"gen_rtx_EXPR_LIST",
"(",
"VOIDmode",
",",
"gen_rtx_REG",
"(",
"word_mode",
",",
"regno",
")",
",",
"GEN_INT",
"(",
"UNITS_PER_WORD",
"*",
"i",
")",
")",
";",
"regno",
"++",
";",
"}",
"return",
"regs",
";",
"}",
"</s>"
] | [
"Used",
"by",
"function_arg",
"and",
"sparc_function_value_1",
"to",
"implement",
"the",
"conventions",
"of",
"the",
"64-bit",
"ABI",
"for",
"passing",
"and",
"returning",
"unions",
".",
"Return",
"an",
"expression",
"valid",
"as",
"a",
"return",
"value",
"for",
"the",
"FUNCTION_ARG",
"and",
"TARGET_FUNCTION_VALUE",
".",
"SIZE",
"is",
"the",
"size",
"in",
"bytes",
"of",
"the",
"union",
".",
"MODE",
"is",
"the",
"argument",
"'s",
"machine",
"mode",
".",
"REGNO",
"is",
"the",
"hard",
"register",
"the",
"union",
"will",
"be",
"passed",
"in",
"."
] | [
"sparc",
"0",
"1",
"1",
"0",
"0"
] | sparc4 | function_arg_union_value | sparc | CPU | GCC | 16,182 | 118 | 1 | [] |
[
"<s>",
"static",
"void",
"macho_branch_islands",
"(",
"void",
")",
"{",
"char",
"tmp_buf",
"[",
"512",
"]",
";",
"while",
"(",
"!",
"vec_safe_is_empty",
"(",
"branch_islands",
")",
")",
"{",
"branch_island",
"*",
"bi",
"=",
"&",
"branch_islands",
"->",
"last",
"(",
")",
";",
"const",
"char",
"*",
"label",
"=",
"IDENTIFIER_POINTER",
"(",
"bi",
"->",
"label_name",
")",
";",
"const",
"char",
"*",
"name",
"=",
"IDENTIFIER_POINTER",
"(",
"bi",
"->",
"function_name",
")",
";",
"char",
"name_buf",
"[",
"512",
"]",
";",
"if",
"(",
"name",
"[",
"0",
"]",
"==",
"'*'",
"||",
"name",
"[",
"0",
"]",
"==",
"'&'",
")",
"strcpy",
"(",
"name_buf",
",",
"name",
"+",
"1",
")",
";",
"else",
"{",
"name_buf",
"[",
"0",
"]",
"=",
"'_'",
";",
"strcpy",
"(",
"name_buf",
"+",
"1",
",",
"name",
")",
";",
"}",
"strcpy",
"(",
"tmp_buf",
",",
"\"\\n\"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"label",
")",
";",
"if",
"(",
"write_symbols",
"==",
"DBX_DEBUG",
"||",
"write_symbols",
"==",
"XCOFF_DEBUG",
")",
"dbxout_stabd",
"(",
"N_SLINE",
",",
"bi",
"->",
"line_number",
")",
";",
"if",
"(",
"flag_pic",
")",
"{",
"if",
"(",
"TARGET_LINK_STACK",
")",
"{",
"char",
"name",
"[",
"32",
"]",
";",
"get_ppc476_thunk_name",
"(",
"name",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\":\\n\\tmflr r0\\n\\tbl \"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"name",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\"\\n\"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"label",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\"_pic:\\n\\tmflr r11\\n\"",
")",
";",
"}",
"else",
"{",
"strcat",
"(",
"tmp_buf",
",",
"\":\\n\\tmflr r0\\n\\tbcl 20,31,\"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"label",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\"_pic\\n\"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"label",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\"_pic:\\n\\tmflr r11\\n\"",
")",
";",
"}",
"strcat",
"(",
"tmp_buf",
",",
"\"\\taddis r11,r11,ha16(\"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"name_buf",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\" - \"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"label",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\"_pic)\\n\"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\"\\tmtlr r0\\n\"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\"\\taddi r12,r11,lo16(\"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"name_buf",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\" - \"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"label",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\"_pic)\\n\"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\"\\tmtctr r12\\n\\tbctr\\n\"",
")",
";",
"}",
"else",
"{",
"strcat",
"(",
"tmp_buf",
",",
"\":\\nlis r12,hi16(\"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"name_buf",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\")\\n\\tori r12,r12,lo16(\"",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"name_buf",
")",
";",
"strcat",
"(",
"tmp_buf",
",",
"\")\\n\\tmtctr r12\\n\\tbctr\"",
")",
";",
"}",
"output_asm_insn",
"(",
"tmp_buf",
",",
"0",
")",
";",
"if",
"(",
"write_symbols",
"==",
"DBX_DEBUG",
"||",
"write_symbols",
"==",
"XCOFF_DEBUG",
")",
"dbxout_stabd",
"(",
"N_SLINE",
",",
"bi",
"->",
"line_number",
")",
";",
"branch_islands",
"->",
"pop",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Generate",
"far-jump",
"branch",
"islands",
"for",
"everything",
"on",
"the",
"branch_island_list",
".",
"Invoked",
"immediately",
"after",
"the",
"last",
"instruction",
"of",
"the",
"epilogue",
"has",
"been",
"emitted",
";",
"the",
"branch-islands",
"must",
"be",
"appended",
"to",
",",
"and",
"contiguous",
"with",
",",
"the",
"function",
"body",
".",
"Mach-O",
"stubs",
"are",
"generated",
"in",
"machopic_output_stub",
"(",
")",
"."
] | [
"powerpcspe",
"512",
"512",
"0",
"0",
"1",
"0",
"1",
"\"\\n\"",
"32",
"\":\\n\\tmflr r0\\n\\tbl \"",
"\"\\n\"",
"\"_pic:\\n\\tmflr r11\\n\"",
"\":\\n\\tmflr r0\\n\\tbcl 20,31,\"",
"\"_pic\\n\"",
"\"_pic:\\n\\tmflr r11\\n\"",
"\"\\taddis r11,r11,ha16(\"",
"\" - \"",
"\"_pic)\\n\"",
"\"\\tmtlr r0\\n\"",
"\"\\taddi r12,r11,lo16(\"",
"\" - \"",
"\"_pic)\\n\"",
"\"\\tmtctr r12\\n\\tbctr\\n\"",
"\":\\nlis r12,hi16(\"",
"\")\\n\\tori r12,r12,lo16(\"",
"\")\\n\\tmtctr r12\\n\\tbctr\"",
"0"
] | powerpcspe | macho_branch_islands | powerpcspe | CPU | GCC | 16,183 | 392 | 1 | [] |
[
"<s>",
"static",
"tree",
"h8300_handle_tiny_data_attribute",
"(",
"tree",
"*",
"node",
",",
"tree",
"name",
",",
"tree",
"args",
"ATTRIBUTE_UNUSED",
",",
"int",
"flags",
"ATTRIBUTE_UNUSED",
",",
"bool",
"*",
"no_add_attrs",
")",
"{",
"tree",
"decl",
"=",
"*",
"node",
";",
"if",
"(",
"TREE_STATIC",
"(",
"decl",
")",
"||",
"DECL_EXTERNAL",
"(",
"decl",
")",
")",
"{",
"set_decl_section_name",
"(",
"decl",
",",
"\".tiny\"",
")",
";",
"}",
"else",
"{",
"warning",
"(",
"OPT_Wattributes",
",",
"\"%qE attribute ignored\"",
",",
"name",
")",
";",
"*",
"no_add_attrs",
"=",
"true",
";",
"}",
"return",
"NULL_TREE",
";",
"}",
"</s>"
] | [
"Handle",
"an",
"``",
"tiny_data",
"''",
"attribute",
";",
"arguments",
"as",
"in",
"struct",
"attribute_spec.handler",
"."
] | [
"h8300",
"\".tiny\"",
"\"%qE attribute ignored\""
] | h8300 | h8300_handle_tiny_data_attribute | h8300 | MPU | GCC | 16,184 | 72 | 1 | [] |
[
"<s>",
"void",
"build",
"(",
"function_builder",
"&",
"b",
",",
"const",
"function_group_info",
"&",
"group",
")",
"const",
"OVERRIDE",
"{",
"b",
".",
"add_overloaded_functions",
"(",
"group",
",",
"MODE_none",
")",
";",
"build_all",
"(",
"b",
",",
"\"v0,vu0\"",
",",
"group",
",",
"MODE_none",
")",
";",
"}",
"</s>"
] | [
"Build",
"new",
"chain",
"starting",
"from",
"insn",
"INSN_UID",
"recursively",
"adding",
"all",
"dependent",
"uses",
"and",
"definitions",
".",
"Return",
"true",
"if",
"OK",
",",
"false",
"if",
"the",
"chain",
"discovery",
"was",
"aborted",
"."
] | [
"aarch64",
"\"v0,vu0\""
] | aarch64-sve-builtins-shapes | build | aarch64 | CPU | GCC | 16,185 | 36 | 1 | [] |
[
"<s>",
"void",
"AVRInstPrinter",
"::",
"printPCRelImm",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"const",
"MCOperand",
"&",
"Op",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNo",
")",
";",
"if",
"(",
"Op",
".",
"isImm",
"(",
")",
")",
"{",
"int64_t",
"Imm",
"=",
"Op",
".",
"getImm",
"(",
")",
";",
"O",
"<<",
"'.'",
";",
"if",
"(",
"Imm",
">=",
"0",
")",
"O",
"<<",
"'+'",
";",
"O",
"<<",
"Imm",
";",
"}",
"else",
"{",
"assert",
"(",
"Op",
".",
"isExpr",
"(",
")",
"&&",
"\"Unknown pcrel immediate operand\"",
")",
";",
"O",
"<<",
"*",
"Op",
".",
"getExpr",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"value",
"(",
"e.g",
"."
] | [
"AVR",
"AVR",
"0",
"\"Unknown pcrel immediate operand\""
] | AVRInstPrinter5 | printPCRelImm | AVR | MPU | LLVM | 16,186 | 91 | 1 | [] |
[
"<s>",
"SparcTargetMachine",
"::",
"SparcTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"StringRef",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"Reloc",
"::",
"Model",
"RM",
",",
"CodeModel",
"::",
"Model",
"CM",
",",
"bool",
"is64bit",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"RM",
",",
"CM",
")",
",",
"Subtarget",
"(",
"TT",
",",
"CPU",
",",
"FS",
",",
"is64bit",
")",
",",
"DataLayout",
"(",
"Subtarget",
".",
"getDataLayout",
"(",
")",
")",
",",
"TLInfo",
"(",
"*",
"this",
")",
",",
"TSInfo",
"(",
"*",
"this",
")",
",",
"InstrInfo",
"(",
"Subtarget",
")",
",",
"FrameLowering",
"(",
"Subtarget",
")",
"{",
"}",
"</s>"
] | [
"Create",
"an",
"ILP32",
"architecture",
"model",
"."
] | [
"Sparc",
"Sparc",
"Sparc"
] | SparcTargetMachine | SparcTargetMachine | Sparc | CPU | LLVM | 16,187 | 90 | 1 | [] |
[
"<s>",
"void",
"ARMAsmPrinter",
"::",
"emitMachineConstantPoolValue",
"(",
"MachineConstantPoolValue",
"*",
"MCPV",
")",
"{",
"const",
"DataLayout",
"&",
"DL",
"=",
"getDataLayout",
"(",
")",
";",
"int",
"Size",
"=",
"DL",
".",
"getTypeAllocSize",
"(",
"MCPV",
"->",
"getType",
"(",
")",
")",
";",
"ARMConstantPoolValue",
"*",
"ACPV",
"=",
"static_cast",
"<",
"ARMConstantPoolValue",
"*",
">",
"(",
"MCPV",
")",
";",
"if",
"(",
"ACPV",
"->",
"isPromotedGlobal",
"(",
")",
")",
"{",
"auto",
"*",
"ACPC",
"=",
"cast",
"<",
"ARMConstantPoolConstant",
">",
"(",
"ACPV",
")",
";",
"for",
"(",
"const",
"auto",
"*",
"GV",
":",
"ACPC",
"->",
"promotedGlobals",
"(",
")",
")",
"{",
"if",
"(",
"!",
"EmittedPromotedGlobalLabels",
".",
"count",
"(",
"GV",
")",
")",
"{",
"MCSymbol",
"*",
"GVSym",
"=",
"getSymbol",
"(",
"GV",
")",
";",
"OutStreamer",
"->",
"emitLabel",
"(",
"GVSym",
")",
";",
"EmittedPromotedGlobalLabels",
".",
"insert",
"(",
"GV",
")",
";",
"}",
"}",
"return",
"emitGlobalConstant",
"(",
"DL",
",",
"ACPC",
"->",
"getPromotedGlobalInit",
"(",
")",
")",
";",
"}",
"MCSymbol",
"*",
"MCSym",
";",
"if",
"(",
"ACPV",
"->",
"isLSDA",
"(",
")",
")",
"{",
"MCSym",
"=",
"getCurExceptionSym",
"(",
")",
";",
"}",
"else",
"if",
"(",
"ACPV",
"->",
"isBlockAddress",
"(",
")",
")",
"{",
"const",
"BlockAddress",
"*",
"BA",
"=",
"cast",
"<",
"ARMConstantPoolConstant",
">",
"(",
"ACPV",
")",
"->",
"getBlockAddress",
"(",
")",
";",
"MCSym",
"=",
"GetBlockAddressSymbol",
"(",
"BA",
")",
";",
"}",
"else",
"if",
"(",
"ACPV",
"->",
"isGlobalValue",
"(",
")",
")",
"{",
"const",
"GlobalValue",
"*",
"GV",
"=",
"cast",
"<",
"ARMConstantPoolConstant",
">",
"(",
"ACPV",
")",
"->",
"getGV",
"(",
")",
";",
"unsigned",
"char",
"TF",
"=",
"Subtarget",
"->",
"isTargetMachO",
"(",
")",
"?",
"ARMII",
"::",
"MO_NONLAZY",
":",
"0",
";",
"MCSym",
"=",
"GetARMGVSymbol",
"(",
"GV",
",",
"TF",
")",
";",
"}",
"else",
"if",
"(",
"ACPV",
"->",
"isMachineBasicBlock",
"(",
")",
")",
"{",
"const",
"MachineBasicBlock",
"*",
"MBB",
"=",
"cast",
"<",
"ARMConstantPoolMBB",
">",
"(",
"ACPV",
")",
"->",
"getMBB",
"(",
")",
";",
"MCSym",
"=",
"MBB",
"->",
"getSymbol",
"(",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"ACPV",
"->",
"isExtSymbol",
"(",
")",
"&&",
"\"unrecognized constant pool value\"",
")",
";",
"auto",
"Sym",
"=",
"cast",
"<",
"ARMConstantPoolSymbol",
">",
"(",
"ACPV",
")",
"->",
"getSymbol",
"(",
")",
";",
"MCSym",
"=",
"GetExternalSymbolSymbol",
"(",
"Sym",
")",
";",
"}",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"MCSym",
",",
"getModifierVariantKind",
"(",
"ACPV",
"->",
"getModifier",
"(",
")",
")",
",",
"OutContext",
")",
";",
"if",
"(",
"ACPV",
"->",
"getPCAdjustment",
"(",
")",
")",
"{",
"MCSymbol",
"*",
"PCLabel",
"=",
"getPICLabel",
"(",
"DL",
".",
"getPrivateGlobalPrefix",
"(",
")",
",",
"getFunctionNumber",
"(",
")",
",",
"ACPV",
"->",
"getLabelId",
"(",
")",
",",
"OutContext",
")",
";",
"const",
"MCExpr",
"*",
"PCRelExpr",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"PCLabel",
",",
"OutContext",
")",
";",
"PCRelExpr",
"=",
"MCBinaryExpr",
"::",
"createAdd",
"(",
"PCRelExpr",
",",
"MCConstantExpr",
"::",
"create",
"(",
"ACPV",
"->",
"getPCAdjustment",
"(",
")",
",",
"OutContext",
")",
",",
"OutContext",
")",
";",
"if",
"(",
"ACPV",
"->",
"mustAddCurrentAddress",
"(",
")",
")",
"{",
"MCSymbol",
"*",
"DotSym",
"=",
"OutContext",
".",
"createTempSymbol",
"(",
")",
";",
"OutStreamer",
"->",
"emitLabel",
"(",
"DotSym",
")",
";",
"const",
"MCExpr",
"*",
"DotExpr",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"DotSym",
",",
"OutContext",
")",
";",
"PCRelExpr",
"=",
"MCBinaryExpr",
"::",
"createSub",
"(",
"PCRelExpr",
",",
"DotExpr",
",",
"OutContext",
")",
";",
"}",
"Expr",
"=",
"MCBinaryExpr",
"::",
"createSub",
"(",
"Expr",
",",
"PCRelExpr",
",",
"OutContext",
")",
";",
"}",
"OutStreamer",
"->",
"emitValue",
"(",
"Expr",
",",
"Size",
")",
";",
"}",
"</s>"
] | [
"EmitMachineConstantPoolValue",
"-",
"Print",
"a",
"machine",
"constantpool",
"value",
"to",
"the",
".s",
"file",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARMII::MO_NONLAZY",
"0",
"ARM",
"ARM",
"\"unrecognized constant pool value\"",
"ARM"
] | ARMAsmPrinter35 | emitMachineConstantPoolValue | ARM | CPU | LLVM | 16,188 | 483 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"mips_msa_output_division",
"(",
"const",
"char",
"*",
"division",
",",
"rtx",
"*",
"operands",
")",
"{",
"const",
"char",
"*",
"s",
";",
"s",
"=",
"division",
";",
"if",
"(",
"TARGET_CHECK_ZERO_DIV",
")",
"{",
"output_asm_insn",
"(",
"\"%(bnz.%v0\\t%w2,1f\"",
",",
"operands",
")",
";",
"output_asm_insn",
"(",
"s",
",",
"operands",
")",
";",
"s",
"=",
"\"break\\t7%)\\n1:\"",
";",
"}",
"return",
"s",
";",
"}",
"</s>"
] | [
"Return",
"the",
"assembly",
"code",
"for",
"MSA",
"DIV_",
"{",
"S",
",",
"U",
"}",
".DF",
"or",
"MOD_",
"{",
"S",
",",
"U",
"}",
".DF",
"instructions",
",",
"which",
"has",
"the",
"operands",
"given",
"by",
"OPERANDS",
".",
"Add",
"in",
"a",
"divide-by-zero",
"check",
"if",
"needed",
"."
] | [
"mips",
"\"%(bnz.%v0\\t%w2,1f\"",
"\"break\\t7%)\\n1:\""
] | mips | mips_msa_output_division | mips | CPU | GCC | 16,189 | 52 | 1 | [] |
[
"<s>",
"virtual",
"bool",
"enableMachineScheduler",
"(",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Enable",
"the",
"MachineScheduler",
"pass",
"for",
"all",
"X86",
"subtargets",
"."
] | [
"AArch64"
] | AArch64Subtarget32 | enableMachineScheduler | AArch64 | CPU | LLVM | 16,190 | 11 | 1 | [] |
[
"<s>",
"static",
"int",
"n_regs_saved_by_prologue",
"(",
"void",
")",
"{",
"e_funkind",
"fkind",
"=",
"funkind",
"(",
"TREE_TYPE",
"(",
"current_function_decl",
")",
")",
";",
"bool",
"is_inthandler",
"=",
"fkind",
"!=",
"SUBROUTINE",
";",
"tree",
"attrs",
"=",
"TYPE_ATTRIBUTES",
"(",
"TREE_TYPE",
"(",
"current_function_decl",
")",
")",
";",
"bool",
"all",
"=",
"(",
"lookup_attribute",
"(",
"\"saveall\"",
",",
"attrs",
")",
"!=",
"NULL_TREE",
"||",
"(",
"is_inthandler",
"&&",
"!",
"crtl",
"->",
"is_leaf",
")",
")",
";",
"int",
"ndregs",
"=",
"all",
"?",
"8",
":",
"n_dregs_to_save",
"(",
"is_inthandler",
",",
"false",
")",
";",
"int",
"npregs",
"=",
"all",
"?",
"6",
":",
"n_pregs_to_save",
"(",
"is_inthandler",
",",
"false",
")",
";",
"int",
"n",
"=",
"ndregs",
"+",
"npregs",
";",
"int",
"i",
";",
"if",
"(",
"all",
"||",
"stack_frame_needed_p",
"(",
")",
")",
"n",
"+=",
"2",
";",
"else",
"{",
"if",
"(",
"must_save_fp_p",
"(",
")",
")",
"n",
"++",
";",
"if",
"(",
"must_save_rets_p",
"(",
")",
")",
"n",
"++",
";",
"}",
"if",
"(",
"fkind",
"!=",
"SUBROUTINE",
"||",
"all",
")",
"{",
"n",
"++",
";",
"if",
"(",
"!",
"crtl",
"->",
"is_leaf",
"||",
"cfun",
"->",
"machine",
"->",
"has_hardware_loops",
"||",
"cfun",
"->",
"machine",
"->",
"has_loopreg_clobber",
")",
"{",
"n",
"+=",
"6",
";",
"}",
"}",
"if",
"(",
"fkind",
"!=",
"SUBROUTINE",
")",
"{",
"if",
"(",
"lookup_attribute",
"(",
"\"nesting\"",
",",
"attrs",
")",
")",
"n",
"++",
";",
"}",
"for",
"(",
"i",
"=",
"REG_P7",
"+",
"1",
";",
"i",
"<",
"REG_CC",
";",
"i",
"++",
")",
"if",
"(",
"all",
"||",
"(",
"fkind",
"!=",
"SUBROUTINE",
"&&",
"(",
"df_regs_ever_live_p",
"(",
"i",
")",
"||",
"(",
"!",
"leaf_function_p",
"(",
")",
"&&",
"call_used_or_fixed_reg_p",
"(",
"i",
")",
")",
")",
")",
")",
"n",
"+=",
"i",
"==",
"REG_A0",
"||",
"i",
"==",
"REG_A1",
"?",
"2",
":",
"1",
";",
"return",
"n",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"registers",
"pushed",
"during",
"the",
"prologue",
"."
] | [
"bfin",
"\"saveall\"",
"8",
"6",
"2",
"6",
"\"nesting\"",
"1",
"2",
"1"
] | bfin | n_regs_saved_by_prologue | bfin | DSP | GCC | 16,191 | 250 | 1 | [] |
[
"<s>",
"int",
"frv_emit_cond_branch",
"(",
"rtx",
"operands",
"[",
"]",
")",
"{",
"rtx",
"test_rtx",
";",
"rtx",
"label_ref",
";",
"rtx",
"if_else",
";",
"enum",
"rtx_code",
"test",
"=",
"GET_CODE",
"(",
"operands",
"[",
"0",
"]",
")",
";",
"rtx",
"cc_reg",
"=",
"frv_emit_comparison",
"(",
"test",
",",
"operands",
"[",
"1",
"]",
",",
"operands",
"[",
"2",
"]",
")",
";",
"machine_mode",
"cc_mode",
"=",
"GET_MODE",
"(",
"cc_reg",
")",
";",
"label_ref",
"=",
"gen_rtx_LABEL_REF",
"(",
"VOIDmode",
",",
"operands",
"[",
"3",
"]",
")",
";",
"test_rtx",
"=",
"gen_rtx_fmt_ee",
"(",
"test",
",",
"cc_mode",
",",
"cc_reg",
",",
"const0_rtx",
")",
";",
"if_else",
"=",
"gen_rtx_IF_THEN_ELSE",
"(",
"cc_mode",
",",
"test_rtx",
",",
"label_ref",
",",
"pc_rtx",
")",
";",
"emit_jump_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"pc_rtx",
",",
"if_else",
")",
")",
";",
"return",
"TRUE",
";",
"}",
"</s>"
] | [
"Emit",
"code",
"for",
"a",
"conditional",
"branch",
".",
"The",
"comparison",
"operands",
"were",
"previously",
"stored",
"in",
"frv_compare_op0",
"and",
"frv_compare_op1",
".",
"XXX",
":",
"I",
"originally",
"wanted",
"to",
"add",
"a",
"clobber",
"of",
"a",
"CCR",
"register",
"to",
"use",
"in",
"conditional",
"execution",
",",
"but",
"that",
"confuses",
"the",
"rest",
"of",
"the",
"compiler",
"."
] | [
"frv",
"0",
"1",
"2",
"3"
] | frv3 | frv_emit_cond_branch | frv | VLIW | GCC | 16,192 | 110 | 1 | [] |
[
"<s>",
"bool",
"PPCTTIImpl",
"::",
"canSaveCmp",
"(",
"Loop",
"*",
"L",
",",
"BranchInst",
"*",
"*",
"BI",
",",
"ScalarEvolution",
"*",
"SE",
",",
"LoopInfo",
"*",
"LI",
",",
"DominatorTree",
"*",
"DT",
",",
"AssumptionCache",
"*",
"AC",
",",
"TargetLibraryInfo",
"*",
"LibInfo",
")",
"{",
"for",
"(",
"Loop",
"*",
"I",
":",
"*",
"L",
")",
"if",
"(",
"canSaveCmp",
"(",
"I",
",",
"BI",
",",
"SE",
",",
"LI",
",",
"DT",
",",
"AC",
",",
"LibInfo",
")",
")",
"return",
"false",
";",
"HardwareLoopInfo",
"HWLoopInfo",
"(",
"L",
")",
";",
"if",
"(",
"!",
"HWLoopInfo",
".",
"canAnalyze",
"(",
"*",
"LI",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"isHardwareLoopProfitable",
"(",
"L",
",",
"*",
"SE",
",",
"*",
"AC",
",",
"LibInfo",
",",
"HWLoopInfo",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"HWLoopInfo",
".",
"isHardwareLoopCandidate",
"(",
"*",
"SE",
",",
"*",
"LI",
",",
"*",
"DT",
")",
")",
"return",
"false",
";",
"*",
"BI",
"=",
"HWLoopInfo",
".",
"ExitBranch",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"can",
"save",
"a",
"compare",
"for",
"loop",
"count",
",",
"for",
"example",
"hardware",
"loop",
"saves",
"a",
"compare",
"."
] | [
"PowerPC",
"PPC"
] | PPCTargetTransformInfo14 | canSaveCmp | PowerPC | CPU | LLVM | 16,193 | 138 | 1 | [] |
[
"<s>",
"bool",
"RISCVDAGToDAGISel",
"::",
"SelectInlineAsmMemoryOperand",
"(",
"const",
"SDValue",
"&",
"Op",
",",
"unsigned",
"ConstraintID",
",",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"&",
"OutOps",
")",
"{",
"switch",
"(",
"ConstraintID",
")",
"{",
"case",
"InlineAsm",
"::",
"Constraint_m",
":",
"OutOps",
".",
"push_back",
"(",
"Op",
")",
";",
"return",
"false",
";",
"case",
"InlineAsm",
"::",
"Constraint_A",
":",
"OutOps",
".",
"push_back",
"(",
"Op",
")",
";",
"return",
"false",
";",
"default",
":",
"break",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"SelectInlineAsmMemoryOperand",
"-",
"Select",
"the",
"specified",
"address",
"as",
"a",
"target",
"addressing",
"mode",
",",
"according",
"to",
"the",
"specified",
"constraint",
"."
] | [
"RISCV",
"RISCV"
] | RISCVISelDAGToDAG | SelectInlineAsmMemoryOperand | RISCV | CPU | LLVM | 16,194 | 67 | 1 | [] |
[
"<s>",
"MCLOHType",
"getKind",
"(",
")",
"const",
"{",
"return",
"Kind",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"Kind",
"of",
"lane",
"offset",
"."
] | [
"AArch64"
] | AArch64MachineFunctionInfo | getKind | AArch64 | CPU | LLVM | 16,195 | 10 | 1 | [] |
[
"<s>",
"static",
"rtx",
"m68hc11_struct_value_rtx",
"(",
"tree",
"fntype",
"ATTRIBUTE_UNUSED",
",",
"int",
"incoming",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"gen_rtx_REG",
"(",
"Pmode",
",",
"HARD_D_REGNUM",
")",
";",
"}",
"</s>"
] | [
"Worker",
"function",
"for",
"TARGET_STRUCT_VALUE_RTX",
"."
] | [
"m68hc11"
] | m68hc111 | m68hc11_struct_value_rtx | m68hc11 | MPU | GCC | 16,196 | 22 | 1 | [] |
[
"<s>",
"unsigned",
"getMachineCSELookAheadLimit",
"(",
")",
"const",
"override",
"{",
"return",
"500",
";",
"}",
"</s>"
] | [
"Return",
"the",
"value",
"to",
"use",
"for",
"the",
"MachineCSE",
"'s",
"LookAheadLimit",
",",
"which",
"is",
"a",
"heuristic",
"used",
"for",
"CSE'ing",
"phys",
"reg",
"defs",
"."
] | [
"AMDGPU",
"500"
] | SIInstrInfo (2) | getMachineCSELookAheadLimit | AMDGPU | GPU | LLVM | 16,197 | 11 | 1 | [] |
[
"<s>",
"unsigned",
"TeeRISCInstrInfo",
"::",
"isLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"assert",
"(",
"0",
")",
";",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"TeeRISC",
"::",
"LD",
")",
"{",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"isFI",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
"{",
"FrameIndex",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isLoadFromStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"destination",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"TeeRISC",
"TeeRISC",
"0",
"TeeRISC::LD",
"1",
"2",
"2",
"0",
"1",
"0",
"0"
] | TeeRISCInstrInfo | isLoadFromStackSlot | TeeRISC | CPU | LLVM | 16,198 | 103 | 1 | [] |
[
"<s>",
"static",
"void",
"pru_reorg",
"(",
"void",
")",
"{",
"rtx_insn",
"*",
"insns",
"=",
"get_insns",
"(",
")",
";",
"compute_bb_for_insn",
"(",
")",
";",
"df_analyze",
"(",
")",
";",
"shorten_branches",
"(",
"get_insns",
"(",
")",
")",
";",
"pru_reorg_loop",
"(",
"insns",
")",
";",
"df_finish_pass",
"(",
"false",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_MACHINE_DEPENDENT_REORG",
"."
] | [
"pru"
] | pru | pru_reorg | pru | CPU | GCC | 16,199 | 41 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.