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",
"MSP430InstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"O",
",",
"StringRef",
"Annot",
")",
"{",
"printInstruction",
"(",
"MI",
",",
"O",
")",
";",
"printAnnotation",
"(",
"O",
",",
"Annot",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"MSP430",
"MSP430"
] | MSP430InstPrinter | printInst | MSP430 | MPU | LLVM | 15,900 | 33 | 1 | [] |
[
"<s>",
"bool",
"Mips16TargetLowering",
"::",
"isEligibleForTailCallOptimization",
"(",
"const",
"CCState",
"&",
"CCInfo",
",",
"unsigned",
"NextStackOffset",
",",
"const",
"MipsFunctionInfo",
"&",
"FI",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"call",
"can",
"be",
"lowered",
"as",
"a",
"tail",
"call",
"."
] | [
"Mips",
"Mips",
"Mips"
] | Mips16ISelLowering (2) | isEligibleForTailCallOptimization | Mips | CPU | LLVM | 15,901 | 24 | 1 | [] |
[
"<s>",
"int",
"condexec_memory_operand",
"(",
"rtx",
"op",
",",
"machine_mode",
"mode",
")",
"{",
"machine_mode",
"op_mode",
"=",
"GET_MODE",
"(",
"op",
")",
";",
"rtx",
"addr",
";",
"if",
"(",
"mode",
"!=",
"VOIDmode",
"&&",
"op_mode",
"!=",
"mode",
")",
"return",
"FALSE",
";",
"switch",
"(",
"op_mode",
")",
"{",
"default",
":",
"return",
"FALSE",
";",
"case",
"QImode",
":",
"case",
"HImode",
":",
"case",
"SImode",
":",
"case",
"SFmode",
":",
"break",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"!=",
"MEM",
")",
"return",
"FALSE",
";",
"addr",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"return",
"frv_legitimate_address_p_1",
"(",
"mode",
",",
"addr",
",",
"reload_completed",
",",
"TRUE",
",",
"FALSE",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"memory",
"operand",
"is",
"one",
"that",
"can",
"be",
"conditionally",
"executed",
"."
] | [
"frv",
"0"
] | frv3 | condexec_memory_operand | frv | VLIW | GCC | 15,902 | 95 | 1 | [] |
[
"<s>",
"void",
"Finish",
"(",
")",
"{",
"const",
"size_t",
"VendorHeaderSize",
"=",
"4",
"+",
"CurrentVendor",
".",
"size",
"(",
")",
"+",
"1",
";",
"const",
"size_t",
"TagHeaderSize",
"=",
"1",
"+",
"4",
";",
"Streamer",
".",
"EmitIntValue",
"(",
"VendorHeaderSize",
"+",
"TagHeaderSize",
"+",
"ContentsSize",
",",
"4",
")",
";",
"Streamer",
".",
"EmitBytes",
"(",
"CurrentVendor",
",",
"0",
")",
";",
"Streamer",
".",
"EmitIntValue",
"(",
"0",
",",
"1",
")",
";",
"Streamer",
".",
"EmitIntValue",
"(",
"ARMBuildAttrs",
"::",
"File",
",",
"1",
")",
";",
"Streamer",
".",
"EmitIntValue",
"(",
"TagHeaderSize",
"+",
"ContentsSize",
",",
"4",
")",
";",
"for",
"(",
"unsigned",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"Contents",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"AttributeItemType",
"item",
"=",
"Contents",
"[",
"i",
"]",
";",
"Streamer",
".",
"EmitULEB128IntValue",
"(",
"item",
".",
"Tag",
",",
"0",
")",
";",
"switch",
"(",
"item",
".",
"Type",
")",
"{",
"case",
"AttributeItemType",
"::",
"NumericAttribute",
":",
"Streamer",
".",
"EmitULEB128IntValue",
"(",
"item",
".",
"IntValue",
",",
"0",
")",
";",
"break",
";",
"case",
"AttributeItemType",
"::",
"TextAttribute",
":",
"Streamer",
".",
"EmitBytes",
"(",
"UppercaseString",
"(",
"item",
".",
"StringValue",
")",
",",
"0",
")",
";",
"Streamer",
".",
"EmitIntValue",
"(",
"0",
",",
"1",
")",
";",
"break",
";",
"default",
":",
"assert",
"(",
"0",
"&&",
"\"Invalid attribute type\"",
")",
";",
"}",
"}",
"Contents",
".",
"clear",
"(",
")",
";",
"}",
"</s>"
] | [
"Finish",
"-",
"Do",
"final",
"processing",
"and",
"write",
"the",
"object",
"to",
"the",
"output",
"stream",
"."
] | [
"ARM",
"4",
"1",
"1",
"4",
"4",
"0",
"0",
"1",
"ARMBuildAttrs::File",
"1",
"4",
"0",
"0",
"0",
"0",
"0",
"1",
"0",
"\"Invalid attribute type\""
] | ARMAsmPrinter96 | Finish | ARM | CPU | LLVM | 15,903 | 192 | 1 | [] |
[
"<s>",
"TargetTransformInfo",
"ARMBaseTargetMachine",
"::",
"getTargetTransformInfo",
"(",
"const",
"Function",
"&",
"F",
")",
"{",
"return",
"TargetTransformInfo",
"(",
"ARMTTIImpl",
"(",
"this",
",",
"F",
")",
")",
";",
"}",
"</s>"
] | [
"Get",
"a",
"TargetTransformInfo",
"implementation",
"for",
"the",
"target",
"."
] | [
"ARM",
"ARM",
"ARM"
] | ARMTargetMachine | getTargetTransformInfo | ARM | CPU | LLVM | 15,904 | 23 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"addLiveIn",
"(",
"MachineFunction",
"&",
"MF",
",",
"unsigned",
"PReg",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
")",
"{",
"unsigned",
"VReg",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"RC",
")",
";",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"addLiveIn",
"(",
"PReg",
",",
"VReg",
")",
";",
"return",
"VReg",
";",
"}",
"</s>"
] | [
"addLiveIn",
"-",
"Add",
"the",
"specified",
"register",
"as",
"a",
"live-in",
"."
] | [
"Nios2"
] | Nios2ISelLowering | addLiveIn | Nios2 | MPU | LLVM | 15,905 | 48 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"SystemZXPLINK64Registers",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"return",
"CSR_SystemZ_XPLINK64_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"SystemZ",
"SystemZXPLINK64Registers::getCalleeSavedRegs",
"SystemZ"
] | SystemZRegisterInfo21 | getCalleeSavedRegs | SystemZ | CPU | LLVM | 15,906 | 18 | 1 | [] |
[
"<s>",
"void",
"R600TargetLowering",
"::",
"getStackAddress",
"(",
"unsigned",
"StackWidth",
",",
"unsigned",
"ElemIdx",
",",
"unsigned",
"&",
"Channel",
",",
"unsigned",
"&",
"PtrIncr",
")",
"const",
"{",
"switch",
"(",
"StackWidth",
")",
"{",
"default",
":",
"case",
"1",
":",
"Channel",
"=",
"0",
";",
"if",
"(",
"ElemIdx",
">",
"0",
")",
"{",
"PtrIncr",
"=",
"1",
";",
"}",
"else",
"{",
"PtrIncr",
"=",
"0",
";",
"}",
"break",
";",
"case",
"2",
":",
"Channel",
"=",
"ElemIdx",
"%",
"2",
";",
"if",
"(",
"ElemIdx",
"==",
"2",
")",
"{",
"PtrIncr",
"=",
"1",
";",
"}",
"else",
"{",
"PtrIncr",
"=",
"0",
";",
"}",
"break",
";",
"case",
"4",
":",
"Channel",
"=",
"ElemIdx",
";",
"PtrIncr",
"=",
"0",
";",
"break",
";",
"}",
"}",
"</s>"
] | [
"Materialize",
"a",
"VReg",
"containing",
"the",
"address",
"of",
"the",
"specified",
"stack-based",
"object",
"."
] | [
"AMDGPU",
"R600",
"1",
"0",
"0",
"1",
"0",
"2",
"2",
"2",
"1",
"0",
"4",
"0"
] | R600ISelLowering (2) | getStackAddress | AMDGPU | GPU | LLVM | 15,907 | 101 | 1 | [] |
[
"<s>",
"static",
"void",
"allocateSpecialInputVGPRs",
"(",
"CCState",
"&",
"CCInfo",
",",
"MachineFunction",
"&",
"MF",
",",
"const",
"SIRegisterInfo",
"&",
"TRI",
",",
"SIMachineFunctionInfo",
"&",
"Info",
")",
"{",
"if",
"(",
"Info",
".",
"hasWorkItemIDX",
"(",
")",
")",
"{",
"unsigned",
"Reg",
"=",
"TRI",
".",
"getPreloadedValue",
"(",
"MF",
",",
"SIRegisterInfo",
"::",
"WORKITEM_ID_X",
")",
";",
"MF",
".",
"addLiveIn",
"(",
"Reg",
",",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
")",
";",
"CCInfo",
".",
"AllocateReg",
"(",
"Reg",
")",
";",
"}",
"if",
"(",
"Info",
".",
"hasWorkItemIDY",
"(",
")",
")",
"{",
"unsigned",
"Reg",
"=",
"TRI",
".",
"getPreloadedValue",
"(",
"MF",
",",
"SIRegisterInfo",
"::",
"WORKITEM_ID_Y",
")",
";",
"MF",
".",
"addLiveIn",
"(",
"Reg",
",",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
")",
";",
"CCInfo",
".",
"AllocateReg",
"(",
"Reg",
")",
";",
"}",
"if",
"(",
"Info",
".",
"hasWorkItemIDZ",
"(",
")",
")",
"{",
"unsigned",
"Reg",
"=",
"TRI",
".",
"getPreloadedValue",
"(",
"MF",
",",
"SIRegisterInfo",
"::",
"WORKITEM_ID_Z",
")",
";",
"MF",
".",
"addLiveIn",
"(",
"Reg",
",",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
")",
";",
"CCInfo",
".",
"AllocateReg",
"(",
"Reg",
")",
";",
"}",
"}",
"</s>"
] | [
"Allocate",
"implicit",
"function",
"VGPR",
"arguments",
"at",
"the",
"end",
"of",
"allocated",
"user",
"arguments",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"AMDGPU::VGPR_32RegClass",
"SI",
"AMDGPU::VGPR_32RegClass",
"SI",
"AMDGPU::VGPR_32RegClass"
] | SIISelLowering114 | allocateSpecialInputVGPRs | AMDGPU | GPU | LLVM | 15,908 | 152 | 1 | [] |
[
"<s>",
"bool",
"HexagonInstrInfo",
"::",
"isValidOffset",
"(",
"const",
"int",
"Opcode",
",",
"const",
"int",
"Offset",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"Hexagon",
"::",
"LDriw",
":",
"case",
"Hexagon",
"::",
"LDriw_f",
":",
"case",
"Hexagon",
"::",
"STriw",
":",
"case",
"Hexagon",
"::",
"STriw_f",
":",
"assert",
"(",
"(",
"Offset",
"%",
"4",
"==",
"0",
")",
"&&",
"\"Offset has incorrect alignment\"",
")",
";",
"return",
"(",
"Offset",
">=",
"Hexagon_MEMW_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_MEMW_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"LDrid",
":",
"case",
"Hexagon",
"::",
"LDrid_f",
":",
"case",
"Hexagon",
"::",
"STrid",
":",
"case",
"Hexagon",
"::",
"STrid_f",
":",
"assert",
"(",
"(",
"Offset",
"%",
"8",
"==",
"0",
")",
"&&",
"\"Offset has incorrect alignment\"",
")",
";",
"return",
"(",
"Offset",
">=",
"Hexagon_MEMD_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_MEMD_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"LDrih",
":",
"case",
"Hexagon",
"::",
"LDriuh",
":",
"case",
"Hexagon",
"::",
"STrih",
":",
"assert",
"(",
"(",
"Offset",
"%",
"2",
"==",
"0",
")",
"&&",
"\"Offset has incorrect alignment\"",
")",
";",
"return",
"(",
"Offset",
">=",
"Hexagon_MEMH_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_MEMH_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"LDrib",
":",
"case",
"Hexagon",
"::",
"STrib",
":",
"case",
"Hexagon",
"::",
"LDriub",
":",
"return",
"(",
"Offset",
">=",
"Hexagon_MEMB_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_MEMB_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"ADD_ri",
":",
"case",
"Hexagon",
"::",
"TFR_FI",
":",
"return",
"(",
"Offset",
">=",
"Hexagon_ADDI_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_ADDI_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"MEMw_ADDSUBi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ADDi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_SUBi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ADDr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_SUBr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ANDr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ORr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ADDSUBi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ADDi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_SUBi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ADDr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_SUBr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ANDr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ORr_MEM_V4",
":",
"assert",
"(",
"(",
"Offset",
"%",
"4",
")",
"==",
"0",
"&&",
"\"MEMOPw offset is not aligned correctly.\"",
")",
";",
"return",
"(",
"0",
"<=",
"Offset",
"&&",
"Offset",
"<=",
"255",
")",
";",
"case",
"Hexagon",
"::",
"MEMh_ADDSUBi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ADDi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_SUBi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ADDr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_SUBr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ANDr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ORr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ADDSUBi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ADDi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_SUBi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ADDr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_SUBr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ANDr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ORr_MEM_V4",
":",
"assert",
"(",
"(",
"Offset",
"%",
"2",
")",
"==",
"0",
"&&",
"\"MEMOPh offset is not aligned correctly.\"",
")",
";",
"return",
"(",
"0",
"<=",
"Offset",
"&&",
"Offset",
"<=",
"127",
")",
";",
"case",
"Hexagon",
"::",
"MEMb_ADDSUBi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ADDi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_SUBi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ADDr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_SUBr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ANDr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ORr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ADDSUBi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ADDi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_SUBi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ADDr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_SUBr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ANDr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ORr_MEM_V4",
":",
"return",
"(",
"0",
"<=",
"Offset",
"&&",
"Offset",
"<=",
"63",
")",
";",
"case",
"Hexagon",
"::",
"STriw_pred",
":",
"case",
"Hexagon",
"::",
"LDriw_pred",
":",
"return",
"true",
";",
"case",
"Hexagon",
"::",
"INLINEASM",
":",
"return",
"true",
";",
"}",
"llvm_unreachable",
"(",
"\"No offset range is defined for this opcode. \"",
"\"Please define it in the above switch statement!\"",
")",
";",
"}",
"</s>"
] | [
"Test",
"the",
"validity",
"of",
"offset",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon::LDriw",
"Hexagon::LDriw_f",
"Hexagon::STriw",
"Hexagon::STriw_f",
"4",
"0",
"\"Offset has incorrect alignment\"",
"Hexagon",
"Hexagon",
"Hexagon::LDrid",
"Hexagon::LDrid_f",
"Hexagon::STrid",
"Hexagon::STrid_f",
"8",
"0",
"\"Offset has incorrect alignment\"",
"Hexagon",
"Hexagon",
"Hexagon::LDrih",
"Hexagon::LDriuh",
"Hexagon::STrih",
"2",
"0",
"\"Offset has incorrect alignment\"",
"Hexagon",
"Hexagon",
"Hexagon::LDrib",
"Hexagon::STrib",
"Hexagon::LDriub",
"Hexagon",
"Hexagon",
"Hexagon::ADD_ri",
"Hexagon::TFR_FI",
"Hexagon",
"Hexagon",
"Hexagon::MEMw_ADDSUBi_indexed_MEM_V4",
"Hexagon::MEMw_ADDi_indexed_MEM_V4",
"Hexagon::MEMw_SUBi_indexed_MEM_V4",
"Hexagon::MEMw_ADDr_indexed_MEM_V4",
"Hexagon::MEMw_SUBr_indexed_MEM_V4",
"Hexagon::MEMw_ANDr_indexed_MEM_V4",
"Hexagon::MEMw_ORr_indexed_MEM_V4",
"Hexagon::MEMw_ADDSUBi_MEM_V4",
"Hexagon::MEMw_ADDi_MEM_V4",
"Hexagon::MEMw_SUBi_MEM_V4",
"Hexagon::MEMw_ADDr_MEM_V4",
"Hexagon::MEMw_SUBr_MEM_V4",
"Hexagon::MEMw_ANDr_MEM_V4",
"Hexagon::MEMw_ORr_MEM_V4",
"4",
"0",
"\"MEMOPw offset is not aligned correctly.\"",
"0",
"255",
"Hexagon::MEMh_ADDSUBi_indexed_MEM_V4",
"Hexagon::MEMh_ADDi_indexed_MEM_V4",
"Hexagon::MEMh_SUBi_indexed_MEM_V4",
"Hexagon::MEMh_ADDr_indexed_MEM_V4",
"Hexagon::MEMh_SUBr_indexed_MEM_V4",
"Hexagon::MEMh_ANDr_indexed_MEM_V4",
"Hexagon::MEMh_ORr_indexed_MEM_V4",
"Hexagon::MEMh_ADDSUBi_MEM_V4",
"Hexagon::MEMh_ADDi_MEM_V4",
"Hexagon::MEMh_SUBi_MEM_V4",
"Hexagon::MEMh_ADDr_MEM_V4",
"Hexagon::MEMh_SUBr_MEM_V4",
"Hexagon::MEMh_ANDr_MEM_V4",
"Hexagon::MEMh_ORr_MEM_V4",
"2",
"0",
"\"MEMOPh offset is not aligned correctly.\"",
"0",
"127",
"Hexagon::MEMb_ADDSUBi_indexed_MEM_V4",
"Hexagon::MEMb_ADDi_indexed_MEM_V4",
"Hexagon::MEMb_SUBi_indexed_MEM_V4",
"Hexagon::MEMb_ADDr_indexed_MEM_V4",
"Hexagon::MEMb_SUBr_indexed_MEM_V4",
"Hexagon::MEMb_ANDr_indexed_MEM_V4",
"Hexagon::MEMb_ORr_indexed_MEM_V4",
"Hexagon::MEMb_ADDSUBi_MEM_V4",
"Hexagon::MEMb_ADDi_MEM_V4",
"Hexagon::MEMb_SUBi_MEM_V4",
"Hexagon::MEMb_ADDr_MEM_V4",
"Hexagon::MEMb_SUBr_MEM_V4",
"Hexagon::MEMb_ANDr_MEM_V4",
"Hexagon::MEMb_ORr_MEM_V4",
"0",
"63",
"Hexagon::STriw_pred",
"Hexagon::LDriw_pred",
"Hexagon::INLINEASM",
"\"No offset range is defined for this opcode. \"",
"\"Please define it in the above switch statement!\""
] | HexagonInstrInfo51 | isValidOffset | Hexagon | DSP | LLVM | 15,909 | 502 | 1 | [] |
[
"<s>",
"bool",
"AMDGPULowerIntrinsics",
"::",
"makeLIDRangeMetadata",
"(",
"Function",
"&",
"F",
")",
"const",
"{",
"auto",
"*",
"TPC",
"=",
"getAnalysisIfAvailable",
"<",
"TargetPassConfig",
">",
"(",
")",
";",
"if",
"(",
"!",
"TPC",
")",
"return",
"false",
";",
"const",
"TargetMachine",
"&",
"TM",
"=",
"TPC",
"->",
"getTM",
"<",
"TargetMachine",
">",
"(",
")",
";",
"const",
"AMDGPUSubtarget",
"&",
"ST",
"=",
"TM",
".",
"getSubtarget",
"<",
"AMDGPUSubtarget",
">",
"(",
"F",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"auto",
"*",
"U",
":",
"F",
".",
"users",
"(",
")",
")",
"{",
"auto",
"*",
"CI",
"=",
"dyn_cast",
"<",
"CallInst",
">",
"(",
"U",
")",
";",
"if",
"(",
"!",
"CI",
")",
"continue",
";",
"Changed",
"|=",
"ST",
".",
"makeLIDRangeMetadata",
"(",
"CI",
")",
";",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"Creates",
"value",
"range",
"metadata",
"on",
"an",
"workitemid",
".",
"*",
"intrinsic",
"call",
"or",
"load",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | AMDGPULowerIntrinsics | makeLIDRangeMetadata | AMDGPU | GPU | LLVM | 15,910 | 110 | 1 | [] |
[
"<s>",
"BitVector",
"BlackfinRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetFrameInfo",
"*",
"TFI",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameInfo",
"(",
")",
";",
"using",
"namespace",
"BF",
";",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"AZ",
")",
";",
"Reserved",
".",
"set",
"(",
"AN",
")",
";",
"Reserved",
".",
"set",
"(",
"AQ",
")",
";",
"Reserved",
".",
"set",
"(",
"AC0",
")",
";",
"Reserved",
".",
"set",
"(",
"AC1",
")",
";",
"Reserved",
".",
"set",
"(",
"AV0",
")",
";",
"Reserved",
".",
"set",
"(",
"AV0S",
")",
";",
"Reserved",
".",
"set",
"(",
"AV1",
")",
";",
"Reserved",
".",
"set",
"(",
"AV1S",
")",
";",
"Reserved",
".",
"set",
"(",
"V",
")",
";",
"Reserved",
".",
"set",
"(",
"VS",
")",
";",
"Reserved",
".",
"set",
"(",
"CYCLES",
")",
".",
"set",
"(",
"CYCLES2",
")",
";",
"Reserved",
".",
"set",
"(",
"L0",
")",
";",
"Reserved",
".",
"set",
"(",
"L1",
")",
";",
"Reserved",
".",
"set",
"(",
"L2",
")",
";",
"Reserved",
".",
"set",
"(",
"L3",
")",
";",
"Reserved",
".",
"set",
"(",
"SP",
")",
";",
"Reserved",
".",
"set",
"(",
"RETS",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
")",
"Reserved",
".",
"set",
"(",
"FP",
")",
";",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"Blackfin",
"BF"
] | BlackfinRegisterInfo4 | getReservedRegs | Blackfin | DSP | LLVM | 15,911 | 190 | 1 | [] |
[
"<s>",
"void",
"SystemZInstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"DestReg",
",",
"int",
"FrameIdx",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
")",
"const",
"{",
"DebugLoc",
"DL",
"=",
"DebugLoc",
"::",
"getUnknownLoc",
"(",
")",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"unsigned",
"Opc",
"=",
"0",
";",
"if",
"(",
"RC",
"==",
"&",
"SystemZ",
"::",
"GR32RegClass",
"||",
"RC",
"==",
"&",
"SystemZ",
"::",
"ADDR32RegClass",
")",
"Opc",
"=",
"SystemZ",
"::",
"MOV32rm",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"SystemZ",
"::",
"GR64RegClass",
"||",
"RC",
"==",
"&",
"SystemZ",
"::",
"ADDR64RegClass",
")",
"{",
"Opc",
"=",
"SystemZ",
"::",
"MOV64rm",
";",
"}",
"else",
"if",
"(",
"RC",
"==",
"&",
"SystemZ",
"::",
"FP32RegClass",
")",
"{",
"Opc",
"=",
"SystemZ",
"::",
"FMOV32rm",
";",
"}",
"else",
"if",
"(",
"RC",
"==",
"&",
"SystemZ",
"::",
"FP64RegClass",
")",
"{",
"Opc",
"=",
"SystemZ",
"::",
"FMOV64rm",
";",
"}",
"else",
"if",
"(",
"RC",
"==",
"&",
"SystemZ",
"::",
"GR64PRegClass",
")",
"{",
"Opc",
"=",
"SystemZ",
"::",
"MOV64Prm",
";",
"}",
"else",
"if",
"(",
"RC",
"==",
"&",
"SystemZ",
"::",
"GR128RegClass",
")",
"{",
"Opc",
"=",
"SystemZ",
"::",
"MOV128rm",
";",
"}",
"else",
"llvm_unreachable",
"(",
"\"Unsupported regclass to load\"",
")",
";",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
",",
"DestReg",
")",
",",
"FrameIdx",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"SystemZ",
"SystemZ",
"0",
"SystemZ::GR32RegClass",
"SystemZ::ADDR32RegClass",
"SystemZ::MOV32rm",
"SystemZ::GR64RegClass",
"SystemZ::ADDR64RegClass",
"SystemZ::MOV64rm",
"SystemZ::FP32RegClass",
"SystemZ::FMOV32rm",
"SystemZ::FP64RegClass",
"SystemZ::FMOV64rm",
"SystemZ::GR64PRegClass",
"SystemZ::MOV64Prm",
"SystemZ::GR128RegClass",
"SystemZ::MOV128rm",
"\"Unsupported regclass to load\""
] | SystemZInstrInfo31 | loadRegFromStackSlot | SystemZ | CPU | LLVM | 15,912 | 206 | 1 | [] |
[
"<s>",
"void",
"SIInstrInfo",
"::",
"legalizeOperandsVOP3",
"(",
"MachineRegisterInfo",
"&",
"MRI",
",",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"unsigned",
"Opc",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"int",
"VOP3Idx",
"[",
"3",
"]",
"=",
"{",
"AMDGPU",
"::",
"getNamedOperandIdx",
"(",
"Opc",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src0",
")",
",",
"AMDGPU",
"::",
"getNamedOperandIdx",
"(",
"Opc",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src1",
")",
",",
"AMDGPU",
"::",
"getNamedOperandIdx",
"(",
"Opc",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src2",
")",
"}",
";",
"int",
"ConstantBusLimit",
"=",
"ST",
".",
"getConstantBusLimit",
"(",
"Opc",
")",
";",
"int",
"LiteralLimit",
"=",
"ST",
".",
"hasVOP3Literal",
"(",
")",
"?",
"1",
":",
"0",
";",
"SmallDenseSet",
"<",
"unsigned",
">",
"SGPRsUsed",
";",
"unsigned",
"SGPRReg",
"=",
"findUsedSGPR",
"(",
"MI",
",",
"VOP3Idx",
")",
";",
"if",
"(",
"SGPRReg",
"!=",
"AMDGPU",
"::",
"NoRegister",
")",
"{",
"SGPRsUsed",
".",
"insert",
"(",
"SGPRReg",
")",
";",
"--",
"ConstantBusLimit",
";",
"}",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"3",
";",
"++",
"i",
")",
"{",
"int",
"Idx",
"=",
"VOP3Idx",
"[",
"i",
"]",
";",
"if",
"(",
"Idx",
"==",
"-",
"1",
")",
"break",
";",
"MachineOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"Idx",
")",
";",
"if",
"(",
"!",
"MO",
".",
"isReg",
"(",
")",
")",
"{",
"if",
"(",
"!",
"isLiteralConstantLike",
"(",
"MO",
",",
"get",
"(",
"Opc",
")",
".",
"OpInfo",
"[",
"Idx",
"]",
")",
")",
"continue",
";",
"if",
"(",
"LiteralLimit",
">",
"0",
"&&",
"ConstantBusLimit",
">",
"0",
")",
"{",
"--",
"LiteralLimit",
";",
"--",
"ConstantBusLimit",
";",
"continue",
";",
"}",
"--",
"LiteralLimit",
";",
"--",
"ConstantBusLimit",
";",
"legalizeOpWithMove",
"(",
"MI",
",",
"Idx",
")",
";",
"continue",
";",
"}",
"if",
"(",
"!",
"RI",
".",
"isSGPRClass",
"(",
"MRI",
".",
"getRegClass",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
")",
")",
"continue",
";",
"if",
"(",
"SGPRsUsed",
".",
"count",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
")",
"continue",
";",
"if",
"(",
"ConstantBusLimit",
">",
"0",
")",
"{",
"SGPRsUsed",
".",
"insert",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"--",
"ConstantBusLimit",
";",
"continue",
";",
"}",
"legalizeOpWithMove",
"(",
"MI",
",",
"Idx",
")",
";",
"}",
"}",
"</s>"
] | [
"Fix",
"operands",
"in",
"MI",
"to",
"satisfy",
"constant",
"bus",
"requirements",
"."
] | [
"AMDGPU",
"SI",
"3",
"AMDGPU::getNamedOperandIdx",
"AMDGPU::OpName",
"AMDGPU::getNamedOperandIdx",
"AMDGPU::OpName",
"AMDGPU::getNamedOperandIdx",
"AMDGPU::OpName",
"1",
"0",
"AMDGPU::NoRegister",
"0",
"3",
"1",
"0",
"0",
"0"
] | SIInstrInfo91 | legalizeOperandsVOP3 | AMDGPU | GPU | LLVM | 15,913 | 308 | 1 | [] |
[
"<s>",
"bool",
"ARMConstantIslands",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"MachineConstantPool",
"&",
"MCP",
"=",
"*",
"MF",
".",
"getConstantPool",
"(",
")",
";",
"TII",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"STI",
"=",
"&",
"MF",
".",
"getTarget",
"(",
")",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"isThumb",
"=",
"AFI",
"->",
"isThumbFunction",
"(",
")",
";",
"isThumb1",
"=",
"AFI",
"->",
"isThumb1OnlyFunction",
"(",
")",
";",
"isThumb2",
"=",
"AFI",
"->",
"isThumb2Function",
"(",
")",
";",
"HasFarJump",
"=",
"false",
";",
"HasInlineAsm",
"=",
"false",
";",
"MF",
".",
"RenumberBlocks",
"(",
")",
";",
"bool",
"MadeChange",
"=",
"false",
";",
"if",
"(",
"isThumb2",
"&&",
"AdjustJumpTableBlocks",
")",
"{",
"JumpTableFunctionScan",
"(",
"MF",
")",
";",
"MadeChange",
"|=",
"ReorderThumb2JumpTables",
"(",
"MF",
")",
";",
"T2JumpTables",
".",
"clear",
"(",
")",
";",
"MF",
".",
"RenumberBlocks",
"(",
")",
";",
"}",
"if",
"(",
"!",
"isThumb1",
")",
"MF",
".",
"EnsureAlignment",
"(",
"2",
")",
";",
"std",
"::",
"vector",
"<",
"MachineInstr",
"*",
">",
"CPEMIs",
";",
"if",
"(",
"!",
"MCP",
".",
"isEmpty",
"(",
")",
")",
"{",
"DoInitialPlacement",
"(",
"MF",
",",
"CPEMIs",
")",
";",
"if",
"(",
"isThumb1",
")",
"MF",
".",
"EnsureAlignment",
"(",
"2",
")",
";",
"}",
"AFI",
"->",
"initConstPoolEntryUId",
"(",
"CPEMIs",
".",
"size",
"(",
")",
")",
";",
"InitialFunctionScan",
"(",
"MF",
",",
"CPEMIs",
")",
";",
"CPEMIs",
".",
"clear",
"(",
")",
";",
"RemoveUnusedCPEntries",
"(",
")",
";",
"unsigned",
"NoCPIters",
"=",
"0",
",",
"NoBRIters",
"=",
"0",
";",
"while",
"(",
"true",
")",
"{",
"bool",
"CPChange",
"=",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"CPUsers",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"CPChange",
"|=",
"HandleConstantPoolUser",
"(",
"MF",
",",
"i",
")",
";",
"if",
"(",
"CPChange",
"&&",
"++",
"NoCPIters",
">",
"30",
")",
"llvm_unreachable",
"(",
"\"Constant Island pass failed to converge!\"",
")",
";",
"DEBUG",
"(",
"dumpBBs",
"(",
")",
")",
";",
"NewWaterList",
".",
"clear",
"(",
")",
";",
"bool",
"BRChange",
"=",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"ImmBranches",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"BRChange",
"|=",
"FixUpImmediateBr",
"(",
"MF",
",",
"ImmBranches",
"[",
"i",
"]",
")",
";",
"if",
"(",
"BRChange",
"&&",
"++",
"NoBRIters",
">",
"30",
")",
"llvm_unreachable",
"(",
"\"Branch Fix Up pass failed to converge!\"",
")",
";",
"DEBUG",
"(",
"dumpBBs",
"(",
")",
")",
";",
"if",
"(",
"!",
"CPChange",
"&&",
"!",
"BRChange",
")",
"break",
";",
"MadeChange",
"=",
"true",
";",
"}",
"if",
"(",
"isThumb2",
")",
"MadeChange",
"|=",
"OptimizeThumb2Instructions",
"(",
"MF",
")",
";",
"verify",
"(",
"MF",
")",
";",
"if",
"(",
"isThumb",
"&&",
"!",
"HasFarJump",
"&&",
"AFI",
"->",
"isLRSpilledForFarJump",
"(",
")",
")",
"MadeChange",
"|=",
"UndoLRSpillRestore",
"(",
")",
";",
"BBSizes",
".",
"clear",
"(",
")",
";",
"BBOffsets",
".",
"clear",
"(",
")",
";",
"WaterList",
".",
"clear",
"(",
")",
";",
"CPUsers",
".",
"clear",
"(",
")",
";",
"CPEntries",
".",
"clear",
"(",
")",
";",
"ImmBranches",
".",
"clear",
"(",
")",
";",
"PushPopMIs",
".",
"clear",
"(",
")",
";",
"T2JumpTables",
".",
"clear",
"(",
")",
";",
"return",
"MadeChange",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"2",
"2",
"0",
"0",
"0",
"30",
"\"Constant Island pass failed to converge!\"",
"0",
"30",
"\"Branch Fix Up pass failed to converge!\""
] | ARMConstantIslandPass47 | runOnMachineFunction | ARM | CPU | LLVM | 15,914 | 452 | 1 | [] |
[
"<s>",
"unsigned",
"getPointerSize",
"(",
")",
"{",
"if",
"(",
"is16BitMode",
"(",
")",
")",
"return",
"16",
";",
"if",
"(",
"is32BitMode",
"(",
")",
")",
"return",
"32",
";",
"if",
"(",
"is64BitMode",
"(",
")",
")",
"return",
"64",
";",
"llvm_unreachable",
"(",
"\"invalid mode\"",
")",
";",
"}",
"</s>"
] | [
"Layout",
"pointer",
"size",
"in",
"bytes",
",",
"rounded",
"up",
"to",
"a",
"whole",
"number",
"of",
"bytes",
"."
] | [
"X86",
"16",
"32",
"64",
"\"invalid mode\""
] | X86AsmParser114 | getPointerSize | X86 | CPU | LLVM | 15,915 | 38 | 1 | [] |
[
"<s>",
"unsigned",
"GCNHazardRecognizer",
"::",
"PreEmitNoops",
"(",
"MachineInstr",
"*",
"MI",
")",
"{",
"int",
"WaitStates",
"=",
"std",
"::",
"max",
"(",
"0",
",",
"checkAnyInstHazards",
"(",
"MI",
")",
")",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isSMRD",
"(",
"*",
"MI",
")",
")",
"return",
"std",
"::",
"max",
"(",
"WaitStates",
",",
"checkSMRDHazards",
"(",
"MI",
")",
")",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isVALU",
"(",
"*",
"MI",
")",
")",
"{",
"WaitStates",
"=",
"std",
"::",
"max",
"(",
"WaitStates",
",",
"checkVALUHazards",
"(",
"MI",
")",
")",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isVMEM",
"(",
"*",
"MI",
")",
")",
"WaitStates",
"=",
"std",
"::",
"max",
"(",
"WaitStates",
",",
"checkVMEMHazards",
"(",
"MI",
")",
")",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isDPP",
"(",
"*",
"MI",
")",
")",
"WaitStates",
"=",
"std",
"::",
"max",
"(",
"WaitStates",
",",
"checkDPPHazards",
"(",
"MI",
")",
")",
";",
"if",
"(",
"isDivFMas",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
"WaitStates",
"=",
"std",
"::",
"max",
"(",
"WaitStates",
",",
"checkDivFMasHazards",
"(",
"MI",
")",
")",
";",
"if",
"(",
"isRWLane",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
"WaitStates",
"=",
"std",
"::",
"max",
"(",
"WaitStates",
",",
"checkRWLaneHazards",
"(",
"MI",
")",
")",
";",
"if",
"(",
"isVInterp",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
"WaitStates",
"=",
"std",
"::",
"max",
"(",
"WaitStates",
",",
"checkReadM0Hazards",
"(",
"MI",
")",
")",
";",
"return",
"WaitStates",
";",
"}",
"if",
"(",
"isSGetReg",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
"return",
"std",
"::",
"max",
"(",
"WaitStates",
",",
"checkGetRegHazards",
"(",
"MI",
")",
")",
";",
"if",
"(",
"isSSetReg",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
"return",
"std",
"::",
"max",
"(",
"WaitStates",
",",
"checkSetRegHazards",
"(",
"MI",
")",
")",
";",
"if",
"(",
"isRFE",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
"return",
"std",
"::",
"max",
"(",
"WaitStates",
",",
"checkRFEHazards",
"(",
"MI",
")",
")",
";",
"if",
"(",
"isSMovRel",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
"return",
"std",
"::",
"max",
"(",
"WaitStates",
",",
"checkReadM0Hazards",
"(",
"MI",
")",
")",
";",
"return",
"WaitStates",
";",
"}",
"</s>"
] | [
"PreEmitNoops",
"-",
"This",
"callback",
"is",
"invoked",
"prior",
"to",
"emitting",
"an",
"instruction",
"."
] | [
"AMDGPU",
"0",
"SI",
"SI",
"SI",
"SI"
] | GCNHazardRecognizer22 | PreEmitNoops | AMDGPU | GPU | LLVM | 15,916 | 300 | 1 | [] |
[
"<s>",
"void",
"SparcInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"Register",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
"->",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
"->",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"*",
"MF",
",",
"FI",
")",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"MFI",
".",
"getObjectSize",
"(",
"FI",
")",
",",
"MFI",
".",
"getObjectAlign",
"(",
"FI",
")",
")",
";",
"if",
"(",
"RC",
"==",
"&",
"SP",
"::",
"I64RegsRegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"SP",
"::",
"STXri",
")",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"SP",
"::",
"IntRegsRegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"SP",
"::",
"STri",
")",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"SP",
"::",
"IntPairRegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"SP",
"::",
"STDri",
")",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"SP",
"::",
"FPRegsRegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"SP",
"::",
"STFri",
")",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"if",
"(",
"SP",
"::",
"DFPRegsRegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
")",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"SP",
"::",
"STDFri",
")",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"if",
"(",
"SP",
"::",
"QFPRegsRegClass",
".",
"hasSubClassEq",
"(",
"RC",
")",
")",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"SP",
"::",
"STQFri",
")",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"llvm_unreachable",
"(",
"\"Can't store this register to stack slot\"",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"Sparc",
"Sparc",
"SP::I64RegsRegClass",
"SP::STXri",
"0",
"SP::IntRegsRegClass",
"SP::STri",
"0",
"SP::IntPairRegClass",
"SP::STDri",
"0",
"SP::FPRegsRegClass",
"SP::STFri",
"0",
"SP::DFPRegsRegClass",
"SP::STDFri",
"0",
"SP::QFPRegsRegClass",
"SP::STQFri",
"0",
"\"Can't store this register to stack slot\""
] | SparcInstrInfo24 | storeRegToStackSlot | Sparc | CPU | LLVM | 15,917 | 430 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isShuffleMaskLegal",
"(",
"const",
"SmallVectorImpl",
"<",
"int",
">",
"&",
"M",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"64",
")",
"return",
"isPALIGNRMask",
"(",
"M",
",",
"VT",
",",
"Subtarget",
"->",
"hasSSSE3",
"(",
")",
")",
";",
"return",
"(",
"VT",
".",
"getVectorNumElements",
"(",
")",
"==",
"2",
"||",
"ShuffleVectorSDNode",
"::",
"isSplatMask",
"(",
"&",
"M",
"[",
"0",
"]",
",",
"VT",
")",
"||",
"isMOVLMask",
"(",
"M",
",",
"VT",
")",
"||",
"isSHUFPMask",
"(",
"M",
",",
"VT",
")",
"||",
"isPSHUFDMask",
"(",
"M",
",",
"VT",
")",
"||",
"isPSHUFHWMask",
"(",
"M",
",",
"VT",
")",
"||",
"isPSHUFLWMask",
"(",
"M",
",",
"VT",
")",
"||",
"isPALIGNRMask",
"(",
"M",
",",
"VT",
",",
"Subtarget",
"->",
"hasSSSE3",
"(",
")",
")",
"||",
"isUNPCKLMask",
"(",
"M",
",",
"VT",
")",
"||",
"isUNPCKHMask",
"(",
"M",
",",
"VT",
")",
"||",
"isUNPCKL_v_undef_Mask",
"(",
"M",
",",
"VT",
")",
"||",
"isUNPCKH_v_undef_Mask",
"(",
"M",
",",
"VT",
")",
")",
";",
"}",
"</s>"
] | [
"Targets",
"can",
"use",
"this",
"to",
"indicate",
"that",
"they",
"only",
"support",
"some",
"VECTOR_SHUFFLE",
"operations",
",",
"those",
"with",
"specific",
"masks",
"."
] | [
"X86",
"X86",
"64",
"2",
"0"
] | X86ISelLowering170 | isShuffleMaskLegal | X86 | CPU | LLVM | 15,918 | 143 | 1 | [] |
[
"<s>",
"int",
"m32c_split_psi_p",
"(",
"rtx",
"*",
"operands",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"\\nm32c_split_psi_p\\n\"",
")",
";",
"debug_rtx",
"(",
"operands",
"[",
"0",
"]",
")",
";",
"debug_rtx",
"(",
"operands",
"[",
"1",
"]",
")",
";",
"if",
"(",
"TARGET_A16",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"yes, A16\\n\"",
")",
";",
"return",
"1",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"operands",
"[",
"1",
"]",
")",
"==",
"MEM",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"operands",
"[",
"1",
"]",
",",
"0",
")",
")",
"==",
"POST_INC",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"yes, pop.l\\n\"",
")",
";",
"return",
"1",
";",
"}",
"fprintf",
"(",
"stderr",
",",
"\"no, default\\n\"",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Returns",
"TRUE",
"if",
"the",
"given",
"PSImode",
"move",
"should",
"be",
"split",
".",
"We",
"split",
"for",
"all",
"r8c/m16c",
"moves",
",",
"since",
"it",
"does",
"n't",
"support",
"them",
",",
"and",
"for",
"POP.L",
"as",
"we",
"can",
"only",
"*",
"push",
"*",
"SImode",
"."
] | [
"m32c",
"\"\\nm32c_split_psi_p\\n\"",
"0",
"1",
"\"yes, A16\\n\"",
"1",
"1",
"1",
"0",
"\"yes, pop.l\\n\"",
"1",
"\"no, default\\n\"",
"0"
] | m32c | m32c_split_psi_p | m32c | MPU | GCC | 15,919 | 97 | 1 | [] |
[
"<s>",
"SDValue",
"XCoreTargetLowering",
"::",
"LowerCall",
"(",
"TargetLowering",
"::",
"CallLoweringInfo",
"&",
"CLI",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"SelectionDAG",
"&",
"DAG",
"=",
"CLI",
".",
"DAG",
";",
"SDLoc",
"&",
"dl",
"=",
"CLI",
".",
"DL",
";",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
"=",
"CLI",
".",
"Outs",
";",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
"=",
"CLI",
".",
"OutVals",
";",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
"=",
"CLI",
".",
"Ins",
";",
"SDValue",
"Chain",
"=",
"CLI",
".",
"Chain",
";",
"SDValue",
"Callee",
"=",
"CLI",
".",
"Callee",
";",
"bool",
"&",
"isTailCall",
"=",
"CLI",
".",
"IsTailCall",
";",
"CallingConv",
"::",
"ID",
"CallConv",
"=",
"CLI",
".",
"CallConv",
";",
"bool",
"isVarArg",
"=",
"CLI",
".",
"IsVarArg",
";",
"isTailCall",
"=",
"false",
";",
"switch",
"(",
"CallConv",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unsupported calling convention\"",
")",
";",
"case",
"CallingConv",
"::",
"Fast",
":",
"case",
"CallingConv",
"::",
"C",
":",
"return",
"LowerCCCCallTo",
"(",
"Chain",
",",
"Callee",
",",
"CallConv",
",",
"isVarArg",
",",
"isTailCall",
",",
"Outs",
",",
"OutVals",
",",
"Ins",
",",
"dl",
",",
"DAG",
",",
"InVals",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"calls",
"into",
"the",
"specified",
"DAG",
"."
] | [
"XCore",
"XCore",
"ISD::OutputArg",
"ISD::InputArg",
"\"Unsupported calling convention\""
] | XCoreISelLowering (2) | LowerCall | XCore | MPU | LLVM | 15,920 | 165 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"Alpha DAG->DAG Pattern Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Alpha",
"\"Alpha DAG->DAG Pattern Instruction Selection\""
] | AlphaISelDAGToDAG1 | getPassName | Alpha | MPU | LLVM | 15,921 | 13 | 1 | [] |
[
"<s>",
"unsigned",
"getMaxMemcpyTPInlineSizeThreshold",
"(",
")",
"const",
"{",
"return",
"128",
";",
"}",
"</s>"
] | [
"getMaxMemcpyTPInlineSizeThreshold",
"-",
"Returns",
"the",
"maximum",
"size",
"that",
"still",
"makes",
"it",
"profitable",
"to",
"inline",
"a",
"llvm.memcpy",
"as",
"a",
"Tail",
"Predicated",
"loop",
"."
] | [
"ARM",
"128"
] | ARMSubtarget100 | getMaxMemcpyTPInlineSizeThreshold | ARM | CPU | LLVM | 15,922 | 10 | 1 | [] |
[
"<s>",
"unsigned",
"M68kInstrInfo",
"::",
"removeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"int",
"*",
"BytesRemoved",
")",
"const",
"{",
"assert",
"(",
"!",
"BytesRemoved",
"&&",
"\"code size not handled\"",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"unsigned",
"Count",
"=",
"0",
";",
"while",
"(",
"I",
"!=",
"MBB",
".",
"begin",
"(",
")",
")",
"{",
"--",
"I",
";",
"if",
"(",
"I",
"->",
"isDebugValue",
"(",
")",
")",
"continue",
";",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"!=",
"M68k",
"::",
"BRA8",
"&&",
"getCondFromBranchOpc",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"==",
"M68k",
"::",
"COND_INVALID",
")",
"break",
";",
"I",
"->",
"eraseFromParent",
"(",
")",
";",
"I",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"++",
"Count",
";",
"}",
"return",
"Count",
";",
"}",
"</s>"
] | [
"Remove",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"the",
"specific",
"MBB",
"."
] | [
"M68k",
"M68k",
"\"code size not handled\"",
"0",
"M68k::BRA8",
"M68k::COND_INVALID"
] | M68kInstrInfo (2) | removeBranch | M68k | MPU | LLVM | 15,923 | 112 | 1 | [] |
[
"<s>",
"bool",
"X86FastISel",
"::",
"fastSelectInstruction",
"(",
"const",
"Instruction",
"*",
"I",
")",
"{",
"switch",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Instruction",
"::",
"Load",
":",
"return",
"X86SelectLoad",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Store",
":",
"return",
"X86SelectStore",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Ret",
":",
"return",
"X86SelectRet",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"ICmp",
":",
"case",
"Instruction",
"::",
"FCmp",
":",
"return",
"X86SelectCmp",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"ZExt",
":",
"return",
"X86SelectZExt",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Br",
":",
"return",
"X86SelectBranch",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"LShr",
":",
"case",
"Instruction",
"::",
"AShr",
":",
"case",
"Instruction",
"::",
"Shl",
":",
"return",
"X86SelectShift",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"SDiv",
":",
"case",
"Instruction",
"::",
"UDiv",
":",
"case",
"Instruction",
"::",
"SRem",
":",
"case",
"Instruction",
"::",
"URem",
":",
"return",
"X86SelectDivRem",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Select",
":",
"return",
"X86SelectSelect",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Trunc",
":",
"return",
"X86SelectTrunc",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"FPExt",
":",
"return",
"X86SelectFPExt",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"FPTrunc",
":",
"return",
"X86SelectFPTrunc",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"IntToPtr",
":",
"case",
"Instruction",
"::",
"PtrToInt",
":",
"{",
"EVT",
"SrcVT",
"=",
"TLI",
".",
"getValueType",
"(",
"I",
"->",
"getOperand",
"(",
"0",
")",
"->",
"getType",
"(",
")",
")",
";",
"EVT",
"DstVT",
"=",
"TLI",
".",
"getValueType",
"(",
"I",
"->",
"getType",
"(",
")",
")",
";",
"if",
"(",
"DstVT",
".",
"bitsGT",
"(",
"SrcVT",
")",
")",
"return",
"X86SelectZExt",
"(",
"I",
")",
";",
"if",
"(",
"DstVT",
".",
"bitsLT",
"(",
"SrcVT",
")",
")",
"return",
"X86SelectTrunc",
"(",
"I",
")",
";",
"unsigned",
"Reg",
"=",
"getRegForValue",
"(",
"I",
"->",
"getOperand",
"(",
"0",
")",
")",
";",
"if",
"(",
"Reg",
"==",
"0",
")",
"return",
"false",
";",
"updateValueMap",
"(",
"I",
",",
"Reg",
")",
";",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"by",
"target-independent",
"code",
"when",
"the",
"normal",
"FastISel",
"process",
"fails",
"to",
"select",
"an",
"instruction",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"0",
"X86",
"X86",
"0",
"0"
] | X86FastISel110 | fastSelectInstruction | X86 | CPU | LLVM | 15,924 | 298 | 1 | [] |
[
"<s>",
"bool",
"PatmosAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"StringRef",
"IDVal",
"=",
"DirectiveID",
".",
"getIdentifier",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".word\"",
")",
"return",
"ParseDirectiveWord",
"(",
"4",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".half\"",
"||",
"IDVal",
"==",
"\".hword\"",
")",
"return",
"ParseDirectiveWord",
"(",
"2",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".fstart\"",
")",
"return",
"ParseDirectiveFStart",
"(",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"Patmos",
"Patmos",
"\".word\"",
"4",
"\".half\"",
"\".hword\"",
"2",
"\".fstart\""
] | PatmosAsmParser | ParseDirective | Patmos | VLIW | LLVM | 15,925 | 78 | 1 | [] |
[
"<s>",
"MCSymbol",
"*",
"DCPU16MCInstLower",
"::",
"GetExternalSymbolSymbol",
"(",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
"{",
"switch",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unknown target flag on GV operand\"",
")",
";",
"case",
"0",
":",
"break",
";",
"}",
"return",
"Printer",
".",
"GetExternalSymbolSymbol",
"(",
"MO",
".",
"getSymbolName",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"MCSymbol",
"for",
"the",
"specified",
"ExternalSymbol",
"."
] | [
"Dcpu16",
"DCPU16",
"\"Unknown target flag on GV operand\"",
"0"
] | DCPU16MCInstLower | GetExternalSymbolSymbol | Dcpu16 | CPU | LLVM | 15,926 | 48 | 1 | [] |
[
"<s>",
"static",
"void",
"output_btfext_core_sections",
"(",
"void",
")",
"{",
"size_t",
"i",
";",
"bpf_core_section_ref",
"sec",
";",
"dw2_asm_output_data",
"(",
"4",
",",
"sizeof",
"(",
"struct",
"btf_ext_reloc",
")",
",",
"\"btfext_core_info_rec_size\"",
")",
";",
"FOR_EACH_VEC_ELT",
"(",
"*",
"bpf_core_sections",
",",
"i",
",",
"sec",
")",
"{",
"sec",
"->",
"name_offset",
"+=",
"ctfc_get_strtab_len",
"(",
"ctf_get_tu_ctfc",
"(",
")",
",",
"CTF_STRTAB",
")",
";",
"dw2_asm_output_data",
"(",
"4",
",",
"sec",
"->",
"name_offset",
",",
"\"btfext_secinfo_sec_name_off\"",
")",
";",
"dw2_asm_output_data",
"(",
"4",
",",
"vec_safe_length",
"(",
"sec",
"->",
"relocs",
")",
",",
"\"btfext_secinfo_num_recs\"",
")",
";",
"output_btfext_core_relocs",
"(",
"sec",
")",
";",
"}",
"}",
"</s>"
] | [
"Output",
"all",
"CO-RE",
"relocation",
"sections",
"."
] | [
"bpf",
"4",
"\"btfext_core_info_rec_size\"",
"4",
"\"btfext_secinfo_sec_name_off\"",
"4",
"\"btfext_secinfo_num_recs\""
] | coreout | output_btfext_core_sections | bpf | Virtual ISA | GCC | 15,927 | 81 | 1 | [] |
[
"<s>",
"static",
"bool",
"mips_lra_p",
"(",
"void",
")",
"{",
"return",
"mips_lra_flag",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_LRA_P",
"."
] | [
"mips"
] | mips | mips_lra_p | mips | CPU | GCC | 15,928 | 11 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"TVM move materializable\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"TVM",
"\"TVM move materializable\""
] | TVMMoveMaterializable | getPassName | TVM | Virtual ISA | LLVM | 15,929 | 11 | 1 | [] |
[
"<s>",
"static",
"void",
"arm_emit_vfp_multi_reg_pop",
"(",
"int",
"first_reg",
",",
"int",
"num_regs",
",",
"rtx",
"base_reg",
")",
"{",
"int",
"i",
",",
"j",
";",
"rtx",
"par",
";",
"rtx",
"dwarf",
"=",
"NULL_RTX",
";",
"rtx",
"tmp",
",",
"reg",
";",
"gcc_assert",
"(",
"num_regs",
"&&",
"num_regs",
"<=",
"32",
")",
";",
"if",
"(",
"num_regs",
"==",
"2",
"&&",
"!",
"arm_arch6",
")",
"{",
"if",
"(",
"first_reg",
"==",
"15",
")",
"first_reg",
"--",
";",
"num_regs",
"++",
";",
"}",
"if",
"(",
"num_regs",
">",
"16",
")",
"{",
"arm_emit_vfp_multi_reg_pop",
"(",
"first_reg",
",",
"16",
",",
"base_reg",
")",
";",
"arm_emit_vfp_multi_reg_pop",
"(",
"first_reg",
"+",
"16",
",",
"num_regs",
"-",
"16",
",",
"base_reg",
")",
";",
"return",
";",
"}",
"par",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"rtvec_alloc",
"(",
"num_regs",
"+",
"1",
")",
")",
";",
"tmp",
"=",
"gen_rtx_SET",
"(",
"base_reg",
",",
"plus_constant",
"(",
"Pmode",
",",
"base_reg",
",",
"8",
"*",
"num_regs",
")",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"tmp",
")",
"=",
"1",
";",
"XVECEXP",
"(",
"par",
",",
"0",
",",
"0",
")",
"=",
"tmp",
";",
"for",
"(",
"j",
"=",
"0",
",",
"i",
"=",
"first_reg",
";",
"j",
"<",
"num_regs",
";",
"i",
"+=",
"2",
")",
"{",
"reg",
"=",
"gen_rtx_REG",
"(",
"DFmode",
",",
"i",
")",
";",
"tmp",
"=",
"gen_rtx_SET",
"(",
"reg",
",",
"gen_frame_mem",
"(",
"DFmode",
",",
"plus_constant",
"(",
"Pmode",
",",
"base_reg",
",",
"8",
"*",
"j",
")",
")",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"tmp",
")",
"=",
"1",
";",
"XVECEXP",
"(",
"par",
",",
"0",
",",
"j",
"+",
"1",
")",
"=",
"tmp",
";",
"dwarf",
"=",
"alloc_reg_note",
"(",
"REG_CFA_RESTORE",
",",
"reg",
",",
"dwarf",
")",
";",
"j",
"++",
";",
"}",
"par",
"=",
"emit_insn",
"(",
"par",
")",
";",
"REG_NOTES",
"(",
"par",
")",
"=",
"dwarf",
";",
"if",
"(",
"REGNO",
"(",
"base_reg",
")",
"==",
"IP_REGNUM",
")",
"{",
"RTX_FRAME_RELATED_P",
"(",
"par",
")",
"=",
"1",
";",
"add_reg_note",
"(",
"par",
",",
"REG_CFA_DEF_CFA",
",",
"hard_frame_pointer_rtx",
")",
";",
"}",
"else",
"arm_add_cfa_adjust_cfa_note",
"(",
"par",
",",
"2",
"*",
"UNITS_PER_WORD",
"*",
"num_regs",
",",
"base_reg",
",",
"base_reg",
")",
";",
"}",
"</s>"
] | [
"Generate",
"and",
"emit",
"an",
"insn",
"pattern",
"that",
"we",
"will",
"recognize",
"as",
"a",
"pop_multi",
"of",
"NUM_REGS",
"consecutive",
"VFP",
"regs",
",",
"starting",
"at",
"FIRST_REG",
".",
"Unfortunately",
",",
"since",
"this",
"insn",
"does",
"not",
"reflect",
"very",
"well",
"the",
"actual",
"semantics",
"of",
"the",
"operation",
",",
"we",
"need",
"to",
"annotate",
"the",
"insn",
"for",
"the",
"benefit",
"of",
"DWARF2",
"frame",
"unwind",
"information",
"."
] | [
"arm",
"32",
"2",
"15",
"16",
"16",
"16",
"16",
"1",
"8",
"1",
"0",
"0",
"0",
"2",
"8",
"1",
"0",
"1",
"1",
"2"
] | arm | arm_emit_vfp_multi_reg_pop | arm | CPU | GCC | 15,930 | 290 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"getPostIndexedAddressParts",
"(",
"SDNode",
"*",
"N",
",",
"SDNode",
"*",
"Op",
",",
"SDValue",
"&",
"Base",
",",
"SDValue",
"&",
"Offset",
",",
"ISD",
"::",
"MemIndexedMode",
"&",
"AM",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"Subtarget",
"->",
"isThumb",
"(",
")",
")",
"return",
"false",
";",
"MVT",
"VT",
";",
"SDValue",
"Ptr",
";",
"bool",
"isSEXTLoad",
"=",
"false",
";",
"if",
"(",
"LoadSDNode",
"*",
"LD",
"=",
"dyn_cast",
"<",
"LoadSDNode",
">",
"(",
"N",
")",
")",
"{",
"VT",
"=",
"LD",
"->",
"getMemoryVT",
"(",
")",
";",
"isSEXTLoad",
"=",
"LD",
"->",
"getExtensionType",
"(",
")",
"==",
"ISD",
"::",
"SEXTLOAD",
";",
"}",
"else",
"if",
"(",
"StoreSDNode",
"*",
"ST",
"=",
"dyn_cast",
"<",
"StoreSDNode",
">",
"(",
"N",
")",
")",
"{",
"VT",
"=",
"ST",
"->",
"getMemoryVT",
"(",
")",
";",
"}",
"else",
"return",
"false",
";",
"bool",
"isInc",
";",
"bool",
"isLegal",
"=",
"getIndexedAddressParts",
"(",
"Op",
",",
"VT",
",",
"isSEXTLoad",
",",
"Base",
",",
"Offset",
",",
"isInc",
",",
"DAG",
")",
";",
"if",
"(",
"isLegal",
")",
"{",
"AM",
"=",
"isInc",
"?",
"ISD",
"::",
"POST_INC",
":",
"ISD",
"::",
"POST_DEC",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"by",
"value",
",",
"base",
"pointer",
"and",
"offset",
"pointer",
"and",
"addressing",
"mode",
"by",
"reference",
"if",
"this",
"node",
"can",
"be",
"combined",
"with",
"a",
"load",
"/",
"store",
"to",
"form",
"a",
"post-indexed",
"load",
"/",
"store",
"."
] | [
"ARM",
"ARM",
"ISD::MemIndexedMode",
"ISD::SEXTLOAD",
"ISD::POST_INC",
"ISD::POST_DEC"
] | ARMISelLowering124 | getPostIndexedAddressParts | ARM | CPU | LLVM | 15,931 | 168 | 1 | [] |
[
"<s>",
"void",
"arm_register_target_pragmas",
"(",
"void",
")",
"{",
"targetm",
".",
"target_option",
".",
"pragma_parse",
"=",
"arm_pragma_target_parse",
";",
"targetm",
".",
"resolve_overloaded_builtin",
"=",
"arm_resolve_overloaded_builtin",
";",
"c_register_pragma",
"(",
"\"GCC\"",
",",
"\"arm\"",
",",
"arm_pragma_arm",
")",
";",
"REGISTER_SUBTARGET_PRAGMAS",
"(",
")",
";",
"}",
"</s>"
] | [
"Register",
"target",
"pragmas",
".",
"We",
"need",
"to",
"add",
"the",
"hook",
"for",
"parsing",
"#",
"pragma",
"GCC",
"option",
"here",
"rather",
"than",
"in",
"arm.cc",
"since",
"it",
"will",
"pull",
"in",
"various",
"preprocessor",
"functions",
",",
"and",
"those",
"are",
"not",
"present",
"in",
"languages",
"like",
"fortran",
"without",
"a",
"preprocessor",
"."
] | [
"arm",
"\"GCC\"",
"\"arm\""
] | arm-c | arm_register_target_pragmas | arm | CPU | GCC | 15,932 | 34 | 1 | [] |
[
"<s>",
"void",
"CSKYAsmPrinter",
"::",
"emitMachineConstantPoolValue",
"(",
"MachineConstantPoolValue",
"*",
"MCPV",
")",
"{",
"int",
"Size",
"=",
"getDataLayout",
"(",
")",
".",
"getTypeAllocSize",
"(",
"MCPV",
"->",
"getType",
"(",
")",
")",
";",
"CSKYConstantPoolValue",
"*",
"CCPV",
"=",
"static_cast",
"<",
"CSKYConstantPoolValue",
"*",
">",
"(",
"MCPV",
")",
";",
"MCSymbol",
"*",
"MCSym",
";",
"if",
"(",
"CCPV",
"->",
"isBlockAddress",
"(",
")",
")",
"{",
"const",
"BlockAddress",
"*",
"BA",
"=",
"cast",
"<",
"CSKYConstantPoolConstant",
">",
"(",
"CCPV",
")",
"->",
"getBlockAddress",
"(",
")",
";",
"MCSym",
"=",
"GetBlockAddressSymbol",
"(",
"BA",
")",
";",
"}",
"else",
"if",
"(",
"CCPV",
"->",
"isGlobalValue",
"(",
")",
")",
"{",
"const",
"GlobalValue",
"*",
"GV",
"=",
"cast",
"<",
"CSKYConstantPoolConstant",
">",
"(",
"CCPV",
")",
"->",
"getGV",
"(",
")",
";",
"MCSym",
"=",
"getSymbol",
"(",
"GV",
")",
";",
"}",
"else",
"if",
"(",
"CCPV",
"->",
"isMachineBasicBlock",
"(",
")",
")",
"{",
"const",
"MachineBasicBlock",
"*",
"MBB",
"=",
"cast",
"<",
"CSKYConstantPoolMBB",
">",
"(",
"CCPV",
")",
"->",
"getMBB",
"(",
")",
";",
"MCSym",
"=",
"MBB",
"->",
"getSymbol",
"(",
")",
";",
"}",
"else",
"if",
"(",
"CCPV",
"->",
"isJT",
"(",
")",
")",
"{",
"signed",
"JTI",
"=",
"cast",
"<",
"CSKYConstantPoolJT",
">",
"(",
"CCPV",
")",
"->",
"getJTI",
"(",
")",
";",
"MCSym",
"=",
"GetJTISymbol",
"(",
"JTI",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"CCPV",
"->",
"isExtSymbol",
"(",
")",
"&&",
"\"unrecognized constant pool value\"",
")",
";",
"StringRef",
"Sym",
"=",
"cast",
"<",
"CSKYConstantPoolSymbol",
">",
"(",
"CCPV",
")",
"->",
"getSymbol",
"(",
")",
";",
"MCSym",
"=",
"GetExternalSymbolSymbol",
"(",
"Sym",
")",
";",
"}",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"MCSym",
",",
"MCSymbolRefExpr",
"::",
"VK_None",
",",
"OutContext",
")",
";",
"if",
"(",
"CCPV",
"->",
"getPCAdjustment",
"(",
")",
")",
"{",
"MCSymbol",
"*",
"PCLabel",
"=",
"OutContext",
".",
"getOrCreateSymbol",
"(",
"Twine",
"(",
"MAI",
"->",
"getPrivateGlobalPrefix",
"(",
")",
")",
"+",
"\"PC\"",
"+",
"Twine",
"(",
"getFunctionNumber",
"(",
")",
")",
"+",
"\"_\"",
"+",
"Twine",
"(",
"CCPV",
"->",
"getLabelID",
"(",
")",
")",
")",
";",
"const",
"MCExpr",
"*",
"PCRelExpr",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"PCLabel",
",",
"OutContext",
")",
";",
"if",
"(",
"CCPV",
"->",
"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",
")",
";",
"}",
"Expr",
"=",
"CSKYMCExpr",
"::",
"create",
"(",
"Expr",
",",
"getModifierVariantKind",
"(",
"CCPV",
"->",
"getModifier",
"(",
")",
")",
",",
"OutContext",
")",
";",
"OutStreamer",
"->",
"emitValue",
"(",
"Expr",
",",
"Size",
")",
";",
"}",
"</s>"
] | [
"EmitMachineConstantPoolValue",
"-",
"Print",
"a",
"machine",
"constantpool",
"value",
"to",
"the",
".s",
"file",
"."
] | [
"CSKY",
"CSKY",
"CSKY",
"CSKY",
"CSKY",
"CSKY",
"CSKY",
"CSKY",
"\"unrecognized constant pool value\"",
"CSKY",
"\"PC\"",
"\"_\"",
"CSKY"
] | CSKYAsmPrinter1 | emitMachineConstantPoolValue | CSKY | CPU | LLVM | 15,933 | 394 | 1 | [] |
[
"<s>",
"const",
"PPCSubtarget",
"*",
"getSubtargetImpl",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"Subtarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"PowerPC",
"PPC"
] | PPCTargetMachine15 | getSubtargetImpl | PowerPC | CPU | LLVM | 15,934 | 14 | 1 | [] |
[
"<s>",
"TargetLowering",
"::",
"AtomicExpansionKind",
"ARMTargetLowering",
"::",
"shouldExpandAtomicLoadInIR",
"(",
"LoadInst",
"*",
"LI",
")",
"const",
"{",
"bool",
"has64BitAtomicLoad",
";",
"if",
"(",
"Subtarget",
"->",
"isMClass",
"(",
")",
")",
"has64BitAtomicLoad",
"=",
"false",
";",
"else",
"if",
"(",
"Subtarget",
"->",
"isThumb",
"(",
")",
")",
"has64BitAtomicLoad",
"=",
"Subtarget",
"->",
"hasV7Ops",
"(",
")",
";",
"else",
"has64BitAtomicLoad",
"=",
"Subtarget",
"->",
"hasV6Ops",
"(",
")",
";",
"unsigned",
"Size",
"=",
"LI",
"->",
"getType",
"(",
")",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"return",
"(",
"Size",
"==",
"64",
"&&",
"has64BitAtomicLoad",
")",
"?",
"AtomicExpansionKind",
"::",
"LLOnly",
":",
"AtomicExpansionKind",
"::",
"None",
";",
"}",
"</s>"
] | [
"Returns",
"how",
"the",
"given",
"(",
"atomic",
")",
"load",
"should",
"be",
"expanded",
"by",
"the",
"IR-level",
"AtomicExpand",
"pass",
"."
] | [
"ARM",
"ARM",
"64"
] | ARMISelLowering12 | shouldExpandAtomicLoadInIR | ARM | CPU | LLVM | 15,935 | 85 | 1 | [] |
[
"<s>",
"void",
"SIInstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"DestReg",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"if",
"(",
"TRI",
"->",
"getCommonSubClass",
"(",
"RC",
",",
"&",
"AMDGPU",
"::",
"SReg_32RegClass",
")",
")",
"{",
"SIMachineFunctionInfo",
"::",
"SpilledReg",
"Spill",
"=",
"MFI",
"->",
"SpillTracker",
".",
"getSpilledReg",
"(",
"FrameIndex",
")",
";",
"assert",
"(",
"Spill",
".",
"VGPR",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"V_READLANE_B32",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"Spill",
".",
"VGPR",
")",
".",
"addImm",
"(",
"Spill",
".",
"Lane",
")",
";",
"}",
"else",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"RC",
"->",
"getSize",
"(",
")",
"/",
"4",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"Flags",
"=",
"RegState",
"::",
"Define",
";",
"if",
"(",
"i",
"==",
"0",
")",
"{",
"Flags",
"|=",
"RegState",
"::",
"Undef",
";",
"}",
"unsigned",
"SubReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"SReg_32RegClass",
")",
";",
"loadRegFromStackSlot",
"(",
"MBB",
",",
"MI",
",",
"SubReg",
",",
"FrameIndex",
"+",
"i",
",",
"&",
"AMDGPU",
"::",
"SReg_32RegClass",
",",
"TRI",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"COPY",
")",
")",
".",
"addReg",
"(",
"DestReg",
",",
"Flags",
",",
"RI",
".",
"getSubRegFromChannel",
"(",
"i",
")",
")",
".",
"addReg",
"(",
"SubReg",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"R600",
"SI",
"SI",
"SI",
"SI",
"0",
"4",
"0"
] | SIInstrInfo16 | loadRegFromStackSlot | R600 | GPU | LLVM | 15,936 | 261 | 1 | [] |
[
"<s>",
"bool",
"LanaiInstrInfo",
"::",
"expandPostRAPseudo",
"(",
"MachineInstr",
"&",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"function",
"is",
"called",
"for",
"all",
"pseudo",
"instructions",
"that",
"remain",
"after",
"register",
"allocation",
"."
] | [
"Lanai",
"Lanai"
] | LanaiInstrInfo (2) | expandPostRAPseudo | Lanai | CPU | LLVM | 15,937 | 14 | 1 | [] |
[
"<s>",
"void",
"setType",
"(",
"StringRef",
"Type",
")",
"{",
"CurType",
"=",
"Type",
";",
"}",
"</s>"
] | [
"Set",
"the",
"low-level",
"type",
"of",
"VReg",
"to",
"Ty",
"."
] | [
"X86"
] | X86AsmParser58 | setType | X86 | CPU | LLVM | 15,938 | 12 | 1 | [] |
[
"<s>",
"void",
"cr16_init_cumulative_args",
"(",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"tree",
"fntype",
",",
"rtx",
"libfunc",
"ATTRIBUTE_UNUSED",
")",
"{",
"tree",
"param",
",",
"next_param",
";",
"cum",
"->",
"ints",
"=",
"0",
";",
"for",
"(",
"param",
"=",
"(",
"fntype",
")",
"?",
"TYPE_ARG_TYPES",
"(",
"fntype",
")",
":",
"0",
";",
"param",
"!=",
"NULL_TREE",
";",
"param",
"=",
"next_param",
")",
"{",
"next_param",
"=",
"TREE_CHAIN",
"(",
"param",
")",
";",
"if",
"(",
"(",
"next_param",
"==",
"NULL_TREE",
")",
"&&",
"(",
"TREE_VALUE",
"(",
"param",
")",
"!=",
"void_type_node",
")",
")",
"{",
"cum",
"->",
"ints",
"=",
"-",
"1",
";",
"return",
";",
"}",
"}",
"}",
"</s>"
] | [
"Implements",
"the",
"macro",
"INIT_CUMULATIVE_ARGS",
"defined",
"in",
"cr16.h",
"."
] | [
"cr16",
"0",
"0",
"1"
] | cr16 | cr16_init_cumulative_args | cr16 | MPU | GCC | 15,939 | 87 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_invalid_builtin",
"(",
"enum",
"rs6000_builtins",
"fncode",
")",
"{",
"size_t",
"uns_fncode",
"=",
"(",
"size_t",
")",
"fncode",
";",
"const",
"char",
"*",
"name",
"=",
"rs6000_builtin_info",
"[",
"uns_fncode",
"]",
".",
"name",
";",
"HOST_WIDE_INT",
"fnmask",
"=",
"rs6000_builtin_info",
"[",
"uns_fncode",
"]",
".",
"mask",
";",
"gcc_assert",
"(",
"name",
"!=",
"NULL",
")",
";",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_CELL",
")",
"!=",
"0",
")",
"error",
"(",
"\"%qs is only valid for the cell processor\"",
",",
"name",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_VSX",
")",
"!=",
"0",
")",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"\"-mvsx\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_HTM",
")",
"!=",
"0",
")",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"\"-mhtm\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_ALTIVEC",
")",
"!=",
"0",
")",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"\"-maltivec\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"(",
"RS6000_BTM_DFP",
"|",
"RS6000_BTM_P8_VECTOR",
")",
")",
"==",
"(",
"RS6000_BTM_DFP",
"|",
"RS6000_BTM_P8_VECTOR",
")",
")",
"error",
"(",
"\"%qs requires the %qs and %qs options\"",
",",
"name",
",",
"\"-mhard-dfp\"",
",",
"\"-mpower8-vector\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_DFP",
")",
"!=",
"0",
")",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"\"-mhard-dfp\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_P8_VECTOR",
")",
"!=",
"0",
")",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"\"-mpower8-vector\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"(",
"RS6000_BTM_P9_VECTOR",
"|",
"RS6000_BTM_64BIT",
")",
")",
"==",
"(",
"RS6000_BTM_P9_VECTOR",
"|",
"RS6000_BTM_64BIT",
")",
")",
"error",
"(",
"\"%qs requires the %qs and %qs options\"",
",",
"name",
",",
"\"-mcpu=power9\"",
",",
"\"-m64\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_P9_VECTOR",
")",
"!=",
"0",
")",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"\"-mcpu=power9\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"(",
"RS6000_BTM_P9_MISC",
"|",
"RS6000_BTM_64BIT",
")",
")",
"==",
"(",
"RS6000_BTM_P9_MISC",
"|",
"RS6000_BTM_64BIT",
")",
")",
"error",
"(",
"\"%qs requires the %qs and %qs options\"",
",",
"name",
",",
"\"-mcpu=power9\"",
",",
"\"-m64\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_P9_MISC",
")",
"==",
"RS6000_BTM_P9_MISC",
")",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"\"-mcpu=power9\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_P10",
")",
"!=",
"0",
")",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"\"-mcpu=power10\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_MMA",
")",
"!=",
"0",
")",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"\"-mmma\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_LDBL128",
")",
"==",
"RS6000_BTM_LDBL128",
")",
"{",
"if",
"(",
"!",
"TARGET_HARD_FLOAT",
")",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"\"-mhard-float\"",
")",
";",
"else",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"TARGET_IEEEQUAD",
"?",
"\"-mabi=ibmlongdouble\"",
":",
"\"-mlong-double-128\"",
")",
";",
"}",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_HARD_FLOAT",
")",
"!=",
"0",
")",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"\"-mhard-float\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_FLOAT128_HW",
")",
"!=",
"0",
")",
"error",
"(",
"\"%qs requires ISA 3.0 IEEE 128-bit floating point\"",
",",
"name",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"RS6000_BTM_FLOAT128",
")",
"!=",
"0",
")",
"error",
"(",
"\"%qs requires the %qs option\"",
",",
"name",
",",
"\"%<-mfloat128%>\"",
")",
";",
"else",
"if",
"(",
"(",
"fnmask",
"&",
"(",
"RS6000_BTM_POPCNTD",
"|",
"RS6000_BTM_POWERPC64",
")",
")",
"==",
"(",
"RS6000_BTM_POPCNTD",
"|",
"RS6000_BTM_POWERPC64",
")",
")",
"error",
"(",
"\"%qs requires the %qs (or newer), and %qs or %qs options\"",
",",
"name",
",",
"\"-mcpu=power7\"",
",",
"\"-m64\"",
",",
"\"-mpowerpc64\"",
")",
";",
"else",
"error",
"(",
"\"%qs is not supported with the current options\"",
",",
"name",
")",
";",
"}",
"</s>"
] | [
"Raise",
"an",
"error",
"message",
"for",
"a",
"builtin",
"function",
"that",
"is",
"called",
"without",
"the",
"appropriate",
"target",
"options",
"being",
"set",
"."
] | [
"rs6000",
"0",
"\"%qs is only valid for the cell processor\"",
"0",
"\"%qs requires the %qs option\"",
"\"-mvsx\"",
"0",
"\"%qs requires the %qs option\"",
"\"-mhtm\"",
"0",
"\"%qs requires the %qs option\"",
"\"-maltivec\"",
"\"%qs requires the %qs and %qs options\"",
"\"-mhard-dfp\"",
"\"-mpower8-vector\"",
"0",
"\"%qs requires the %qs option\"",
"\"-mhard-dfp\"",
"0",
"\"%qs requires the %qs option\"",
"\"-mpower8-vector\"",
"\"%qs requires the %qs and %qs options\"",
"\"-mcpu=power9\"",
"\"-m64\"",
"0",
"\"%qs requires the %qs option\"",
"\"-mcpu=power9\"",
"\"%qs requires the %qs and %qs options\"",
"\"-mcpu=power9\"",
"\"-m64\"",
"\"%qs requires the %qs option\"",
"\"-mcpu=power9\"",
"0",
"\"%qs requires the %qs option\"",
"\"-mcpu=power10\"",
"0",
"\"%qs requires the %qs option\"",
"\"-mmma\"",
"\"%qs requires the %qs option\"",
"\"-mhard-float\"",
"\"%qs requires the %qs option\"",
"\"-mabi=ibmlongdouble\"",
"\"-mlong-double-128\"",
"0",
"\"%qs requires the %qs option\"",
"\"-mhard-float\"",
"0",
"\"%qs requires ISA 3.0 IEEE 128-bit floating point\"",
"0",
"\"%qs requires the %qs option\"",
"\"%<-mfloat128%>\"",
"\"%qs requires the %qs (or newer), and %qs or %qs options\"",
"\"-mcpu=power7\"",
"\"-m64\"",
"\"-mpowerpc64\"",
"\"%qs is not supported with the current options\""
] | rs6000-call1 | rs6000_invalid_builtin | rs6000 | CPU | GCC | 15,940 | 473 | 1 | [] |
[
"<s>",
"bool",
"OptimizeLEAPass",
"::",
"isReplaceable",
"(",
"const",
"MachineInstr",
"&",
"First",
",",
"const",
"MachineInstr",
"&",
"Last",
",",
"int64_t",
"&",
"AddrDispShift",
")",
"const",
"{",
"assert",
"(",
"isLEA",
"(",
"First",
")",
"&&",
"isLEA",
"(",
"Last",
")",
"&&",
"\"The function works only with LEA instructions\"",
")",
";",
"AddrDispShift",
"=",
"getAddrDispShift",
"(",
"Last",
",",
"1",
",",
"First",
",",
"1",
")",
";",
"if",
"(",
"MRI",
"->",
"getRegClass",
"(",
"First",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
"!=",
"MRI",
"->",
"getRegClass",
"(",
"Last",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
")",
"return",
"false",
";",
"for",
"(",
"auto",
"&",
"MO",
":",
"MRI",
"->",
"use_operands",
"(",
"Last",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"MO",
".",
"getParent",
"(",
")",
";",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MI",
".",
"getDesc",
"(",
")",
";",
"int",
"MemOpNo",
"=",
"X86II",
"::",
"getMemoryOperandNo",
"(",
"Desc",
".",
"TSFlags",
",",
"MI",
".",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"MemOpNo",
"<",
"0",
")",
"return",
"false",
";",
"MemOpNo",
"+=",
"X86II",
"::",
"getOperandBias",
"(",
"Desc",
")",
";",
"if",
"(",
"!",
"isIdenticalOp",
"(",
"MI",
".",
"getOperand",
"(",
"MemOpNo",
"+",
"X86",
"::",
"AddrBaseReg",
")",
",",
"MO",
")",
")",
"return",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"MI",
".",
"getNumOperands",
"(",
")",
";",
"i",
"++",
")",
"if",
"(",
"i",
"!=",
"(",
"unsigned",
")",
"(",
"MemOpNo",
"+",
"X86",
"::",
"AddrBaseReg",
")",
"&&",
"isIdenticalOp",
"(",
"MI",
".",
"getOperand",
"(",
"i",
")",
",",
"MO",
")",
")",
"return",
"false",
";",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"MemOpNo",
"+",
"X86",
"::",
"AddrDisp",
")",
".",
"isImm",
"(",
")",
"&&",
"!",
"isInt",
"<",
"32",
">",
"(",
"MI",
".",
"getOperand",
"(",
"MemOpNo",
"+",
"X86",
"::",
"AddrDisp",
")",
".",
"getImm",
"(",
")",
"+",
"AddrDispShift",
")",
")",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Check",
"whether",
"metadata",
"is",
"replaceable",
"."
] | [
"X86",
"\"The function works only with LEA instructions\"",
"1",
"1",
"0",
"0",
"0",
"X86II::getMemoryOperandNo",
"0",
"X86II::getOperandBias",
"X86::AddrBaseReg",
"0",
"X86::AddrBaseReg",
"X86::AddrDisp",
"32",
"X86::AddrDisp"
] | X86OptimizeLEAs1 | isReplaceable | X86 | CPU | LLVM | 15,941 | 286 | 1 | [] |
[
"<s>",
"bool",
"isMem",
"(",
")",
"const",
"{",
"return",
"Kind",
"==",
"Memory",
";",
"}",
"</s>"
] | [
"isMem",
"-",
"Is",
"this",
"a",
"memory",
"operand",
"?"
] | [
"OR1K"
] | OR1KAsmParser | isMem | OR1K | CPU | LLVM | 15,942 | 12 | 1 | [] |
[
"<s>",
"static",
"bool",
"v850_handle_option",
"(",
"size_t",
"code",
",",
"const",
"char",
"*",
"arg",
",",
"int",
"value",
"ATTRIBUTE_UNUSED",
")",
"{",
"switch",
"(",
"code",
")",
"{",
"case",
"OPT_mspace",
":",
"target_flags",
"|=",
"MASK_EP",
"|",
"MASK_PROLOG_FUNCTION",
";",
"return",
"true",
";",
"case",
"OPT_mv850",
":",
"target_flags",
"&=",
"~",
"(",
"MASK_CPU",
"^",
"MASK_V850",
")",
";",
"return",
"true",
";",
"case",
"OPT_mv850e",
":",
"case",
"OPT_mv850e1",
":",
"target_flags",
"&=",
"~",
"(",
"MASK_CPU",
"^",
"MASK_V850E",
")",
";",
"return",
"true",
";",
"case",
"OPT_mtda",
":",
"return",
"v850_handle_memory_option",
"(",
"SMALL_MEMORY_TDA",
",",
"arg",
")",
";",
"case",
"OPT_msda",
":",
"return",
"v850_handle_memory_option",
"(",
"SMALL_MEMORY_SDA",
",",
"arg",
")",
";",
"case",
"OPT_mzda",
":",
"return",
"v850_handle_memory_option",
"(",
"SMALL_MEMORY_ZDA",
",",
"arg",
")",
";",
"default",
":",
"return",
"true",
";",
"}",
"}",
"</s>"
] | [
"Implement",
"TARGET_HANDLE_OPTION",
"."
] | [
"v850"
] | v8503 | v850_handle_option | v850 | MPU | GCC | 15,943 | 107 | 1 | [] |
[
"<s>",
"rtx",
"legitimize_pic_address",
"(",
"rtx",
"orig",
",",
"rtx",
"reg",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"orig",
")",
"==",
"LABEL_REF",
"||",
"(",
"GET_CODE",
"(",
"orig",
")",
"==",
"SYMBOL_REF",
"&&",
"(",
"CONSTANT_POOL_ADDRESS_P",
"(",
"orig",
")",
"||",
"!",
"MN10300_GLOBAL_P",
"(",
"orig",
")",
")",
")",
")",
"{",
"if",
"(",
"reg",
"==",
"0",
")",
"reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_insn",
"(",
"gen_symGOTOFF2reg",
"(",
"reg",
",",
"orig",
")",
")",
";",
"return",
"reg",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"orig",
")",
"==",
"SYMBOL_REF",
")",
"{",
"if",
"(",
"reg",
"==",
"0",
")",
"reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_insn",
"(",
"gen_symGOT2reg",
"(",
"reg",
",",
"orig",
")",
")",
";",
"return",
"reg",
";",
"}",
"return",
"orig",
";",
"}",
"</s>"
] | [
"Legitimize",
"PIC",
"addresses",
".",
"If",
"the",
"address",
"is",
"already",
"position-independent",
",",
"we",
"return",
"ORIG",
".",
"Newly",
"generated",
"position-independent",
"addresses",
"go",
"into",
"a",
"reg",
".",
"This",
"is",
"REG",
"if",
"nonzero",
",",
"otherwise",
"we",
"allocate",
"register",
"(",
"s",
")",
"as",
"necessary",
"."
] | [
"mn10300",
"0",
"0"
] | mn103003 | legitimize_pic_address | mn10300 | MPU | GCC | 15,944 | 111 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"isCandidateToMergeOrPair",
"(",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"if",
"(",
"MI",
"->",
"hasOrderedMemoryRef",
"(",
")",
")",
"return",
"false",
";",
"assert",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"isReg",
"(",
")",
"&&",
"\"Expected a reg operand.\"",
")",
";",
"if",
"(",
"!",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
")",
"return",
"false",
";",
"unsigned",
"BaseReg",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"&",
"getRegisterInfo",
"(",
")",
";",
"if",
"(",
"MI",
"->",
"modifiesRegister",
"(",
"BaseReg",
",",
"TRI",
")",
")",
"return",
"false",
";",
"if",
"(",
"isLdStPairSuppressed",
"(",
"MI",
")",
")",
"return",
"false",
";",
"if",
"(",
"Subtarget",
".",
"avoidQuadLdStPairs",
"(",
")",
")",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"AArch64",
"::",
"LDURQi",
":",
"case",
"AArch64",
"::",
"STURQi",
":",
"case",
"AArch64",
"::",
"LDRQui",
":",
"case",
"AArch64",
"::",
"STRQui",
":",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"is",
"a",
"load/store",
"that",
"can",
"be",
"potentially",
"paired/merged",
"."
] | [
"AArch64",
"AArch64",
"1",
"\"Expected a reg operand.\"",
"2",
"1",
"AArch64::LDURQi",
"AArch64::STURQi",
"AArch64::LDRQui",
"AArch64::STRQui"
] | AArch64InstrInfo110 | isCandidateToMergeOrPair | AArch64 | CPU | LLVM | 15,945 | 154 | 1 | [] |
[
"<s>",
"static",
"tree",
"cris_md_asm_clobbers",
"(",
"tree",
"outputs",
",",
"tree",
"inputs",
",",
"tree",
"in_clobbers",
")",
"{",
"HARD_REG_SET",
"mof_set",
";",
"tree",
"clobbers",
";",
"tree",
"t",
";",
"CLEAR_HARD_REG_SET",
"(",
"mof_set",
")",
";",
"SET_HARD_REG_BIT",
"(",
"mof_set",
",",
"CRIS_MOF_REGNUM",
")",
";",
"clobbers",
"=",
"tree_cons",
"(",
"NULL_TREE",
",",
"build_string",
"(",
"strlen",
"(",
"reg_names",
"[",
"CRIS_CC0_REGNUM",
"]",
")",
",",
"reg_names",
"[",
"CRIS_CC0_REGNUM",
"]",
")",
",",
"in_clobbers",
")",
";",
"for",
"(",
"t",
"=",
"outputs",
";",
"t",
"!=",
"NULL",
";",
"t",
"=",
"TREE_CHAIN",
"(",
"t",
")",
")",
"{",
"tree",
"val",
"=",
"TREE_VALUE",
"(",
"t",
")",
";",
"if",
"(",
"strchr",
"(",
"TREE_STRING_POINTER",
"(",
"TREE_VALUE",
"(",
"TREE_PURPOSE",
"(",
"t",
")",
")",
")",
",",
"'h'",
")",
"!=",
"NULL",
"||",
"tree_overlaps_hard_reg_set",
"(",
"val",
",",
"&",
"mof_set",
")",
"!=",
"NULL_TREE",
")",
"return",
"clobbers",
";",
"}",
"for",
"(",
"t",
"=",
"inputs",
";",
"t",
"!=",
"NULL",
";",
"t",
"=",
"TREE_CHAIN",
"(",
"t",
")",
")",
"{",
"tree",
"val",
"=",
"TREE_VALUE",
"(",
"t",
")",
";",
"if",
"(",
"strchr",
"(",
"TREE_STRING_POINTER",
"(",
"TREE_VALUE",
"(",
"TREE_PURPOSE",
"(",
"t",
")",
")",
")",
",",
"'h'",
")",
"!=",
"NULL",
"||",
"tree_overlaps_hard_reg_set",
"(",
"val",
",",
"&",
"mof_set",
")",
"!=",
"NULL_TREE",
")",
"return",
"clobbers",
";",
"}",
"return",
"tree_cons",
"(",
"NULL_TREE",
",",
"build_string",
"(",
"strlen",
"(",
"reg_names",
"[",
"CRIS_MOF_REGNUM",
"]",
")",
",",
"reg_names",
"[",
"CRIS_MOF_REGNUM",
"]",
")",
",",
"clobbers",
")",
";",
"}",
"</s>"
] | [
"Worker",
"function",
"for",
"TARGET_MD_ASM_CLOBBERS",
"."
] | [
"cris"
] | cris3 | cris_md_asm_clobbers | cris | MPU | GCC | 15,946 | 205 | 1 | [] |
[
"<s>",
"bool",
"X86CallLowering",
"::",
"lowerReturn",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Value",
"*",
"Val",
",",
"ArrayRef",
"<",
"Register",
">",
"VRegs",
",",
"FunctionLoweringInfo",
"&",
"FLI",
")",
"const",
"{",
"assert",
"(",
"(",
"(",
"Val",
"&&",
"!",
"VRegs",
".",
"empty",
"(",
")",
")",
"||",
"(",
"!",
"Val",
"&&",
"VRegs",
".",
"empty",
"(",
")",
")",
")",
"&&",
"\"Return value without a vreg\"",
")",
";",
"auto",
"MIB",
"=",
"MIRBuilder",
".",
"buildInstrNoInsert",
"(",
"X86",
"::",
"RET",
")",
".",
"addImm",
"(",
"0",
")",
";",
"if",
"(",
"!",
"VRegs",
".",
"empty",
"(",
")",
")",
"{",
"MachineFunction",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"const",
"Function",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"DataLayout",
"&",
"DL",
"=",
"MF",
".",
"getDataLayout",
"(",
")",
";",
"ArgInfo",
"OrigRetInfo",
"(",
"VRegs",
",",
"Val",
"->",
"getType",
"(",
")",
",",
"0",
")",
";",
"setArgFlags",
"(",
"OrigRetInfo",
",",
"AttributeList",
"::",
"ReturnIndex",
",",
"DL",
",",
"F",
")",
";",
"SmallVector",
"<",
"ArgInfo",
",",
"4",
">",
"SplitRetInfos",
";",
"splitToValueTypes",
"(",
"OrigRetInfo",
",",
"SplitRetInfos",
",",
"DL",
",",
"F",
".",
"getCallingConv",
"(",
")",
")",
";",
"X86OutgoingValueAssigner",
"Assigner",
"(",
"RetCC_X86",
")",
";",
"X86OutgoingValueHandler",
"Handler",
"(",
"MIRBuilder",
",",
"MRI",
",",
"MIB",
")",
";",
"if",
"(",
"!",
"determineAndHandleAssignments",
"(",
"Handler",
",",
"Assigner",
",",
"SplitRetInfos",
",",
"MIRBuilder",
",",
"F",
".",
"getCallingConv",
"(",
")",
",",
"F",
".",
"isVarArg",
"(",
")",
")",
")",
"return",
"false",
";",
"}",
"MIRBuilder",
".",
"insertInstr",
"(",
"MIB",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"hook",
"behaves",
"as",
"the",
"extended",
"lowerReturn",
"function",
",",
"but",
"for",
"targets",
"that",
"do",
"not",
"support",
"swifterror",
"value",
"promotion",
"."
] | [
"X86",
"X86",
"\"Return value without a vreg\"",
"X86::RET",
"0",
"0",
"4",
"X86",
"X86",
"X86"
] | X86CallLowering11 | lowerReturn | X86 | CPU | LLVM | 15,947 | 231 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"SPUTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"if",
"(",
"node_names",
".",
"empty",
"(",
")",
")",
"{",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"RET_FLAG",
"]",
"=",
"\"SPUISD::RET_FLAG\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"Hi",
"]",
"=",
"\"SPUISD::Hi\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"Lo",
"]",
"=",
"\"SPUISD::Lo\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"PCRelAddr",
"]",
"=",
"\"SPUISD::PCRelAddr\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"AFormAddr",
"]",
"=",
"\"SPUISD::AFormAddr\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"IndirectAddr",
"]",
"=",
"\"SPUISD::IndirectAddr\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"LDRESULT",
"]",
"=",
"\"SPUISD::LDRESULT\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"CALL",
"]",
"=",
"\"SPUISD::CALL\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"SHUFB",
"]",
"=",
"\"SPUISD::SHUFB\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"SHUFFLE_MASK",
"]",
"=",
"\"SPUISD::SHUFFLE_MASK\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"CNTB",
"]",
"=",
"\"SPUISD::CNTB\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"PREFSLOT2VEC",
"]",
"=",
"\"SPUISD::PREFSLOT2VEC\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"VEC2PREFSLOT",
"]",
"=",
"\"SPUISD::VEC2PREFSLOT\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"SHLQUAD_L_BITS",
"]",
"=",
"\"SPUISD::SHLQUAD_L_BITS\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"SHLQUAD_L_BYTES",
"]",
"=",
"\"SPUISD::SHLQUAD_L_BYTES\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"VEC_ROTL",
"]",
"=",
"\"SPUISD::VEC_ROTL\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"VEC_ROTR",
"]",
"=",
"\"SPUISD::VEC_ROTR\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"ROTBYTES_LEFT",
"]",
"=",
"\"SPUISD::ROTBYTES_LEFT\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"ROTBYTES_LEFT_BITS",
"]",
"=",
"\"SPUISD::ROTBYTES_LEFT_BITS\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"SELECT_MASK",
"]",
"=",
"\"SPUISD::SELECT_MASK\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"SELB",
"]",
"=",
"\"SPUISD::SELB\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"ADD64_MARKER",
"]",
"=",
"\"SPUISD::ADD64_MARKER\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"SUB64_MARKER",
"]",
"=",
"\"SPUISD::SUB64_MARKER\"",
";",
"node_names",
"[",
"(",
"unsigned",
")",
"SPUISD",
"::",
"MUL64_MARKER",
"]",
"=",
"\"SPUISD::MUL64_MARKER\"",
";",
"}",
"std",
"::",
"map",
"<",
"unsigned",
",",
"const",
"char",
"*",
">",
"::",
"iterator",
"i",
"=",
"node_names",
".",
"find",
"(",
"Opcode",
")",
";",
"return",
"(",
"(",
"i",
"!=",
"node_names",
".",
"end",
"(",
")",
")",
"?",
"i",
"->",
"second",
":",
"0",
")",
";",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"CellSPU",
"SPU",
"SPUISD::RET_FLAG",
"\"SPUISD::RET_FLAG\"",
"SPUISD::Hi",
"\"SPUISD::Hi\"",
"SPUISD::Lo",
"\"SPUISD::Lo\"",
"SPUISD::PCRelAddr",
"\"SPUISD::PCRelAddr\"",
"SPUISD::AFormAddr",
"\"SPUISD::AFormAddr\"",
"SPUISD::IndirectAddr",
"\"SPUISD::IndirectAddr\"",
"SPUISD::LDRESULT",
"\"SPUISD::LDRESULT\"",
"SPUISD::CALL",
"\"SPUISD::CALL\"",
"SPUISD::SHUFB",
"\"SPUISD::SHUFB\"",
"SPUISD::SHUFFLE_MASK",
"\"SPUISD::SHUFFLE_MASK\"",
"SPUISD::CNTB",
"\"SPUISD::CNTB\"",
"SPUISD::PREFSLOT2VEC",
"\"SPUISD::PREFSLOT2VEC\"",
"SPUISD::VEC2PREFSLOT",
"\"SPUISD::VEC2PREFSLOT\"",
"SPUISD::SHLQUAD_L_BITS",
"\"SPUISD::SHLQUAD_L_BITS\"",
"SPUISD::SHLQUAD_L_BYTES",
"\"SPUISD::SHLQUAD_L_BYTES\"",
"SPUISD::VEC_ROTL",
"\"SPUISD::VEC_ROTL\"",
"SPUISD::VEC_ROTR",
"\"SPUISD::VEC_ROTR\"",
"SPUISD::ROTBYTES_LEFT",
"\"SPUISD::ROTBYTES_LEFT\"",
"SPUISD::ROTBYTES_LEFT_BITS",
"\"SPUISD::ROTBYTES_LEFT_BITS\"",
"SPUISD::SELECT_MASK",
"\"SPUISD::SELECT_MASK\"",
"SPUISD::SELB",
"\"SPUISD::SELB\"",
"SPUISD::ADD64_MARKER",
"\"SPUISD::ADD64_MARKER\"",
"SPUISD::SUB64_MARKER",
"\"SPUISD::SUB64_MARKER\"",
"SPUISD::MUL64_MARKER",
"\"SPUISD::MUL64_MARKER\"",
"0"
] | SPUISelLowering1 | getTargetNodeName | CellSPU | MPU | LLVM | 15,948 | 351 | 1 | [] |
[
"<s>",
"static",
"bool",
"cortexa7_younger",
"(",
"FILE",
"*",
"file",
",",
"int",
"verbose",
",",
"rtx_insn",
"*",
"insn",
")",
"{",
"if",
"(",
"recog_memoized",
"(",
"insn",
")",
"<",
"0",
")",
"{",
"if",
"(",
"verbose",
">",
"5",
")",
"fprintf",
"(",
"file",
",",
"\";; not cortexa7_younger %d\\n\"",
",",
"INSN_UID",
"(",
"insn",
")",
")",
";",
"return",
"false",
";",
"}",
"switch",
"(",
"get_attr_type",
"(",
"insn",
")",
")",
"{",
"case",
"TYPE_ALU_IMM",
":",
"case",
"TYPE_ALUS_IMM",
":",
"case",
"TYPE_LOGIC_IMM",
":",
"case",
"TYPE_LOGICS_IMM",
":",
"case",
"TYPE_EXTEND",
":",
"case",
"TYPE_MVN_IMM",
":",
"case",
"TYPE_MOV_IMM",
":",
"case",
"TYPE_MOV_REG",
":",
"case",
"TYPE_MOV_SHIFT",
":",
"case",
"TYPE_MOV_SHIFT_REG",
":",
"case",
"TYPE_BRANCH",
":",
"case",
"TYPE_CALL",
":",
"return",
"true",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"and",
"only",
"if",
"this",
"insn",
"can",
"dual-issue",
"as",
"younger",
"."
] | [
"arm",
"0",
"5",
"\";; not cortexa7_younger %d\\n\""
] | arm | cortexa7_younger | arm | CPU | GCC | 15,949 | 102 | 1 | [] |
[
"<s>",
"static",
"bool",
"isBranch",
"(",
"unsigned",
"Opcode",
")",
"{",
"return",
"Opcode",
"==",
"AMDGPU",
"::",
"BRANCH",
"||",
"Opcode",
"==",
"AMDGPU",
"::",
"BRANCH_COND_i32",
"||",
"Opcode",
"==",
"AMDGPU",
"::",
"BRANCH_COND_f32",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"this",
"is",
"a",
"conditional",
",",
"unconditional",
",",
"or",
"indirect",
"branch",
"."
] | [
"R600"
] | R600InstrInfo11 | isBranch | R600 | GPU | LLVM | 15,950 | 28 | 1 | [] |
[
"<s>",
"bool",
"xxspltib_constant_p",
"(",
"rtx",
"op",
",",
"machine_mode",
"mode",
",",
"int",
"*",
"num_insns_ptr",
",",
"int",
"*",
"constant_ptr",
")",
"{",
"size_t",
"nunits",
"=",
"GET_MODE_NUNITS",
"(",
"mode",
")",
";",
"size_t",
"i",
";",
"HOST_WIDE_INT",
"value",
";",
"rtx",
"element",
";",
"*",
"num_insns_ptr",
"=",
"-",
"1",
";",
"*",
"constant_ptr",
"=",
"256",
";",
"if",
"(",
"!",
"TARGET_P9_VECTOR",
")",
"return",
"false",
";",
"if",
"(",
"mode",
"==",
"VOIDmode",
")",
"mode",
"=",
"GET_MODE",
"(",
"op",
")",
";",
"else",
"if",
"(",
"mode",
"!=",
"GET_MODE",
"(",
"op",
")",
"&&",
"GET_MODE",
"(",
"op",
")",
"!=",
"VOIDmode",
")",
"return",
"false",
";",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"VEC_DUPLICATE",
")",
"{",
"if",
"(",
"mode",
"!=",
"V16QImode",
"&&",
"mode",
"!=",
"V8HImode",
"&&",
"mode",
"!=",
"V4SImode",
"&&",
"mode",
"!=",
"V2DImode",
")",
"return",
"false",
";",
"element",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"element",
")",
")",
"return",
"false",
";",
"value",
"=",
"INTVAL",
"(",
"element",
")",
";",
"if",
"(",
"!",
"IN_RANGE",
"(",
"value",
",",
"-",
"128",
",",
"127",
")",
")",
"return",
"false",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"CONST_VECTOR",
")",
"{",
"if",
"(",
"mode",
"!=",
"V16QImode",
"&&",
"mode",
"!=",
"V8HImode",
"&&",
"mode",
"!=",
"V4SImode",
"&&",
"mode",
"!=",
"V2DImode",
")",
"return",
"false",
";",
"element",
"=",
"CONST_VECTOR_ELT",
"(",
"op",
",",
"0",
")",
";",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"element",
")",
")",
"return",
"false",
";",
"value",
"=",
"INTVAL",
"(",
"element",
")",
";",
"if",
"(",
"!",
"IN_RANGE",
"(",
"value",
",",
"-",
"128",
",",
"127",
")",
")",
"return",
"false",
";",
"for",
"(",
"i",
"=",
"1",
";",
"i",
"<",
"nunits",
";",
"i",
"++",
")",
"{",
"element",
"=",
"CONST_VECTOR_ELT",
"(",
"op",
",",
"i",
")",
";",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"element",
")",
")",
"return",
"false",
";",
"if",
"(",
"value",
"!=",
"INTVAL",
"(",
"element",
")",
")",
"return",
"false",
";",
"}",
"}",
"else",
"if",
"(",
"CONST_INT_P",
"(",
"op",
")",
")",
"{",
"if",
"(",
"!",
"SCALAR_INT_MODE_P",
"(",
"mode",
")",
")",
"return",
"false",
";",
"value",
"=",
"INTVAL",
"(",
"op",
")",
";",
"if",
"(",
"!",
"IN_RANGE",
"(",
"value",
",",
"-",
"128",
",",
"127",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"IN_RANGE",
"(",
"value",
",",
"-",
"1",
",",
"0",
")",
")",
"{",
"if",
"(",
"!",
"(",
"reg_addr",
"[",
"mode",
"]",
".",
"addr_mask",
"[",
"RELOAD_REG_VMX",
"]",
"&",
"RELOAD_REG_VALID",
")",
")",
"return",
"false",
";",
"if",
"(",
"EASY_VECTOR_15",
"(",
"value",
")",
")",
"return",
"false",
";",
"}",
"}",
"else",
"return",
"false",
";",
"if",
"(",
"(",
"mode",
"==",
"V4SImode",
"||",
"mode",
"==",
"V8HImode",
")",
"&&",
"!",
"IN_RANGE",
"(",
"value",
",",
"-",
"1",
",",
"0",
")",
"&&",
"EASY_VECTOR_15",
"(",
"value",
")",
")",
"return",
"false",
";",
"if",
"(",
"mode",
"==",
"V16QImode",
")",
"*",
"num_insns_ptr",
"=",
"1",
";",
"else",
"if",
"(",
"IN_RANGE",
"(",
"value",
",",
"-",
"1",
",",
"0",
")",
")",
"*",
"num_insns_ptr",
"=",
"1",
";",
"else",
"*",
"num_insns_ptr",
"=",
"2",
";",
"*",
"constant_ptr",
"=",
"(",
"int",
")",
"value",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"OP",
"is",
"of",
"the",
"given",
"MODE",
"and",
"can",
"be",
"synthesized",
"with",
"ISA",
"3.0",
"instructions",
"(",
"xxspltib",
",",
"vupkhsb/vextsb2w/vextb2d",
")",
".",
"Return",
"the",
"number",
"of",
"instructions",
"needed",
"(",
"1",
"or",
"2",
")",
"into",
"the",
"address",
"pointed",
"via",
"NUM_INSNS_PTR",
".",
"Return",
"the",
"constant",
"that",
"is",
"being",
"split",
"via",
"CONSTANT_PTR",
"."
] | [
"powerpcspe",
"1",
"256",
"0",
"128",
"127",
"0",
"128",
"127",
"1",
"128",
"127",
"1",
"0",
"1",
"0",
"1",
"1",
"0",
"1",
"2"
] | powerpcspe | xxspltib_constant_p | powerpcspe | CPU | GCC | 15,951 | 456 | 1 | [] |
[
"<s>",
"unsigned",
"int",
"rs6000_dbx_register_number",
"(",
"unsigned",
"int",
"regno",
",",
"unsigned",
"int",
"format",
")",
"{",
"if",
"(",
"SPE_HIGH_REGNO_P",
"(",
"regno",
")",
")",
"return",
"regno",
"-",
"FIRST_SPE_HIGH_REGNO",
"+",
"1200",
";",
"if",
"(",
"(",
"format",
"==",
"0",
"&&",
"write_symbols",
"!=",
"DWARF2_DEBUG",
")",
"||",
"format",
"==",
"2",
")",
"return",
"regno",
";",
"if",
"(",
"regno",
"<=",
"63",
")",
"return",
"regno",
";",
"if",
"(",
"regno",
"==",
"LR_REGNO",
")",
"return",
"108",
";",
"if",
"(",
"regno",
"==",
"CTR_REGNO",
")",
"return",
"109",
";",
"if",
"(",
"format",
"==",
"1",
"&&",
"regno",
"==",
"CR2_REGNO",
")",
"return",
"64",
";",
"if",
"(",
"CR_REGNO_P",
"(",
"regno",
")",
")",
"return",
"regno",
"-",
"CR0_REGNO",
"+",
"86",
";",
"if",
"(",
"regno",
"==",
"CA_REGNO",
")",
"return",
"101",
";",
"if",
"(",
"ALTIVEC_REGNO_P",
"(",
"regno",
")",
")",
"return",
"regno",
"-",
"FIRST_ALTIVEC_REGNO",
"+",
"1124",
";",
"if",
"(",
"regno",
"==",
"VRSAVE_REGNO",
")",
"return",
"356",
";",
"if",
"(",
"regno",
"==",
"VSCR_REGNO",
")",
"return",
"67",
";",
"if",
"(",
"regno",
"==",
"SPE_ACC_REGNO",
")",
"return",
"99",
";",
"if",
"(",
"regno",
"==",
"SPEFSCR_REGNO",
")",
"return",
"612",
";",
"return",
"regno",
";",
"}",
"</s>"
] | [
"Map",
"internal",
"gcc",
"register",
"numbers",
"to",
"DWARF2",
"register",
"numbers",
"."
] | [
"rs6000",
"1200",
"0",
"2",
"63",
"108",
"109",
"1",
"64",
"86",
"101",
"1124",
"356",
"67",
"99",
"612"
] | rs60004 | rs6000_dbx_register_number | rs6000 | CPU | GCC | 15,952 | 163 | 1 | [] |
[
"<s>",
"bool",
"aarch64_process_target_attr",
"(",
"tree",
"args",
",",
"const",
"char",
"*",
"pragma_or_attr",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"args",
")",
"==",
"TREE_LIST",
")",
"{",
"do",
"{",
"tree",
"head",
"=",
"TREE_VALUE",
"(",
"args",
")",
";",
"if",
"(",
"head",
")",
"{",
"if",
"(",
"!",
"aarch64_process_target_attr",
"(",
"head",
",",
"pragma_or_attr",
")",
")",
"return",
"false",
";",
"}",
"args",
"=",
"TREE_CHAIN",
"(",
"args",
")",
";",
"}",
"while",
"(",
"args",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"TREE_CODE",
"(",
"args",
")",
"!=",
"STRING_CST",
")",
"{",
"error",
"(",
"\"attribute %<target%> argument not a string\"",
")",
";",
"return",
"false",
";",
"}",
"size_t",
"len",
"=",
"strlen",
"(",
"TREE_STRING_POINTER",
"(",
"args",
")",
")",
";",
"char",
"*",
"str_to_check",
"=",
"(",
"char",
"*",
")",
"alloca",
"(",
"len",
"+",
"1",
")",
";",
"strcpy",
"(",
"str_to_check",
",",
"TREE_STRING_POINTER",
"(",
"args",
")",
")",
";",
"if",
"(",
"len",
"==",
"0",
")",
"{",
"error",
"(",
"\"malformed target %s value\"",
",",
"pragma_or_attr",
")",
";",
"return",
"false",
";",
"}",
"unsigned",
"int",
"num_commas",
"=",
"num_occurences_in_str",
"(",
"','",
",",
"str_to_check",
")",
";",
"char",
"*",
"token",
"=",
"strtok",
"(",
"str_to_check",
",",
"\",\"",
")",
";",
"unsigned",
"int",
"num_attrs",
"=",
"0",
";",
"while",
"(",
"token",
")",
"{",
"num_attrs",
"++",
";",
"if",
"(",
"!",
"aarch64_process_one_target_attr",
"(",
"token",
",",
"pragma_or_attr",
")",
")",
"{",
"error",
"(",
"\"target %s %qs is invalid\"",
",",
"pragma_or_attr",
",",
"token",
")",
";",
"return",
"false",
";",
"}",
"token",
"=",
"strtok",
"(",
"NULL",
",",
"\",\"",
")",
";",
"}",
"if",
"(",
"num_attrs",
"!=",
"num_commas",
"+",
"1",
")",
"{",
"error",
"(",
"\"malformed target %s list %qs\"",
",",
"pragma_or_attr",
",",
"TREE_STRING_POINTER",
"(",
"args",
")",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Parse",
"the",
"tree",
"in",
"ARGS",
"that",
"contains",
"the",
"target",
"attribute",
"information",
"and",
"update",
"the",
"global",
"target",
"options",
"space",
".",
"PRAGMA_OR_ATTR",
"is",
"a",
"string",
"to",
"be",
"used",
"in",
"error",
"messages",
",",
"specifying",
"whether",
"this",
"is",
"processing",
"a",
"target",
"attribute",
"or",
"a",
"target",
"pragma",
"."
] | [
"aarch64",
"\"attribute %<target%> argument not a string\"",
"1",
"0",
"\"malformed target %s value\"",
"\",\"",
"0",
"\"target %s %qs is invalid\"",
"\",\"",
"1",
"\"malformed target %s list %qs\""
] | aarch644 | aarch64_process_target_attr | aarch64 | CPU | GCC | 15,953 | 240 | 1 | [] |
[
"<s>",
"static",
"rtx_insn",
"*",
"emit_window_save",
"(",
"rtx",
"increment",
")",
"{",
"rtx_insn",
"*",
"insn",
"=",
"emit_insn",
"(",
"gen_window_save",
"(",
"increment",
")",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_REGISTER",
",",
"gen_rtx_SET",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"RETURN_ADDR_REGNUM",
")",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"INCOMING_RETURN_ADDR_REGNUM",
")",
")",
")",
";",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_WINDOW_SAVE",
",",
"const0_rtx",
")",
";",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_DEF_CFA",
",",
"plus_constant",
"(",
"Pmode",
",",
"hard_frame_pointer_rtx",
",",
"INCOMING_FRAME_SP_OFFSET",
")",
")",
";",
"return",
"insn",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"window_save",
"insn",
"."
] | [
"sparc",
"1"
] | sparc | emit_window_save | sparc | CPU | GCC | 15,954 | 81 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_set_compression_mode",
"(",
"unsigned",
"int",
"compression_mode",
")",
"{",
"if",
"(",
"compression_mode",
"==",
"old_compression_mode",
")",
"return",
";",
"target_flags",
"=",
"mips_base_target_flags",
";",
"flag_schedule_insns",
"=",
"mips_base_schedule_insns",
";",
"flag_reorder_blocks_and_partition",
"=",
"mips_base_reorder_blocks_and_partition",
";",
"flag_move_loop_invariants",
"=",
"mips_base_move_loop_invariants",
";",
"align_loops",
"=",
"mips_base_align_loops",
";",
"align_jumps",
"=",
"mips_base_align_jumps",
";",
"align_functions",
"=",
"mips_base_align_functions",
";",
"target_flags",
"&=",
"~",
"(",
"MASK_MIPS16",
"|",
"MASK_MICROMIPS",
")",
";",
"target_flags",
"|=",
"compression_mode",
";",
"if",
"(",
"compression_mode",
"&",
"MASK_MIPS16",
")",
"{",
"target_flags",
"|=",
"MASK_MIPS16",
";",
"target_flags",
"&=",
"~",
"MASK_SYNCI",
";",
"flag_schedule_insns",
"=",
"0",
";",
"flag_reorder_blocks_and_partition",
"=",
"0",
";",
"flag_move_loop_invariants",
"=",
"0",
";",
"target_flags",
"|=",
"MASK_EXPLICIT_RELOCS",
";",
"targetm",
".",
"min_anchor_offset",
"=",
"0",
";",
"targetm",
".",
"max_anchor_offset",
"=",
"127",
";",
"targetm",
".",
"const_anchor",
"=",
"0",
";",
"target_flags",
"&=",
"~",
"MASK_RELAX_PIC_CALLS",
";",
"target_flags",
"&=",
"~",
"MASK_FIX_R4000",
";",
"if",
"(",
"flag_pic",
"&&",
"!",
"TARGET_OLDABI",
")",
"sorry",
"(",
"\"MIPS16 PIC for ABIs other than o32 and o64\"",
")",
";",
"if",
"(",
"TARGET_XGOT",
")",
"sorry",
"(",
"\"MIPS16 -mxgot code\"",
")",
";",
"if",
"(",
"TARGET_HARD_FLOAT_ABI",
"&&",
"!",
"TARGET_OLDABI",
")",
"sorry",
"(",
"\"hard-float MIPS16 code for ABIs other than o32 and o64\"",
")",
";",
"}",
"else",
"{",
"if",
"(",
"TARGET_MICROMIPS",
")",
"target_flags",
"&=",
"~",
"MASK_BRANCHLIKELY",
";",
"if",
"(",
"TARGET_64BIT",
")",
"{",
"if",
"(",
"align_loops",
"==",
"0",
")",
"align_loops",
"=",
"8",
";",
"if",
"(",
"align_jumps",
"==",
"0",
")",
"align_jumps",
"=",
"8",
";",
"if",
"(",
"align_functions",
"==",
"0",
")",
"align_functions",
"=",
"8",
";",
"}",
"targetm",
".",
"min_anchor_offset",
"=",
"-",
"32768",
";",
"targetm",
".",
"max_anchor_offset",
"=",
"32767",
";",
"targetm",
".",
"const_anchor",
"=",
"0x8000",
";",
"}",
"mips_init_relocs",
"(",
")",
";",
"if",
"(",
"compression_mode",
"&",
"MASK_MIPS16",
")",
"{",
"if",
"(",
"!",
"mips16_globals",
")",
"mips16_globals",
"=",
"save_target_globals_default_opts",
"(",
")",
";",
"else",
"restore_target_globals",
"(",
"mips16_globals",
")",
";",
"}",
"else",
"restore_target_globals",
"(",
"&",
"default_target_globals",
")",
";",
"old_compression_mode",
"=",
"compression_mode",
";",
"}",
"</s>"
] | [
"Set",
"up",
"the",
"target-dependent",
"global",
"state",
"for",
"ISA",
"mode",
"COMPRESSION_MODE",
",",
"which",
"is",
"either",
"MASK_MIPS16",
"or",
"MASK_MICROMIPS",
"."
] | [
"mips",
"0",
"0",
"0",
"0",
"127",
"0",
"\"MIPS16 PIC for ABIs other than o32 and o64\"",
"\"MIPS16 -mxgot code\"",
"\"hard-float MIPS16 code for ABIs other than o32 and o64\"",
"0",
"8",
"0",
"8",
"0",
"8",
"32768",
"32767",
"0x8000"
] | mips4 | mips_set_compression_mode | mips | CPU | GCC | 15,955 | 260 | 1 | [] |
[
"<s>",
"int",
"find_post_update_rtx",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"rtx",
"mem_rtx",
";",
"int",
"i",
",",
"len",
";",
"switch",
"(",
"get_attr_type",
"(",
"insn",
")",
")",
"{",
"case",
"TYPE_LOAD_MULTIPLE",
":",
"case",
"TYPE_STORE_MULTIPLE",
":",
"len",
"=",
"parallel_elements",
"(",
"insn",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"len",
";",
"++",
"i",
")",
"{",
"rtx",
"curr_insn",
"=",
"parallel_element",
"(",
"insn",
",",
"i",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"curr_insn",
")",
"==",
"SET",
"&&",
"REG_P",
"(",
"SET_DEST",
"(",
"curr_insn",
")",
")",
"&&",
"GET_CODE",
"(",
"SET_SRC",
"(",
"curr_insn",
")",
")",
"==",
"PLUS",
")",
"return",
"i",
";",
"}",
"return",
"-",
"1",
";",
"case",
"TYPE_LOAD",
":",
"case",
"TYPE_FLOAD",
":",
"case",
"TYPE_STORE",
":",
"case",
"TYPE_FSTORE",
":",
"mem_rtx",
"=",
"extract_mem_rtx",
"(",
"insn",
")",
";",
"switch",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"mem_rtx",
",",
"0",
")",
")",
")",
"{",
"case",
"POST_INC",
":",
"case",
"POST_DEC",
":",
"case",
"POST_MODIFY",
":",
"return",
"0",
";",
"default",
":",
"return",
"-",
"1",
";",
"}",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Find",
"the",
"post",
"update",
"rtx",
"in",
"INSN",
".",
"If",
"INSN",
"is",
"a",
"load/store",
"multiple",
"insn",
",",
"the",
"function",
"returns",
"the",
"vector",
"index",
"of",
"its",
"parallel",
"part",
".",
"If",
"INSN",
"is",
"a",
"single",
"load/store",
"insn",
",",
"the",
"function",
"returns",
"0",
".",
"If",
"INSN",
"is",
"not",
"a",
"post-",
"update",
"insn",
",",
"the",
"function",
"returns",
"-1",
"."
] | [
"nds32",
"0",
"1",
"0",
"0",
"1"
] | nds32-utils | find_post_update_rtx | nds32 | CPU | GCC | 15,956 | 155 | 1 | [] |
[
"<s>",
"static",
"void",
"frv_function_arg_advance",
"(",
"cumulative_args_t",
"cum_v",
",",
"const",
"function_arg_info",
"&",
"arg",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"cum",
"=",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"machine_mode",
"xmode",
"=",
"(",
"arg",
".",
"mode",
"==",
"BLKmode",
")",
"?",
"SImode",
":",
"arg",
".",
"mode",
";",
"int",
"bytes",
"=",
"GET_MODE_SIZE",
"(",
"xmode",
")",
";",
"int",
"words",
"=",
"(",
"bytes",
"+",
"UNITS_PER_WORD",
"-",
"1",
")",
"/",
"UNITS_PER_WORD",
";",
"int",
"arg_num",
"=",
"*",
"cum",
";",
"*",
"cum",
"=",
"arg_num",
"+",
"words",
";",
"if",
"(",
"TARGET_DEBUG_ARG",
")",
"fprintf",
"(",
"stderr",
",",
"\"function_adv: words = %2d, mode = %4s, named = %d, size = %3d\\n\"",
",",
"arg_num",
",",
"GET_MODE_NAME",
"(",
"arg",
".",
"mode",
")",
",",
"arg",
".",
"named",
",",
"words",
"*",
"UNITS_PER_WORD",
")",
";",
"}",
"</s>"
] | [
"A",
"C",
"statement",
"(",
"sans",
"semicolon",
")",
"to",
"update",
"the",
"summarizer",
"variable",
"CUM",
"to",
"advance",
"past",
"an",
"argument",
"in",
"the",
"argument",
"list",
".",
"The",
"values",
"MODE",
",",
"TYPE",
"and",
"NAMED",
"describe",
"that",
"argument",
".",
"Once",
"this",
"is",
"done",
",",
"the",
"variable",
"CUM",
"is",
"suitable",
"for",
"analyzing",
"the",
"*",
"following",
"*",
"argument",
"with",
"`",
"FUNCTION_ARG",
"'",
",",
"etc",
".",
"This",
"macro",
"need",
"not",
"do",
"anything",
"if",
"the",
"argument",
"in",
"question",
"was",
"passed",
"on",
"the",
"stack",
".",
"The",
"compiler",
"knows",
"how",
"to",
"track",
"the",
"amount",
"of",
"stack",
"space",
"used",
"for",
"arguments",
"without",
"any",
"special",
"help",
"."
] | [
"frv",
"1",
"\"function_adv: words = %2d, mode = %4s, named = %d, size = %3d\\n\""
] | frv | frv_function_arg_advance | frv | VLIW | GCC | 15,957 | 102 | 1 | [] |
[
"<s>",
"void",
"MipsTargetLowering",
"::",
"getOpndList",
"(",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Ops",
",",
"std",
"::",
"deque",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"SDValue",
">",
">",
"&",
"RegsToPass",
",",
"bool",
"IsPICCall",
",",
"bool",
"GlobalOrExternal",
",",
"bool",
"InternalLinkage",
",",
"CallLoweringInfo",
"&",
"CLI",
",",
"SDValue",
"Callee",
",",
"SDValue",
"Chain",
")",
"const",
"{",
"if",
"(",
"IsPICCall",
"&&",
"!",
"InternalLinkage",
")",
"{",
"unsigned",
"GPReg",
"=",
"IsN64",
"?",
"Mips",
"::",
"GP_64",
":",
"Mips",
"::",
"GP",
";",
"EVT",
"Ty",
"=",
"IsN64",
"?",
"MVT",
"::",
"i64",
":",
"MVT",
"::",
"i32",
";",
"RegsToPass",
".",
"push_back",
"(",
"std",
"::",
"make_pair",
"(",
"GPReg",
",",
"getGlobalReg",
"(",
"CLI",
".",
"DAG",
",",
"Ty",
")",
")",
")",
";",
"}",
"SDValue",
"InFlag",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"RegsToPass",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"Chain",
"=",
"CLI",
".",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"CLI",
".",
"DL",
",",
"RegsToPass",
"[",
"i",
"]",
".",
"first",
",",
"RegsToPass",
"[",
"i",
"]",
".",
"second",
",",
"InFlag",
")",
";",
"InFlag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"}",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"RegsToPass",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"Ops",
".",
"push_back",
"(",
"CLI",
".",
"DAG",
".",
"getRegister",
"(",
"RegsToPass",
"[",
"i",
"]",
".",
"first",
",",
"RegsToPass",
"[",
"i",
"]",
".",
"second",
".",
"getValueType",
"(",
")",
")",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"getTargetMachine",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"const",
"uint32_t",
"*",
"Mask",
"=",
"TRI",
"->",
"getCallPreservedMask",
"(",
"CLI",
".",
"CallConv",
")",
";",
"assert",
"(",
"Mask",
"&&",
"\"Missing call preserved mask for calling convention\"",
")",
";",
"if",
"(",
"Subtarget",
"->",
"inMips16HardFloat",
"(",
")",
")",
"{",
"if",
"(",
"GlobalAddressSDNode",
"*",
"G",
"=",
"dyn_cast",
"<",
"GlobalAddressSDNode",
">",
"(",
"CLI",
".",
"Callee",
")",
")",
"{",
"llvm",
"::",
"StringRef",
"Sym",
"=",
"G",
"->",
"getGlobal",
"(",
")",
"->",
"getName",
"(",
")",
";",
"Function",
"*",
"F",
"=",
"G",
"->",
"getGlobal",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getFunction",
"(",
"Sym",
")",
";",
"if",
"(",
"F",
"&&",
"F",
"->",
"hasFnAttribute",
"(",
"\"__Mips16RetHelper\"",
")",
")",
"{",
"Mask",
"=",
"MipsRegisterInfo",
"::",
"getMips16RetHelperMask",
"(",
")",
";",
"}",
"}",
"}",
"Ops",
".",
"push_back",
"(",
"CLI",
".",
"DAG",
".",
"getRegisterMask",
"(",
"Mask",
")",
")",
";",
"if",
"(",
"InFlag",
".",
"getNode",
"(",
")",
")",
"Ops",
".",
"push_back",
"(",
"InFlag",
")",
";",
"}",
"</s>"
] | [
"This",
"function",
"fills",
"Ops",
",",
"which",
"is",
"the",
"list",
"of",
"operands",
"that",
"will",
"later",
"be",
"used",
"when",
"a",
"function",
"call",
"node",
"is",
"created",
"."
] | [
"Mips",
"Mips",
"Mips::GP_64",
"Mips::GP",
"MVT::i64",
"MVT::i32",
"0",
"1",
"0",
"\"Missing call preserved mask for calling convention\"",
"Mips",
"\"__Mips16RetHelper\"",
"Mips",
"Mips"
] | MipsISelLowering38 | getOpndList | Mips | CPU | LLVM | 15,958 | 371 | 1 | [] |
[
"<s>",
"MCSectionGBZ80",
"*",
"GBZ80TargetObjectFile",
"::",
"getSection",
"(",
"SectionKind",
"Kind",
",",
"StringRef",
"N",
",",
"GBSectionType",
"T",
",",
"uint16_t",
"A",
",",
"unsigned",
"B",
",",
"unsigned",
"Align",
",",
"const",
"GlobalObject",
"*",
"GO",
")",
"const",
"{",
"GBZ80SectionData",
"Data",
"(",
"N",
",",
"T",
",",
"A",
",",
"B",
",",
"Align",
",",
"GO",
")",
";",
"if",
"(",
"Sections",
".",
"count",
"(",
"Data",
")",
")",
"return",
"Sections",
"[",
"Data",
"]",
";",
"MCSectionGBZ80",
"*",
"Section",
"=",
"new",
"MCSectionGBZ80",
"(",
"Kind",
",",
"Data",
",",
"nullptr",
")",
";",
"Sections",
"[",
"Data",
"]",
"=",
"Section",
";",
"return",
"Section",
";",
"}",
"</s>"
] | [
"Get",
"the",
"section",
"associated",
"with",
"a",
"defined",
",",
"non-absolute",
"symbol",
"."
] | [
"GBZ80",
"GB",
"GB",
"GB",
"GB",
"GB",
"GB"
] | GBZ80TargetObjectFile | getSection | GBZ80 | MPU | LLVM | 15,959 | 87 | 1 | [] |
[
"<s>",
"static",
"bool",
"Check",
"(",
"DecodeStatus",
"&",
"Out",
",",
"DecodeStatus",
"In",
")",
"{",
"switch",
"(",
"In",
")",
"{",
"case",
"MCDisassembler",
"::",
"Success",
":",
"return",
"true",
";",
"case",
"MCDisassembler",
"::",
"SoftFail",
":",
"Out",
"=",
"In",
";",
"return",
"true",
";",
"case",
"MCDisassembler",
"::",
"Fail",
":",
"Out",
"=",
"In",
";",
"return",
"false",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Matches",
"check",
"string",
"and",
"its",
"``",
"not",
"strings",
"''",
"and/or",
"``",
"dag",
"strings",
"''",
"."
] | [
"ARM"
] | ARMDisassembler13 | Check | ARM | CPU | LLVM | 15,960 | 54 | 1 | [] |
[
"<s>",
"static",
"void",
"arc_override_options",
"(",
"void",
")",
"{",
"if",
"(",
"arc_cpu",
"==",
"PROCESSOR_NONE",
")",
"arc_cpu",
"=",
"PROCESSOR_ARC700",
";",
"if",
"(",
"arc_size_opt_level",
"==",
"3",
")",
"optimize_size",
"=",
"1",
";",
"if",
"(",
"flag_pic",
")",
"target_flags",
"|=",
"MASK_NO_SDATA_SET",
";",
"if",
"(",
"flag_no_common",
"==",
"255",
")",
"flag_no_common",
"=",
"!",
"TARGET_NO_SDATA_SET",
";",
"\\",
"if",
"(",
"TARGET_MIXED_CODE",
")",
"TARGET_Q_CLASS",
"=",
"1",
";",
"if",
"(",
"!",
"TARGET_Q_CLASS",
")",
"TARGET_COMPACT_CASESI",
"=",
"0",
";",
"if",
"(",
"TARGET_COMPACT_CASESI",
")",
"TARGET_CASE_VECTOR_PC_RELATIVE",
"=",
"1",
";",
"arc_init",
"(",
")",
";",
"}",
"</s>"
] | [
"Check",
"ARC",
"options",
",",
"generate",
"derived",
"target",
"attributes",
"."
] | [
"arc",
"3",
"1",
"255",
"1",
"0",
"1"
] | arc4 | arc_override_options | arc | MPU | GCC | 15,961 | 77 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUCallLowering",
"::",
"lowerFormalArguments",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Function",
"::",
"ArgumentListType",
"&",
"Args",
",",
"const",
"SmallVectorImpl",
"<",
"unsigned",
">",
"&",
"VRegs",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"VRegs",
",",
"for",
"GlobalISel",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPUCallLowering47 | lowerFormalArguments | AMDGPU | GPU | LLVM | 15,962 | 30 | 1 | [] |
[
"<s>",
"static",
"HOST_WIDE_INT",
"cris_constant_alignment",
"(",
"const_tree",
",",
"HOST_WIDE_INT",
"basic_align",
")",
"{",
"return",
"MAX",
"(",
"cris_preferred_minimum_alignment",
"(",
")",
",",
"basic_align",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_CONSTANT_ALIGNMENT",
".",
"Note",
"that",
"this",
"hook",
"has",
"the",
"effect",
"of",
"making",
"gcc",
"believe",
"that",
"ALL",
"references",
"to",
"constant",
"stuff",
"(",
"in",
"code",
"segment",
",",
"like",
"strings",
")",
"have",
"this",
"alignment",
".",
"That",
"is",
"a",
"rather",
"rushed",
"assumption",
".",
"Luckily",
"we",
"do",
"not",
"care",
"about",
"the",
"``",
"alignment",
"''",
"operand",
"to",
"builtin",
"memcpy",
"(",
"only",
"place",
"where",
"it",
"counts",
")",
",",
"so",
"it",
"does",
"n't",
"affect",
"any",
"bad",
"spots",
"."
] | [
"cris"
] | cris | cris_constant_alignment | cris | MPU | GCC | 15,963 | 21 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseInstrInfo",
"::",
"PredicateInstruction",
"(",
"MachineInstr",
"*",
"MI",
",",
"const",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Pred",
")",
"const",
"{",
"unsigned",
"Opc",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"isUncondBranchOpcode",
"(",
"Opc",
")",
")",
"{",
"MI",
"->",
"setDesc",
"(",
"get",
"(",
"getMatchingCondBranchOpcode",
"(",
"Opc",
")",
")",
")",
";",
"MachineInstrBuilder",
"(",
"*",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
",",
"MI",
")",
".",
"addImm",
"(",
"Pred",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
")",
".",
"addReg",
"(",
"Pred",
"[",
"1",
"]",
".",
"getReg",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"int",
"PIdx",
"=",
"MI",
"->",
"findFirstPredOperandIdx",
"(",
")",
";",
"if",
"(",
"PIdx",
"!=",
"-",
"1",
")",
"{",
"MachineOperand",
"&",
"PMO",
"=",
"MI",
"->",
"getOperand",
"(",
"PIdx",
")",
";",
"PMO",
".",
"setImm",
"(",
"Pred",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
")",
";",
"MI",
"->",
"getOperand",
"(",
"PIdx",
"+",
"1",
")",
".",
"setReg",
"(",
"Pred",
"[",
"1",
"]",
".",
"getReg",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Convert",
"the",
"instruction",
"into",
"a",
"predicated",
"instruction",
"."
] | [
"ARM",
"ARM",
"0",
"1",
"1",
"0",
"1",
"1"
] | ARMBaseInstrInfo (2) | PredicateInstruction | ARM | CPU | LLVM | 15,964 | 164 | 1 | [] |
[
"<s>",
"bool",
"PPCTargetLowering",
"::",
"useLoadStackGuardNode",
"(",
")",
"const",
"{",
"if",
"(",
"!",
"Subtarget",
".",
"isTargetLinux",
"(",
")",
")",
"return",
"TargetLowering",
"::",
"useLoadStackGuardNode",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"If",
"this",
"function",
"returns",
"true",
",",
"SelectionDAGBuilder",
"emits",
"a",
"LOAD_STACK_GUARD",
"node",
"when",
"it",
"is",
"lowering",
"Intrinsic",
":",
":stackprotector",
"."
] | [
"PowerPC",
"PPC"
] | PPCISelLowering (2)7 | useLoadStackGuardNode | PowerPC | CPU | LLVM | 15,965 | 28 | 1 | [] |
[
"<s>",
"ARMBaseTargetMachine",
"::",
"ARMBaseTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Optional",
"<",
"Reloc",
"::",
"Model",
">",
"RM",
",",
"Optional",
"<",
"CodeModel",
"::",
"Model",
">",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
",",
"bool",
"isLittle",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"computeDataLayout",
"(",
"TT",
",",
"CPU",
",",
"Options",
",",
"isLittle",
")",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"getEffectiveRelocModel",
"(",
"TT",
",",
"RM",
")",
",",
"getEffectiveCodeModel",
"(",
"CM",
",",
"CodeModel",
"::",
"Small",
")",
",",
"OL",
")",
",",
"TargetABI",
"(",
"computeTargetABI",
"(",
"TT",
",",
"CPU",
",",
"Options",
")",
")",
",",
"TLOF",
"(",
"createTLOF",
"(",
"getTargetTriple",
"(",
")",
")",
")",
",",
"isLittle",
"(",
"isLittle",
")",
"{",
"if",
"(",
"Options",
".",
"FloatABIType",
"==",
"FloatABI",
"::",
"Default",
")",
"{",
"if",
"(",
"isTargetHardFloat",
"(",
")",
")",
"this",
"->",
"Options",
".",
"FloatABIType",
"=",
"FloatABI",
"::",
"Hard",
";",
"else",
"this",
"->",
"Options",
".",
"FloatABIType",
"=",
"FloatABI",
"::",
"Soft",
";",
"}",
"if",
"(",
"Options",
".",
"EABIVersion",
"==",
"EABI",
"::",
"Default",
"||",
"Options",
".",
"EABIVersion",
"==",
"EABI",
"::",
"Unknown",
")",
"{",
"if",
"(",
"(",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"GNUEABI",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"GNUEABIHF",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"MuslEABI",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"MuslEABIHF",
")",
"&&",
"!",
"(",
"TargetTriple",
".",
"isOSWindows",
"(",
")",
"||",
"TargetTriple",
".",
"isOSDarwin",
"(",
")",
")",
")",
"this",
"->",
"Options",
".",
"EABIVersion",
"=",
"EABI",
"::",
"GNU",
";",
"else",
"this",
"->",
"Options",
".",
"EABIVersion",
"=",
"EABI",
"::",
"EABI5",
";",
"}",
"if",
"(",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
")",
"{",
"this",
"->",
"Options",
".",
"TrapUnreachable",
"=",
"true",
";",
"this",
"->",
"Options",
".",
"NoTrapAfterNoreturn",
"=",
"true",
";",
"}",
"initAsmInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"Create",
"an",
"ARM",
"architecture",
"model",
"."
] | [
"ARM",
"ARM",
"ARM"
] | ARMTargetMachine | ARMBaseTargetMachine | ARM | CPU | LLVM | 15,966 | 289 | 1 | [] |
[
"<s>",
"static",
"rtx",
"c6x_sched_dfa_pre_cycle_insn",
"(",
"void",
")",
"{",
"return",
"const0_rtx",
";",
"}",
"</s>"
] | [
"Used",
"together",
"with",
"the",
"collapse_ndfa",
"option",
",",
"this",
"ensures",
"that",
"we",
"reach",
"a",
"deterministic",
"automaton",
"state",
"before",
"trying",
"to",
"advance",
"a",
"cycle",
".",
"With",
"collapse_ndfa",
",",
"genautomata",
"creates",
"advance",
"cycle",
"arcs",
"only",
"for",
"such",
"deterministic",
"states",
"."
] | [
"c6x"
] | c6x | c6x_sched_dfa_pre_cycle_insn | c6x | VLIW | GCC | 15,967 | 11 | 1 | [] |
[
"<s>",
"void",
"LanaiInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"StringRef",
"Annotation",
",",
"const",
"MCSubtargetInfo",
"&",
")",
"{",
"if",
"(",
"!",
"printAlias",
"(",
"MI",
",",
"OS",
")",
"&&",
"!",
"printAliasInstr",
"(",
"MI",
",",
"OS",
")",
")",
"printInstruction",
"(",
"MI",
",",
"OS",
")",
";",
"printAnnotation",
"(",
"OS",
",",
"Annotation",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"Lanai",
"Lanai"
] | LanaiInstPrinter | printInst | Lanai | CPU | LLVM | 15,968 | 55 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"long",
"rs6000_arg_size",
"(",
"enum",
"machine_mode",
"mode",
",",
"tree",
"type",
")",
"{",
"unsigned",
"long",
"size",
";",
"if",
"(",
"mode",
"!=",
"BLKmode",
")",
"size",
"=",
"GET_MODE_SIZE",
"(",
"mode",
")",
";",
"else",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"if",
"(",
"TARGET_32BIT",
")",
"return",
"(",
"size",
"+",
"3",
")",
">>",
"2",
";",
"else",
"return",
"(",
"size",
"+",
"7",
")",
">>",
"3",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"size",
"(",
"in",
"words",
")",
"of",
"a",
"function",
"argument",
"."
] | [
"rs6000",
"3",
"2",
"7",
"3"
] | rs60003 | rs6000_arg_size | rs6000 | CPU | GCC | 15,969 | 62 | 1 | [] |
[
"<s>",
"static",
"bool",
"classof",
"(",
"const",
"DiagnosticInfo",
"*",
"DI",
")",
"{",
"return",
"DI",
"->",
"getKind",
"(",
")",
"==",
"getKindID",
"(",
")",
";",
"}",
"</s>"
] | [
"Methods",
"for",
"support",
"type",
"inquiry",
"through",
"isa",
",",
"cast",
",",
"and",
"dyn_cast",
":"
] | [
"AMDGPU"
] | AMDGPUDiagnosticInfoUnsupported | classof | AMDGPU | GPU | LLVM | 15,970 | 22 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"shouldExpandAtomicLoadInIR",
"(",
"LoadInst",
"*",
"LI",
")",
"const",
"{",
"unsigned",
"Size",
"=",
"LI",
"->",
"getType",
"(",
")",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"return",
"(",
"Size",
"==",
"64",
")",
"&&",
"!",
"Subtarget",
"->",
"isMClass",
"(",
")",
";",
"}",
"</s>"
] | [
"Returns",
"how",
"the",
"given",
"(",
"atomic",
")",
"load",
"should",
"be",
"expanded",
"by",
"the",
"IR-level",
"AtomicExpand",
"pass",
"."
] | [
"ARM",
"ARM",
"64"
] | ARMISelLowering (2)3 | shouldExpandAtomicLoadInIR | ARM | CPU | LLVM | 15,971 | 39 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"shouldSinkOperands",
"(",
"Instruction",
"*",
"I",
",",
"SmallVectorImpl",
"<",
"Use",
"*",
">",
"&",
"Ops",
")",
"const",
"{",
"using",
"namespace",
"llvm",
"::",
"PatternMatch",
";",
"if",
"(",
"!",
"I",
"->",
"getType",
"(",
")",
"->",
"isVectorTy",
"(",
")",
"||",
"!",
"Subtarget",
".",
"hasVInstructions",
"(",
")",
")",
"return",
"false",
";",
"auto",
"IsSinker",
"=",
"[",
"&",
"]",
"(",
"Instruction",
"*",
"I",
",",
"int",
"Operand",
")",
"{",
"switch",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"Instruction",
"::",
"Add",
":",
"case",
"Instruction",
"::",
"Sub",
":",
"case",
"Instruction",
"::",
"Mul",
":",
"case",
"Instruction",
"::",
"And",
":",
"case",
"Instruction",
"::",
"Or",
":",
"case",
"Instruction",
"::",
"Xor",
":",
"case",
"Instruction",
"::",
"FAdd",
":",
"case",
"Instruction",
"::",
"FSub",
":",
"case",
"Instruction",
"::",
"FMul",
":",
"case",
"Instruction",
"::",
"FDiv",
":",
"case",
"Instruction",
"::",
"ICmp",
":",
"case",
"Instruction",
"::",
"FCmp",
":",
"return",
"true",
";",
"case",
"Instruction",
"::",
"Shl",
":",
"case",
"Instruction",
"::",
"LShr",
":",
"case",
"Instruction",
"::",
"AShr",
":",
"return",
"Operand",
"==",
"1",
";",
"case",
"Instruction",
"::",
"Call",
":",
"if",
"(",
"auto",
"*",
"II",
"=",
"dyn_cast",
"<",
"IntrinsicInst",
">",
"(",
"I",
")",
")",
"{",
"switch",
"(",
"II",
"->",
"getIntrinsicID",
"(",
")",
")",
"{",
"case",
"Intrinsic",
"::",
"fma",
":",
"return",
"Operand",
"==",
"0",
"||",
"Operand",
"==",
"1",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"return",
"false",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
";",
"for",
"(",
"auto",
"OpIdx",
":",
"enumerate",
"(",
"I",
"->",
"operands",
"(",
")",
")",
")",
"{",
"if",
"(",
"!",
"IsSinker",
"(",
"I",
",",
"OpIdx",
".",
"index",
"(",
")",
")",
")",
"continue",
";",
"Instruction",
"*",
"Op",
"=",
"dyn_cast",
"<",
"Instruction",
">",
"(",
"OpIdx",
".",
"value",
"(",
")",
".",
"get",
"(",
")",
")",
";",
"if",
"(",
"!",
"Op",
"||",
"any_of",
"(",
"Ops",
",",
"[",
"&",
"]",
"(",
"Use",
"*",
"U",
")",
"{",
"return",
"U",
"->",
"get",
"(",
")",
"==",
"Op",
";",
"}",
")",
")",
"continue",
";",
"if",
"(",
"!",
"match",
"(",
"Op",
",",
"m_Shuffle",
"(",
"m_InsertElt",
"(",
"m_Undef",
"(",
")",
",",
"m_Value",
"(",
")",
",",
"m_ZeroInt",
"(",
")",
")",
",",
"m_Undef",
"(",
")",
",",
"m_ZeroMask",
"(",
")",
")",
")",
")",
"continue",
";",
"for",
"(",
"Use",
"&",
"U",
":",
"Op",
"->",
"uses",
"(",
")",
")",
"{",
"Instruction",
"*",
"Insn",
"=",
"cast",
"<",
"Instruction",
">",
"(",
"U",
".",
"getUser",
"(",
")",
")",
";",
"if",
"(",
"!",
"IsSinker",
"(",
"Insn",
",",
"U",
".",
"getOperandNo",
"(",
")",
")",
")",
"return",
"false",
";",
"}",
"Ops",
".",
"push_back",
"(",
"&",
"Op",
"->",
"getOperandUse",
"(",
"0",
")",
")",
";",
"Ops",
".",
"push_back",
"(",
"&",
"OpIdx",
".",
"value",
"(",
")",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"sinking",
"I",
"'s",
"operands",
"to",
"the",
"same",
"basic",
"block",
"as",
"I",
"is",
"profitable",
",",
"e.g",
"."
] | [
"RISCV",
"RISCV",
"1",
"Intrinsic::fma",
"0",
"1",
"0"
] | RISCVISelLowering18 | shouldSinkOperands | RISCV | CPU | LLVM | 15,972 | 412 | 1 | [] |
[
"<s>",
"static",
"const",
"simd_vec_cost",
"*",
"aarch64_simd_vec_costs_for_flags",
"(",
"unsigned",
"int",
"flags",
")",
"{",
"const",
"cpu_vector_cost",
"*",
"costs",
"=",
"aarch64_tune_params",
".",
"vec_costs",
";",
"if",
"(",
"(",
"flags",
"&",
"VEC_ANY_SVE",
")",
"&&",
"costs",
"->",
"sve",
")",
"return",
"costs",
"->",
"sve",
";",
"return",
"costs",
"->",
"advsimd",
";",
"}",
"</s>"
] | [
"Return",
"the",
"appropriate",
"SIMD",
"costs",
"for",
"vectors",
"with",
"VEC_",
"*",
"flags",
"FLAGS",
"."
] | [
"aarch64"
] | aarch641 | aarch64_simd_vec_costs_for_flags | aarch64 | CPU | GCC | 15,973 | 43 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyReplacePhysRegs",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"LLVM_DEBUG",
"(",
"{",
"dbgs",
"(",
")",
"<<",
"\"********** Replace Physical Registers **********\\n\"",
"<<",
"\"********** Function: \"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
";",
"}",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"auto",
"&",
"TRI",
"=",
"*",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"assert",
"(",
"!",
"mustPreserveAnalysisID",
"(",
"LiveIntervalsID",
")",
"&&",
"\"LiveIntervals shouldn't be active yet!\"",
")",
";",
"MRI",
".",
"leaveSSA",
"(",
")",
";",
"MRI",
".",
"invalidateLiveness",
"(",
")",
";",
"for",
"(",
"unsigned",
"PReg",
"=",
"WebAssembly",
"::",
"NoRegister",
"+",
"1",
";",
"PReg",
"<",
"WebAssembly",
"::",
"NUM_TARGET_REGS",
";",
"++",
"PReg",
")",
"{",
"if",
"(",
"PReg",
"==",
"WebAssembly",
"::",
"VALUE_STACK",
"||",
"PReg",
"==",
"WebAssembly",
"::",
"ARGUMENTS",
")",
"continue",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TRI",
".",
"getMinimalPhysRegClass",
"(",
"PReg",
")",
";",
"unsigned",
"VReg",
"=",
"WebAssembly",
"::",
"NoRegister",
";",
"for",
"(",
"MachineOperand",
"&",
"MO",
":",
"llvm",
"::",
"make_early_inc_range",
"(",
"MRI",
".",
"reg_operands",
"(",
"PReg",
")",
")",
")",
"{",
"if",
"(",
"!",
"MO",
".",
"isImplicit",
"(",
")",
")",
"{",
"if",
"(",
"VReg",
"==",
"WebAssembly",
"::",
"NoRegister",
")",
"{",
"VReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"RC",
")",
";",
"if",
"(",
"PReg",
"==",
"TRI",
".",
"getFrameRegister",
"(",
"MF",
")",
")",
"{",
"auto",
"FI",
"=",
"MF",
".",
"getInfo",
"<",
"WebAssemblyFunctionInfo",
">",
"(",
")",
";",
"assert",
"(",
"!",
"FI",
"->",
"isFrameBaseVirtual",
"(",
")",
")",
";",
"FI",
"->",
"setFrameBaseVreg",
"(",
"VReg",
")",
";",
"LLVM_DEBUG",
"(",
"{",
"dbgs",
"(",
")",
"<<",
"\"replacing preg \"",
"<<",
"PReg",
"<<",
"\" with \"",
"<<",
"VReg",
"<<",
"\" (\"",
"<<",
"Register",
"::",
"virtReg2Index",
"(",
"VReg",
")",
"<<",
"\")\\n\"",
";",
"}",
")",
";",
"}",
"}",
"MO",
".",
"setReg",
"(",
"VReg",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"}",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"********** Replace Physical Registers **********\\n\"",
"\"********** Function: \"",
"WebAssembly",
"\"LiveIntervals shouldn't be active yet!\"",
"WebAssembly::NoRegister",
"1",
"WebAssembly::NUM_TARGET_REGS",
"WebAssembly::VALUE_STACK",
"WebAssembly::ARGUMENTS",
"WebAssembly::NoRegister",
"WebAssembly::NoRegister",
"WebAssembly",
"\"replacing preg \"",
"\" with \"",
"\" (\"",
"\")\\n\""
] | WebAssemblyReplacePhysRegs2 | runOnMachineFunction | WebAssembly | Virtual ISA | LLVM | 15,974 | 281 | 1 | [] |
[
"<s>",
"static",
"tree",
"build_processor_model_struct",
"(",
"void",
")",
"{",
"const",
"char",
"*",
"field_name",
"[",
"]",
"=",
"{",
"\"__cpu_vendor\"",
",",
"\"__cpu_type\"",
",",
"\"__cpu_subtype\"",
",",
"\"__cpu_features\"",
"}",
";",
"tree",
"field",
"=",
"NULL_TREE",
",",
"field_chain",
"=",
"NULL_TREE",
";",
"int",
"i",
";",
"tree",
"type",
"=",
"make_node",
"(",
"RECORD_TYPE",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"3",
";",
"++",
"i",
")",
"{",
"field",
"=",
"build_decl",
"(",
"UNKNOWN_LOCATION",
",",
"FIELD_DECL",
",",
"get_identifier",
"(",
"field_name",
"[",
"i",
"]",
")",
",",
"unsigned_type_node",
")",
";",
"if",
"(",
"field_chain",
"!=",
"NULL_TREE",
")",
"DECL_CHAIN",
"(",
"field",
")",
"=",
"field_chain",
";",
"field_chain",
"=",
"field",
";",
"}",
"field",
"=",
"build_decl",
"(",
"UNKNOWN_LOCATION",
",",
"FIELD_DECL",
",",
"get_identifier",
"(",
"field_name",
"[",
"3",
"]",
")",
",",
"build_array_type",
"(",
"unsigned_type_node",
",",
"build_index_type",
"(",
"size_one_node",
")",
")",
")",
";",
"if",
"(",
"field_chain",
"!=",
"NULL_TREE",
")",
"DECL_CHAIN",
"(",
"field",
")",
"=",
"field_chain",
";",
"field_chain",
"=",
"field",
";",
"finish_builtin_struct",
"(",
"type",
",",
"\"__processor_model\"",
",",
"field_chain",
",",
"NULL_TREE",
")",
";",
"return",
"type",
";",
"}",
"</s>"
] | [
"This",
"builds",
"the",
"processor_model",
"struct",
"type",
"defined",
"in",
"libgcc/config/i386/cpuinfo.c"
] | [
"i386",
"\"__cpu_vendor\"",
"\"__cpu_type\"",
"\"__cpu_subtype\"",
"\"__cpu_features\"",
"0",
"3",
"3",
"\"__processor_model\""
] | i386-builtins | build_processor_model_struct | i386 | CPU | GCC | 15,975 | 154 | 1 | [] |
[
"<s>",
"bool",
"X86DomainReassignment",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"DisableX86DomainReassignment",
")",
"return",
"false",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"***** Machine Function before Domain Reassignment *****\\n\"",
")",
";",
"DEBUG",
"(",
"MF",
".",
"print",
"(",
"dbgs",
"(",
")",
")",
")",
";",
"STI",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"if",
"(",
"!",
"STI",
"->",
"hasAVX512",
"(",
")",
")",
"return",
"false",
";",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"assert",
"(",
"MRI",
"->",
"isSSA",
"(",
")",
"&&",
"\"Expected MIR to be in SSA form\"",
")",
";",
"TII",
"=",
"STI",
"->",
"getInstrInfo",
"(",
")",
";",
"initConverters",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"EnclosedEdges",
".",
"clear",
"(",
")",
";",
"EnclosedInstrs",
".",
"clear",
"(",
")",
";",
"std",
"::",
"vector",
"<",
"Closure",
">",
"Closures",
";",
"for",
"(",
"unsigned",
"Idx",
"=",
"0",
";",
"Idx",
"<",
"MRI",
"->",
"getNumVirtRegs",
"(",
")",
";",
"++",
"Idx",
")",
"{",
"unsigned",
"Reg",
"=",
"TargetRegisterInfo",
"::",
"index2VirtReg",
"(",
"Idx",
")",
";",
"if",
"(",
"!",
"isGPR",
"(",
"MRI",
"->",
"getRegClass",
"(",
"Reg",
")",
")",
")",
"continue",
";",
"if",
"(",
"EnclosedEdges",
".",
"count",
"(",
"Reg",
")",
")",
"continue",
";",
"Closure",
"C",
"(",
"{",
"MaskDomain",
"}",
")",
";",
"buildClosure",
"(",
"C",
",",
"Reg",
")",
";",
"if",
"(",
"!",
"C",
".",
"empty",
"(",
")",
"&&",
"C",
".",
"isLegal",
"(",
"MaskDomain",
")",
")",
"Closures",
".",
"push_back",
"(",
"std",
"::",
"move",
"(",
"C",
")",
")",
";",
"}",
"for",
"(",
"Closure",
"&",
"C",
":",
"Closures",
")",
"if",
"(",
"isReassignmentProfitable",
"(",
"C",
",",
"MaskDomain",
")",
")",
"{",
"reassign",
"(",
"C",
",",
"MaskDomain",
")",
";",
"++",
"NumClosuresConverted",
";",
"Changed",
"=",
"true",
";",
"}",
"DeleteContainerSeconds",
"(",
"Converters",
")",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"***** Machine Function after Domain Reassignment *****\\n\"",
")",
";",
"DEBUG",
"(",
"MF",
".",
"print",
"(",
"dbgs",
"(",
")",
")",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"X86",
"\"***** Machine Function before Domain Reassignment *****\\n\"",
"X86",
"\"Expected MIR to be in SSA form\"",
"0",
"\"***** Machine Function after Domain Reassignment *****\\n\""
] | X86DomainReassignment1 | runOnMachineFunction | X86 | CPU | LLVM | 15,976 | 295 | 1 | [] |
[
"<s>",
"void",
"XtensaInstrInfo",
"::",
"copyPhysReg",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"unsigned",
"DestReg",
",",
"unsigned",
"SrcReg",
",",
"bool",
"KillSrc",
")",
"const",
"{",
"if",
"(",
"Xtensa",
"::",
"GPRRegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Xtensa",
"::",
"MOV_r",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
")",
";",
"}",
"else",
"{",
"llvm_unreachable",
"(",
"\"Impossible reg-to-reg copy\"",
")",
";",
"}",
"}",
"</s>"
] | [
"}",
"Branch",
"Analysis",
"&",
"Modification"
] | [
"Xtensa",
"Xtensa",
"Xtensa::GPRRegClass",
"Xtensa::MOV_r",
"\"Impossible reg-to-reg copy\""
] | XtensaInstrInfo | copyPhysReg | Xtensa | MPU | LLVM | 15,977 | 77 | 1 | [] |
[
"<s>",
"DecodeStatus",
"AGCDisassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"MI",
",",
"uint64_t",
"&",
"Size",
",",
"ArrayRef",
"<",
"uint8_t",
">",
"Bytes",
",",
"uint64_t",
"Address",
",",
"raw_ostream",
"&",
"OS",
",",
"raw_ostream",
"&",
"CS",
")",
"const",
"{",
"uint16_t",
"Instruction",
";",
"DecodeStatus",
"Result",
";",
"Instruction",
"=",
"support",
"::",
"endian",
"::",
"read16be",
"(",
"Bytes",
".",
"data",
"(",
")",
")",
";",
"Instruction",
"=",
"(",
"Instruction",
"&",
"0xFFFE",
")",
">>",
"1",
";",
"Result",
"=",
"decodeInstruction",
"(",
"DecoderTable16",
",",
"MI",
",",
"Instruction",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"!=",
"AGC",
"::",
"EXTEND",
")",
"{",
"Size",
"=",
"2",
";",
"return",
"Result",
";",
"}",
"Instruction",
"=",
"support",
"::",
"endian",
"::",
"read16be",
"(",
"Bytes",
".",
"drop_front",
"(",
"2",
")",
".",
"data",
"(",
")",
")",
";",
"Instruction",
"=",
"(",
"Instruction",
"&",
"0xFFFE",
")",
">>",
"1",
";",
"Result",
"=",
"decodeInstruction",
"(",
"DecoderTableExtracode16",
",",
"MI",
",",
"Instruction",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"Size",
"=",
"4",
";",
"return",
"Result",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"AGC",
"AGC",
"support::endian",
"0xFFFE",
"1",
"AGC::EXTEND",
"2",
"support::endian",
"2",
"0xFFFE",
"1",
"4"
] | AGCDisassembler | getInstruction | AGC | MPU | LLVM | 15,978 | 156 | 1 | [] |
[
"<s>",
"const",
"uint16_t",
"*",
"SparcRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"return",
"CSR_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"Sparc",
"Sparc"
] | SparcRegisterInfo13 | getCalleeSavedRegs | Sparc | CPU | LLVM | 15,979 | 18 | 1 | [] |
[
"<s>",
"bool",
"aarch64_simd_shift_imm_p",
"(",
"rtx",
"x",
",",
"machine_mode",
"mode",
",",
"bool",
"left",
")",
"{",
"x",
"=",
"unwrap_const_vec_duplicate",
"(",
"x",
")",
";",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"x",
")",
")",
"return",
"false",
";",
"int",
"bit_width",
"=",
"GET_MODE_UNIT_SIZE",
"(",
"mode",
")",
"*",
"BITS_PER_UNIT",
";",
"if",
"(",
"left",
")",
"return",
"IN_RANGE",
"(",
"INTVAL",
"(",
"x",
")",
",",
"0",
",",
"bit_width",
"-",
"1",
")",
";",
"else",
"return",
"IN_RANGE",
"(",
"INTVAL",
"(",
"x",
")",
",",
"1",
",",
"bit_width",
")",
";",
"}",
"</s>"
] | [
"Check",
"of",
"immediate",
"shift",
"constants",
"are",
"within",
"range",
"."
] | [
"aarch64",
"0",
"1",
"1"
] | aarch64 | aarch64_simd_shift_imm_p | aarch64 | CPU | GCC | 15,980 | 75 | 1 | [] |
[
"<s>",
"void",
"m32r_init_expanders",
"(",
"void",
")",
"{",
"}",
"</s>"
] | [
"Do",
"anything",
"needed",
"before",
"RTL",
"is",
"emitted",
"for",
"each",
"function",
"."
] | [
"m32r"
] | m32r | m32r_init_expanders | m32r | MPU | GCC | 15,981 | 7 | 1 | [] |
[
"<s>",
"bool",
"AArch64RegisterInfo",
"::",
"useFPForScavengingIndex",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"return",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
"&&",
"!",
"hasBasePointer",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"wants",
"to",
"use",
"frame",
"pointer",
"based",
"accesses",
"to",
"spill",
"to",
"the",
"scavenger",
"emergency",
"spill",
"slot",
"."
] | [
"AArch64",
"AArch64"
] | AArch64RegisterInfo (2) | useFPForScavengingIndex | AArch64 | CPU | LLVM | 15,982 | 37 | 1 | [] |
[
"<s>",
"GCNSubtarget",
"&",
"GCNSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"GPU",
",",
"StringRef",
"FS",
")",
"{",
"SmallString",
"<",
"256",
">",
"FullFS",
"(",
"\"+promote-alloca,+dx10-clamp,+load-store-opt,\"",
")",
";",
"if",
"(",
"isAmdHsaOS",
"(",
")",
")",
"FullFS",
"+=",
"\"+flat-address-space,+flat-for-global,+unaligned-buffer-access,+trap-handler,\"",
";",
"if",
"(",
"getGeneration",
"(",
")",
">=",
"AMDGPUSubtarget",
"::",
"SOUTHERN_ISLANDS",
")",
"{",
"FullFS",
"+=",
"\"+fp64-fp16-denormals,\"",
";",
"}",
"else",
"{",
"FullFS",
"+=",
"\"-fp32-denormals,\"",
";",
"}",
"FullFS",
"+=",
"\"+enable-prt-strict-null,\"",
";",
"FullFS",
"+=",
"FS",
";",
"ParseSubtargetFeatures",
"(",
"GPU",
",",
"FullFS",
")",
";",
"assert",
"(",
"!",
"hasFP64",
"(",
")",
"||",
"(",
"getGeneration",
"(",
")",
">=",
"AMDGPUSubtarget",
"::",
"SOUTHERN_ISLANDS",
")",
")",
";",
"if",
"(",
"!",
"hasAddr64",
"(",
")",
"&&",
"!",
"FS",
".",
"contains",
"(",
"\"flat-for-global\"",
")",
")",
"{",
"FlatForGlobal",
"=",
"true",
";",
"}",
"if",
"(",
"MaxPrivateElementSize",
"==",
"0",
")",
"MaxPrivateElementSize",
"=",
"4",
";",
"if",
"(",
"LDSBankCount",
"==",
"0",
")",
"LDSBankCount",
"=",
"32",
";",
"if",
"(",
"TT",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"amdgcn",
")",
"{",
"if",
"(",
"LocalMemorySize",
"==",
"0",
")",
"LocalMemorySize",
"=",
"32768",
";",
"if",
"(",
"!",
"HasMovrel",
"&&",
"!",
"HasVGPRIndexMode",
")",
"HasMovrel",
"=",
"true",
";",
"}",
"HasFminFmaxLegacy",
"=",
"getGeneration",
"(",
")",
"<",
"AMDGPUSubtarget",
"::",
"VOLCANIC_ISLANDS",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"AMDGPU",
"256",
"\"+promote-alloca,+dx10-clamp,+load-store-opt,\"",
"\"+flat-address-space,+flat-for-global,+unaligned-buffer-access,+trap-handler,\"",
"AMDGPU",
"\"+fp64-fp16-denormals,\"",
"\"-fp32-denormals,\"",
"\"+enable-prt-strict-null,\"",
"AMDGPU",
"\"flat-for-global\"",
"0",
"4",
"0",
"32",
"0",
"32768",
"AMDGPU"
] | AMDGPUSubtarget28 | initializeSubtargetDependencies | AMDGPU | GPU | LLVM | 15,983 | 185 | 1 | [] |
[
"<s>",
"static",
"void",
"rl78_alloc_physical_registers_cmp",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"int",
"tmp_id",
";",
"rtx",
"saved_op1",
";",
"rtx_insn",
"*",
"prev",
"=",
"prev_nonnote_nondebug_insn",
"(",
"insn",
")",
";",
"rtx",
"first",
";",
"OP",
"(",
"1",
")",
"=",
"transcode_memory_rtx",
"(",
"OP",
"(",
"1",
")",
",",
"DE",
",",
"insn",
")",
";",
"OP",
"(",
"2",
")",
"=",
"transcode_memory_rtx",
"(",
"OP",
"(",
"2",
")",
",",
"HL",
",",
"insn",
")",
";",
"MAYBE_OK",
"(",
"insn",
")",
";",
"if",
"(",
"REG_P",
"(",
"OP",
"(",
"1",
")",
")",
"&&",
"REGNO",
"(",
"OP",
"(",
"1",
")",
")",
"!=",
"AX_REG",
"&&",
"GET_MODE",
"(",
"OP",
"(",
"1",
")",
")",
"==",
"HImode",
"&&",
"MEM_P",
"(",
"OP",
"(",
"2",
")",
")",
")",
"{",
"rtx",
"cmp",
"=",
"XEXP",
"(",
"SET_SRC",
"(",
"PATTERN",
"(",
"insn",
")",
")",
",",
"0",
")",
";",
"OP",
"(",
"2",
")",
"=",
"move_to_acc",
"(",
"2",
",",
"insn",
")",
";",
"switch",
"(",
"GET_CODE",
"(",
"cmp",
")",
")",
"{",
"case",
"EQ",
":",
"case",
"NE",
":",
"break",
";",
"case",
"LTU",
":",
"cmp",
"=",
"gen_rtx_GTU",
"(",
"HImode",
",",
"OP",
"(",
"2",
")",
",",
"OP",
"(",
"1",
")",
")",
";",
"break",
";",
"case",
"GTU",
":",
"cmp",
"=",
"gen_rtx_LTU",
"(",
"HImode",
",",
"OP",
"(",
"2",
")",
",",
"OP",
"(",
"1",
")",
")",
";",
"break",
";",
"case",
"LEU",
":",
"cmp",
"=",
"gen_rtx_GEU",
"(",
"HImode",
",",
"OP",
"(",
"2",
")",
",",
"OP",
"(",
"1",
")",
")",
";",
"break",
";",
"case",
"GEU",
":",
"cmp",
"=",
"gen_rtx_LEU",
"(",
"HImode",
",",
"OP",
"(",
"2",
")",
",",
"OP",
"(",
"1",
")",
")",
";",
"break",
";",
"case",
"LT",
":",
"case",
"GT",
":",
"case",
"LE",
":",
"case",
"GE",
":",
"debug_rtx",
"(",
"insn",
")",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"cmp",
")",
"==",
"EQ",
"||",
"GET_CODE",
"(",
"cmp",
")",
"==",
"NE",
")",
"PATTERN",
"(",
"insn",
")",
"=",
"gen_cbranchhi4_real",
"(",
"cmp",
",",
"OP",
"(",
"2",
")",
",",
"OP",
"(",
"1",
")",
",",
"OP",
"(",
"3",
")",
")",
";",
"else",
"PATTERN",
"(",
"insn",
")",
"=",
"gen_cbranchhi4_real_inverted",
"(",
"cmp",
",",
"OP",
"(",
"2",
")",
",",
"OP",
"(",
"1",
")",
",",
"OP",
"(",
"3",
")",
")",
";",
"MUST_BE_OK",
"(",
"insn",
")",
";",
"}",
"if",
"(",
"rtx_equal_p",
"(",
"OP",
"(",
"1",
")",
",",
"OP",
"(",
"2",
")",
")",
")",
"{",
"OP",
"(",
"1",
")",
"=",
"OP",
"(",
"2",
")",
"=",
"BC",
";",
"MUST_BE_OK",
"(",
"insn",
")",
";",
"}",
"tmp_id",
"=",
"get_max_insn_count",
"(",
")",
";",
"saved_op1",
"=",
"OP",
"(",
"1",
")",
";",
"OP",
"(",
"1",
")",
"=",
"move_to_acc",
"(",
"1",
",",
"insn",
")",
";",
"MAYBE_OK",
"(",
"insn",
")",
";",
"if",
"(",
"tmp_id",
"==",
"get_max_insn_count",
"(",
")",
")",
"force_into_acc",
"(",
"saved_op1",
",",
"insn",
")",
";",
"if",
"(",
"prev",
")",
"first",
"=",
"next_nonnote_nondebug_insn",
"(",
"prev",
")",
";",
"else",
"for",
"(",
"first",
"=",
"insn",
";",
"prev_nonnote_nondebug_insn",
"(",
"first",
")",
";",
"first",
"=",
"prev_nonnote_nondebug_insn",
"(",
"first",
")",
")",
";",
"OP",
"(",
"2",
")",
"=",
"move_to_hl",
"(",
"2",
",",
"first",
")",
";",
"MUST_BE_OK",
"(",
"insn",
")",
";",
"}",
"</s>"
] | [
"Devirtualize",
"a",
"compare",
"insn",
"."
] | [
"rl78",
"1",
"1",
"2",
"2",
"1",
"1",
"1",
"2",
"0",
"2",
"2",
"2",
"1",
"2",
"1",
"2",
"1",
"2",
"1",
"2",
"1",
"3",
"2",
"1",
"3",
"1",
"2",
"1",
"2",
"1",
"1",
"1",
"2",
"2"
] | rl783 | rl78_alloc_physical_registers_cmp | rl78 | MPU | GCC | 15,984 | 462 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"SDValue",
",",
"SDValue",
">",
"SystemZSelectionDAGInfo",
"::",
"EmitTargetCodeForMemchr",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"SDLoc",
"DL",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Src",
",",
"SDValue",
"Char",
",",
"SDValue",
"Length",
",",
"MachinePointerInfo",
"SrcPtrInfo",
")",
"const",
"{",
"EVT",
"PtrVT",
"=",
"Src",
".",
"getValueType",
"(",
")",
";",
"SDVTList",
"VTs",
"=",
"DAG",
".",
"getVTList",
"(",
"PtrVT",
",",
"MVT",
"::",
"Other",
",",
"MVT",
"::",
"Glue",
")",
";",
"Length",
"=",
"DAG",
".",
"getZExtOrTrunc",
"(",
"Length",
",",
"DL",
",",
"PtrVT",
")",
";",
"Char",
"=",
"DAG",
".",
"getZExtOrTrunc",
"(",
"Char",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
";",
"Char",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AND",
",",
"DL",
",",
"MVT",
"::",
"i32",
",",
"Char",
",",
"DAG",
".",
"getConstant",
"(",
"255",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"SDValue",
"Limit",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"PtrVT",
",",
"Src",
",",
"Length",
")",
";",
"SDValue",
"End",
"=",
"DAG",
".",
"getNode",
"(",
"SystemZISD",
"::",
"SEARCH_STRING",
",",
"DL",
",",
"VTs",
",",
"Chain",
",",
"Limit",
",",
"Src",
",",
"Char",
")",
";",
"Chain",
"=",
"End",
".",
"getValue",
"(",
"1",
")",
";",
"SDValue",
"Glue",
"=",
"End",
".",
"getValue",
"(",
"2",
")",
";",
"SDValue",
"Ops",
"[",
"]",
"=",
"{",
"End",
",",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"PtrVT",
")",
",",
"DAG",
".",
"getConstant",
"(",
"SystemZ",
"::",
"CCMASK_SRST",
",",
"MVT",
"::",
"i32",
")",
",",
"DAG",
".",
"getConstant",
"(",
"SystemZ",
"::",
"CCMASK_SRST_FOUND",
",",
"MVT",
"::",
"i32",
")",
",",
"Glue",
"}",
";",
"VTs",
"=",
"DAG",
".",
"getVTList",
"(",
"PtrVT",
",",
"MVT",
"::",
"Glue",
")",
";",
"End",
"=",
"DAG",
".",
"getNode",
"(",
"SystemZISD",
"::",
"SELECT_CCMASK",
",",
"DL",
",",
"VTs",
",",
"Ops",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"End",
",",
"Chain",
")",
";",
"}",
"</s>"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memchr",
",",
"in",
"cases",
"where",
"that",
"is",
"faster",
"than",
"a",
"libcall",
"."
] | [
"SystemZ",
"SystemZ",
"MVT::Other",
"MVT::Glue",
"MVT::i32",
"ISD::AND",
"MVT::i32",
"255",
"MVT::i32",
"ISD::ADD",
"SystemZISD::SEARCH_STRING",
"1",
"2",
"0",
"SystemZ::CCMASK_SRST",
"MVT::i32",
"SystemZ::CCMASK_SRST_FOUND",
"MVT::i32",
"MVT::Glue",
"SystemZISD::SELECT_CCMASK"
] | SystemZSelectionDAGInfo8 | EmitTargetCodeForMemchr | SystemZ | CPU | LLVM | 15,985 | 271 | 1 | [] |
[
"<s>",
"const",
"uint16_t",
"*",
"SPURegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"static",
"const",
"uint16_t",
"SPU_CalleeSaveRegs",
"[",
"]",
"=",
"{",
"SPU",
"::",
"R80",
",",
"SPU",
"::",
"R81",
",",
"SPU",
"::",
"R82",
",",
"SPU",
"::",
"R83",
",",
"SPU",
"::",
"R84",
",",
"SPU",
"::",
"R85",
",",
"SPU",
"::",
"R86",
",",
"SPU",
"::",
"R87",
",",
"SPU",
"::",
"R88",
",",
"SPU",
"::",
"R89",
",",
"SPU",
"::",
"R90",
",",
"SPU",
"::",
"R91",
",",
"SPU",
"::",
"R92",
",",
"SPU",
"::",
"R93",
",",
"SPU",
"::",
"R94",
",",
"SPU",
"::",
"R95",
",",
"SPU",
"::",
"R96",
",",
"SPU",
"::",
"R97",
",",
"SPU",
"::",
"R98",
",",
"SPU",
"::",
"R99",
",",
"SPU",
"::",
"R100",
",",
"SPU",
"::",
"R101",
",",
"SPU",
"::",
"R102",
",",
"SPU",
"::",
"R103",
",",
"SPU",
"::",
"R104",
",",
"SPU",
"::",
"R105",
",",
"SPU",
"::",
"R106",
",",
"SPU",
"::",
"R107",
",",
"SPU",
"::",
"R108",
",",
"SPU",
"::",
"R109",
",",
"SPU",
"::",
"R110",
",",
"SPU",
"::",
"R111",
",",
"SPU",
"::",
"R112",
",",
"SPU",
"::",
"R113",
",",
"SPU",
"::",
"R114",
",",
"SPU",
"::",
"R115",
",",
"SPU",
"::",
"R116",
",",
"SPU",
"::",
"R117",
",",
"SPU",
"::",
"R118",
",",
"SPU",
"::",
"R119",
",",
"SPU",
"::",
"R120",
",",
"SPU",
"::",
"R121",
",",
"SPU",
"::",
"R122",
",",
"SPU",
"::",
"R123",
",",
"SPU",
"::",
"R124",
",",
"SPU",
"::",
"R125",
",",
"SPU",
"::",
"R126",
",",
"SPU",
"::",
"R127",
",",
"SPU",
"::",
"R2",
",",
"SPU",
"::",
"R1",
",",
"SPU",
"::",
"R0",
",",
"0",
"}",
";",
"return",
"SPU_CalleeSaveRegs",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"CellSPU",
"SPU",
"SPU",
"SPU::R80",
"SPU::R81",
"SPU::R82",
"SPU::R83",
"SPU::R84",
"SPU::R85",
"SPU::R86",
"SPU::R87",
"SPU::R88",
"SPU::R89",
"SPU::R90",
"SPU::R91",
"SPU::R92",
"SPU::R93",
"SPU::R94",
"SPU::R95",
"SPU::R96",
"SPU::R97",
"SPU::R98",
"SPU::R99",
"SPU::R100",
"SPU::R101",
"SPU::R102",
"SPU::R103",
"SPU::R104",
"SPU::R105",
"SPU::R106",
"SPU::R107",
"SPU::R108",
"SPU::R109",
"SPU::R110",
"SPU::R111",
"SPU::R112",
"SPU::R113",
"SPU::R114",
"SPU::R115",
"SPU::R116",
"SPU::R117",
"SPU::R118",
"SPU::R119",
"SPU::R120",
"SPU::R121",
"SPU::R122",
"SPU::R123",
"SPU::R124",
"SPU::R125",
"SPU::R126",
"SPU::R127",
"SPU::R2",
"SPU::R1",
"SPU::R0",
"0",
"SPU"
] | SPURegisterInfo4 | getCalleeSavedRegs | CellSPU | MPU | LLVM | 15,986 | 233 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"LM32 DAG->DAG Pattern Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"LM32",
"\"LM32 DAG->DAG Pattern Instruction Selection\""
] | LM32ISelDAGToDAG | getPassName | LM32 | MPU | LLVM | 15,987 | 13 | 1 | [] |
[
"<s>",
"size_t",
"size",
"(",
")",
"const",
"{",
"return",
"Vector",
".",
"size",
"(",
")",
";",
"}",
"</s>"
] | [
"The",
"number",
"of",
"name/type",
"pairs",
"is",
"returned",
"."
] | [
"Hexagon"
] | HexagonBitTracker (2) | size | Hexagon | DSP | LLVM | 15,988 | 14 | 1 | [] |
[
"<s>",
"unsigned",
"MipsMCCodeEmitter",
"::",
"getBranchTarget26OpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"unsigned",
"OpNo",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"const",
"MCOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OpNo",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
">>",
"2",
";",
"assert",
"(",
"MO",
".",
"isExpr",
"(",
")",
"&&",
"\"getBranchTarget26OpValue expects only expressions or immediates\"",
")",
";",
"const",
"MCExpr",
"*",
"FixupExpression",
"=",
"MCBinaryExpr",
"::",
"createAdd",
"(",
"MO",
".",
"getExpr",
"(",
")",
",",
"MCConstantExpr",
"::",
"create",
"(",
"-",
"4",
",",
"Ctx",
")",
",",
"Ctx",
")",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"0",
",",
"FixupExpression",
",",
"MCFixupKind",
"(",
"Mips",
"::",
"fixup_MIPS_PC26_S2",
")",
")",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getBranchTarget26OpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"the",
"branch",
"target",
"operand",
"."
] | [
"Mips",
"Mips",
"2",
"\"getBranchTarget26OpValue expects only expressions or immediates\"",
"4",
"0",
"Mips::fixup_MIPS_PC26_S2",
"0"
] | MipsMCCodeEmitter (2) | getBranchTarget26OpValue | Mips | CPU | LLVM | 15,989 | 120 | 1 | [] |
[
"<s>",
"AArch64Subtarget",
"::",
"AArch64Subtarget",
"(",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"const",
"TargetMachine",
"&",
"TM",
",",
"bool",
"LittleEndian",
")",
":",
"AArch64GenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"ARMProcFamily",
"(",
"Others",
")",
",",
"HasV8_1aOps",
"(",
"false",
")",
",",
"HasFPARMv8",
"(",
"false",
")",
",",
"HasNEON",
"(",
"false",
")",
",",
"HasCrypto",
"(",
"false",
")",
",",
"HasCRC",
"(",
"false",
")",
",",
"HasZeroCycleRegMove",
"(",
"false",
")",
",",
"HasZeroCycleZeroing",
"(",
"false",
")",
",",
"IsLittle",
"(",
"LittleEndian",
")",
",",
"CPUString",
"(",
"CPU",
")",
",",
"TargetTriple",
"(",
"TT",
")",
",",
"FrameLowering",
"(",
")",
",",
"InstrInfo",
"(",
"initializeSubtargetDependencies",
"(",
"FS",
")",
")",
",",
"TSInfo",
"(",
"TM",
".",
"getDataLayout",
"(",
")",
")",
",",
"TLInfo",
"(",
"TM",
",",
"*",
"this",
")",
"{",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64Subtarget64 | AArch64Subtarget | AArch64 | CPU | LLVM | 15,990 | 128 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"setPreservesCFG",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"ScalarEvolutionWrapperPass",
">",
"(",
")",
";",
"getLoopAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"TPC"
] | TPCIndexSpace | getAnalysisUsage | TPC | Virtual ISA | LLVM | 15,991 | 31 | 1 | [] |
[
"<s>",
"void",
"AlphaRegisterInfo",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"(",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"?",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
":",
"DebugLoc",
"(",
")",
")",
";",
"bool",
"FP",
"=",
"hasFP",
"(",
"MF",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"Alpha",
"::",
"LDAHg",
")",
",",
"Alpha",
"::",
"R29",
")",
".",
"addGlobalAddress",
"(",
"const_cast",
"<",
"Function",
"*",
">",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"R27",
")",
".",
"addImm",
"(",
"++",
"curgpdist",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"Alpha",
"::",
"LDAg",
")",
",",
"Alpha",
"::",
"R29",
")",
".",
"addGlobalAddress",
"(",
"const_cast",
"<",
"Function",
"*",
">",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"R29",
")",
".",
"addImm",
"(",
"curgpdist",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"Alpha",
"::",
"ALTENT",
")",
")",
".",
"addGlobalAddress",
"(",
"const_cast",
"<",
"Function",
"*",
">",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
")",
";",
"long",
"NumBytes",
"=",
"MFI",
"->",
"getStackSize",
"(",
")",
";",
"if",
"(",
"FP",
")",
"NumBytes",
"+=",
"8",
";",
"if",
"(",
"NumBytes",
"==",
"0",
")",
"return",
";",
"unsigned",
"Align",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameInfo",
"(",
")",
"->",
"getStackAlignment",
"(",
")",
";",
"NumBytes",
"=",
"(",
"NumBytes",
"+",
"Align",
"-",
"1",
")",
"/",
"Align",
"*",
"Align",
";",
"MFI",
"->",
"setStackSize",
"(",
"NumBytes",
")",
";",
"NumBytes",
"=",
"-",
"NumBytes",
";",
"if",
"(",
"NumBytes",
">=",
"IMM_LOW",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"Alpha",
"::",
"LDA",
")",
",",
"Alpha",
"::",
"R30",
")",
".",
"addImm",
"(",
"NumBytes",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"R30",
")",
";",
"}",
"else",
"if",
"(",
"getUpper16",
"(",
"NumBytes",
")",
">=",
"IMM_LOW",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"Alpha",
"::",
"LDAH",
")",
",",
"Alpha",
"::",
"R30",
")",
".",
"addImm",
"(",
"getUpper16",
"(",
"NumBytes",
")",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"R30",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"Alpha",
"::",
"LDA",
")",
",",
"Alpha",
"::",
"R30",
")",
".",
"addImm",
"(",
"getLower16",
"(",
"NumBytes",
")",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"R30",
")",
";",
"}",
"else",
"{",
"report_fatal_error",
"(",
"\"Too big a stack frame at \"",
"+",
"Twine",
"(",
"NumBytes",
")",
")",
";",
"}",
"if",
"(",
"FP",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"Alpha",
"::",
"STQ",
")",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"R15",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"R30",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"Alpha",
"::",
"BISr",
")",
",",
"Alpha",
"::",
"R15",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"R30",
")",
".",
"addReg",
"(",
"Alpha",
"::",
"R30",
")",
";",
"}",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"Alpha",
"Alpha",
"Alpha::LDAHg",
"Alpha::R29",
"Alpha::R27",
"Alpha::LDAg",
"Alpha::R29",
"Alpha::R29",
"Alpha::ALTENT",
"8",
"0",
"1",
"Alpha::LDA",
"Alpha::R30",
"Alpha::R30",
"Alpha::LDAH",
"Alpha::R30",
"Alpha::R30",
"Alpha::LDA",
"Alpha::R30",
"Alpha::R30",
"\"Too big a stack frame at \"",
"Alpha::STQ",
"Alpha::R15",
"0",
"Alpha::R30",
"Alpha::BISr",
"Alpha::R15",
"Alpha::R30",
"Alpha::R30"
] | AlphaRegisterInfo | emitPrologue | Alpha | MPU | LLVM | 15,992 | 497 | 1 | [] |
[
"<s>",
"unsigned",
"AMDGPURegisterBankInfo",
"::",
"copyCost",
"(",
"const",
"RegisterBank",
"&",
"A",
",",
"const",
"RegisterBank",
"&",
"B",
",",
"unsigned",
"Size",
")",
"const",
"{",
"return",
"RegisterBankInfo",
"::",
"copyCost",
"(",
"A",
",",
"B",
",",
"Size",
")",
";",
"}",
"</s>"
] | [
"Get",
"the",
"cost",
"of",
"a",
"copy",
"from",
"B",
"to",
"A",
",",
"or",
"put",
"differently",
",",
"get",
"the",
"cost",
"of",
"A",
"=",
"COPY",
"B",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPURegisterBankInfo13 | copyCost | AMDGPU | GPU | LLVM | 15,993 | 33 | 1 | [] |
[
"<s>",
"TargetLowering",
"::",
"AtomicExpansionKind",
"X86TargetLowering",
"::",
"shouldExpandAtomicRMWInIR",
"(",
"AtomicRMWInst",
"*",
"AI",
")",
"const",
"{",
"unsigned",
"NativeWidth",
"=",
"Subtarget",
".",
"is64Bit",
"(",
")",
"?",
"64",
":",
"32",
";",
"Type",
"*",
"MemType",
"=",
"AI",
"->",
"getType",
"(",
")",
";",
"if",
"(",
"MemType",
"->",
"getPrimitiveSizeInBits",
"(",
")",
">",
"NativeWidth",
")",
"{",
"return",
"needsCmpXchgNb",
"(",
"MemType",
")",
"?",
"AtomicExpansionKind",
"::",
"CmpXChg",
":",
"AtomicExpansionKind",
"::",
"None",
";",
"}",
"AtomicRMWInst",
"::",
"BinOp",
"Op",
"=",
"AI",
"->",
"getOperation",
"(",
")",
";",
"switch",
"(",
"Op",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unknown atomic operation\"",
")",
";",
"case",
"AtomicRMWInst",
"::",
"Xchg",
":",
"case",
"AtomicRMWInst",
"::",
"Add",
":",
"case",
"AtomicRMWInst",
"::",
"Sub",
":",
"return",
"AtomicExpansionKind",
"::",
"None",
";",
"case",
"AtomicRMWInst",
"::",
"Or",
":",
"case",
"AtomicRMWInst",
"::",
"And",
":",
"case",
"AtomicRMWInst",
"::",
"Xor",
":",
"return",
"!",
"AI",
"->",
"use_empty",
"(",
")",
"?",
"AtomicExpansionKind",
"::",
"CmpXChg",
":",
"AtomicExpansionKind",
"::",
"None",
";",
"case",
"AtomicRMWInst",
"::",
"Nand",
":",
"case",
"AtomicRMWInst",
"::",
"Max",
":",
"case",
"AtomicRMWInst",
"::",
"Min",
":",
"case",
"AtomicRMWInst",
"::",
"UMax",
":",
"case",
"AtomicRMWInst",
"::",
"UMin",
":",
"return",
"AtomicExpansionKind",
"::",
"CmpXChg",
";",
"}",
"}",
"</s>"
] | [
"Returns",
"how",
"the",
"IR-level",
"AtomicExpand",
"pass",
"should",
"expand",
"the",
"given",
"AtomicRMW",
",",
"if",
"at",
"all",
"."
] | [
"X86",
"X86",
"64",
"32",
"\"Unknown atomic operation\""
] | X86ISelLowering (2)8 | shouldExpandAtomicRMWInIR | X86 | CPU | LLVM | 15,994 | 168 | 1 | [] |
[
"<s>",
"void",
"print_operand_address",
"(",
"FILE",
"*",
"file",
",",
"register",
"rtx",
"addr",
")",
"{",
"rtx",
"reg",
";",
"rtx",
"offset",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"AND",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
"==",
"CONST_INT",
"&&",
"INTVAL",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
"==",
"-",
"16",
")",
"addr",
"=",
"XEXP",
"(",
"addr",
",",
"0",
")",
";",
"switch",
"(",
"GET_CODE",
"(",
"addr",
")",
")",
"{",
"case",
"REG",
":",
"fprintf",
"(",
"file",
",",
"\"0(%s)\"",
",",
"reg_names",
"[",
"REGNO",
"(",
"addr",
")",
"]",
")",
";",
"break",
";",
"case",
"PLUS",
":",
"reg",
"=",
"XEXP",
"(",
"addr",
",",
"0",
")",
";",
"offset",
"=",
"XEXP",
"(",
"addr",
",",
"1",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"offset",
")",
"==",
"REG",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"%s,%s\"",
",",
"reg_names",
"[",
"REGNO",
"(",
"reg",
")",
"]",
",",
"reg_names",
"[",
"REGNO",
"(",
"offset",
")",
"]",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"offset",
")",
"==",
"CONST_INT",
")",
"{",
"fprintf",
"(",
"file",
",",
"HOST_WIDE_INT_PRINT_DEC",
"\"(%s)\"",
",",
"INTVAL",
"(",
"offset",
")",
",",
"reg_names",
"[",
"REGNO",
"(",
"reg",
")",
"]",
")",
";",
"}",
"else",
"abort",
"(",
")",
";",
"break",
";",
"case",
"CONST",
":",
"case",
"LABEL_REF",
":",
"case",
"SYMBOL_REF",
":",
"case",
"CONST_INT",
":",
"output_addr_const",
"(",
"file",
",",
"addr",
")",
";",
"break",
";",
"default",
":",
"debug_rtx",
"(",
"addr",
")",
";",
"abort",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Print",
"the",
"operand",
"address",
"represented",
"by",
"the",
"rtx",
"addr"
] | [
"spu",
"1",
"1",
"16",
"0",
"\"0(%s)\"",
"0",
"1",
"\"%s,%s\"",
"\"(%s)\""
] | spu | print_operand_address | spu | MPU | GCC | 15,995 | 218 | 1 | [] |
[
"<s>",
"int",
"same_cmp_following_p",
"(",
"rtx",
"i1",
")",
"{",
"rtx_insn",
"*",
"i2",
",",
"*",
"i3",
";",
"i2",
"=",
"next_nonnote_insn",
"(",
"i1",
")",
";",
"if",
"(",
"i2",
"==",
"NULL",
")",
"return",
"0",
";",
"i3",
"=",
"next_nonnote_insn",
"(",
"i2",
")",
";",
"if",
"(",
"i3",
"==",
"NULL",
")",
"return",
"0",
";",
"return",
"(",
"INSN_P",
"(",
"i3",
")",
"&&",
"rtx_equal_p",
"(",
"PATTERN",
"(",
"i1",
")",
",",
"PATTERN",
"(",
"i3",
")",
")",
"&&",
"any_condjump_p",
"(",
"i2",
")",
"&&",
"onlyjump_p",
"(",
"i2",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"we",
"have",
"the",
"same",
"comparison",
"insn",
"as",
"I1",
"two",
"insns",
"after",
"I1",
".",
"I1",
"is",
"assumed",
"to",
"be",
"a",
"comparison",
"insn",
"."
] | [
"h8300",
"0",
"0"
] | h83004 | same_cmp_following_p | h8300 | MPU | GCC | 15,996 | 78 | 1 | [] |
[
"<s>",
"unsigned",
"X86TargetLowering",
"::",
"getRegPressureLimit",
"(",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"unsigned",
"FPDiff",
"=",
"RegInfo",
"->",
"hasFP",
"(",
"MF",
")",
"?",
"1",
":",
"0",
";",
"switch",
"(",
"RC",
"->",
"getID",
"(",
")",
")",
"{",
"default",
":",
"return",
"0",
";",
"case",
"X86",
"::",
"GR32RegClassID",
":",
"return",
"4",
"-",
"FPDiff",
";",
"case",
"X86",
"::",
"GR64RegClassID",
":",
"return",
"8",
"-",
"FPDiff",
";",
"case",
"X86",
"::",
"VR128RegClassID",
":",
"return",
"Subtarget",
"->",
"is64Bit",
"(",
")",
"?",
"10",
":",
"4",
";",
"case",
"X86",
"::",
"VR64RegClassID",
":",
"return",
"4",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"register",
"pressure",
"``",
"high",
"water",
"mark",
"''",
"for",
"the",
"specific",
"register",
"class",
"."
] | [
"X86",
"X86",
"1",
"0",
"0",
"X86::GR32RegClassID",
"4",
"X86::GR64RegClassID",
"8",
"X86::VR128RegClassID",
"10",
"4",
"X86::VR64RegClassID",
"4"
] | X86ISelLowering73 | getRegPressureLimit | X86 | CPU | LLVM | 15,997 | 90 | 1 | [] |
[
"<s>",
"bool",
"RISCVInstrInfo",
"::",
"verifyInstruction",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"StringRef",
"&",
"ErrInfo",
")",
"const",
"{",
"const",
"MCInstrInfo",
"*",
"MCII",
"=",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"MCInstrDesc",
"const",
"&",
"Desc",
"=",
"MCII",
"->",
"get",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
";",
"for",
"(",
"auto",
"&",
"OI",
":",
"enumerate",
"(",
"Desc",
".",
"operands",
"(",
")",
")",
")",
"{",
"unsigned",
"OpType",
"=",
"OI",
".",
"value",
"(",
")",
".",
"OperandType",
";",
"if",
"(",
"OpType",
">=",
"RISCVOp",
"::",
"OPERAND_FIRST_RISCV_IMM",
"&&",
"OpType",
"<=",
"RISCVOp",
"::",
"OPERAND_LAST_RISCV_IMM",
")",
"{",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OI",
".",
"index",
"(",
")",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"{",
"int64_t",
"Imm",
"=",
"MO",
".",
"getImm",
"(",
")",
";",
"bool",
"Ok",
";",
"switch",
"(",
"OpType",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unexpected operand type\"",
")",
";",
"case",
"RISCVOp",
"::",
"OPERAND_UIMM2",
":",
"Ok",
"=",
"isUInt",
"<",
"2",
">",
"(",
"Imm",
")",
";",
"break",
";",
"case",
"RISCVOp",
"::",
"OPERAND_UIMM3",
":",
"Ok",
"=",
"isUInt",
"<",
"3",
">",
"(",
"Imm",
")",
";",
"break",
";",
"case",
"RISCVOp",
"::",
"OPERAND_UIMM4",
":",
"Ok",
"=",
"isUInt",
"<",
"4",
">",
"(",
"Imm",
")",
";",
"break",
";",
"case",
"RISCVOp",
"::",
"OPERAND_UIMM5",
":",
"Ok",
"=",
"isUInt",
"<",
"5",
">",
"(",
"Imm",
")",
";",
"break",
";",
"case",
"RISCVOp",
"::",
"OPERAND_UIMM7",
":",
"Ok",
"=",
"isUInt",
"<",
"7",
">",
"(",
"Imm",
")",
";",
"break",
";",
"case",
"RISCVOp",
"::",
"OPERAND_UIMM12",
":",
"Ok",
"=",
"isUInt",
"<",
"12",
">",
"(",
"Imm",
")",
";",
"break",
";",
"case",
"RISCVOp",
"::",
"OPERAND_SIMM12",
":",
"Ok",
"=",
"isInt",
"<",
"12",
">",
"(",
"Imm",
")",
";",
"break",
";",
"case",
"RISCVOp",
"::",
"OPERAND_UIMM20",
":",
"Ok",
"=",
"isUInt",
"<",
"20",
">",
"(",
"Imm",
")",
";",
"break",
";",
"case",
"RISCVOp",
"::",
"OPERAND_UIMMLOG2XLEN",
":",
"if",
"(",
"STI",
".",
"getTargetTriple",
"(",
")",
".",
"isArch64Bit",
"(",
")",
")",
"Ok",
"=",
"isUInt",
"<",
"6",
">",
"(",
"Imm",
")",
";",
"else",
"Ok",
"=",
"isUInt",
"<",
"5",
">",
"(",
"Imm",
")",
";",
"break",
";",
"case",
"RISCVOp",
"::",
"OPERAND_RVKRNUM",
":",
"Ok",
"=",
"Imm",
">=",
"0",
"&&",
"Imm",
"<=",
"10",
";",
"break",
";",
"}",
"if",
"(",
"!",
"Ok",
")",
"{",
"ErrInfo",
"=",
"\"Invalid immediate\"",
";",
"return",
"false",
";",
"}",
"}",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Perform",
"target-specific",
"instruction",
"verification",
"."
] | [
"RISCV",
"RISCV",
"RISCVOp::OPERAND_FIRST_RISCV_IMM",
"RISCVOp::OPERAND_LAST_RISCV_IMM",
"\"Unexpected operand type\"",
"RISCVOp::OPERAND_UIMM2",
"2",
"RISCVOp::OPERAND_UIMM3",
"3",
"RISCVOp::OPERAND_UIMM4",
"4",
"RISCVOp::OPERAND_UIMM5",
"5",
"RISCVOp::OPERAND_UIMM7",
"7",
"RISCVOp::OPERAND_UIMM12",
"12",
"RISCVOp::OPERAND_SIMM12",
"12",
"RISCVOp::OPERAND_UIMM20",
"20",
"RISCVOp::OPERAND_UIMMLOG2XLEN",
"6",
"5",
"RISCVOp::OPERAND_RVKRNUM",
"0",
"10",
"\"Invalid immediate\""
] | RISCVInstrInfo22 | verifyInstruction | RISCV | CPU | LLVM | 15,998 | 349 | 1 | [] |
[
"<s>",
"void",
"M680x0FrameLowering",
"::",
"emitSPUpdate",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"MBBI",
",",
"int64_t",
"NumBytes",
",",
"bool",
"InEpilogue",
")",
"const",
"{",
"bool",
"isSub",
"=",
"NumBytes",
"<",
"0",
";",
"uint64_t",
"Offset",
"=",
"isSub",
"?",
"-",
"NumBytes",
":",
"NumBytes",
";",
"uint64_t",
"Chunk",
"=",
"(",
"1LL",
"<<",
"31",
")",
"-",
"1",
";",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MBBI",
")",
";",
"while",
"(",
"Offset",
")",
"{",
"if",
"(",
"Offset",
">",
"Chunk",
")",
"{",
"unsigned",
"Reg",
"=",
"0",
";",
"if",
"(",
"isSub",
"&&",
"!",
"isRegLiveIn",
"(",
"MBB",
",",
"M680x0",
"::",
"D0",
")",
")",
"Reg",
"=",
"(",
"unsigned",
")",
"(",
"M680x0",
"::",
"D0",
")",
";",
"else",
"Reg",
"=",
"findDeadCallerSavedReg",
"(",
"MBB",
",",
"MBBI",
",",
"TRI",
")",
";",
"if",
"(",
"Reg",
")",
"{",
"unsigned",
"Opc",
"=",
"M680x0",
"::",
"MOV32ri",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"Reg",
")",
".",
"addImm",
"(",
"Offset",
")",
";",
"Opc",
"=",
"isSub",
"?",
"getSUBrrOpcode",
"(",
")",
":",
"getADDrrOpcode",
"(",
")",
";",
"MachineInstr",
"*",
"MI",
"=",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addReg",
"(",
"Reg",
")",
";",
"MI",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"Offset",
"=",
"0",
";",
"continue",
";",
"}",
"}",
"uint64_t",
"ThisVal",
"=",
"std",
"::",
"min",
"(",
"Offset",
",",
"Chunk",
")",
";",
"MachineInstrBuilder",
"MI",
"=",
"BuildStackAdjustment",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"isSub",
"?",
"-",
"ThisVal",
":",
"ThisVal",
",",
"InEpilogue",
")",
";",
"if",
"(",
"isSub",
")",
"MI",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"else",
"MI",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameDestroy",
")",
";",
"Offset",
"-=",
"ThisVal",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"a",
"series",
"of",
"instructions",
"to",
"increment",
"/",
"decrement",
"the",
"stack",
"pointer",
"by",
"a",
"constant",
"value",
"."
] | [
"M680x0",
"M680x0",
"0",
"1LL",
"31",
"1",
"0",
"M680x0::D0",
"M680x0::D0",
"M680x0::MOV32ri",
"3",
"0"
] | M680x0FrameLowering | emitSPUpdate | M680x0 | MPU | LLVM | 15,999 | 275 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.