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>",
"bool",
"AArch64A57FPLoadBalancing",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"F",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"F",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"F",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
".",
"balanceFPOps",
"(",
")",
")",
"return",
"false",
";",
"bool",
"Changed",
"=",
"false",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"***** AArch64A57FPLoadBalancing *****\\n\"",
")",
";",
"MRI",
"=",
"&",
"F",
".",
"getRegInfo",
"(",
")",
";",
"TRI",
"=",
"F",
".",
"getRegInfo",
"(",
")",
".",
"getTargetRegisterInfo",
"(",
")",
";",
"RCI",
".",
"runOnMachineFunction",
"(",
"F",
")",
";",
"for",
"(",
"auto",
"&",
"MBB",
":",
"F",
")",
"{",
"Changed",
"|=",
"runOnBasicBlock",
"(",
"MBB",
")",
";",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"\"***** AArch64A57FPLoadBalancing *****\\n\""
] | AArch64A57FPLoadBalancing12 | runOnMachineFunction | AArch64 | CPU | LLVM | 20,300 | 106 | 1 | [] |
[
"<s>",
"virtual",
"uint64_t",
"getMachineOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"const",
"MCOperand",
"&",
"MO",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"return",
"0",
";",
"}",
"</s>"
] | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"R600",
"0"
] | AMDGPUMCCodeEmitter2 | getMachineOpValue | R600 | GPU | LLVM | 20,301 | 32 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseInstrInfo",
"::",
"isReallyTriviallyReMaterializable",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"AAResults",
"*",
"AA",
")",
"const",
"{",
"return",
"isVCTP",
"(",
"&",
"MI",
")",
"&&",
"!",
"isPredicated",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"For",
"instructions",
"with",
"opcodes",
"for",
"which",
"the",
"M_REMATERIALIZABLE",
"flag",
"is",
"set",
",",
"this",
"hook",
"lets",
"the",
"target",
"specify",
"whether",
"the",
"instruction",
"is",
"actually",
"trivially",
"rematerializable",
",",
"taking",
"into",
"consideration",
"its",
"operands",
"."
] | [
"ARM",
"ARM"
] | ARMBaseInstrInfo110 | isReallyTriviallyReMaterializable | ARM | CPU | LLVM | 20,302 | 30 | 1 | [] |
[
"<s>",
"void",
"applyFixup",
"(",
"const",
"MCAssembler",
"&",
"Asm",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
"Target",
",",
"MutableArrayRef",
"<",
"char",
">",
"Data",
",",
"uint64_t",
"Value",
",",
"bool",
"IsResolved",
",",
"const",
"MCSubtargetInfo",
"*",
"STI",
")",
"const",
"override",
"{",
"unsigned",
"NumBytes",
"=",
"4",
";",
"Value",
"=",
"adjustFixupValue",
"(",
"Fixup",
",",
"Value",
")",
";",
"if",
"(",
"!",
"Value",
")",
"{",
"return",
";",
"}",
"unsigned",
"Offset",
"=",
"Fixup",
".",
"getOffset",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"NumBytes",
";",
"++",
"i",
")",
"{",
"Data",
"[",
"Offset",
"+",
"i",
"]",
"|=",
"uint8_t",
"(",
"(",
"Value",
">>",
"(",
"i",
"*",
"8",
")",
")",
"&",
"0xff",
")",
";",
"}",
"}",
"</s>"
] | [
"Apply",
"the",
"Value",
"for",
"given",
"Fixup",
"into",
"the",
"provided",
"data",
"fragment",
",",
"at",
"the",
"offset",
"specified",
"by",
"the",
"fixup",
"and",
"following",
"the",
"fixup",
"kind",
"as",
"appropriate",
"."
] | [
"UPT",
"4",
"0",
"8",
"0xff"
] | UPTAsmBackend | applyFixup | UPT | CPU | LLVM | 20,303 | 109 | 1 | [] |
[
"<s>",
"static",
"bool",
"nios2_small_section_name_p",
"(",
"const",
"char",
"*",
"section",
")",
"{",
"return",
"(",
"strcmp",
"(",
"section",
",",
"\".sbss\"",
")",
"==",
"0",
"||",
"startswith",
"(",
"section",
",",
"\".sbss.\"",
")",
"||",
"strcmp",
"(",
"section",
",",
"\".sdata\"",
")",
"==",
"0",
"||",
"startswith",
"(",
"section",
",",
"\".sdata.\"",
")",
"||",
"(",
"nios2_gprel_sec",
"&&",
"regexec",
"(",
"&",
"nios2_gprel_sec_regex",
",",
"section",
",",
"0",
",",
"NULL",
",",
"0",
")",
"==",
"0",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"SECTION",
"is",
"a",
"small",
"section",
"name",
"."
] | [
"nios2",
"\".sbss\"",
"0",
"\".sbss.\"",
"\".sdata\"",
"0",
"\".sdata.\"",
"0",
"0",
"0"
] | nios2 | nios2_small_section_name_p | nios2 | MPU | GCC | 20,304 | 66 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"Hexagon RDF optimizations\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Hexagon",
"\"Hexagon RDF optimizations\""
] | HexagonRDFOpt | getPassName | Hexagon | DSP | LLVM | 20,305 | 13 | 1 | [] |
[
"<s>",
"virtual",
"void",
"print",
"(",
"raw_ostream",
"&",
"O",
")",
"const",
"{",
"switch",
"(",
"Kind",
")",
"{",
"case",
"k_Tok",
":",
"O",
"<<",
"\"Token \"",
"<<",
"Tok",
";",
"break",
";",
"case",
"k_Reg",
":",
"O",
"<<",
"\"Register \"",
"<<",
"Reg",
";",
"break",
";",
"case",
"k_Imm",
":",
"O",
"<<",
"\"Immediate \"",
"<<",
"*",
"Imm",
";",
"break",
";",
"case",
"k_Mem",
":",
"O",
"<<",
"\"Memory \"",
";",
"O",
"<<",
"*",
"Mem",
".",
"Offset",
"<<",
"\"(\"",
"<<",
"Reg",
"<<",
"\")\"",
";",
"break",
";",
"case",
"k_IndReg",
":",
"O",
"<<",
"\"RegInd \"",
"<<",
"Reg",
";",
"break",
";",
"case",
"k_PostIndReg",
":",
"O",
"<<",
"\"PostInc \"",
"<<",
"Reg",
";",
"break",
";",
"}",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"MSP430",
"\"Token \"",
"\"Register \"",
"\"Immediate \"",
"\"Memory \"",
"\"(\"",
"\")\"",
"\"RegInd \"",
"\"PostInc \""
] | MSP430AsmParser | print | MSP430 | MPU | LLVM | 20,306 | 95 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"AArch64RegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
"CC",
")",
"const",
"{",
"bool",
"SCS",
"=",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"ShadowCallStack",
")",
";",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"GHC",
")",
"return",
"SCS",
"?",
"CSR_AArch64_NoRegs_SCS_RegMask",
":",
"CSR_AArch64_NoRegs_RegMask",
";",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"AnyReg",
")",
"return",
"SCS",
"?",
"CSR_AArch64_AllRegs_SCS_RegMask",
":",
"CSR_AArch64_AllRegs_RegMask",
";",
"if",
"(",
"MF",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
".",
"isTargetDarwin",
"(",
")",
")",
"{",
"if",
"(",
"SCS",
")",
"report_fatal_error",
"(",
"\"ShadowCallStack attribute not supported on Darwin.\"",
")",
";",
"return",
"getDarwinCallPreservedMask",
"(",
"MF",
",",
"CC",
")",
";",
"}",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"AArch64_VectorCall",
")",
"return",
"SCS",
"?",
"CSR_AArch64_AAVPCS_SCS_RegMask",
":",
"CSR_AArch64_AAVPCS_RegMask",
";",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"AArch64_SVE_VectorCall",
")",
"return",
"SCS",
"?",
"CSR_AArch64_SVE_AAPCS_SCS_RegMask",
":",
"CSR_AArch64_SVE_AAPCS_RegMask",
";",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"CFGuard_Check",
")",
"return",
"CSR_Win_AArch64_CFGuard_Check_RegMask",
";",
"if",
"(",
"MF",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
".",
"getTargetLowering",
"(",
")",
"->",
"supportSwiftError",
"(",
")",
"&&",
"MF",
".",
"getFunction",
"(",
")",
".",
"getAttributes",
"(",
")",
".",
"hasAttrSomewhere",
"(",
"Attribute",
"::",
"SwiftError",
")",
")",
"return",
"SCS",
"?",
"CSR_AArch64_AAPCS_SwiftError_SCS_RegMask",
":",
"CSR_AArch64_AAPCS_SwiftError_RegMask",
";",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"SwiftTail",
")",
"{",
"if",
"(",
"SCS",
")",
"report_fatal_error",
"(",
"\"ShadowCallStack attribute not supported with swifttail\"",
")",
";",
"return",
"CSR_AArch64_AAPCS_SwiftTail_RegMask",
";",
"}",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"PreserveMost",
")",
"return",
"SCS",
"?",
"CSR_AArch64_RT_MostRegs_SCS_RegMask",
":",
"CSR_AArch64_RT_MostRegs_RegMask",
";",
"else",
"return",
"SCS",
"?",
"CSR_AArch64_AAPCS_SCS_RegMask",
":",
"CSR_AArch64_AAPCS_RegMask",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"\"ShadowCallStack attribute not supported on Darwin.\"",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"\"ShadowCallStack attribute not supported with swifttail\"",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64RegisterInfo25 | getCallPreservedMask | AArch64 | CPU | LLVM | 20,307 | 229 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUInstrInfo",
"::",
"isPredicated",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"instruction",
"is",
"already",
"predicated",
"."
] | [
"R600"
] | AMDGPUInstrInfo10 | isPredicated | R600 | GPU | LLVM | 20,308 | 16 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"X86RegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
"CC",
")",
"const",
"{",
"const",
"X86Subtarget",
"&",
"Subtarget",
"=",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"bool",
"HasSSE",
"=",
"Subtarget",
".",
"hasSSE1",
"(",
")",
";",
"bool",
"HasAVX",
"=",
"Subtarget",
".",
"hasAVX",
"(",
")",
";",
"bool",
"HasAVX512",
"=",
"Subtarget",
".",
"hasAVX512",
"(",
")",
";",
"switch",
"(",
"CC",
")",
"{",
"case",
"CallingConv",
"::",
"GHC",
":",
"case",
"CallingConv",
"::",
"HiPE",
":",
"return",
"CSR_NoRegs_RegMask",
";",
"case",
"CallingConv",
"::",
"AnyReg",
":",
"if",
"(",
"HasAVX",
")",
"return",
"CSR_64_AllRegs_AVX_RegMask",
";",
"return",
"CSR_64_AllRegs_RegMask",
";",
"case",
"CallingConv",
"::",
"PreserveMost",
":",
"return",
"CSR_64_RT_MostRegs_RegMask",
";",
"case",
"CallingConv",
"::",
"PreserveAll",
":",
"if",
"(",
"HasAVX",
")",
"return",
"CSR_64_RT_AllRegs_AVX_RegMask",
";",
"return",
"CSR_64_RT_AllRegs_RegMask",
";",
"case",
"CallingConv",
"::",
"CXX_FAST_TLS",
":",
"if",
"(",
"Is64Bit",
")",
"return",
"CSR_64_TLS_Darwin_RegMask",
";",
"break",
";",
"case",
"CallingConv",
"::",
"Intel_OCL_BI",
":",
"{",
"if",
"(",
"HasAVX512",
"&&",
"IsWin64",
")",
"return",
"CSR_Win64_Intel_OCL_BI_AVX512_RegMask",
";",
"if",
"(",
"HasAVX512",
"&&",
"Is64Bit",
")",
"return",
"CSR_64_Intel_OCL_BI_AVX512_RegMask",
";",
"if",
"(",
"HasAVX",
"&&",
"IsWin64",
")",
"return",
"CSR_Win64_Intel_OCL_BI_AVX_RegMask",
";",
"if",
"(",
"HasAVX",
"&&",
"Is64Bit",
")",
"return",
"CSR_64_Intel_OCL_BI_AVX_RegMask",
";",
"if",
"(",
"!",
"HasAVX",
"&&",
"!",
"IsWin64",
"&&",
"Is64Bit",
")",
"return",
"CSR_64_Intel_OCL_BI_RegMask",
";",
"break",
";",
"}",
"CASE_OBF_MASK",
"(",
"0",
")",
"CASE_OBF_MASK",
"(",
"1",
")",
"CASE_OBF_MASK",
"(",
"2",
")",
"CASE_OBF_MASK",
"(",
"3",
")",
"CASE_OBF_MASK",
"(",
"4",
")",
"CASE_OBF_MASK",
"(",
"5",
")",
"CASE_OBF_MASK",
"(",
"6",
")",
"CASE_OBF_MASK",
"(",
"7",
")",
"CASE_OBF_MASK",
"(",
"8",
")",
"CASE_OBF_MASK",
"(",
"9",
")",
"case",
"CallingConv",
"::",
"HHVM",
":",
"return",
"CSR_64_HHVM_RegMask",
";",
"case",
"CallingConv",
"::",
"X86_RegCall",
":",
"if",
"(",
"Is64Bit",
")",
"{",
"if",
"(",
"IsWin64",
")",
"{",
"return",
"(",
"HasSSE",
"?",
"CSR_Win64_RegCall_RegMask",
":",
"CSR_Win64_RegCall_NoSSE_RegMask",
")",
";",
"}",
"else",
"{",
"return",
"(",
"HasSSE",
"?",
"CSR_SysV64_RegCall_RegMask",
":",
"CSR_SysV64_RegCall_NoSSE_RegMask",
")",
";",
"}",
"}",
"else",
"{",
"return",
"(",
"HasSSE",
"?",
"CSR_32_RegCall_RegMask",
":",
"CSR_32_RegCall_NoSSE_RegMask",
")",
";",
"}",
"case",
"CallingConv",
"::",
"Cold",
":",
"if",
"(",
"Is64Bit",
")",
"return",
"CSR_64_MostRegs_RegMask",
";",
"break",
";",
"case",
"CallingConv",
"::",
"Win64",
":",
"return",
"CSR_Win64_RegMask",
";",
"case",
"CallingConv",
"::",
"X86_64_SysV",
":",
"return",
"CSR_64_RegMask",
";",
"case",
"CallingConv",
"::",
"X86_INTR",
":",
"if",
"(",
"Is64Bit",
")",
"{",
"if",
"(",
"HasAVX512",
")",
"return",
"CSR_64_AllRegs_AVX512_RegMask",
";",
"if",
"(",
"HasAVX",
")",
"return",
"CSR_64_AllRegs_AVX_RegMask",
";",
"if",
"(",
"HasSSE",
")",
"return",
"CSR_64_AllRegs_RegMask",
";",
"return",
"CSR_64_AllRegs_NoSSE_RegMask",
";",
"}",
"else",
"{",
"if",
"(",
"HasAVX512",
")",
"return",
"CSR_32_AllRegs_AVX512_RegMask",
";",
"if",
"(",
"HasAVX",
")",
"return",
"CSR_32_AllRegs_AVX_RegMask",
";",
"if",
"(",
"HasSSE",
")",
"return",
"CSR_32_AllRegs_SSE_RegMask",
";",
"return",
"CSR_32_AllRegs_RegMask",
";",
"}",
"default",
":",
"break",
";",
"}",
"if",
"(",
"Is64Bit",
")",
"{",
"const",
"Function",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"bool",
"IsSwiftCC",
"=",
"Subtarget",
".",
"getTargetLowering",
"(",
")",
"->",
"supportSwiftError",
"(",
")",
"&&",
"F",
".",
"getAttributes",
"(",
")",
".",
"hasAttrSomewhere",
"(",
"Attribute",
"::",
"SwiftError",
")",
";",
"if",
"(",
"IsSwiftCC",
")",
"return",
"IsWin64",
"?",
"CSR_Win64_SwiftError_RegMask",
":",
"CSR_64_SwiftError_RegMask",
";",
"return",
"IsWin64",
"?",
"CSR_Win64_RegMask",
":",
"CSR_64_RegMask",
";",
"}",
"return",
"CSR_32_RegMask",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"X86",
"X86",
"X86"
] | X86RegisterInfo102 | getCallPreservedMask | X86 | CPU | LLVM | 20,309 | 448 | 1 | [] |
[
"<s>",
"void",
"X86InstrInfo",
"::",
"replaceBranchWithTailCall",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"BranchCond",
",",
"const",
"MachineInstr",
"&",
"TailCall",
")",
"const",
"{",
"assert",
"(",
"canMakeTailCallConditional",
"(",
"BranchCond",
",",
"TailCall",
")",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"while",
"(",
"I",
"!=",
"MBB",
".",
"begin",
"(",
")",
")",
"{",
"--",
"I",
";",
"if",
"(",
"I",
"->",
"isDebugValue",
"(",
")",
")",
"continue",
";",
"if",
"(",
"!",
"I",
"->",
"isBranch",
"(",
")",
")",
"assert",
"(",
"0",
"&&",
"\"Can't find the branch to replace!\"",
")",
";",
"X86",
"::",
"CondCode",
"CC",
"=",
"getCondFromBranchOpc",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
";",
"assert",
"(",
"BranchCond",
".",
"size",
"(",
")",
"==",
"1",
")",
";",
"if",
"(",
"CC",
"!=",
"BranchCond",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
")",
"continue",
";",
"break",
";",
"}",
"unsigned",
"Opc",
"=",
"TailCall",
".",
"getOpcode",
"(",
")",
"==",
"X86",
"::",
"TCRETURNdi",
"?",
"X86",
"::",
"TCRETURNdicc",
":",
"X86",
"::",
"TCRETURNdi64cc",
";",
"auto",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"MBB",
".",
"findDebugLoc",
"(",
"I",
")",
",",
"get",
"(",
"Opc",
")",
")",
";",
"MIB",
"->",
"addOperand",
"(",
"TailCall",
".",
"getOperand",
"(",
"0",
")",
")",
";",
"MIB",
".",
"addImm",
"(",
"0",
")",
";",
"MIB",
"->",
"addOperand",
"(",
"BranchCond",
"[",
"0",
"]",
")",
";",
"MIB",
".",
"copyImplicitOps",
"(",
"TailCall",
")",
";",
"LivePhysRegs",
"LiveRegs",
"(",
"&",
"getRegisterInfo",
"(",
")",
")",
";",
"LiveRegs",
".",
"addLiveOuts",
"(",
"MBB",
")",
";",
"SmallVector",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"MachineOperand",
"*",
">",
",",
"8",
">",
"Clobbers",
";",
"LiveRegs",
".",
"stepForward",
"(",
"*",
"MIB",
",",
"Clobbers",
")",
";",
"for",
"(",
"const",
"auto",
"&",
"C",
":",
"Clobbers",
")",
"{",
"MIB",
".",
"addReg",
"(",
"C",
".",
"first",
",",
"RegState",
"::",
"Implicit",
")",
";",
"MIB",
".",
"addReg",
"(",
"C",
".",
"first",
",",
"RegState",
"::",
"Implicit",
"|",
"RegState",
"::",
"Define",
")",
";",
"}",
"I",
"->",
"eraseFromParent",
"(",
")",
";",
"}",
"</s>"
] | [
"Replace",
"the",
"conditional",
"branch",
"in",
"MBB",
"with",
"a",
"conditional",
"tail",
"call",
"."
] | [
"X86",
"X86",
"0",
"\"Can't find the branch to replace!\"",
"X86::CondCode",
"1",
"0",
"X86::TCRETURNdi",
"X86::TCRETURNdicc",
"X86::TCRETURNdi64cc",
"0",
"0",
"0",
"8"
] | X86InstrInfo114 | replaceBranchWithTailCall | X86 | CPU | LLVM | 20,310 | 297 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_split_plus",
"(",
"rtx",
"x",
",",
"rtx",
"*",
"base_ptr",
",",
"HOST_WIDE_INT",
"*",
"offset_ptr",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
")",
"{",
"*",
"base_ptr",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"*",
"offset_ptr",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
";",
"}",
"else",
"{",
"*",
"base_ptr",
"=",
"x",
";",
"*",
"offset_ptr",
"=",
"0",
";",
"}",
"}",
"</s>"
] | [
"If",
"X",
"is",
"a",
"PLUS",
"of",
"a",
"CONST_INT",
",",
"return",
"the",
"two",
"terms",
"in",
"*",
"BASE_PTR",
"and",
"*",
"OFFSET_PTR",
".",
"Return",
"X",
"in",
"*",
"BASE_PTR",
"and",
"0",
"in",
"*",
"OFFSET_PTR",
"otherwise",
"."
] | [
"mips",
"1",
"0",
"1",
"0"
] | mips | mips_split_plus | mips | CPU | GCC | 20,311 | 74 | 1 | [] |
[
"<s>",
"void",
"PPCPassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createPPCEarlyReturnPass",
"(",
")",
",",
"false",
")",
";",
"addPass",
"(",
"createPPCBranchSelectionPass",
"(",
")",
",",
"false",
")",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC"
] | PPCTargetMachine13 | addPreEmitPass | PowerPC | CPU | LLVM | 20,312 | 36 | 1 | [] |
[
"<s>",
"Optional",
"<",
"MCFixupKind",
">",
"M88kMCAsmBackend",
"::",
"getFixupKind",
"(",
"StringRef",
"Name",
")",
"const",
"{",
"unsigned",
"Type",
"=",
"llvm",
"::",
"StringSwitch",
"<",
"unsigned",
">",
"(",
"Name",
")",
".",
"Default",
"(",
"-",
"1u",
")",
";",
"if",
"(",
"Type",
"!=",
"-",
"1u",
")",
"return",
"static_cast",
"<",
"MCFixupKind",
">",
"(",
"FirstLiteralRelocationKind",
"+",
"Type",
")",
";",
"return",
"None",
";",
"}",
"</s>"
] | [
"getFixupKind",
"-",
"Get",
"the",
"fixup",
"kind",
"of",
"this",
"expression",
"."
] | [
"M88k",
"M88k",
"1u",
"1u"
] | M88kMCAsmBackend | getFixupKind | M88k | MPU | LLVM | 20,313 | 54 | 1 | [] |
[
"<s>",
"static",
"int",
"calc_live_regs",
"(",
"int",
"*",
"count",
")",
"{",
"int",
"reg",
";",
"int",
"live_regs_mask",
"=",
"0",
";",
"*",
"count",
"=",
"0",
";",
"for",
"(",
"reg",
"=",
"0",
";",
"reg",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"reg",
"++",
")",
"{",
"if",
"(",
"regs_ever_live",
"[",
"reg",
"]",
"&&",
"!",
"call_used_regs",
"[",
"reg",
"]",
")",
"{",
"(",
"*",
"count",
")",
"++",
";",
"live_regs_mask",
"|=",
"(",
"1",
"<<",
"reg",
")",
";",
"}",
"}",
"return",
"live_regs_mask",
";",
"}",
"</s>"
] | [
"Work",
"out",
"the",
"registers",
"which",
"need",
"to",
"be",
"saved",
",",
"both",
"as",
"a",
"mask",
"and",
"a",
"count"
] | [
"mcore",
"0",
"0",
"0",
"1"
] | mcore3 | calc_live_regs | mcore | MPU | GCC | 20,314 | 70 | 1 | [] |
[
"<s>",
"static",
"bool",
"visium_can_change_mode_class",
"(",
"machine_mode",
"from",
",",
"machine_mode",
"to",
",",
"reg_class_t",
"rclass",
")",
"{",
"return",
"(",
"rclass",
"!=",
"MDB",
"||",
"GET_MODE_SIZE",
"(",
"from",
")",
"==",
"GET_MODE_SIZE",
"(",
"to",
")",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_CAN_CHANGE_MODE_CLASS",
".",
"It",
"'s",
"not",
"obvious",
"from",
"the",
"documentation",
"of",
"the",
"hook",
"that",
"MDB",
"can",
"not",
"change",
"mode",
".",
"However",
"difficulties",
"arise",
"from",
"expressions",
"of",
"the",
"form",
"(",
"subreg",
":",
"SI",
"(",
"reg",
":",
"DI",
"R_MDB",
")",
"0",
")",
"There",
"is",
"no",
"way",
"to",
"convert",
"that",
"reference",
"to",
"a",
"single",
"machine",
"register",
"and",
",",
"without",
"the",
"following",
"definition",
",",
"reload",
"will",
"quietly",
"convert",
"it",
"to",
"(",
"reg",
":",
"SI",
"R_MDB",
")",
"."
] | [
"visium"
] | visium | visium_can_change_mode_class | visium | Virtual ISA | GCC | 20,315 | 32 | 1 | [] |
[
"<s>",
"static",
"void",
"aarch64_define_unconditional_macros",
"(",
"cpp_reader",
"*",
"pfile",
")",
"{",
"builtin_define",
"(",
"\"__aarch64__\"",
")",
";",
"builtin_define",
"(",
"\"__ARM_64BIT_STATE\"",
")",
";",
"builtin_define",
"(",
"\"__ARM_ARCH_ISA_A64\"",
")",
";",
"builtin_define_with_int_value",
"(",
"\"__ARM_ALIGN_MAX_PWR\"",
",",
"28",
")",
";",
"builtin_define_with_int_value",
"(",
"\"__ARM_ALIGN_MAX_STACK_PWR\"",
",",
"16",
")",
";",
"builtin_define",
"(",
"\"__ARM_ARCH_8A\"",
")",
";",
"builtin_define_with_int_value",
"(",
"\"__ARM_ARCH_PROFILE\"",
",",
"AARCH64_ISA_V8_R",
"?",
"'R'",
":",
"'A'",
")",
";",
"builtin_define",
"(",
"\"__ARM_FEATURE_CLZ\"",
")",
";",
"builtin_define",
"(",
"\"__ARM_FEATURE_IDIV\"",
")",
";",
"builtin_define",
"(",
"\"__ARM_FEATURE_UNALIGNED\"",
")",
";",
"builtin_define",
"(",
"\"__ARM_PCS_AAPCS64\"",
")",
";",
"builtin_define_with_int_value",
"(",
"\"__ARM_SIZEOF_WCHAR_T\"",
",",
"WCHAR_TYPE_SIZE",
"/",
"8",
")",
";",
"builtin_define",
"(",
"\"__GCC_ASM_FLAG_OUTPUTS__\"",
")",
";",
"}",
"</s>"
] | [
"Define",
"the",
"macros",
"that",
"we",
"always",
"expect",
"to",
"have",
"on",
"AArch64",
"."
] | [
"aarch64",
"\"__aarch64__\"",
"\"__ARM_64BIT_STATE\"",
"\"__ARM_ARCH_ISA_A64\"",
"\"__ARM_ALIGN_MAX_PWR\"",
"28",
"\"__ARM_ALIGN_MAX_STACK_PWR\"",
"16",
"\"__ARM_ARCH_8A\"",
"\"__ARM_ARCH_PROFILE\"",
"\"__ARM_FEATURE_CLZ\"",
"\"__ARM_FEATURE_IDIV\"",
"\"__ARM_FEATURE_UNALIGNED\"",
"\"__ARM_PCS_AAPCS64\"",
"\"__ARM_SIZEOF_WCHAR_T\"",
"8",
"\"__GCC_ASM_FLAG_OUTPUTS__\""
] | aarch64-c | aarch64_define_unconditional_macros | aarch64 | CPU | GCC | 20,316 | 89 | 1 | [] |
[
"<s>",
"static",
"MipsOperand",
"*",
"CreateReg",
"(",
"unsigned",
"Index",
",",
"RegKind",
"RegKind",
",",
"const",
"MCRegisterInfo",
"*",
"RegInfo",
",",
"SMLoc",
"S",
",",
"SMLoc",
"E",
",",
"MipsAsmParser",
"&",
"Parser",
")",
"{",
"MipsOperand",
"*",
"Op",
"=",
"new",
"MipsOperand",
"(",
"k_RegisterIndex",
",",
"Parser",
")",
";",
"Op",
"->",
"RegIdx",
".",
"Index",
"=",
"Index",
";",
"Op",
"->",
"RegIdx",
".",
"RegInfo",
"=",
"RegInfo",
";",
"Op",
"->",
"RegIdx",
".",
"Kind",
"=",
"RegKind",
";",
"Op",
"->",
"StartLoc",
"=",
"S",
";",
"Op",
"->",
"EndLoc",
"=",
"E",
";",
"return",
"Op",
";",
"}",
"</s>"
] | [
"CreateReg",
"-",
"Allocate",
"a",
"single",
"virtual",
"register",
"for",
"the",
"given",
"type",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips",
"Mips"
] | MipsAsmParser43 | CreateReg | Mips | CPU | LLVM | 20,317 | 79 | 1 | [] |
[
"<s>",
"void",
"load_got_register",
"(",
"void",
")",
"{",
"if",
"(",
"!",
"global_offset_table_rtx",
")",
"global_offset_table_rtx",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"GLOBAL_OFFSET_TABLE_REGNUM",
")",
";",
"if",
"(",
"TARGET_VXWORKS_RTP",
")",
"emit_insn",
"(",
"gen_vxworks_load_got",
"(",
")",
")",
";",
"else",
"{",
"if",
"(",
"!",
"got_helper_rtx",
")",
"{",
"char",
"name",
"[",
"32",
"]",
";",
"get_pc_thunk_name",
"(",
"name",
",",
"GLOBAL_OFFSET_TABLE_REGNUM",
")",
";",
"got_helper_rtx",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"ggc_strdup",
"(",
"name",
")",
")",
";",
"}",
"emit_insn",
"(",
"gen_load_pcrel_sym",
"(",
"global_offset_table_rtx",
",",
"sparc_got",
"(",
")",
",",
"got_helper_rtx",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"code",
"to",
"load",
"the",
"GOT",
"register",
"."
] | [
"sparc",
"32"
] | sparc7 | load_got_register | sparc | CPU | GCC | 20,318 | 81 | 1 | [] |
[
"<s>",
"int",
"sparc_initial_elimination_offset",
"(",
"int",
"to",
")",
"{",
"int",
"offset",
";",
"if",
"(",
"to",
"==",
"STACK_POINTER_REGNUM",
")",
"offset",
"=",
"sparc_compute_frame_size",
"(",
"get_frame_size",
"(",
")",
",",
"crtl",
"->",
"is_leaf",
")",
";",
"else",
"offset",
"=",
"0",
";",
"offset",
"+=",
"SPARC_STACK_BIAS",
";",
"return",
"offset",
";",
"}",
"</s>"
] | [
"Implement",
"the",
"macro",
"INITIAL_ELIMINATION_OFFSET",
",",
"return",
"the",
"OFFSET",
"."
] | [
"sparc",
"0"
] | sparc | sparc_initial_elimination_offset | sparc | CPU | GCC | 20,319 | 42 | 1 | [] |
[
"<s>",
"bool",
"SIAnnotateControlFlow",
"::",
"isUniform",
"(",
"BranchInst",
"*",
"T",
")",
"{",
"return",
"DA",
"->",
"isUniform",
"(",
"T",
")",
"||",
"T",
"->",
"getMetadata",
"(",
"\"structurizecfg.uniform\"",
")",
"!=",
"nullptr",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"value",
"V",
"is",
"uniform",
"across",
"VF",
"lanes",
",",
"when",
"VF",
"is",
"provided",
",",
"and",
"otherwise",
"if",
"V",
"is",
"invariant",
"across",
"all",
"loop",
"iterations",
"."
] | [
"AMDGPU",
"SI",
"\"structurizecfg.uniform\""
] | SIAnnotateControlFlow19 | isUniform | AMDGPU | GPU | LLVM | 20,320 | 28 | 1 | [] |
[
"<s>",
"unsigned",
"NyuziInstrInfo",
"::",
"isLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"Nyuzi",
"::",
"LW",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"Nyuzi",
"::",
"BLOCK_LOADI",
")",
"{",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isFI",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
"{",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isLoadFromStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"destination",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"Nyuzi",
"Nyuzi",
"Nyuzi::LW",
"Nyuzi::BLOCK_LOADI",
"1",
"2",
"2",
"0",
"1",
"0",
"0"
] | NyuziInstrInfo | isLoadFromStackSlot | Nyuzi | GPU | LLVM | 20,321 | 108 | 1 | [] |
[
"<s>",
"SDValue",
"VETargetLowering",
"::",
"lowerToVVP",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"auto",
"OCOpt",
"=",
"getVVPOpcode",
"(",
"Op",
"->",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"!",
"OCOpt",
".",
"hasValue",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"unsigned",
"VVPOC",
"=",
"OCOpt",
".",
"getValue",
"(",
")",
";",
"EVT",
"OpVecVT",
"=",
"Op",
".",
"getValueType",
"(",
")",
";",
"EVT",
"LegalVecVT",
"=",
"getTypeToTransformTo",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"OpVecVT",
")",
";",
"SDLoc",
"DL",
"(",
"Op",
")",
";",
"SDValue",
"AVL",
"=",
"DAG",
".",
"getConstant",
"(",
"OpVecVT",
".",
"getVectorNumElements",
"(",
")",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
";",
"MVT",
"MaskVT",
"=",
"MVT",
"::",
"v256i1",
";",
"SDValue",
"ConstTrue",
"=",
"DAG",
".",
"getConstant",
"(",
"1",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
";",
"SDValue",
"Mask",
"=",
"DAG",
".",
"getNode",
"(",
"VEISD",
"::",
"VEC_BROADCAST",
",",
"DL",
",",
"MaskVT",
",",
"ConstTrue",
")",
";",
"bool",
"IsBinaryOp",
"=",
"false",
";",
"switch",
"(",
"VVPOC",
")",
"{",
"case",
"VEISD",
"::",
"VVPNAME",
":",
"\\",
"IsBinaryOp",
"=",
"true",
";",
"\\",
"break",
";",
"}",
"if",
"(",
"IsBinaryOp",
")",
"{",
"assert",
"(",
"LegalVecVT",
".",
"isSimple",
"(",
")",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"VVPOC",
",",
"DL",
",",
"LegalVecVT",
",",
"Op",
"->",
"getOperand",
"(",
"0",
")",
",",
"Op",
"->",
"getOperand",
"(",
"1",
")",
",",
"Mask",
",",
"AVL",
")",
";",
"}",
"llvm_unreachable",
"(",
"\"lowerToVVP called for unexpected SDNode.\"",
")",
";",
"}",
"</s>"
] | [
"}",
"Custom",
"Inserter"
] | [
"VE",
"VE",
"MVT::i32",
"MVT::v256i1",
"1",
"MVT::i32",
"VEISD::VEC_BROADCAST",
"VEISD::VVPNAME",
"0",
"1",
"\"lowerToVVP called for unexpected SDNode.\""
] | VEISelLowering12 | lowerToVVP | VE | CPU | LLVM | 20,322 | 215 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"shouldInsertFencesForAtomic",
"(",
"const",
"Instruction",
"*",
"I",
")",
"const",
"{",
"return",
"isOpSuitableForLDPSTP",
"(",
"I",
")",
";",
"}",
"</s>"
] | [
"Helper",
"functions",
"for",
"atomic",
"operations",
"."
] | [
"AArch64",
"AArch64"
] | AArch64ISelLowering (2)2 | shouldInsertFencesForAtomic | AArch64 | CPU | LLVM | 20,323 | 19 | 1 | [] |
[
"<s>",
"static",
"bool",
"load_insn_p",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"!=",
"SET",
")",
"return",
"false",
";",
"switch",
"(",
"get_attr_type",
"(",
"insn",
")",
")",
"{",
"case",
"TYPE_LOAD",
":",
"case",
"TYPE_SLOAD",
":",
"case",
"TYPE_FPLOAD",
":",
"return",
"true",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"</s>"
] | [
"True",
"if",
"INSN",
"is",
"a",
"load",
"instruction",
"."
] | [
"sparc"
] | sparc | load_insn_p | sparc | CPU | GCC | 20,324 | 51 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"SystemZ Instruction Shortening\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"SystemZ",
"\"SystemZ Instruction Shortening\""
] | SystemZShortenInst | getPassName | SystemZ | CPU | LLVM | 20,325 | 13 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"MSP430TargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"(",
"MSP430ISD",
"::",
"NodeType",
")",
"Opcode",
")",
"{",
"case",
"MSP430ISD",
"::",
"FIRST_NUMBER",
":",
"break",
";",
"case",
"MSP430ISD",
"::",
"RET_FLAG",
":",
"return",
"\"MSP430ISD::RET_FLAG\"",
";",
"case",
"MSP430ISD",
"::",
"RETI_FLAG",
":",
"return",
"\"MSP430ISD::RETI_FLAG\"",
";",
"case",
"MSP430ISD",
"::",
"RRA",
":",
"return",
"\"MSP430ISD::RRA\"",
";",
"case",
"MSP430ISD",
"::",
"RLA",
":",
"return",
"\"MSP430ISD::RLA\"",
";",
"case",
"MSP430ISD",
"::",
"RRC",
":",
"return",
"\"MSP430ISD::RRC\"",
";",
"case",
"MSP430ISD",
"::",
"RRCL",
":",
"return",
"\"MSP430ISD::RRCL\"",
";",
"case",
"MSP430ISD",
"::",
"CALL",
":",
"return",
"\"MSP430ISD::CALL\"",
";",
"case",
"MSP430ISD",
"::",
"Wrapper",
":",
"return",
"\"MSP430ISD::Wrapper\"",
";",
"case",
"MSP430ISD",
"::",
"BR_CC",
":",
"return",
"\"MSP430ISD::BR_CC\"",
";",
"case",
"MSP430ISD",
"::",
"CMP",
":",
"return",
"\"MSP430ISD::CMP\"",
";",
"case",
"MSP430ISD",
"::",
"SETCC",
":",
"return",
"\"MSP430ISD::SETCC\"",
";",
"case",
"MSP430ISD",
"::",
"SELECT_CC",
":",
"return",
"\"MSP430ISD::SELECT_CC\"",
";",
"case",
"MSP430ISD",
"::",
"DADD",
":",
"return",
"\"MSP430ISD::DADD\"",
";",
"}",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"MSP430",
"MSP430",
"MSP430ISD::NodeType",
"MSP430ISD::FIRST_NUMBER",
"MSP430ISD::RET_FLAG",
"\"MSP430ISD::RET_FLAG\"",
"MSP430ISD::RETI_FLAG",
"\"MSP430ISD::RETI_FLAG\"",
"MSP430ISD::RRA",
"\"MSP430ISD::RRA\"",
"MSP430ISD::RLA",
"\"MSP430ISD::RLA\"",
"MSP430ISD::RRC",
"\"MSP430ISD::RRC\"",
"MSP430ISD::RRCL",
"\"MSP430ISD::RRCL\"",
"MSP430ISD::CALL",
"\"MSP430ISD::CALL\"",
"MSP430ISD::Wrapper",
"\"MSP430ISD::Wrapper\"",
"MSP430ISD::BR_CC",
"\"MSP430ISD::BR_CC\"",
"MSP430ISD::CMP",
"\"MSP430ISD::CMP\"",
"MSP430ISD::SETCC",
"\"MSP430ISD::SETCC\"",
"MSP430ISD::SELECT_CC",
"\"MSP430ISD::SELECT_CC\"",
"MSP430ISD::DADD",
"\"MSP430ISD::DADD\""
] | MSP430ISelLowering (2)1 | getTargetNodeName | MSP430 | MPU | LLVM | 20,326 | 138 | 1 | [] |
[
"<s>",
"static",
"void",
"nios2_print_operand_address",
"(",
"FILE",
"*",
"file",
",",
"machine_mode",
"mode",
",",
"rtx",
"op",
")",
"{",
"switch",
"(",
"GET_CODE",
"(",
"op",
")",
")",
"{",
"case",
"CONST",
":",
"case",
"CONST_INT",
":",
"case",
"LABEL_REF",
":",
"case",
"CONST_DOUBLE",
":",
"case",
"SYMBOL_REF",
":",
"if",
"(",
"gprel_constant_p",
"(",
"op",
")",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"%%gprel(\"",
")",
";",
"output_addr_const",
"(",
"file",
",",
"op",
")",
";",
"fprintf",
"(",
"file",
",",
"\")(%s)\"",
",",
"reg_names",
"[",
"GP_REGNO",
"]",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"r0rel_constant_p",
"(",
"op",
")",
")",
"{",
"if",
"(",
"CONST_INT_P",
"(",
"op",
")",
")",
"{",
"output_addr_const",
"(",
"file",
",",
"op",
")",
";",
"fprintf",
"(",
"file",
",",
"\"(r0)\"",
")",
";",
"return",
";",
"}",
"else",
"{",
"fprintf",
"(",
"file",
",",
"\"%%lo(\"",
")",
";",
"output_addr_const",
"(",
"file",
",",
"op",
")",
";",
"fprintf",
"(",
"file",
",",
"\")(r0)\"",
")",
";",
"return",
";",
"}",
"}",
"break",
";",
"case",
"PLUS",
":",
"{",
"rtx",
"op0",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"rtx",
"op1",
"=",
"XEXP",
"(",
"op",
",",
"1",
")",
";",
"if",
"(",
"REG_P",
"(",
"op0",
")",
"&&",
"CONSTANT_P",
"(",
"op1",
")",
")",
"{",
"output_addr_const",
"(",
"file",
",",
"op1",
")",
";",
"fprintf",
"(",
"file",
",",
"\"(%s)\"",
",",
"reg_names",
"[",
"REGNO",
"(",
"op0",
")",
"]",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"REG_P",
"(",
"op1",
")",
"&&",
"CONSTANT_P",
"(",
"op0",
")",
")",
"{",
"output_addr_const",
"(",
"file",
",",
"op0",
")",
";",
"fprintf",
"(",
"file",
",",
"\"(%s)\"",
",",
"reg_names",
"[",
"REGNO",
"(",
"op1",
")",
"]",
")",
";",
"return",
";",
"}",
"}",
"break",
";",
"case",
"LO_SUM",
":",
"{",
"rtx",
"op0",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"rtx",
"op1",
"=",
"XEXP",
"(",
"op",
",",
"1",
")",
";",
"if",
"(",
"REG_P",
"(",
"op0",
")",
"&&",
"CONSTANT_P",
"(",
"op1",
")",
")",
"{",
"nios2_print_operand",
"(",
"file",
",",
"op1",
",",
"'L'",
")",
";",
"fprintf",
"(",
"file",
",",
"\"(%s)\"",
",",
"reg_names",
"[",
"REGNO",
"(",
"op0",
")",
"]",
")",
";",
"return",
";",
"}",
"}",
"break",
";",
"case",
"REG",
":",
"fprintf",
"(",
"file",
",",
"\"0(%s)\"",
",",
"reg_names",
"[",
"REGNO",
"(",
"op",
")",
"]",
")",
";",
"return",
";",
"case",
"MEM",
":",
"{",
"rtx",
"base",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"nios2_print_operand_address",
"(",
"file",
",",
"mode",
",",
"base",
")",
";",
"return",
";",
"}",
"default",
":",
"break",
";",
"}",
"fprintf",
"(",
"stderr",
",",
"\"Missing way to print address\\n\"",
")",
";",
"debug_rtx",
"(",
"op",
")",
";",
"gcc_unreachable",
"(",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_PRINT_OPERAND_ADDRESS",
"."
] | [
"nios2",
"\"%%gprel(\"",
"\")(%s)\"",
"\"(r0)\"",
"\"%%lo(\"",
"\")(r0)\"",
"0",
"1",
"\"(%s)\"",
"\"(%s)\"",
"0",
"1",
"\"(%s)\"",
"\"0(%s)\"",
"0",
"\"Missing way to print address\\n\""
] | nios2 | nios2_print_operand_address | nios2 | MPU | GCC | 20,327 | 377 | 1 | [] |
[
"<s>",
"void",
"assignValueToAddress",
"(",
"Register",
"ValVReg",
",",
"Register",
"Addr",
",",
"uint64_t",
"Size",
",",
"MachinePointerInfo",
"&",
"MPO",
",",
"CCValAssign",
"&",
"VA",
")",
"override",
"{",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"LocInfo",
"::",
"AExt",
")",
"{",
"Size",
"=",
"VA",
".",
"getLocVT",
"(",
")",
".",
"getSizeInBits",
"(",
")",
"/",
"8",
";",
"ValVReg",
"=",
"MIRBuilder",
".",
"buildAnyExt",
"(",
"LLT",
"::",
"scalar",
"(",
"Size",
"*",
"8",
")",
",",
"ValVReg",
")",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"auto",
"MMO",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
".",
"getMachineMemOperand",
"(",
"MPO",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"Size",
",",
"1",
")",
";",
"MIRBuilder",
".",
"buildStore",
"(",
"ValVReg",
",",
"Addr",
",",
"*",
"MMO",
")",
";",
"}",
"</s>"
] | [
"An",
"overload",
"which",
"takes",
"an",
"ArgInfo",
"if",
"additional",
"information",
"about",
"the",
"arg",
"is",
"needed",
"."
] | [
"AArch64",
"8",
"8",
"0",
"1"
] | AArch64CallLowering14 | assignValueToAddress | AArch64 | CPU | LLVM | 20,328 | 114 | 1 | [] |
[
"<s>",
"EVT",
"PTXTargetLowering",
"::",
"getSetCCResultType",
"(",
"EVT",
"VT",
")",
"const",
"{",
"return",
"MVT",
"::",
"i1",
";",
"}",
"</s>"
] | [
"Return",
"the",
"value",
"type",
"to",
"use",
"for",
"ISD",
":",
":SETCC",
"."
] | [
"PTX",
"PTX",
"MVT::i1"
] | PTXISelLowering | getSetCCResultType | PTX | GPU | LLVM | 20,329 | 16 | 1 | [] |
[
"<s>",
"void",
"HexagonFrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"auto",
"&",
"HST",
"=",
"static_cast",
"<",
"const",
"HexagonSubtarget",
"&",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
")",
";",
"auto",
"&",
"HRI",
"=",
"*",
"HST",
".",
"getRegisterInfo",
"(",
")",
";",
"assert",
"(",
"&",
"MF",
".",
"front",
"(",
")",
"==",
"&",
"MBB",
"&&",
"\"Shrink-wrapping not yet supported\"",
")",
";",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
"=",
"MFI",
"->",
"getCalleeSavedInfo",
"(",
")",
";",
"MachineBasicBlock",
"*",
"PrologB",
"=",
"&",
"MF",
".",
"front",
"(",
")",
",",
"*",
"EpilogB",
"=",
"nullptr",
";",
"if",
"(",
"EnableShrinkWrapping",
")",
"findShrunkPrologEpilog",
"(",
"MF",
",",
"PrologB",
",",
"EpilogB",
")",
";",
"insertCSRSpillsInBlock",
"(",
"*",
"PrologB",
",",
"CSI",
",",
"HRI",
")",
";",
"insertPrologueInBlock",
"(",
"*",
"PrologB",
")",
";",
"if",
"(",
"EpilogB",
")",
"{",
"insertCSRRestoresInBlock",
"(",
"*",
"EpilogB",
",",
"CSI",
",",
"HRI",
")",
";",
"insertEpilogueInBlock",
"(",
"*",
"EpilogB",
")",
";",
"}",
"else",
"{",
"for",
"(",
"auto",
"&",
"B",
":",
"MF",
")",
"if",
"(",
"!",
"B",
".",
"empty",
"(",
")",
"&&",
"B",
".",
"back",
"(",
")",
".",
"isReturn",
"(",
")",
")",
"insertCSRRestoresInBlock",
"(",
"B",
",",
"CSI",
",",
"HRI",
")",
";",
"for",
"(",
"auto",
"&",
"B",
":",
"MF",
")",
"if",
"(",
"!",
"B",
".",
"empty",
"(",
")",
"&&",
"B",
".",
"back",
"(",
")",
".",
"isReturn",
"(",
")",
")",
"insertEpilogueInBlock",
"(",
"B",
")",
";",
"}",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"\"Shrink-wrapping not yet supported\""
] | HexagonFrameLowering52 | emitPrologue | Hexagon | DSP | LLVM | 20,330 | 224 | 1 | [] |
[
"<s>",
"static",
"tree",
"tilepro_build_builtin_va_list",
"(",
"void",
")",
"{",
"tree",
"f_args",
",",
"f_skip",
",",
"record",
",",
"type_decl",
";",
"bool",
"owp",
";",
"record",
"=",
"lang_hooks",
".",
"types",
".",
"make_type",
"(",
"RECORD_TYPE",
")",
";",
"type_decl",
"=",
"build_decl",
"(",
"BUILTINS_LOCATION",
",",
"TYPE_DECL",
",",
"get_identifier",
"(",
"\"__va_list_tag\"",
")",
",",
"record",
")",
";",
"f_args",
"=",
"build_decl",
"(",
"BUILTINS_LOCATION",
",",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"__args\"",
")",
",",
"ptr_type_node",
")",
";",
"f_skip",
"=",
"build_decl",
"(",
"BUILTINS_LOCATION",
",",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"__skip\"",
")",
",",
"ptr_type_node",
")",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_args",
")",
"=",
"record",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_skip",
")",
"=",
"record",
";",
"TREE_CHAIN",
"(",
"record",
")",
"=",
"type_decl",
";",
"TYPE_NAME",
"(",
"record",
")",
"=",
"type_decl",
";",
"TYPE_FIELDS",
"(",
"record",
")",
"=",
"f_args",
";",
"TREE_CHAIN",
"(",
"f_args",
")",
"=",
"f_skip",
";",
"owp",
"=",
"warn_padded",
";",
"warn_padded",
"=",
"false",
";",
"layout_type",
"(",
"record",
")",
";",
"warn_padded",
"=",
"owp",
";",
"return",
"record",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_BUILD_BUILTIN_VA_LIST",
"."
] | [
"tilepro",
"\"__va_list_tag\"",
"\"__args\"",
"\"__skip\""
] | tilepro | tilepro_build_builtin_va_list | tilepro | VLIW | GCC | 20,331 | 141 | 1 | [] |
[
"<s>",
"bool",
"SPIRVModuleAnalysis",
"::",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"{",
"SPIRVTargetMachine",
"&",
"TM",
"=",
"getAnalysis",
"<",
"TargetPassConfig",
">",
"(",
")",
".",
"getTM",
"<",
"SPIRVTargetMachine",
">",
"(",
")",
";",
"ST",
"=",
"TM",
".",
"getSubtargetImpl",
"(",
")",
";",
"GR",
"=",
"ST",
"->",
"getSPIRVGlobalRegistry",
"(",
")",
";",
"TII",
"=",
"ST",
"->",
"getInstrInfo",
"(",
")",
";",
"MMI",
"=",
"&",
"getAnalysis",
"<",
"MachineModuleInfoWrapperPass",
">",
"(",
")",
".",
"getMMI",
"(",
")",
";",
"setBaseInfo",
"(",
"M",
")",
";",
"collectReqs",
"(",
"M",
",",
"MAI",
",",
"MMI",
",",
"*",
"ST",
")",
";",
"processSwitches",
"(",
"M",
",",
"MAI",
",",
"MMI",
")",
";",
"processDefInstrs",
"(",
"M",
")",
";",
"numberRegistersGlobally",
"(",
"M",
")",
";",
"processOtherInstrs",
"(",
"M",
")",
";",
"if",
"(",
"MAI",
".",
"MS",
"[",
"SPIRV",
"::",
"MB_EntryPoints",
"]",
".",
"empty",
"(",
")",
")",
"MAI",
".",
"Reqs",
".",
"addCapability",
"(",
"Capability",
"::",
"Linkage",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] | [
"SPIRV",
"SPIRV",
"SPIRV",
"SPIRV",
"SPIRV",
"SPIRV::MB_EntryPoints"
] | SPIRVModuleAnalysis1 | runOnModule | SPIRV | Virtual ISA | LLVM | 20,332 | 137 | 1 | [] |
[
"<s>",
"SDValue",
"AMDGPUTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"Op",
".",
"getNode",
"(",
")",
"->",
"dump",
"(",
")",
";",
"assert",
"(",
"0",
"&&",
"\"Custom lowering code for this\"",
"\"instruction is not implemented yet!\"",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SDIV",
":",
"return",
"LowerSDIV",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SREM",
":",
"return",
"LowerSREM",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND_INREG",
":",
"return",
"LowerSIGN_EXTEND_INREG",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BRCOND",
":",
"return",
"LowerBRCOND",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"LowerINTRINSIC_WO_CHAIN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"UDIVREM",
":",
"return",
"LowerUDIVREM",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"return",
"Op",
";",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"R600",
"0",
"\"Custom lowering code for this\"",
"\"instruction is not implemented yet!\"",
"ISD::SDIV",
"ISD::SREM",
"ISD::SIGN_EXTEND_INREG",
"SI",
"ISD::BRCOND",
"ISD::INTRINSIC_WO_CHAIN",
"SI",
"ISD::UDIVREM"
] | AMDGPUISelLowering131 | LowerOperation | R600 | GPU | LLVM | 20,333 | 128 | 1 | [] |
[
"<s>",
"SMLoc",
"getStartLoc",
"(",
")",
"const",
"override",
"{",
"return",
"StartLoc",
";",
"}",
"</s>"
] | [
"getStartLoc",
"-",
"Get",
"the",
"location",
"of",
"the",
"first",
"token",
"of",
"this",
"operand",
"."
] | [
"LC2200"
] | LC2200AsmParser | getStartLoc | LC2200 | CPU | LLVM | 20,334 | 11 | 1 | [] |
[
"<s>",
"bool",
"ARMAsmPrinter",
"::",
"lowerOperand",
"(",
"const",
"MachineOperand",
"&",
"MO",
",",
"MCOperand",
"&",
"MCOp",
")",
"{",
"switch",
"(",
"MO",
".",
"getType",
"(",
")",
")",
"{",
"default",
":",
"assert",
"(",
"0",
"&&",
"\"unknown operand type\"",
")",
";",
"return",
"false",
";",
"case",
"MachineOperand",
"::",
"MO_Register",
":",
"if",
"(",
"MO",
".",
"isImplicit",
"(",
")",
"&&",
"MO",
".",
"getReg",
"(",
")",
"!=",
"ARM",
"::",
"CPSR",
")",
"return",
"false",
";",
"assert",
"(",
"!",
"MO",
".",
"getSubReg",
"(",
")",
"&&",
"\"Subregs should be eliminated!\"",
")",
";",
"MCOp",
"=",
"MCOperand",
"::",
"CreateReg",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_Immediate",
":",
"MCOp",
"=",
"MCOperand",
"::",
"CreateImm",
"(",
"MO",
".",
"getImm",
"(",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_MachineBasicBlock",
":",
"MCOp",
"=",
"MCOperand",
"::",
"CreateExpr",
"(",
"MCSymbolRefExpr",
"::",
"Create",
"(",
"MO",
".",
"getMBB",
"(",
")",
"->",
"getSymbol",
"(",
")",
",",
"OutContext",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_GlobalAddress",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"Mang",
"->",
"getSymbol",
"(",
"MO",
".",
"getGlobal",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_ExternalSymbol",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"GetExternalSymbolSymbol",
"(",
"MO",
".",
"getSymbolName",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_JumpTableIndex",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"GetJTISymbol",
"(",
"MO",
".",
"getIndex",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_ConstantPoolIndex",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"GetCPISymbol",
"(",
"MO",
".",
"getIndex",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_BlockAddress",
":",
"MCOp",
"=",
"GetSymbolRef",
"(",
"MO",
",",
"GetBlockAddressSymbol",
"(",
"MO",
".",
"getBlockAddress",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_FPImmediate",
":",
"{",
"APFloat",
"Val",
"=",
"MO",
".",
"getFPImm",
"(",
")",
"->",
"getValueAPF",
"(",
")",
";",
"bool",
"ignored",
";",
"Val",
".",
"convert",
"(",
"APFloat",
"::",
"IEEEdouble",
",",
"APFloat",
"::",
"rmTowardZero",
",",
"&",
"ignored",
")",
";",
"MCOp",
"=",
"MCOperand",
"::",
"CreateFPImm",
"(",
"Val",
".",
"convertToDouble",
"(",
")",
")",
";",
"break",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Wrapper",
"for",
"MCInstLowering.lowerOperand",
"(",
")",
"for",
"the",
"tblgen'erated",
"pseudo",
"lowering",
"."
] | [
"ARM",
"ARM",
"0",
"\"unknown operand type\"",
"ARM::CPSR",
"\"Subregs should be eliminated!\""
] | ARMMCInstLower39 | lowerOperand | ARM | CPU | LLVM | 20,335 | 316 | 1 | [] |
[
"<s>",
"virtual",
"MachineInstr",
"*",
"foldMemoryOperandImpl",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineInstr",
"*",
"MI",
",",
"const",
"SmallVectorImpl",
"<",
"unsigned",
">",
"&",
"Ops",
",",
"MachineInstr",
"*",
"LoadMI",
")",
"const",
"{",
"return",
"0",
";",
"}",
"</s>"
] | [
"foldMemoryOperand",
"-",
"Same",
"as",
"the",
"previous",
"version",
"except",
"it",
"allows",
"folding",
"of",
"any",
"load",
"and",
"store",
"from",
"/",
"to",
"any",
"address",
",",
"not",
"just",
"from",
"a",
"specific",
"stack",
"slot",
"."
] | [
"CellSPU",
"0"
] | SPUInstrInfo1 | foldMemoryOperandImpl | CellSPU | MPU | LLVM | 20,336 | 31 | 1 | [] |
[
"<s>",
"static",
"bool",
"mcore_hard_regno_mode_ok",
"(",
"unsigned",
"int",
"regno",
",",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"TARGET_8ALIGN",
"&&",
"GET_MODE_SIZE",
"(",
"mode",
")",
">",
"UNITS_PER_WORD",
")",
"return",
"(",
"regno",
"&",
"1",
")",
"==",
"0",
";",
"return",
"regno",
"<",
"18",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_HARD_REGNO_MODE_OK",
".",
"We",
"may",
"keep",
"double",
"values",
"in",
"even",
"registers",
"."
] | [
"mcore",
"1",
"0",
"18"
] | mcore | mcore_hard_regno_mode_ok | mcore | MPU | GCC | 20,337 | 38 | 1 | [] |
[
"<s>",
"void",
"PPCSubtarget",
"::",
"overrideSchedPolicy",
"(",
"MachineSchedPolicy",
"&",
"Policy",
",",
"MachineInstr",
"*",
"begin",
",",
"MachineInstr",
"*",
"end",
",",
"unsigned",
"NumRegionInstrs",
")",
"const",
"{",
"if",
"(",
"needsAggressiveScheduling",
"(",
"DarwinDirective",
")",
")",
"{",
"Policy",
".",
"OnlyTopDown",
"=",
"false",
";",
"Policy",
".",
"OnlyBottomUp",
"=",
"false",
";",
"}",
"Policy",
".",
"ShouldTrackPressure",
"=",
"true",
";",
"}",
"</s>"
] | [
"Override",
"generic",
"scheduling",
"policy",
"within",
"a",
"region",
"."
] | [
"PowerPC",
"PPC"
] | PPCSubtarget (2) | overrideSchedPolicy | PowerPC | CPU | LLVM | 20,338 | 50 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"isLegalAddImmediate",
"(",
"int64_t",
"Imm",
")",
"const",
"{",
"return",
"isInt",
"<",
"12",
">",
"(",
"Imm",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"specified",
"immediate",
"is",
"legal",
"add",
"immediate",
",",
"that",
"is",
"the",
"target",
"has",
"add",
"instructions",
"which",
"can",
"add",
"a",
"register",
"and",
"the",
"immediate",
"without",
"having",
"to",
"materialize",
"the",
"immediate",
"into",
"a",
"register",
"."
] | [
"RI5CY",
"RISCV",
"12"
] | RISCVISelLowering | isLegalAddImmediate | RI5CY | CPU | LLVM | 20,339 | 20 | 1 | [] |
[
"<s>",
"static",
"void",
"sh_option_override",
"(",
"void",
")",
"{",
"int",
"regno",
";",
"SUBTARGET_OVERRIDE_OPTIONS",
";",
"sh_cpu",
"=",
"PROCESSOR_SH1",
";",
"assembler_dialect",
"=",
"0",
";",
"if",
"(",
"TARGET_SH2",
")",
"sh_cpu",
"=",
"PROCESSOR_SH2",
";",
"if",
"(",
"TARGET_SH2E",
")",
"sh_cpu",
"=",
"PROCESSOR_SH2E",
";",
"if",
"(",
"TARGET_SH2A",
")",
"sh_cpu",
"=",
"PROCESSOR_SH2A",
";",
"if",
"(",
"TARGET_SH3",
")",
"sh_cpu",
"=",
"PROCESSOR_SH3",
";",
"if",
"(",
"TARGET_SH3E",
")",
"sh_cpu",
"=",
"PROCESSOR_SH3E",
";",
"if",
"(",
"TARGET_SH4",
")",
"{",
"assembler_dialect",
"=",
"1",
";",
"sh_cpu",
"=",
"PROCESSOR_SH4",
";",
"}",
"if",
"(",
"TARGET_SH4A",
")",
"{",
"assembler_dialect",
"=",
"1",
";",
"sh_cpu",
"=",
"PROCESSOR_SH4A",
";",
"}",
"if",
"(",
"!",
"TARGET_SH3",
"&&",
"TARGET_USERMODE",
")",
"TARGET_USERMODE",
"=",
"false",
";",
"if",
"(",
"!",
"strcmp",
"(",
"sh_div_str",
",",
"\"call-div1\"",
")",
")",
"sh_div_strategy",
"=",
"SH_DIV_CALL_DIV1",
";",
"else",
"if",
"(",
"!",
"strcmp",
"(",
"sh_div_str",
",",
"\"call-fp\"",
")",
"&&",
"TARGET_FPU_ANY",
")",
"sh_div_strategy",
"=",
"SH_DIV_CALL_FP",
";",
"else",
"if",
"(",
"!",
"strcmp",
"(",
"sh_div_str",
",",
"\"call-table\"",
")",
"&&",
"TARGET_DYNSHIFT",
")",
"sh_div_strategy",
"=",
"SH_DIV_CALL_TABLE",
";",
"else",
"{",
"if",
"(",
"TARGET_HARD_SH4",
")",
"sh_div_strategy",
"=",
"SH_DIV_CALL_TABLE",
";",
"else",
"if",
"(",
"TARGET_SH2A",
")",
"sh_div_strategy",
"=",
"SH_DIV_INTRINSIC",
";",
"else",
"sh_div_strategy",
"=",
"SH_DIV_CALL_DIV1",
";",
"}",
"if",
"(",
"sh_divsi3_libfunc",
"[",
"0",
"]",
")",
";",
"else",
"if",
"(",
"TARGET_DIVIDE_CALL_FP",
")",
"sh_divsi3_libfunc",
"=",
"\"__sdivsi3_i4\"",
";",
"else",
"if",
"(",
"TARGET_DIVIDE_CALL_TABLE",
")",
"sh_divsi3_libfunc",
"=",
"\"__sdivsi3_i4i\"",
";",
"else",
"sh_divsi3_libfunc",
"=",
"\"__sdivsi3\"",
";",
"if",
"(",
"sh_branch_cost",
"==",
"-",
"1",
")",
"{",
"sh_branch_cost",
"=",
"2",
";",
"}",
"if",
"(",
"!",
"global_options_set",
".",
"x_TARGET_ZDCBRANCH",
"&&",
"TARGET_HARD_SH4",
")",
"TARGET_ZDCBRANCH",
"=",
"1",
";",
"if",
"(",
"TARGET_FDPIC",
"&&",
"!",
"flag_pic",
")",
"flag_pic",
"=",
"2",
";",
"for",
"(",
"regno",
"=",
"0",
";",
"regno",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"regno",
"++",
")",
"if",
"(",
"!",
"VALID_REGISTER_P",
"(",
"regno",
")",
")",
"sh_register_names",
"[",
"regno",
"]",
"[",
"0",
"]",
"=",
"'\\0'",
";",
"for",
"(",
"regno",
"=",
"0",
";",
"regno",
"<",
"ADDREGNAMES_SIZE",
";",
"regno",
"++",
")",
"if",
"(",
"!",
"VALID_REGISTER_P",
"(",
"ADDREGNAMES_REGNO",
"(",
"regno",
")",
")",
")",
"sh_additional_register_names",
"[",
"regno",
"]",
"[",
"0",
"]",
"=",
"'\\0'",
";",
"if",
"(",
"flag_pic",
"&&",
"!",
"TARGET_PREFERGOT",
")",
"flag_no_function_cse",
"=",
"1",
";",
"if",
"(",
"targetm",
".",
"small_register_classes_for_mode_p",
"(",
"VOIDmode",
")",
")",
"{",
"if",
"(",
"!",
"TARGET_HARD_SH4",
"||",
"flag_pic",
")",
"flag_schedule_insns",
"=",
"0",
";",
"else",
"if",
"(",
"flag_exceptions",
")",
"{",
"if",
"(",
"flag_schedule_insns",
"&&",
"global_options_set",
".",
"x_flag_schedule_insns",
")",
"warning",
"(",
"0",
",",
"\"ignoring %<-fschedule-insns%> because of exception \"",
"\"handling bug\"",
")",
";",
"flag_schedule_insns",
"=",
"0",
";",
"}",
"else",
"if",
"(",
"flag_schedule_insns",
"&&",
"!",
"global_options_set",
".",
"x_flag_schedule_insns",
")",
"flag_schedule_insns",
"=",
"0",
";",
"}",
"if",
"(",
"(",
"flag_unwind_tables",
"||",
"flag_asynchronous_unwind_tables",
"||",
"flag_exceptions",
"||",
"flag_non_call_exceptions",
")",
"&&",
"flag_omit_frame_pointer",
"&&",
"!",
"TARGET_ACCUMULATE_OUTGOING_ARGS",
")",
"{",
"warning",
"(",
"0",
",",
"\"unwind tables currently require either a frame pointer \"",
"\"or %<-maccumulate-outgoing-args%> for correctness\"",
")",
";",
"TARGET_ACCUMULATE_OUTGOING_ARGS",
"=",
"1",
";",
"}",
"if",
"(",
"flag_unsafe_math_optimizations",
")",
"{",
"if",
"(",
"global_options_set",
".",
"x_TARGET_FSCA",
"==",
"0",
"&&",
"TARGET_SH4A_FP",
")",
"TARGET_FSCA",
"=",
"1",
";",
"if",
"(",
"global_options_set",
".",
"x_TARGET_FSRRA",
"==",
"0",
"&&",
"TARGET_SH4A_FP",
")",
"TARGET_FSRRA",
"=",
"1",
";",
"}",
"TARGET_FSRRA",
"=",
"TARGET_FSRRA",
"&&",
"flag_unsafe_math_optimizations",
"&&",
"flag_finite_math_only",
";",
"if",
"(",
"!",
"global_options_set",
".",
"x_TARGET_IEEE",
")",
"TARGET_IEEE",
"=",
"!",
"flag_finite_math_only",
";",
"if",
"(",
"sh_fixed_range_str",
")",
"sh_fix_range",
"(",
"sh_fixed_range_str",
")",
";",
"if",
"(",
"flag_strict_volatile_bitfields",
"<",
"0",
"&&",
"abi_version_at_least",
"(",
"2",
")",
")",
"flag_strict_volatile_bitfields",
"=",
"1",
";",
"sh_override_options_after_change",
"(",
")",
";",
"selected_atomic_model_",
"=",
"parse_validate_atomic_model_option",
"(",
"sh_atomic_model_str",
")",
";",
"register_sh_passes",
"(",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_OPTION_OVERRIDE",
"macro",
".",
"Validate",
"and",
"override",
"various",
"options",
",",
"and",
"do",
"some",
"machine",
"dependent",
"initialization",
"."
] | [
"sh",
"0",
"1",
"1",
"\"call-div1\"",
"\"call-fp\"",
"\"call-table\"",
"0",
"\"__sdivsi3_i4\"",
"\"__sdivsi3_i4i\"",
"\"__sdivsi3\"",
"1",
"2",
"1",
"2",
"0",
"0",
"0",
"0",
"1",
"0",
"0",
"\"ignoring %<-fschedule-insns%> because of exception \"",
"\"handling bug\"",
"0",
"0",
"0",
"\"unwind tables currently require either a frame pointer \"",
"\"or %<-maccumulate-outgoing-args%> for correctness\"",
"1",
"0",
"1",
"0",
"1",
"0",
"2",
"1"
] | sh8 | sh_option_override | sh | CPU | GCC | 20,340 | 504 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_scalar_mode_supported_p",
"(",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"DECIMAL_FLOAT_MODE_P",
"(",
"mode",
")",
")",
"return",
"default_decimal_float_supported_p",
"(",
")",
";",
"else",
"if",
"(",
"mode",
"==",
"TFmode",
")",
"return",
"true",
";",
"else",
"return",
"default_scalar_mode_supported_p",
"(",
"mode",
")",
";",
"}",
"</s>"
] | [
"Target",
"hook",
"for",
"scalar_mode_supported_p",
"."
] | [
"i386"
] | i3864 | ix86_scalar_mode_supported_p | i386 | CPU | GCC | 20,341 | 38 | 1 | [] |
[
"<s>",
"void",
"setType",
"(",
"nodeType",
"value",
")",
"{",
"type",
".",
"setNodeType",
"(",
"value",
")",
";",
"}",
"</s>"
] | [
"Set",
"the",
"low-level",
"type",
"of",
"VReg",
"to",
"Ty",
"."
] | [
"TPC"
] | TPCCostModelEmitter | setType | TPC | Virtual ISA | LLVM | 20,342 | 15 | 1 | [] |
[
"<s>",
"unsigned",
"PPCMCCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"const",
"MCOperand",
"&",
"MO",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
")",
"const",
"{",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"{",
"assert",
"(",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"!=",
"PPC",
"::",
"MTOCRF",
"&&",
"MI",
".",
"getOpcode",
"(",
")",
"!=",
"PPC",
"::",
"MTOCRF8",
"&&",
"MI",
".",
"getOpcode",
"(",
")",
"!=",
"PPC",
"::",
"MFOCRF",
"&&",
"MI",
".",
"getOpcode",
"(",
")",
"!=",
"PPC",
"::",
"MFOCRF8",
")",
"||",
"MO",
".",
"getReg",
"(",
")",
"<",
"PPC",
"::",
"CR0",
"||",
"MO",
".",
"getReg",
"(",
")",
">",
"PPC",
"::",
"CR7",
")",
";",
"return",
"CTX",
".",
"getRegisterInfo",
"(",
")",
"->",
"getEncodingValue",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"}",
"assert",
"(",
"MO",
".",
"isImm",
"(",
")",
"&&",
"\"Relocation required in an instruction that we cannot encode!\"",
")",
";",
"return",
"MO",
".",
"getImm",
"(",
")",
";",
"}",
"</s>"
] | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"PowerPC",
"PPC",
"PPC::MTOCRF",
"PPC::MTOCRF8",
"PPC::MFOCRF",
"PPC::MFOCRF8",
"PPC::CR0",
"PPC::CR7",
"\"Relocation required in an instruction that we cannot encode!\""
] | PPCMCCodeEmitter14 | getMachineOpValue | PowerPC | CPU | LLVM | 20,343 | 134 | 1 | [] |
[
"<s>",
"void",
"scalar_chain",
"::",
"replace_with_subreg_in_insn",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"reg",
",",
"rtx",
"new_reg",
")",
"{",
"replace_with_subreg",
"(",
"single_set",
"(",
"insn",
")",
",",
"reg",
",",
"new_reg",
")",
";",
"}",
"</s>"
] | [
"Replace",
"REG",
"in",
"INSN",
"with",
"a",
"V2DI",
"subreg",
"of",
"NEW_REG",
"."
] | [
"i386"
] | i3865 | replace_with_subreg_in_insn | i386 | CPU | GCC | 20,344 | 29 | 1 | [] |
[
"<s>",
"const",
"HexagonTargetLowering",
"*",
"getTLI",
"(",
")",
"const",
"{",
"return",
"TLI",
";",
"}",
"</s>"
] | [
"Getter",
"for",
"generic",
"TargetLowering",
"class",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonTargetTransformInfo (2) | getTLI | Hexagon | DSP | LLVM | 20,345 | 12 | 1 | [] |
[
"<s>",
"BitVector",
"GBZ80RegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"GB",
"::",
"SP",
")",
";",
"Reserved",
".",
"set",
"(",
"GB",
"::",
"IME",
")",
";",
"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",
"."
] | [
"GBZ80",
"GB",
"GB::SP",
"GB::IME"
] | GBZ80RegisterInfo | getReservedRegs | GBZ80 | MPU | LLVM | 20,346 | 42 | 1 | [] |
[
"<s>",
"bool",
"PPCFastISel",
"::",
"isTypeLegal",
"(",
"Type",
"*",
"Ty",
",",
"MVT",
"&",
"VT",
")",
"{",
"EVT",
"Evt",
"=",
"TLI",
".",
"getValueType",
"(",
"DL",
",",
"Ty",
",",
"true",
")",
";",
"if",
"(",
"Evt",
"==",
"MVT",
"::",
"Other",
"||",
"!",
"Evt",
".",
"isSimple",
"(",
")",
")",
"return",
"false",
";",
"VT",
"=",
"Evt",
".",
"getSimpleVT",
"(",
")",
";",
"return",
"TLI",
".",
"isTypeLegal",
"(",
"VT",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"type",
"is",
"legal",
"."
] | [
"PowerPC",
"PPC",
"MVT::Other"
] | PPCFastISel (2) | isTypeLegal | PowerPC | CPU | LLVM | 20,347 | 63 | 1 | [] |
[
"<s>",
"bool",
"ARMFrameLowering",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetRegisterInfo",
"*",
"RegInfo",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"if",
"(",
"STI",
".",
"isTargetIOS",
"(",
")",
")",
"return",
"true",
";",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"return",
"(",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"Options",
".",
"DisableFramePointerElim",
"(",
"MF",
")",
"&&",
"MFI",
"->",
"hasCalls",
"(",
")",
")",
"||",
"RegInfo",
"->",
"needsStackRealignment",
"(",
"MF",
")",
"||",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
"||",
"MFI",
"->",
"isFrameAddressTaken",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"ARM",
"ARM"
] | ARMFrameLowering | hasFP | ARM | CPU | LLVM | 20,348 | 93 | 1 | [] |
[
"<s>",
"bool",
"X86PartialReduction",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"F",
")",
")",
"return",
"false",
";",
"auto",
"*",
"TPC",
"=",
"getAnalysisIfAvailable",
"<",
"TargetPassConfig",
">",
"(",
")",
";",
"if",
"(",
"!",
"TPC",
")",
"return",
"false",
";",
"auto",
"&",
"TM",
"=",
"TPC",
"->",
"getTM",
"<",
"X86TargetMachine",
">",
"(",
")",
";",
"ST",
"=",
"TM",
".",
"getSubtargetImpl",
"(",
"F",
")",
";",
"DL",
"=",
"&",
"F",
".",
"getParent",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"bool",
"MadeChange",
"=",
"false",
";",
"for",
"(",
"auto",
"&",
"BB",
":",
"F",
")",
"{",
"for",
"(",
"auto",
"&",
"I",
":",
"BB",
")",
"{",
"auto",
"*",
"BO",
"=",
"dyn_cast",
"<",
"BinaryOperator",
">",
"(",
"&",
"I",
")",
";",
"if",
"(",
"!",
"BO",
")",
"continue",
";",
"if",
"(",
"!",
"isVectorReductionOp",
"(",
"*",
"BO",
")",
")",
"continue",
";",
"if",
"(",
"BO",
"->",
"getOpcode",
"(",
")",
"==",
"Instruction",
"::",
"Add",
")",
"{",
"if",
"(",
"tryMAddPattern",
"(",
"BO",
")",
")",
"{",
"MadeChange",
"=",
"true",
";",
"continue",
";",
"}",
"if",
"(",
"trySADPattern",
"(",
"BO",
")",
")",
"{",
"MadeChange",
"=",
"true",
";",
"continue",
";",
"}",
"}",
"}",
"}",
"return",
"MadeChange",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"X86",
"X86",
"X86"
] | X86PartialReduction1 | runOnFunction | X86 | CPU | LLVM | 20,349 | 178 | 1 | [] |
[
"<s>",
"static",
"void",
"nios2_output_dwarf_dtprel",
"(",
"FILE",
"*",
"file",
",",
"int",
"size",
",",
"rtx",
"x",
")",
"{",
"gcc_assert",
"(",
"size",
"==",
"4",
")",
";",
"fprintf",
"(",
"file",
",",
"\"\\t.4byte\\t%%tls_ldo(\"",
")",
";",
"output_addr_const",
"(",
"file",
",",
"x",
")",
";",
"fprintf",
"(",
"file",
",",
"\")\"",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ASM_OUTPUT_DWARF_DTPREL",
"."
] | [
"nios2",
"4",
"\"\\t.4byte\\t%%tls_ldo(\"",
"\")\""
] | nios2 | nios2_output_dwarf_dtprel | nios2 | MPU | GCC | 20,350 | 44 | 1 | [] |
[
"<s>",
"SUnit",
"*",
"SystemZPostRASchedStrategy",
"::",
"pickNode",
"(",
"bool",
"&",
"IsTopNode",
")",
"{",
"IsTopNode",
"=",
"true",
";",
"if",
"(",
"Available",
".",
"empty",
"(",
")",
")",
"return",
"nullptr",
";",
"if",
"(",
"Available",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"** Only one: \"",
";",
"HazardRec",
"->",
"dumpSU",
"(",
"*",
"Available",
".",
"begin",
"(",
")",
",",
"dbgs",
"(",
")",
")",
";",
"dbgs",
"(",
")",
"<<",
"\"\\n\"",
";",
")",
";",
"return",
"*",
"Available",
".",
"begin",
"(",
")",
";",
"}",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"** Available: \"",
";",
"Available",
".",
"dump",
"(",
"*",
"HazardRec",
")",
";",
")",
";",
"Candidate",
"Best",
";",
"for",
"(",
"auto",
"*",
"SU",
":",
"Available",
")",
"{",
"Candidate",
"c",
"(",
"SU",
",",
"*",
"HazardRec",
")",
";",
"if",
"(",
"Best",
".",
"SU",
"==",
"nullptr",
"||",
"c",
"<",
"Best",
")",
"{",
"Best",
"=",
"c",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"** Best so far: \"",
";",
")",
";",
"}",
"else",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"** Tried : \"",
";",
")",
";",
"DEBUG",
"(",
"HazardRec",
"->",
"dumpSU",
"(",
"c",
".",
"SU",
",",
"dbgs",
"(",
")",
")",
";",
"c",
".",
"dumpCosts",
"(",
")",
";",
"dbgs",
"(",
")",
"<<",
"\" Height:\"",
"<<",
"c",
".",
"SU",
"->",
"getHeight",
"(",
")",
";",
"dbgs",
"(",
")",
"<<",
"\"\\n\"",
";",
")",
";",
"if",
"(",
"!",
"SU",
"->",
"isScheduleHigh",
"&&",
"Best",
".",
"noCost",
"(",
")",
")",
"break",
";",
"}",
"assert",
"(",
"Best",
".",
"SU",
"!=",
"nullptr",
")",
";",
"return",
"Best",
".",
"SU",
";",
"}",
"</s>"
] | [
"Pick",
"the",
"next",
"node",
"to",
"schedule",
",",
"or",
"return",
"NULL",
"."
] | [
"SystemZ",
"SystemZ",
"1",
"\"** Only one: \"",
"\"\\n\"",
"\"** Available: \"",
"\"** Best so far: \"",
"\"** Tried : \"",
"\" Height:\"",
"\"\\n\""
] | SystemZMachineScheduler12 | pickNode | SystemZ | CPU | LLVM | 20,351 | 230 | 1 | [] |
[
"<s>",
"rtx",
"sh_movrt_set_dest",
"(",
"const",
"rtx_insn",
"*",
"i",
")",
"{",
"if",
"(",
"i",
"==",
"NULL",
")",
"return",
"NULL",
";",
"const_rtx",
"p",
"=",
"PATTERN",
"(",
"i",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"p",
")",
"==",
"PARALLEL",
")",
"p",
"=",
"XVECEXP",
"(",
"p",
",",
"0",
",",
"0",
")",
";",
"return",
"GET_CODE",
"(",
"p",
")",
"==",
"SET",
"&&",
"arith_reg_dest",
"(",
"XEXP",
"(",
"p",
",",
"0",
")",
",",
"SImode",
")",
"&&",
"negt_reg_operand",
"(",
"XEXP",
"(",
"p",
",",
"1",
")",
",",
"VOIDmode",
")",
"?",
"XEXP",
"(",
"p",
",",
"0",
")",
":",
"NULL",
";",
"}",
"</s>"
] | [
"Given",
"an",
"insn",
",",
"check",
"whether",
"it",
"'s",
"a",
"'movrt",
"'",
"kind",
"of",
"insn",
",",
"i.e",
".",
"an",
"insn",
"that",
"stores",
"the",
"negated",
"T",
"bit",
"in",
"a",
"register",
",",
"and",
"return",
"the",
"destination",
"register",
"rtx",
",",
"or",
"null",
"."
] | [
"sh",
"0",
"0",
"0",
"1",
"0"
] | sh4 | sh_movrt_set_dest | sh | CPU | GCC | 20,352 | 88 | 1 | [] |
[
"<s>",
"unsigned",
"AMDGPUTTIImpl",
"::",
"getNumberOfRegisters",
"(",
"bool",
"Vec",
")",
"{",
"if",
"(",
"Vec",
")",
"return",
"0",
";",
"if",
"(",
"ST",
"->",
"getGeneration",
"(",
")",
">=",
"AMDGPUSubtarget",
"::",
"SOUTHERN_ISLANDS",
")",
"return",
"256",
";",
"return",
"4",
"*",
"128",
";",
"}",
"</s>"
] | [
"�",
"?",
"Vector",
"TTI",
"begin",
"�",
"?"
] | [
"AMDGPU",
"AMDGPU",
"0",
"AMDGPU",
"256",
"4",
"128"
] | AMDGPUTargetTransformInfo11 | getNumberOfRegisters | AMDGPU | GPU | LLVM | 20,353 | 37 | 1 | [] |
[
"<s>",
"EVT",
"HexagonTargetLowering",
"::",
"getOptimalMemOpType",
"(",
"const",
"MemOp",
"&",
"Op",
",",
"const",
"AttributeList",
"&",
"FuncAttributes",
")",
"const",
"{",
"if",
"(",
"Op",
".",
"size",
"(",
")",
">=",
"8",
"&&",
"Op",
".",
"isAligned",
"(",
"Align",
"(",
"8",
")",
")",
")",
"return",
"MVT",
"::",
"i64",
";",
"if",
"(",
"Op",
".",
"size",
"(",
")",
">=",
"4",
"&&",
"Op",
".",
"isAligned",
"(",
"Align",
"(",
"4",
")",
")",
")",
"return",
"MVT",
"::",
"i32",
";",
"if",
"(",
"Op",
".",
"size",
"(",
")",
">=",
"2",
"&&",
"Op",
".",
"isAligned",
"(",
"Align",
"(",
"2",
")",
")",
")",
"return",
"MVT",
"::",
"i16",
";",
"return",
"MVT",
"::",
"Other",
";",
"}",
"</s>"
] | [
"It",
"returns",
"EVT",
":",
":Other",
"if",
"the",
"type",
"should",
"be",
"determined",
"using",
"generic",
"target-independent",
"logic",
"."
] | [
"Hexagon",
"Hexagon",
"8",
"8",
"MVT::i64",
"4",
"4",
"MVT::i32",
"2",
"2",
"MVT::i16",
"MVT::Other"
] | HexagonISelLowering100 | getOptimalMemOpType | Hexagon | DSP | LLVM | 20,354 | 98 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyLowerRefTypesIntPtrConv",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"********** Lower RefTypes IntPtr Convs **********\\n\"",
"\"********** Function: \"",
"<<",
"F",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
")",
";",
"std",
"::",
"set",
"<",
"Instruction",
"*",
">",
"worklist",
";",
"for",
"(",
"inst_iterator",
"I",
"=",
"inst_begin",
"(",
"F",
")",
",",
"E",
"=",
"inst_end",
"(",
"F",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"PtrToIntInst",
"*",
"PTI",
"=",
"dyn_cast",
"<",
"PtrToIntInst",
">",
"(",
"&",
"*",
"I",
")",
";",
"IntToPtrInst",
"*",
"ITP",
"=",
"dyn_cast",
"<",
"IntToPtrInst",
">",
"(",
"&",
"*",
"I",
")",
";",
"if",
"(",
"!",
"(",
"PTI",
"&&",
"WebAssembly",
"::",
"isRefType",
"(",
"PTI",
"->",
"getPointerOperand",
"(",
")",
"->",
"getType",
"(",
")",
")",
")",
"&&",
"!",
"(",
"ITP",
"&&",
"WebAssembly",
"::",
"isRefType",
"(",
"ITP",
"->",
"getDestTy",
"(",
")",
")",
")",
")",
"continue",
";",
"UndefValue",
"*",
"U",
"=",
"UndefValue",
"::",
"get",
"(",
"I",
"->",
"getType",
"(",
")",
")",
";",
"I",
"->",
"replaceAllUsesWith",
"(",
"U",
")",
";",
"Function",
"*",
"TrapIntrin",
"=",
"Intrinsic",
"::",
"getDeclaration",
"(",
"F",
".",
"getParent",
"(",
")",
",",
"Intrinsic",
"::",
"debugtrap",
")",
";",
"CallInst",
"::",
"Create",
"(",
"TrapIntrin",
",",
"{",
"}",
",",
"\"\"",
",",
"&",
"*",
"I",
")",
";",
"worklist",
".",
"insert",
"(",
"&",
"*",
"I",
")",
";",
"}",
"for",
"(",
"Instruction",
"*",
"I",
":",
"worklist",
")",
"I",
"->",
"eraseFromParent",
"(",
")",
";",
"return",
"!",
"worklist",
".",
"empty",
"(",
")",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"********** Lower RefTypes IntPtr Convs **********\\n\"",
"\"********** Function: \"",
"WebAssembly::isRefType",
"WebAssembly::isRefType",
"Intrinsic::getDeclaration",
"Intrinsic::debugtrap",
"\"\""
] | WebAssemblyLowerRefTypesIntPtrConv | runOnFunction | WebAssembly | Virtual ISA | LLVM | 20,355 | 220 | 1 | [] |
[
"<s>",
"bool",
"X86FastISel",
"::",
"isTypeLegal",
"(",
"Type",
"*",
"Ty",
",",
"MVT",
"&",
"VT",
",",
"bool",
"AllowI1",
")",
"{",
"EVT",
"evt",
"=",
"TLI",
".",
"getValueType",
"(",
"DL",
",",
"Ty",
",",
"true",
")",
";",
"if",
"(",
"evt",
"==",
"MVT",
"::",
"Other",
"||",
"!",
"evt",
".",
"isSimple",
"(",
")",
")",
"return",
"false",
";",
"VT",
"=",
"evt",
".",
"getSimpleVT",
"(",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
"&&",
"!",
"Subtarget",
"->",
"hasSSE2",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
"&&",
"!",
"Subtarget",
"->",
"hasSSE1",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f80",
")",
"return",
"false",
";",
"return",
"(",
"AllowI1",
"&&",
"VT",
"==",
"MVT",
"::",
"i1",
")",
"||",
"TLI",
".",
"isTypeLegal",
"(",
"VT",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"type",
"is",
"legal",
"."
] | [
"X86",
"X86",
"MVT::Other",
"MVT::f64",
"MVT::f32",
"MVT::f80",
"MVT::i1"
] | X86FastISel56 | isTypeLegal | X86 | CPU | LLVM | 20,356 | 123 | 1 | [] |
[
"<s>",
"static",
"char",
"*",
"read_file",
"(",
"const",
"char",
"*",
"filename",
",",
"size_t",
"*",
"plen",
")",
"{",
"size_t",
"alloc",
"=",
"16384",
";",
"size_t",
"base",
"=",
"0",
";",
"char",
"*",
"buffer",
";",
"FILE",
"*",
"stream",
"=",
"fopen",
"(",
"filename",
",",
"\"rb\"",
")",
";",
"if",
"(",
"!",
"stream",
")",
"{",
"perror",
"(",
"filename",
")",
";",
"exit",
"(",
"1",
")",
";",
"}",
"if",
"(",
"!",
"fseek",
"(",
"stream",
",",
"0",
",",
"SEEK_END",
")",
")",
"{",
"long",
"s",
"=",
"ftell",
"(",
"stream",
")",
";",
"if",
"(",
"s",
">=",
"0",
")",
"alloc",
"=",
"s",
"+",
"100",
";",
"fseek",
"(",
"stream",
",",
"0",
",",
"SEEK_SET",
")",
";",
"}",
"buffer",
"=",
"malloc",
"(",
"alloc",
")",
";",
"for",
"(",
";",
";",
")",
"{",
"size_t",
"n",
"=",
"fread",
"(",
"buffer",
"+",
"base",
",",
"1",
",",
"alloc",
"-",
"base",
"-",
"1",
",",
"stream",
")",
";",
"if",
"(",
"!",
"n",
")",
"break",
";",
"base",
"+=",
"n",
";",
"if",
"(",
"base",
"+",
"1",
"==",
"alloc",
")",
"{",
"alloc",
"*=",
"2",
";",
"buffer",
"=",
"realloc",
"(",
"buffer",
",",
"alloc",
")",
";",
"}",
"}",
"buffer",
"[",
"base",
"]",
"=",
"0",
";",
"*",
"plen",
"=",
"base",
";",
"fclose",
"(",
"stream",
")",
";",
"return",
"buffer",
";",
"}",
"</s>"
] | [
"Read",
"the",
"whole",
"input",
"file",
".",
"It",
"will",
"be",
"NUL",
"terminated",
"(",
"but",
"remember",
",",
"there",
"could",
"be",
"a",
"NUL",
"in",
"the",
"file",
"itself",
"."
] | [
"gcn",
"16384",
"0",
"\"rb\"",
"1",
"0",
"0",
"100",
"0",
"1",
"1",
"1",
"2",
"0"
] | gcn-run | read_file | gcn | GPU | GCC | 20,357 | 189 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"Tile64DAGToDAGISel",
"::",
"getGlobalBaseReg",
"(",
")",
"{",
"unsigned",
"GlobalBaseReg",
"=",
"TM",
".",
"getInstrInfo",
"(",
")",
"->",
"getGlobalBaseReg",
"(",
"MF",
")",
";",
"return",
"CurDAG",
"->",
"getRegister",
"(",
"GlobalBaseReg",
",",
"TLI",
".",
"getPointerTy",
"(",
")",
")",
".",
"getNode",
"(",
")",
";",
"}",
"</s>"
] | [
"getGlobalBaseReg",
"-",
"Return",
"a",
"virtual",
"register",
"initialized",
"with",
"the",
"the",
"global",
"base",
"register",
"value",
"."
] | [
"Tile64"
] | Tile64ISelDAGToDAG | getGlobalBaseReg | Tile64 | VLIW | LLVM | 20,358 | 41 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"AdvSIMD Scalar Operation Optimization\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AArch64",
"\"AdvSIMD Scalar Operation Optimization\""
] | AArch64AdvSIMDScalarPass13 | getPassName | AArch64 | CPU | LLVM | 20,359 | 13 | 1 | [] |
[
"<s>",
"bool",
"AlphaAsmPrinter",
"::",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
")",
"{",
"printOperand",
"(",
"MI",
",",
"OpNo",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"PrintAsmOperand",
"-",
"Print",
"out",
"an",
"operand",
"for",
"an",
"inline",
"asm",
"expression",
"."
] | [
"Alpha",
"Alpha"
] | AlphaAsmPrinter1 | PrintAsmOperand | Alpha | MPU | LLVM | 20,360 | 33 | 1 | [] |
[
"<s>",
"static",
"int",
"s390_vec_n_elem",
"(",
"tree",
"fndecl",
")",
"{",
"tree",
"b_arg_chain",
";",
"int",
"n_elem",
"=",
"-",
"1",
";",
"if",
"(",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"fndecl",
")",
")",
")",
"==",
"VECTOR_TYPE",
")",
"n_elem",
"=",
"TYPE_VECTOR_SUBPARTS",
"(",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"(",
"fndecl",
")",
")",
")",
")",
";",
"for",
"(",
"b_arg_chain",
"=",
"TYPE_ARG_TYPES",
"(",
"TREE_TYPE",
"(",
"fndecl",
")",
")",
";",
"!",
"VOID_TYPE_P",
"(",
"TREE_VALUE",
"(",
"b_arg_chain",
")",
")",
";",
"b_arg_chain",
"=",
"TREE_CHAIN",
"(",
"b_arg_chain",
")",
")",
"{",
"int",
"tmp_n_elem",
";",
"if",
"(",
"TREE_CODE",
"(",
"TREE_VALUE",
"(",
"b_arg_chain",
")",
")",
"!=",
"VECTOR_TYPE",
")",
"continue",
";",
"tmp_n_elem",
"=",
"TYPE_VECTOR_SUBPARTS",
"(",
"TREE_VALUE",
"(",
"b_arg_chain",
")",
")",
";",
"if",
"(",
"n_elem",
"!=",
"-",
"1",
"&&",
"n_elem",
"!=",
"tmp_n_elem",
")",
"return",
"-",
"1",
";",
"n_elem",
"=",
"tmp_n_elem",
";",
"}",
"return",
"n_elem",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"elements",
"in",
"the",
"vector",
"arguments",
"of",
"FNDECL",
"in",
"case",
"all",
"it",
"matches",
"for",
"all",
"vector",
"arguments",
",",
"-1",
"otherwise",
"."
] | [
"s390",
"1",
"1",
"1"
] | s390-c | s390_vec_n_elem | s390 | MPU | GCC | 20,361 | 127 | 1 | [] |
[
"<s>",
"int",
"ix86_frame_pointer_required",
"(",
"void",
")",
"{",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"accesses_prev_frame",
")",
"return",
"1",
";",
"if",
"(",
"SUBTARGET_FRAME_POINTER_REQUIRED",
")",
"return",
"1",
";",
"if",
"(",
"TARGET_OMIT_LEAF_FRAME_POINTER",
"&&",
"(",
"!",
"current_function_is_leaf",
")",
")",
"return",
"1",
";",
"if",
"(",
"current_function_profile",
")",
"return",
"1",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Value",
"should",
"be",
"nonzero",
"if",
"functions",
"must",
"have",
"frame",
"pointers",
".",
"Zero",
"means",
"the",
"frame",
"pointer",
"need",
"not",
"be",
"set",
"up",
"(",
"and",
"parms",
"may",
"be",
"accessed",
"via",
"the",
"stack",
"pointer",
")",
"in",
"functions",
"that",
"seem",
"suitable",
"."
] | [
"i386",
"1",
"1",
"1",
"1",
"0"
] | i3863 | ix86_frame_pointer_required | i386 | CPU | GCC | 20,362 | 47 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"isShuffleMaskLegal",
"(",
"ArrayRef",
"<",
"int",
">",
"M",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"VT",
".",
"getVectorNumElements",
"(",
")",
"==",
"4",
"&&",
"(",
"VT",
".",
"is128BitVector",
"(",
")",
"||",
"VT",
".",
"is64BitVector",
"(",
")",
")",
")",
"{",
"unsigned",
"PFIndexes",
"[",
"4",
"]",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"4",
";",
"++",
"i",
")",
"{",
"if",
"(",
"M",
"[",
"i",
"]",
"<",
"0",
")",
"PFIndexes",
"[",
"i",
"]",
"=",
"8",
";",
"else",
"PFIndexes",
"[",
"i",
"]",
"=",
"M",
"[",
"i",
"]",
";",
"}",
"unsigned",
"PFTableIndex",
"=",
"PFIndexes",
"[",
"0",
"]",
"*",
"9",
"*",
"9",
"*",
"9",
"+",
"PFIndexes",
"[",
"1",
"]",
"*",
"9",
"*",
"9",
"+",
"PFIndexes",
"[",
"2",
"]",
"*",
"9",
"+",
"PFIndexes",
"[",
"3",
"]",
";",
"unsigned",
"PFEntry",
"=",
"PerfectShuffleTable",
"[",
"PFTableIndex",
"]",
";",
"unsigned",
"Cost",
"=",
"(",
"PFEntry",
">>",
"30",
")",
";",
"if",
"(",
"Cost",
"<=",
"4",
"&&",
"(",
"Subtarget",
"->",
"hasNEON",
"(",
")",
"||",
"isLegalMVEShuffleOp",
"(",
"PFEntry",
")",
")",
")",
"return",
"true",
";",
"}",
"bool",
"ReverseVEXT",
",",
"isV_UNDEF",
";",
"unsigned",
"Imm",
",",
"WhichResult",
";",
"unsigned",
"EltSize",
"=",
"VT",
".",
"getScalarSizeInBits",
"(",
")",
";",
"if",
"(",
"EltSize",
">=",
"32",
"||",
"ShuffleVectorSDNode",
"::",
"isSplatMask",
"(",
"&",
"M",
"[",
"0",
"]",
",",
"VT",
")",
"||",
"ShuffleVectorInst",
"::",
"isIdentityMask",
"(",
"M",
")",
"||",
"isVREVMask",
"(",
"M",
",",
"VT",
",",
"64",
")",
"||",
"isVREVMask",
"(",
"M",
",",
"VT",
",",
"32",
")",
"||",
"isVREVMask",
"(",
"M",
",",
"VT",
",",
"16",
")",
")",
"return",
"true",
";",
"else",
"if",
"(",
"Subtarget",
"->",
"hasNEON",
"(",
")",
"&&",
"(",
"isVEXTMask",
"(",
"M",
",",
"VT",
",",
"ReverseVEXT",
",",
"Imm",
")",
"||",
"isVTBLMask",
"(",
"M",
",",
"VT",
")",
"||",
"isNEONTwoResultShuffleMask",
"(",
"M",
",",
"VT",
",",
"WhichResult",
",",
"isV_UNDEF",
")",
")",
")",
"return",
"true",
";",
"else",
"if",
"(",
"(",
"VT",
"==",
"MVT",
"::",
"v8i16",
"||",
"VT",
"==",
"MVT",
"::",
"v8f16",
"||",
"VT",
"==",
"MVT",
"::",
"v16i8",
")",
"&&",
"isReverseMask",
"(",
"M",
",",
"VT",
")",
")",
"return",
"true",
";",
"else",
"if",
"(",
"Subtarget",
"->",
"hasMVEIntegerOps",
"(",
")",
"&&",
"(",
"isVMOVNMask",
"(",
"M",
",",
"VT",
",",
"true",
",",
"false",
")",
"||",
"isVMOVNMask",
"(",
"M",
",",
"VT",
",",
"false",
",",
"false",
")",
"||",
"isVMOVNMask",
"(",
"M",
",",
"VT",
",",
"true",
",",
"true",
")",
")",
")",
"return",
"true",
";",
"else",
"return",
"false",
";",
"}",
"</s>"
] | [
"Targets",
"can",
"use",
"this",
"to",
"indicate",
"that",
"they",
"only",
"support",
"some",
"VECTOR_SHUFFLE",
"operations",
",",
"those",
"with",
"specific",
"masks",
"."
] | [
"ARM",
"ARM",
"4",
"4",
"0",
"4",
"0",
"8",
"0",
"9",
"9",
"9",
"1",
"9",
"9",
"2",
"9",
"3",
"30",
"4",
"32",
"0",
"64",
"32",
"16",
"MVT::v8i16",
"MVT::v8f16",
"MVT::v16i8"
] | ARMISelLowering (2)5 | isShuffleMaskLegal | ARM | CPU | LLVM | 20,363 | 368 | 1 | [] |
[
"<s>",
"uint32_t",
"AMDGPUTargetLowering",
"::",
"getImplicitParameterOffset",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"const",
"ImplicitParameter",
"Param",
")",
"const",
"{",
"const",
"AMDGPUMachineFunction",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"AMDGPUMachineFunction",
">",
"(",
")",
";",
"const",
"AMDGPUSubtarget",
"&",
"ST",
"=",
"AMDGPUSubtarget",
"::",
"get",
"(",
"getTargetMachine",
"(",
")",
",",
"MF",
".",
"getFunction",
"(",
")",
")",
";",
"unsigned",
"ExplicitArgOffset",
"=",
"ST",
".",
"getExplicitKernelArgOffset",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
";",
"const",
"Align",
"Alignment",
"=",
"ST",
".",
"getAlignmentForImplicitArgPtr",
"(",
")",
";",
"uint64_t",
"ArgOffset",
"=",
"alignTo",
"(",
"MFI",
"->",
"getExplicitKernArgSize",
"(",
")",
",",
"Alignment",
")",
"+",
"ExplicitArgOffset",
";",
"switch",
"(",
"Param",
")",
"{",
"case",
"FIRST_IMPLICIT",
":",
"return",
"ArgOffset",
";",
"case",
"PRIVATE_BASE",
":",
"return",
"ArgOffset",
"+",
"AMDGPU",
"::",
"ImplicitArg",
"::",
"PRIVATE_BASE_OFFSET",
";",
"case",
"SHARED_BASE",
":",
"return",
"ArgOffset",
"+",
"AMDGPU",
"::",
"ImplicitArg",
"::",
"SHARED_BASE_OFFSET",
";",
"case",
"QUEUE_PTR",
":",
"return",
"ArgOffset",
"+",
"AMDGPU",
"::",
"ImplicitArg",
"::",
"QUEUE_PTR_OFFSET",
";",
"}",
"llvm_unreachable",
"(",
"\"unexpected implicit parameter type\"",
")",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"that",
"returns",
"the",
"byte",
"offset",
"of",
"the",
"given",
"type",
"of",
"implicit",
"parameter",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU::ImplicitArg",
"AMDGPU::ImplicitArg",
"AMDGPU::ImplicitArg",
"\"unexpected implicit parameter type\""
] | AMDGPUISelLowering (2)1 | getImplicitParameterOffset | AMDGPU | GPU | LLVM | 20,364 | 144 | 1 | [] |
[
"<s>",
"bool",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"override",
"{",
"X86LowerAMXType",
"LAT",
"(",
"F",
")",
";",
"bool",
"C",
"=",
"LAT",
".",
"visit",
"(",
")",
";",
"return",
"C",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"X86",
"X86"
] | X86LowerAMXType10 | runOnFunction | X86 | CPU | LLVM | 20,365 | 28 | 1 | [] |
[
"<s>",
"char",
"*",
"aarch64_output_sve_scalar_inc_dec",
"(",
"rtx",
"offset",
")",
"{",
"poly_int64",
"offset_value",
"=",
"rtx_to_poly_int64",
"(",
"offset",
")",
";",
"gcc_assert",
"(",
"offset_value",
".",
"coeffs",
"[",
"0",
"]",
"==",
"offset_value",
".",
"coeffs",
"[",
"1",
"]",
")",
";",
"if",
"(",
"offset_value",
".",
"coeffs",
"[",
"1",
"]",
">",
"0",
")",
"return",
"aarch64_output_sve_cnt_immediate",
"(",
"\"inc\"",
",",
"\"%x0\"",
",",
"AARCH64_SV_ALL",
",",
"offset_value",
".",
"coeffs",
"[",
"1",
"]",
",",
"0",
")",
";",
"else",
"return",
"aarch64_output_sve_cnt_immediate",
"(",
"\"dec\"",
",",
"\"%x0\"",
",",
"AARCH64_SV_ALL",
",",
"-",
"offset_value",
".",
"coeffs",
"[",
"1",
"]",
",",
"0",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"asm",
"string",
"for",
"adding",
"SVE",
"INC/DEC",
"immediate",
"OFFSET",
"to",
"operand",
"0",
"."
] | [
"aarch64",
"0",
"1",
"1",
"0",
"\"inc\"",
"\"%x0\"",
"1",
"0",
"\"dec\"",
"\"%x0\"",
"1",
"0"
] | aarch64 | aarch64_output_sve_scalar_inc_dec | aarch64 | CPU | GCC | 20,366 | 85 | 1 | [] |
[
"<s>",
"bool",
"TVMIfConversionTerm",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"********** TVM IF-CONVERSION TERM **********\\n\"",
"<<",
"\"********** Function: \"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
")",
";",
"if",
"(",
"skipFunction",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"TII",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"DomTree",
"=",
"&",
"getAnalysis",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"Loops",
"=",
"getAnalysisIfAvailable",
"<",
"MachineLoopInfo",
">",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"auto",
"DomNode",
":",
"post_order",
"(",
"DomTree",
")",
")",
"if",
"(",
"tryConvertIf",
"(",
"DomNode",
"->",
"getBlock",
"(",
")",
")",
")",
"Changed",
"=",
"true",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"TVM",
"TVM",
"\"********** TVM IF-CONVERSION TERM **********\\n\"",
"\"********** Function: \""
] | TVMIfConversionTerm | runOnMachineFunction | TVM | Virtual ISA | LLVM | 20,367 | 108 | 1 | [] |
[
"<s>",
"ScheduleHazardRecognizer",
"::",
"HazardType",
"GCNHazardRecognizer",
"::",
"getHazardType",
"(",
"SUnit",
"*",
"SU",
",",
"int",
"Stalls",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"SU",
"->",
"getInstr",
"(",
")",
";",
"auto",
"HazardType",
"=",
"IsHazardRecognizerMode",
"?",
"NoopHazard",
":",
"Hazard",
";",
"if",
"(",
"MI",
"->",
"isBundle",
"(",
")",
")",
"return",
"NoHazard",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isSMRD",
"(",
"*",
"MI",
")",
"&&",
"checkSMRDHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"(",
"SIInstrInfo",
"::",
"isVMEM",
"(",
"*",
"MI",
")",
"||",
"SIInstrInfo",
"::",
"isFLAT",
"(",
"*",
"MI",
")",
")",
"&&",
"checkVMEMHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"ST",
".",
"hasNSAtoVMEMBug",
"(",
")",
"&&",
"checkNSAtoVMEMHazard",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"checkFPAtomicToDenormModeHazard",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"ST",
".",
"hasNoDataDepHazard",
"(",
")",
")",
"return",
"NoHazard",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isVALU",
"(",
"*",
"MI",
")",
"&&",
"checkVALUHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isDPP",
"(",
"*",
"MI",
")",
"&&",
"checkDPPHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"isDivFMas",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"checkDivFMasHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"isRWLane",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"checkRWLaneHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"isSGetReg",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"checkGetRegHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"isSSetReg",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"checkSetRegHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"isRFE",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"checkRFEHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"ST",
".",
"hasReadM0MovRelInterpHazard",
"(",
")",
"&&",
"(",
"TII",
".",
"isVINTRP",
"(",
"*",
"MI",
")",
"||",
"isSMovRel",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
"&&",
"checkReadM0Hazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"ST",
".",
"hasReadM0SendMsgHazard",
"(",
")",
"&&",
"isSendMsgTraceDataOrGDS",
"(",
"TII",
",",
"*",
"MI",
")",
"&&",
"checkReadM0Hazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isMAI",
"(",
"*",
"MI",
")",
"&&",
"checkMAIHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"(",
"SIInstrInfo",
"::",
"isVMEM",
"(",
"*",
"MI",
")",
"||",
"SIInstrInfo",
"::",
"isFLAT",
"(",
"*",
"MI",
")",
"||",
"SIInstrInfo",
"::",
"isDS",
"(",
"*",
"MI",
")",
")",
"&&",
"checkMAILdStHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"if",
"(",
"MI",
"->",
"isInlineAsm",
"(",
")",
"&&",
"checkInlineAsmHazards",
"(",
"MI",
")",
">",
"0",
")",
"return",
"HazardType",
";",
"return",
"NoHazard",
";",
"}",
"</s>"
] | [
"getHazardType",
"-",
"Return",
"the",
"hazard",
"type",
"of",
"emitting",
"this",
"node",
"."
] | [
"AMDGPU",
"SI",
"0",
"SI",
"SI",
"0",
"0",
"0",
"SI",
"0",
"SI",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"SI",
"0",
"SI",
"SI",
"SI",
"0",
"0"
] | GCNHazardRecognizer16 | getHazardType | AMDGPU | GPU | LLVM | 20,368 | 424 | 1 | [] |
[
"<s>",
"static",
"bool",
"msp430_no_hwmult",
"(",
"void",
")",
"{",
"static",
"const",
"char",
"*",
"known_nomult_mcus",
"[",
"]",
"=",
"{",
"\"msp430c091\"",
",",
"\"msp430c092\"",
",",
"\"msp430c111\"",
",",
"\"msp430c1111\"",
",",
"\"msp430c112\"",
",",
"\"msp430c1121\"",
",",
"\"msp430c1331\"",
",",
"\"msp430c1351\"",
",",
"\"msp430c311s\"",
",",
"\"msp430c312\"",
",",
"\"msp430c313\"",
",",
"\"msp430c314\"",
",",
"\"msp430c315\"",
",",
"\"msp430c323\"",
",",
"\"msp430c325\"",
",",
"\"msp430c412\"",
",",
"\"msp430c413\"",
",",
"\"msp430e112\"",
",",
"\"msp430e313\"",
",",
"\"msp430e315\"",
",",
"\"msp430e325\"",
",",
"\"msp430f110\"",
",",
"\"msp430f1101\"",
",",
"\"msp430f1101a\"",
",",
"\"msp430f1111\"",
",",
"\"msp430f1111a\"",
",",
"\"msp430f112\"",
",",
"\"msp430f1121\"",
",",
"\"msp430f1121a\"",
",",
"\"msp430f1122\"",
",",
"\"msp430f1132\"",
",",
"\"msp430f122\"",
",",
"\"msp430f1222\"",
",",
"\"msp430f123\"",
",",
"\"msp430f1232\"",
",",
"\"msp430f133\"",
",",
"\"msp430f135\"",
",",
"\"msp430f155\"",
",",
"\"msp430f156\"",
",",
"\"msp430f157\"",
",",
"\"msp430f2001\"",
",",
"\"msp430f2002\"",
",",
"\"msp430f2003\"",
",",
"\"msp430f2011\"",
",",
"\"msp430f2012\"",
",",
"\"msp430f2013\"",
",",
"\"msp430f2101\"",
",",
"\"msp430f2111\"",
",",
"\"msp430f2112\"",
",",
"\"msp430f2121\"",
",",
"\"msp430f2122\"",
",",
"\"msp430f2131\"",
",",
"\"msp430f2132\"",
",",
"\"msp430f2232\"",
",",
"\"msp430f2234\"",
",",
"\"msp430f2252\"",
",",
"\"msp430f2254\"",
",",
"\"msp430f2272\"",
",",
"\"msp430f2274\"",
",",
"\"msp430f412\"",
",",
"\"msp430f413\"",
",",
"\"msp430f4132\"",
",",
"\"msp430f415\"",
",",
"\"msp430f4152\"",
",",
"\"msp430f417\"",
",",
"\"msp430f4250\"",
",",
"\"msp430f4260\"",
",",
"\"msp430f4270\"",
",",
"\"msp430f435\"",
",",
"\"msp430f4351\"",
",",
"\"msp430f436\"",
",",
"\"msp430f4361\"",
",",
"\"msp430f437\"",
",",
"\"msp430f4371\"",
",",
"\"msp430f438\"",
",",
"\"msp430f439\"",
",",
"\"msp430f477\"",
",",
"\"msp430f478\"",
",",
"\"msp430f479\"",
",",
"\"msp430fe423\"",
",",
"\"msp430fe4232\"",
",",
"\"msp430fe423a\"",
",",
"\"msp430fe4242\"",
",",
"\"msp430fe425\"",
",",
"\"msp430fe4252\"",
",",
"\"msp430fe425a\"",
",",
"\"msp430fe427\"",
",",
"\"msp430fe4272\"",
",",
"\"msp430fe427a\"",
",",
"\"msp430fg4250\"",
",",
"\"msp430fg4260\"",
",",
"\"msp430fg4270\"",
",",
"\"msp430fg437\"",
",",
"\"msp430fg438\"",
",",
"\"msp430fg439\"",
",",
"\"msp430fg477\"",
",",
"\"msp430fg478\"",
",",
"\"msp430fg479\"",
",",
"\"msp430fr2032\"",
",",
"\"msp430fr2033\"",
",",
"\"msp430fr4131\"",
",",
"\"msp430fr4132\"",
",",
"\"msp430fr4133\"",
",",
"\"msp430fw423\"",
",",
"\"msp430fw425\"",
",",
"\"msp430fw427\"",
",",
"\"msp430fw428\"",
",",
"\"msp430fw429\"",
",",
"\"msp430g2001\"",
",",
"\"msp430g2101\"",
",",
"\"msp430g2102\"",
",",
"\"msp430g2111\"",
",",
"\"msp430g2112\"",
",",
"\"msp430g2113\"",
",",
"\"msp430g2121\"",
",",
"\"msp430g2131\"",
",",
"\"msp430g2132\"",
",",
"\"msp430g2152\"",
",",
"\"msp430g2153\"",
",",
"\"msp430g2201\"",
",",
"\"msp430g2202\"",
",",
"\"msp430g2203\"",
",",
"\"msp430g2210\"",
",",
"\"msp430g2211\"",
",",
"\"msp430g2212\"",
",",
"\"msp430g2213\"",
",",
"\"msp430g2221\"",
",",
"\"msp430g2230\"",
",",
"\"msp430g2231\"",
",",
"\"msp430g2232\"",
",",
"\"msp430g2233\"",
",",
"\"msp430g2252\"",
",",
"\"msp430g2253\"",
",",
"\"msp430g2302\"",
",",
"\"msp430g2303\"",
",",
"\"msp430g2312\"",
",",
"\"msp430g2313\"",
",",
"\"msp430g2332\"",
",",
"\"msp430g2333\"",
",",
"\"msp430g2352\"",
",",
"\"msp430g2353\"",
",",
"\"msp430g2402\"",
",",
"\"msp430g2403\"",
",",
"\"msp430g2412\"",
",",
"\"msp430g2413\"",
",",
"\"msp430g2432\"",
",",
"\"msp430g2433\"",
",",
"\"msp430g2444\"",
",",
"\"msp430g2452\"",
",",
"\"msp430g2453\"",
",",
"\"msp430g2513\"",
",",
"\"msp430g2533\"",
",",
"\"msp430g2544\"",
",",
"\"msp430g2553\"",
",",
"\"msp430g2744\"",
",",
"\"msp430g2755\"",
",",
"\"msp430g2855\"",
",",
"\"msp430g2955\"",
",",
"\"msp430l092\"",
",",
"\"msp430p112\"",
",",
"\"msp430p313\"",
",",
"\"msp430p315\"",
",",
"\"msp430p315s\"",
",",
"\"msp430p325\"",
",",
"\"msp430tch5e\"",
"}",
";",
"static",
"const",
"char",
"*",
"cached_match",
"=",
"NULL",
";",
"static",
"bool",
"cached_result",
";",
"int",
"i",
";",
"if",
"(",
"msp430_hwmult_type",
"==",
"NONE",
")",
"return",
"true",
";",
"if",
"(",
"target_mcu",
"==",
"NULL",
"||",
"msp430_hwmult_type",
"!=",
"AUTO",
")",
"return",
"false",
";",
"if",
"(",
"target_mcu",
"==",
"cached_match",
")",
"return",
"cached_result",
";",
"cached_match",
"=",
"target_mcu",
";",
"for",
"(",
"i",
"=",
"ARRAY_SIZE",
"(",
"known_nomult_mcus",
")",
";",
"i",
"--",
";",
")",
"if",
"(",
"strcasecmp",
"(",
"target_mcu",
",",
"known_nomult_mcus",
"[",
"i",
"]",
")",
"==",
"0",
")",
"return",
"cached_result",
"=",
"true",
";",
"return",
"cached_result",
"=",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"current",
"MCU",
"does",
"not",
"have",
"a",
"hardware",
"multiplier",
"of",
"any",
"kind",
"."
] | [
"msp430",
"\"msp430c091\"",
"\"msp430c092\"",
"\"msp430c111\"",
"\"msp430c1111\"",
"\"msp430c112\"",
"\"msp430c1121\"",
"\"msp430c1331\"",
"\"msp430c1351\"",
"\"msp430c311s\"",
"\"msp430c312\"",
"\"msp430c313\"",
"\"msp430c314\"",
"\"msp430c315\"",
"\"msp430c323\"",
"\"msp430c325\"",
"\"msp430c412\"",
"\"msp430c413\"",
"\"msp430e112\"",
"\"msp430e313\"",
"\"msp430e315\"",
"\"msp430e325\"",
"\"msp430f110\"",
"\"msp430f1101\"",
"\"msp430f1101a\"",
"\"msp430f1111\"",
"\"msp430f1111a\"",
"\"msp430f112\"",
"\"msp430f1121\"",
"\"msp430f1121a\"",
"\"msp430f1122\"",
"\"msp430f1132\"",
"\"msp430f122\"",
"\"msp430f1222\"",
"\"msp430f123\"",
"\"msp430f1232\"",
"\"msp430f133\"",
"\"msp430f135\"",
"\"msp430f155\"",
"\"msp430f156\"",
"\"msp430f157\"",
"\"msp430f2001\"",
"\"msp430f2002\"",
"\"msp430f2003\"",
"\"msp430f2011\"",
"\"msp430f2012\"",
"\"msp430f2013\"",
"\"msp430f2101\"",
"\"msp430f2111\"",
"\"msp430f2112\"",
"\"msp430f2121\"",
"\"msp430f2122\"",
"\"msp430f2131\"",
"\"msp430f2132\"",
"\"msp430f2232\"",
"\"msp430f2234\"",
"\"msp430f2252\"",
"\"msp430f2254\"",
"\"msp430f2272\"",
"\"msp430f2274\"",
"\"msp430f412\"",
"\"msp430f413\"",
"\"msp430f4132\"",
"\"msp430f415\"",
"\"msp430f4152\"",
"\"msp430f417\"",
"\"msp430f4250\"",
"\"msp430f4260\"",
"\"msp430f4270\"",
"\"msp430f435\"",
"\"msp430f4351\"",
"\"msp430f436\"",
"\"msp430f4361\"",
"\"msp430f437\"",
"\"msp430f4371\"",
"\"msp430f438\"",
"\"msp430f439\"",
"\"msp430f477\"",
"\"msp430f478\"",
"\"msp430f479\"",
"\"msp430fe423\"",
"\"msp430fe4232\"",
"\"msp430fe423a\"",
"\"msp430fe4242\"",
"\"msp430fe425\"",
"\"msp430fe4252\"",
"\"msp430fe425a\"",
"\"msp430fe427\"",
"\"msp430fe4272\"",
"\"msp430fe427a\"",
"\"msp430fg4250\"",
"\"msp430fg4260\"",
"\"msp430fg4270\"",
"\"msp430fg437\"",
"\"msp430fg438\"",
"\"msp430fg439\"",
"\"msp430fg477\"",
"\"msp430fg478\"",
"\"msp430fg479\"",
"\"msp430fr2032\"",
"\"msp430fr2033\"",
"\"msp430fr4131\"",
"\"msp430fr4132\"",
"\"msp430fr4133\"",
"\"msp430fw423\"",
"\"msp430fw425\"",
"\"msp430fw427\"",
"\"msp430fw428\"",
"\"msp430fw429\"",
"\"msp430g2001\"",
"\"msp430g2101\"",
"\"msp430g2102\"",
"\"msp430g2111\"",
"\"msp430g2112\"",
"\"msp430g2113\"",
"\"msp430g2121\"",
"\"msp430g2131\"",
"\"msp430g2132\"",
"\"msp430g2152\"",
"\"msp430g2153\"",
"\"msp430g2201\"",
"\"msp430g2202\"",
"\"msp430g2203\"",
"\"msp430g2210\"",
"\"msp430g2211\"",
"\"msp430g2212\"",
"\"msp430g2213\"",
"\"msp430g2221\"",
"\"msp430g2230\"",
"\"msp430g2231\"",
"\"msp430g2232\"",
"\"msp430g2233\"",
"\"msp430g2252\"",
"\"msp430g2253\"",
"\"msp430g2302\"",
"\"msp430g2303\"",
"\"msp430g2312\"",
"\"msp430g2313\"",
"\"msp430g2332\"",
"\"msp430g2333\"",
"\"msp430g2352\"",
"\"msp430g2353\"",
"\"msp430g2402\"",
"\"msp430g2403\"",
"\"msp430g2412\"",
"\"msp430g2413\"",
"\"msp430g2432\"",
"\"msp430g2433\"",
"\"msp430g2444\"",
"\"msp430g2452\"",
"\"msp430g2453\"",
"\"msp430g2513\"",
"\"msp430g2533\"",
"\"msp430g2544\"",
"\"msp430g2553\"",
"\"msp430g2744\"",
"\"msp430g2755\"",
"\"msp430g2855\"",
"\"msp430g2955\"",
"\"msp430l092\"",
"\"msp430p112\"",
"\"msp430p313\"",
"\"msp430p315\"",
"\"msp430p315s\"",
"\"msp430p325\"",
"\"msp430tch5e\"",
"0"
] | msp4302 | msp430_no_hwmult | msp430 | MPU | GCC | 20,369 | 435 | 1 | [] |
[
"<s>",
"void",
"setSymbolSize",
"(",
"const",
"MCSymbol",
"*",
"Symbol",
",",
"uint64_t",
"Size",
")",
"override",
"{",
"}",
"</s>"
] | [
"For",
"symbols",
"that",
"have",
"a",
"size",
"designated",
"(",
"e.g",
"."
] | [
"BPF"
] | BTFDebug | setSymbolSize | BPF | Virtual ISA | LLVM | 20,370 | 14 | 1 | [] |
[
"<s>",
"static",
"inline",
"int",
"choose_baseaddr_len",
"(",
"unsigned",
"int",
"regno",
",",
"HOST_WIDE_INT",
"offset",
")",
"{",
"int",
"len",
"=",
"4",
";",
"if",
"(",
"offset",
"==",
"0",
")",
"{",
"len",
"=",
"(",
"regno",
"==",
"BP_REG",
"||",
"regno",
"==",
"R13_REG",
")",
";",
"}",
"else",
"if",
"(",
"IN_RANGE",
"(",
"offset",
",",
"-",
"128",
",",
"127",
")",
")",
"len",
"=",
"1",
";",
"if",
"(",
"regno",
"==",
"SP_REG",
"||",
"regno",
"==",
"R12_REG",
")",
"len",
"++",
";",
"return",
"len",
";",
"}",
"</s>"
] | [
"This",
"is",
"semi-inlined",
"memory_address_length",
",",
"but",
"simplified",
"since",
"we",
"know",
"that",
"we",
"'re",
"always",
"dealing",
"with",
"reg+offset",
",",
"and",
"to",
"avoid",
"having",
"to",
"create",
"and",
"discard",
"all",
"that",
"rtl",
"."
] | [
"i386",
"4",
"0",
"128",
"127",
"1"
] | i386 | choose_baseaddr_len | i386 | CPU | GCC | 20,371 | 72 | 1 | [] |
[
"<s>",
"SDValue",
"AMDGPUTargetLowering",
"::",
"combineFMinMaxLegacy",
"(",
"const",
"SDLoc",
"&",
"DL",
",",
"EVT",
"VT",
",",
"SDValue",
"LHS",
",",
"SDValue",
"RHS",
",",
"SDValue",
"True",
",",
"SDValue",
"False",
",",
"SDValue",
"CC",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"if",
"(",
"!",
"(",
"LHS",
"==",
"True",
"&&",
"RHS",
"==",
"False",
")",
"&&",
"!",
"(",
"LHS",
"==",
"False",
"&&",
"RHS",
"==",
"True",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"SelectionDAG",
"&",
"DAG",
"=",
"DCI",
".",
"DAG",
";",
"ISD",
"::",
"CondCode",
"CCOpcode",
"=",
"cast",
"<",
"CondCodeSDNode",
">",
"(",
"CC",
")",
"->",
"get",
"(",
")",
";",
"switch",
"(",
"CCOpcode",
")",
"{",
"case",
"ISD",
"::",
"SETOEQ",
":",
"case",
"ISD",
"::",
"SETONE",
":",
"case",
"ISD",
"::",
"SETUNE",
":",
"case",
"ISD",
"::",
"SETNE",
":",
"case",
"ISD",
"::",
"SETUEQ",
":",
"case",
"ISD",
"::",
"SETEQ",
":",
"case",
"ISD",
"::",
"SETFALSE",
":",
"case",
"ISD",
"::",
"SETFALSE2",
":",
"case",
"ISD",
"::",
"SETTRUE",
":",
"case",
"ISD",
"::",
"SETTRUE2",
":",
"case",
"ISD",
"::",
"SETUO",
":",
"case",
"ISD",
"::",
"SETO",
":",
"break",
";",
"case",
"ISD",
"::",
"SETULE",
":",
"case",
"ISD",
"::",
"SETULT",
":",
"{",
"if",
"(",
"LHS",
"==",
"True",
")",
"return",
"DAG",
".",
"getNode",
"(",
"AMDGPUISD",
"::",
"FMIN_LEGACY",
",",
"DL",
",",
"VT",
",",
"RHS",
",",
"LHS",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"AMDGPUISD",
"::",
"FMAX_LEGACY",
",",
"DL",
",",
"VT",
",",
"LHS",
",",
"RHS",
")",
";",
"}",
"case",
"ISD",
"::",
"SETOLE",
":",
"case",
"ISD",
"::",
"SETOLT",
":",
"case",
"ISD",
"::",
"SETLE",
":",
"case",
"ISD",
"::",
"SETLT",
":",
"{",
"if",
"(",
"DCI",
".",
"getDAGCombineLevel",
"(",
")",
"<",
"AfterLegalizeDAG",
"&&",
"!",
"DCI",
".",
"isCalledByLegalizer",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"LHS",
"==",
"True",
")",
"return",
"DAG",
".",
"getNode",
"(",
"AMDGPUISD",
"::",
"FMIN_LEGACY",
",",
"DL",
",",
"VT",
",",
"LHS",
",",
"RHS",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"AMDGPUISD",
"::",
"FMAX_LEGACY",
",",
"DL",
",",
"VT",
",",
"RHS",
",",
"LHS",
")",
";",
"}",
"case",
"ISD",
"::",
"SETUGE",
":",
"case",
"ISD",
"::",
"SETUGT",
":",
"{",
"if",
"(",
"LHS",
"==",
"True",
")",
"return",
"DAG",
".",
"getNode",
"(",
"AMDGPUISD",
"::",
"FMAX_LEGACY",
",",
"DL",
",",
"VT",
",",
"RHS",
",",
"LHS",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"AMDGPUISD",
"::",
"FMIN_LEGACY",
",",
"DL",
",",
"VT",
",",
"LHS",
",",
"RHS",
")",
";",
"}",
"case",
"ISD",
"::",
"SETGT",
":",
"case",
"ISD",
"::",
"SETGE",
":",
"case",
"ISD",
"::",
"SETOGE",
":",
"case",
"ISD",
"::",
"SETOGT",
":",
"{",
"if",
"(",
"DCI",
".",
"getDAGCombineLevel",
"(",
")",
"<",
"AfterLegalizeDAG",
"&&",
"!",
"DCI",
".",
"isCalledByLegalizer",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"LHS",
"==",
"True",
")",
"return",
"DAG",
".",
"getNode",
"(",
"AMDGPUISD",
"::",
"FMAX_LEGACY",
",",
"DL",
",",
"VT",
",",
"LHS",
",",
"RHS",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"AMDGPUISD",
"::",
"FMIN_LEGACY",
",",
"DL",
",",
"VT",
",",
"RHS",
",",
"LHS",
")",
";",
"}",
"case",
"ISD",
"::",
"SETCC_INVALID",
":",
"llvm_unreachable",
"(",
"\"Invalid setcc condcode!\"",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"Generate",
"Min/Max",
"node",
"."
] | [
"AMDGPU",
"AMDGPU",
"ISD::CondCode",
"ISD::SETOEQ",
"ISD::SETONE",
"ISD::SETUNE",
"ISD::SETNE",
"ISD::SETUEQ",
"ISD::SETEQ",
"ISD::SETFALSE",
"ISD::SETFALSE2",
"ISD::SETTRUE",
"ISD::SETTRUE2",
"ISD::SETUO",
"ISD::SETO",
"ISD::SETULE",
"ISD::SETULT",
"AMDGPUISD::FMIN_LEGACY",
"AMDGPUISD::FMAX_LEGACY",
"ISD::SETOLE",
"ISD::SETOLT",
"ISD::SETLE",
"ISD::SETLT",
"AMDGPUISD::FMIN_LEGACY",
"AMDGPUISD::FMAX_LEGACY",
"ISD::SETUGE",
"ISD::SETUGT",
"AMDGPUISD::FMAX_LEGACY",
"AMDGPUISD::FMIN_LEGACY",
"ISD::SETGT",
"ISD::SETGE",
"ISD::SETOGE",
"ISD::SETOGT",
"AMDGPUISD::FMAX_LEGACY",
"AMDGPUISD::FMIN_LEGACY",
"ISD::SETCC_INVALID",
"\"Invalid setcc condcode!\""
] | AMDGPUISelLowering (2)1 | combineFMinMaxLegacy | AMDGPU | GPU | LLVM | 20,372 | 452 | 1 | [] |
[
"<s>",
"int",
"vms_c_get_crtl_ver",
"(",
"void",
")",
"{",
"return",
"VMS_DEFAULT_CRTL_VER",
";",
"}",
"</s>"
] | [
"The",
"default",
"value",
"for",
"_CRTL_VER",
"macro",
"."
] | [
"vms"
] | vms-c | vms_c_get_crtl_ver | vms | Virtual ISA | GCC | 20,373 | 10 | 1 | [] |
[
"<s>",
"bool",
"GBZ80PreRA",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"bool",
"Modified",
"=",
"false",
";",
"this",
"->",
"MF",
"=",
"&",
"MF",
";",
"const",
"GBZ80Subtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"GBZ80Subtarget",
">",
"(",
")",
";",
"TRI",
"=",
"STI",
".",
"getRegisterInfo",
"(",
")",
";",
"TII",
"=",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"DT",
"=",
"&",
"getAnalysis",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"Modified",
"|=",
"combinePostIncMemAccs",
"(",
")",
";",
"if",
"(",
"WidenRegClasses",
")",
"Modified",
"|=",
"widenConstrainedRegClasses",
"(",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"GBZ80",
"GB",
"GB",
"GB"
] | GBZ80PreRA | runOnMachineFunction | GBZ80 | MPU | LLVM | 20,374 | 91 | 1 | [] |
[
"<s>",
"void",
"PPCAIXAsmPrinter",
"::",
"emitGlobalVariable",
"(",
"const",
"GlobalVariable",
"*",
"GV",
")",
"{",
"ValidateGV",
"(",
"GV",
")",
";",
"if",
"(",
"isSpecialLLVMGlobalArrayForStaticInit",
"(",
"GV",
")",
")",
"return",
";",
"MCSymbolXCOFF",
"*",
"GVSym",
"=",
"cast",
"<",
"MCSymbolXCOFF",
">",
"(",
"getSymbol",
"(",
"GV",
")",
")",
";",
"GVSym",
"->",
"setStorageClass",
"(",
"TargetLoweringObjectFileXCOFF",
"::",
"getStorageClassForGlobal",
"(",
"GV",
")",
")",
";",
"if",
"(",
"GV",
"->",
"isDeclarationForLinker",
"(",
")",
")",
"{",
"emitLinkage",
"(",
"GV",
",",
"GVSym",
")",
";",
"return",
";",
"}",
"SectionKind",
"GVKind",
"=",
"getObjFileLowering",
"(",
")",
".",
"getKindForGlobal",
"(",
"GV",
",",
"TM",
")",
";",
"if",
"(",
"!",
"GVKind",
".",
"isGlobalWriteableData",
"(",
")",
"&&",
"!",
"GVKind",
".",
"isReadOnly",
"(",
")",
")",
"report_fatal_error",
"(",
"\"Encountered a global variable kind that is \"",
"\"not supported yet.\"",
")",
";",
"MCSectionXCOFF",
"*",
"Csect",
"=",
"cast",
"<",
"MCSectionXCOFF",
">",
"(",
"getObjFileLowering",
"(",
")",
".",
"SectionForGlobal",
"(",
"GV",
",",
"GVKind",
",",
"TM",
")",
")",
";",
"OutStreamer",
"->",
"SwitchSection",
"(",
"Csect",
")",
";",
"const",
"DataLayout",
"&",
"DL",
"=",
"GV",
"->",
"getParent",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"if",
"(",
"GVKind",
".",
"isCommon",
"(",
")",
"||",
"GVKind",
".",
"isBSSLocal",
"(",
")",
")",
"{",
"Align",
"Alignment",
"=",
"GV",
"->",
"getAlign",
"(",
")",
".",
"getValueOr",
"(",
"DL",
".",
"getPreferredAlign",
"(",
"GV",
")",
")",
";",
"uint64_t",
"Size",
"=",
"DL",
".",
"getTypeAllocSize",
"(",
"GV",
"->",
"getType",
"(",
")",
"->",
"getElementType",
"(",
")",
")",
";",
"if",
"(",
"GVKind",
".",
"isBSSLocal",
"(",
")",
")",
"OutStreamer",
"->",
"emitXCOFFLocalCommonSymbol",
"(",
"OutContext",
".",
"getOrCreateSymbol",
"(",
"GVSym",
"->",
"getUnqualifiedName",
"(",
")",
")",
",",
"Size",
",",
"GVSym",
",",
"Alignment",
".",
"value",
"(",
")",
")",
";",
"else",
"OutStreamer",
"->",
"emitCommonSymbol",
"(",
"GVSym",
",",
"Size",
",",
"Alignment",
".",
"value",
"(",
")",
")",
";",
"return",
";",
"}",
"MCSymbol",
"*",
"EmittedInitSym",
"=",
"GVSym",
";",
"emitLinkage",
"(",
"GV",
",",
"EmittedInitSym",
")",
";",
"emitAlignment",
"(",
"getGVAlignment",
"(",
"GV",
",",
"DL",
")",
",",
"GV",
")",
";",
"OutStreamer",
"->",
"emitLabel",
"(",
"EmittedInitSym",
")",
";",
"emitGlobalConstant",
"(",
"GV",
"->",
"getParent",
"(",
")",
"->",
"getDataLayout",
"(",
")",
",",
"GV",
"->",
"getInitializer",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"the",
"specified",
"global",
"variable",
"to",
"the",
".s",
"file",
"."
] | [
"PowerPC",
"PPC",
"\"Encountered a global variable kind that is \"",
"\"not supported yet.\""
] | PPCAsmPrinter121 | emitGlobalVariable | PowerPC | CPU | LLVM | 20,375 | 309 | 1 | [] |
[
"<s>",
"static",
"section",
"*",
"arm_function_section",
"(",
"tree",
"decl",
",",
"enum",
"node_frequency",
"freq",
",",
"bool",
"startup",
",",
"bool",
"exit",
")",
"{",
"const",
"char",
"*",
"section_name",
";",
"section",
"*",
"sec",
";",
"if",
"(",
"!",
"decl",
"||",
"TREE_CODE",
"(",
"decl",
")",
"!=",
"FUNCTION_DECL",
")",
"return",
"default_function_section",
"(",
"decl",
",",
"freq",
",",
"startup",
",",
"exit",
")",
";",
"if",
"(",
"!",
"target_pure_code",
")",
"return",
"default_function_section",
"(",
"decl",
",",
"freq",
",",
"startup",
",",
"exit",
")",
";",
"section_name",
"=",
"DECL_SECTION_NAME",
"(",
"decl",
")",
";",
"if",
"(",
"!",
"section_name",
")",
"{",
"section",
"*",
"default_sec",
"=",
"default_function_section",
"(",
"decl",
",",
"freq",
",",
"startup",
",",
"exit",
")",
";",
"if",
"(",
"default_sec",
")",
"default_sec",
"->",
"common",
".",
"flags",
"|=",
"SECTION_ARM_PURECODE",
";",
"return",
"default_sec",
";",
"}",
"sec",
"=",
"get_named_section",
"(",
"decl",
",",
"section_name",
",",
"0",
")",
";",
"if",
"(",
"!",
"sec",
")",
"sec",
"=",
"get_named_section",
"(",
"decl",
",",
"NULL",
",",
"0",
")",
";",
"sec",
"->",
"common",
".",
"flags",
"|=",
"SECTION_ARM_PURECODE",
";",
"return",
"sec",
";",
"}",
"</s>"
] | [
"Implement",
"the",
"TARGET_ASM_FUNCTION_SECTION",
"hook",
".",
"If",
"pure-code",
"is",
"passed",
"as",
"an",
"option",
",",
"make",
"sure",
"all",
"functions",
"are",
"in",
"sections",
"that",
"have",
"the",
"SHF_ARM_PURECODE",
"attribute",
"."
] | [
"arm",
"0",
"0"
] | arm | arm_function_section | arm | CPU | GCC | 20,376 | 152 | 1 | [] |
[
"<s>",
"static",
"void",
"ft32_compute_frame",
"(",
"void",
")",
"{",
"int",
"stack_alignment",
"=",
"STACK_BOUNDARY",
"/",
"BITS_PER_UNIT",
";",
"int",
"padding_locals",
";",
"int",
"regno",
";",
"cfun",
"->",
"machine",
"->",
"local_vars_size",
"=",
"get_frame_size",
"(",
")",
";",
"padding_locals",
"=",
"cfun",
"->",
"machine",
"->",
"local_vars_size",
"%",
"stack_alignment",
";",
"if",
"(",
"padding_locals",
")",
"padding_locals",
"=",
"stack_alignment",
"-",
"padding_locals",
";",
"cfun",
"->",
"machine",
"->",
"local_vars_size",
"+=",
"padding_locals",
";",
"cfun",
"->",
"machine",
"->",
"callee_saved_reg_size",
"=",
"0",
";",
"for",
"(",
"regno",
"=",
"0",
";",
"regno",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"regno",
"++",
")",
"if",
"(",
"df_regs_ever_live_p",
"(",
"regno",
")",
"&&",
"!",
"call_used_or_fixed_reg_p",
"(",
"regno",
")",
")",
"cfun",
"->",
"machine",
"->",
"callee_saved_reg_size",
"+=",
"4",
";",
"cfun",
"->",
"machine",
"->",
"size_for_adjusting_sp",
"=",
"0",
"+",
"cfun",
"->",
"machine",
"->",
"local_vars_size",
"+",
"(",
"ACCUMULATE_OUTGOING_ARGS",
"?",
"(",
"HOST_WIDE_INT",
")",
"crtl",
"->",
"outgoing_args_size",
":",
"0",
")",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"size",
"of",
"the",
"local",
"area",
"and",
"the",
"size",
"to",
"be",
"adjusted",
"by",
"the",
"*",
"prologue",
"and",
"epilogue",
"."
] | [
"ft32",
"0",
"0",
"4",
"0",
"0"
] | ft32 | ft32_compute_frame | ft32 | MPU | GCC | 20,377 | 128 | 1 | [] |
[
"<s>",
"bool",
"MSP430AsmPrinter",
"::",
"doInitialization",
"(",
"Module",
"&",
"M",
")",
"{",
"Mang",
"=",
"new",
"Mangler",
"(",
"M",
",",
"\"\"",
",",
"TAI",
"->",
"getPrivateGlobalPrefix",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Set",
"up",
"the",
"AsmPrinter",
"when",
"we",
"are",
"working",
"on",
"a",
"new",
"module",
"."
] | [
"MSP430",
"MSP430",
"\"\""
] | MSP430AsmPrinter8 | doInitialization | MSP430 | MPU | LLVM | 20,378 | 30 | 1 | [] |
[
"<s>",
"static",
"bool",
"s390_can_change_mode_class",
"(",
"machine_mode",
"from_mode",
",",
"machine_mode",
"to_mode",
",",
"reg_class_t",
"rclass",
")",
"{",
"machine_mode",
"small_mode",
";",
"machine_mode",
"big_mode",
";",
"if",
"(",
"reg_classes_intersect_p",
"(",
"VEC_REGS",
",",
"rclass",
")",
"&&",
"(",
"(",
"s390_is_fpr128",
"(",
"from_mode",
")",
"&&",
"s390_is_vr128",
"(",
"to_mode",
")",
")",
"||",
"(",
"s390_is_vr128",
"(",
"from_mode",
")",
"&&",
"s390_is_fpr128",
"(",
"to_mode",
")",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"from_mode",
")",
"==",
"GET_MODE_SIZE",
"(",
"to_mode",
")",
")",
"return",
"true",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"from_mode",
")",
"<",
"GET_MODE_SIZE",
"(",
"to_mode",
")",
")",
"{",
"small_mode",
"=",
"from_mode",
";",
"big_mode",
"=",
"to_mode",
";",
"}",
"else",
"{",
"small_mode",
"=",
"to_mode",
";",
"big_mode",
"=",
"from_mode",
";",
"}",
"if",
"(",
"reg_classes_intersect_p",
"(",
"VEC_REGS",
",",
"rclass",
")",
"&&",
"(",
"GET_MODE_SIZE",
"(",
"small_mode",
")",
"<",
"8",
"||",
"s390_class_max_nregs",
"(",
"VEC_REGS",
",",
"big_mode",
")",
"==",
"1",
")",
")",
"return",
"false",
";",
"if",
"(",
"reg_classes_intersect_p",
"(",
"ACCESS_REGS",
",",
"rclass",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_CAN_CHANGE_MODE_CLASS",
"."
] | [
"s390",
"8",
"1"
] | s390 | s390_can_change_mode_class | s390 | MPU | GCC | 20,379 | 152 | 1 | [] |
[
"<s>",
"void",
"SystemZHazardRecognizer",
"::",
"copyState",
"(",
"SystemZHazardRecognizer",
"*",
"Incoming",
")",
"{",
"CurrGroupSize",
"=",
"Incoming",
"->",
"CurrGroupSize",
";",
"DEBUG",
"(",
"CurGroupDbg",
"=",
"Incoming",
"->",
"CurGroupDbg",
";",
")",
";",
"ProcResourceCounters",
"=",
"Incoming",
"->",
"ProcResourceCounters",
";",
"CriticalResourceIdx",
"=",
"Incoming",
"->",
"CriticalResourceIdx",
";",
"LastFPdOpCycleIdx",
"=",
"Incoming",
"->",
"LastFPdOpCycleIdx",
";",
"GrpCount",
"=",
"Incoming",
"->",
"GrpCount",
";",
"}",
"</s>"
] | [
"Copy",
"counters",
"from",
"end",
"of",
"single",
"predecessor",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ"
] | SystemZHazardRecognizer10 | copyState | SystemZ | CPU | LLVM | 20,380 | 51 | 1 | [] |
[
"<s>",
"static",
"rtx",
"xtensa_function_arg",
"(",
"cumulative_args_t",
"cum",
",",
"const",
"function_arg_info",
"&",
"arg",
")",
"{",
"return",
"xtensa_function_arg_1",
"(",
"cum",
",",
"arg",
",",
"false",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_FUNCTION_ARG",
"."
] | [
"xtensa"
] | xtensa | xtensa_function_arg | xtensa | MPU | GCC | 20,381 | 24 | 1 | [] |
[
"<s>",
"int",
"PPCRegisterInfo",
"::",
"getDwarfRegNum",
"(",
"unsigned",
"RegNum",
",",
"bool",
"isEH",
")",
"const",
"{",
"return",
"PPCGenRegisterInfo",
"::",
"getDwarfRegNumFull",
"(",
"RegNum",
",",
"0",
")",
";",
"}",
"</s>"
] | [
"Map",
"a",
"target",
"register",
"to",
"an",
"equivalent",
"dwarf",
"register",
"number",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"0"
] | PPCRegisterInfo21 | getDwarfRegNum | PowerPC | CPU | LLVM | 20,382 | 24 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseRegisterInfo",
"::",
"needsFrameBaseReg",
"(",
"MachineInstr",
"*",
"MI",
",",
"int64_t",
"Offset",
")",
"const",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"!",
"MI",
"->",
"getOperand",
"(",
"i",
")",
".",
"isFI",
"(",
")",
";",
"++",
"i",
")",
"{",
"assert",
"(",
"i",
"<",
"MI",
"->",
"getNumOperands",
"(",
")",
"&&",
"\"Instr doesn't have FrameIndex operand!\"",
")",
";",
"}",
"unsigned",
"Opc",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opc",
")",
"{",
"case",
"ARM",
"::",
"LDR",
":",
"case",
"ARM",
"::",
"LDRH",
":",
"case",
"ARM",
"::",
"LDRB",
":",
"case",
"ARM",
"::",
"STR",
":",
"case",
"ARM",
"::",
"STRH",
":",
"case",
"ARM",
"::",
"STRB",
":",
"case",
"ARM",
"::",
"t2LDRi12",
":",
"case",
"ARM",
"::",
"t2LDRi8",
":",
"case",
"ARM",
"::",
"t2STRi12",
":",
"case",
"ARM",
"::",
"t2STRi8",
":",
"case",
"ARM",
"::",
"VLDRS",
":",
"case",
"ARM",
"::",
"VLDRD",
":",
"case",
"ARM",
"::",
"VSTRS",
":",
"case",
"ARM",
"::",
"VSTRD",
":",
"case",
"ARM",
"::",
"tSTRspi",
":",
"case",
"ARM",
"::",
"tLDRspi",
":",
"if",
"(",
"ForceAllBaseRegAlloc",
")",
"return",
"true",
";",
"break",
";",
"default",
":",
"return",
"false",
";",
"}",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"int64_t",
"FPOffset",
"=",
"Offset",
"-",
"8",
";",
"if",
"(",
"!",
"AFI",
"->",
"isThumbFunction",
"(",
")",
"||",
"!",
"AFI",
"->",
"isThumb1OnlyFunction",
"(",
")",
")",
"FPOffset",
"-=",
"80",
";",
"Offset",
"=",
"-",
"Offset",
";",
"Offset",
"+=",
"MFI",
"->",
"getLocalFrameSize",
"(",
")",
";",
"Offset",
"+=",
"128",
";",
"unsigned",
"StackAlign",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameInfo",
"(",
")",
"->",
"getStackAlignment",
"(",
")",
";",
"if",
"(",
"hasFP",
"(",
"MF",
")",
"&&",
"!",
"(",
"(",
"MFI",
"->",
"getLocalFrameMaxAlign",
"(",
")",
">",
"StackAlign",
")",
"&&",
"canRealignStack",
"(",
"MF",
")",
")",
")",
"{",
"if",
"(",
"isFrameOffsetLegal",
"(",
"MI",
",",
"FPOffset",
")",
")",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
"&&",
"isFrameOffsetLegal",
"(",
"MI",
",",
"Offset",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"instruction",
"'s",
"frame",
"index",
"reference",
"would",
"be",
"better",
"served",
"by",
"a",
"base",
"register",
"other",
"than",
"FP",
"or",
"SP",
"."
] | [
"ARM",
"ARM",
"0",
"\"Instr doesn't have FrameIndex operand!\"",
"ARM::LDR",
"ARM::LDRH",
"ARM::LDRB",
"ARM::STR",
"ARM::STRH",
"ARM::STRB",
"ARM::t2LDRi12",
"ARM::t2LDRi8",
"ARM::t2STRi12",
"ARM::t2STRi8",
"ARM::VLDRS",
"ARM::VLDRD",
"ARM::VSTRS",
"ARM::VSTRD",
"ARM::tSTRspi",
"ARM::tLDRspi",
"ARM",
"ARM",
"8",
"80",
"128"
] | ARMBaseRegisterInfo29 | needsFrameBaseReg | ARM | CPU | LLVM | 20,383 | 321 | 1 | [] |
[
"<s>",
"unsigned",
"HexagonInstrInfo",
"::",
"getInstrLatency",
"(",
"const",
"InstrItineraryData",
"*",
"ItinData",
",",
"const",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"*",
"PredCost",
")",
"const",
"{",
"return",
"getInstrTimingClassLatency",
"(",
"ItinData",
",",
"&",
"MI",
")",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"instruction",
"latency",
"of",
"a",
"given",
"instruction",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonInstrInfo (2) | getInstrLatency | Hexagon | DSP | LLVM | 20,384 | 31 | 1 | [] |
[
"<s>",
"void",
"pa_asm_output_aligned_local",
"(",
"FILE",
"*",
"stream",
",",
"const",
"char",
"*",
"name",
",",
"unsigned",
"HOST_WIDE_INT",
"size",
",",
"unsigned",
"int",
"align",
")",
"{",
"switch_to_section",
"(",
"bss_section",
")",
";",
"fprintf",
"(",
"stream",
",",
"\"\\t.align %u\\n\"",
",",
"align",
"/",
"BITS_PER_UNIT",
")",
";",
"fprintf",
"(",
"stream",
",",
"\"%s\"",
",",
"LOCAL_ASM_OP",
")",
";",
"assemble_name",
"(",
"stream",
",",
"name",
")",
";",
"fprintf",
"(",
"stream",
",",
"\"\\n\"",
")",
";",
"ASM_OUTPUT_LABEL",
"(",
"stream",
",",
"name",
")",
";",
"fprintf",
"(",
"stream",
",",
"\"\\t.block \"",
"HOST_WIDE_INT_PRINT_UNSIGNED",
"\"\\n\"",
",",
"size",
")",
";",
"}",
"</s>"
] | [
"We",
"ca",
"n't",
"use",
".comm",
"for",
"local",
"common",
"storage",
"as",
"the",
"SOM",
"linker",
"effectively",
"treats",
"the",
"symbol",
"as",
"universal",
"and",
"uses",
"the",
"same",
"storage",
"for",
"local",
"symbols",
"with",
"the",
"same",
"name",
"in",
"different",
"object",
"files",
".",
"The",
".block",
"directive",
"reserves",
"an",
"uninitialized",
"block",
"of",
"storage",
".",
"However",
",",
"it",
"'s",
"not",
"common",
"storage",
".",
"Fortunately",
",",
"GCC",
"never",
"requests",
"common",
"storage",
"with",
"the",
"same",
"name",
"in",
"any",
"given",
"translation",
"unit",
"."
] | [
"pa",
"\"\\t.align %u\\n\"",
"\"%s\"",
"\"\\n\"",
"\"\\t.block \"",
"\"\\n\""
] | pa4 | pa_asm_output_aligned_local | pa | CPU | GCC | 20,385 | 79 | 1 | [] |
[
"<s>",
"static",
"bool",
"find_mem_ref",
"(",
"rtx",
"pat",
",",
"rtx",
"*",
"mem_ref",
")",
"{",
"const",
"char",
"*",
"fmt",
";",
"int",
"i",
",",
"j",
";",
"if",
"(",
"tie_operand",
"(",
"pat",
",",
"VOIDmode",
")",
")",
"return",
"false",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"MEM",
")",
"{",
"*",
"mem_ref",
"=",
"pat",
";",
"return",
"true",
";",
"}",
"fmt",
"=",
"GET_RTX_FORMAT",
"(",
"GET_CODE",
"(",
"pat",
")",
")",
";",
"for",
"(",
"i",
"=",
"GET_RTX_LENGTH",
"(",
"GET_CODE",
"(",
"pat",
")",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
")",
"{",
"if",
"(",
"fmt",
"[",
"i",
"]",
"==",
"'e'",
")",
"{",
"if",
"(",
"find_mem_ref",
"(",
"XEXP",
"(",
"pat",
",",
"i",
")",
",",
"mem_ref",
")",
")",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"fmt",
"[",
"i",
"]",
"==",
"'E'",
")",
"for",
"(",
"j",
"=",
"XVECLEN",
"(",
"pat",
",",
"i",
")",
"-",
"1",
";",
"j",
">=",
"0",
";",
"j",
"--",
")",
"{",
"if",
"(",
"find_mem_ref",
"(",
"XVECEXP",
"(",
"pat",
",",
"i",
",",
"j",
")",
",",
"mem_ref",
")",
")",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Determine",
"if",
"PAT",
"refers",
"to",
"memory",
".",
"If",
"so",
",",
"set",
"MEM_REF",
"to",
"the",
"MEM",
"rtx",
"and",
"return",
"true",
"."
] | [
"powerpcspe",
"1",
"0",
"1",
"0"
] | powerpcspe | find_mem_ref | powerpcspe | CPU | GCC | 20,386 | 169 | 1 | [] |
[
"<s>",
"void",
"AMDGPUPassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"const",
"AMDGPUTargetMachine",
"&",
"TM",
"=",
"getAMDGPUTargetMachine",
"(",
")",
";",
"disablePass",
"(",
"&",
"StackMapLivenessID",
")",
";",
"disablePass",
"(",
"&",
"FuncletLayoutID",
")",
";",
"disablePass",
"(",
"&",
"PatchableFunctionID",
")",
";",
"addPass",
"(",
"createAMDGPUPrintfRuntimeBinding",
"(",
")",
")",
";",
"addPass",
"(",
"createAMDGPUFixFunctionBitcastsPass",
"(",
")",
")",
";",
"addPass",
"(",
"createAMDGPUPropagateAttributesEarlyPass",
"(",
"&",
"TM",
")",
")",
";",
"addPass",
"(",
"createAtomicExpandPass",
"(",
")",
")",
";",
"addPass",
"(",
"createAMDGPULowerIntrinsicsPass",
"(",
")",
")",
";",
"addPass",
"(",
"createAMDGPUAlwaysInlinePass",
"(",
")",
")",
";",
"addPass",
"(",
"createAlwaysInlinerLegacyPass",
"(",
")",
")",
";",
"addPass",
"(",
"createBarrierNoopPass",
"(",
")",
")",
";",
"if",
"(",
"TM",
".",
"getTargetTriple",
"(",
")",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"r600",
")",
"addPass",
"(",
"createR600OpenCLImageTypeLoweringPass",
"(",
")",
")",
";",
"addPass",
"(",
"createAMDGPUOpenCLEnqueuedBlockLoweringPass",
"(",
")",
")",
";",
"if",
"(",
"EnableLowerModuleLDS",
")",
"addPass",
"(",
"createAMDGPULowerModuleLDSPass",
"(",
")",
")",
";",
"if",
"(",
"TM",
".",
"getOptLevel",
"(",
")",
">",
"CodeGenOpt",
"::",
"None",
")",
"{",
"addPass",
"(",
"createInferAddressSpacesPass",
"(",
")",
")",
";",
"addPass",
"(",
"createAMDGPUPromoteAlloca",
"(",
")",
")",
";",
"if",
"(",
"EnableSROA",
")",
"addPass",
"(",
"createSROAPass",
"(",
")",
")",
";",
"if",
"(",
"EnableScalarIRPasses",
".",
"getNumOccurrences",
"(",
")",
"?",
"EnableScalarIRPasses",
":",
"TM",
".",
"getOptLevel",
"(",
")",
">",
"CodeGenOpt",
"::",
"Less",
")",
"addStraightLineScalarOptimizationPasses",
"(",
")",
";",
"if",
"(",
"EnableAMDGPUAliasAnalysis",
")",
"{",
"addPass",
"(",
"createAMDGPUAAWrapperPass",
"(",
")",
")",
";",
"addPass",
"(",
"createExternalAAWrapperPass",
"(",
"[",
"]",
"(",
"Pass",
"&",
"P",
",",
"Function",
"&",
",",
"AAResults",
"&",
"AAR",
")",
"{",
"if",
"(",
"auto",
"*",
"WrapperPass",
"=",
"P",
".",
"getAnalysisIfAvailable",
"<",
"AMDGPUAAWrapperPass",
">",
"(",
")",
")",
"AAR",
".",
"addAAResult",
"(",
"WrapperPass",
"->",
"getResult",
"(",
")",
")",
";",
"}",
")",
")",
";",
"}",
"}",
"if",
"(",
"TM",
".",
"getTargetTriple",
"(",
")",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"amdgcn",
")",
"{",
"addPass",
"(",
"createAMDGPUCodeGenPreparePass",
"(",
")",
")",
";",
"}",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"if",
"(",
"EnableScalarIRPasses",
".",
"getNumOccurrences",
"(",
")",
"?",
"EnableScalarIRPasses",
":",
"TM",
".",
"getOptLevel",
"(",
")",
">",
"CodeGenOpt",
"::",
"Less",
")",
"addEarlyCSEOrGVNPass",
"(",
")",
";",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"R600",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | AMDGPUTargetMachine74 | addIRPasses | AMDGPU | GPU | LLVM | 20,387 | 314 | 1 | [] |
[
"<s>",
"static",
"bool",
"nds32_modes_tieable_p",
"(",
"machine_mode",
"mode1",
",",
"machine_mode",
"mode2",
")",
"{",
"if",
"(",
"(",
"GET_MODE_CLASS",
"(",
"mode1",
")",
"==",
"MODE_INT",
"&&",
"GET_MODE_CLASS",
"(",
"mode2",
")",
"==",
"MODE_INT",
")",
"&&",
"GET_MODE_SIZE",
"(",
"mode1",
")",
"<=",
"UNITS_PER_WORD",
"&&",
"GET_MODE_SIZE",
"(",
"mode2",
")",
"<=",
"UNITS_PER_WORD",
")",
"return",
"true",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"mode1",
")",
"==",
"GET_MODE_SIZE",
"(",
"mode2",
")",
")",
"{",
"if",
"(",
"(",
"TARGET_FPU_SINGLE",
"&&",
"!",
"TARGET_FPU_DOUBLE",
")",
"&&",
"(",
"mode1",
"==",
"DFmode",
"||",
"mode2",
"==",
"DFmode",
")",
")",
"return",
"false",
";",
"else",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_MODES_TIEABLE_P",
".",
"We",
"can",
"use",
"general",
"registers",
"to",
"tie",
"QI/HI/SI",
"modes",
"together",
"."
] | [
"nds32"
] | nds32 | nds32_modes_tieable_p | nds32 | CPU | GCC | 20,388 | 90 | 1 | [] |
[
"<s>",
"void",
"SystemZHazardRecognizer",
"::",
"EmitInstruction",
"(",
"SUnit",
"*",
"SU",
")",
"{",
"const",
"MCSchedClassDesc",
"*",
"SC",
"=",
"getSchedClass",
"(",
"SU",
")",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"++ HazardRecognizer emitting \"",
";",
"dumpSU",
"(",
"SU",
",",
"dbgs",
"(",
")",
")",
";",
"dbgs",
"(",
")",
"<<",
"\"\\n\"",
";",
")",
";",
"LLVM_DEBUG",
"(",
"dumpCurrGroup",
"(",
"\"Decode group before emission\"",
")",
";",
")",
";",
"if",
"(",
"!",
"fitsIntoCurrentGroup",
"(",
"SU",
")",
")",
"nextGroup",
"(",
")",
";",
"LLVM_DEBUG",
"(",
"raw_string_ostream",
"cgd",
"(",
"CurGroupDbg",
")",
";",
"if",
"(",
"CurGroupDbg",
".",
"length",
"(",
")",
")",
"cgd",
"<<",
"\", \"",
";",
"dumpSU",
"(",
"SU",
",",
"cgd",
")",
";",
")",
";",
"LastEmittedMI",
"=",
"SU",
"->",
"getInstr",
"(",
")",
";",
"if",
"(",
"SU",
"->",
"isCall",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"++ Clearing state after call.\\n\"",
";",
")",
";",
"Reset",
"(",
")",
";",
"LastEmittedMI",
"=",
"SU",
"->",
"getInstr",
"(",
")",
";",
"return",
";",
"}",
"for",
"(",
"TargetSchedModel",
"::",
"ProcResIter",
"PI",
"=",
"SchedModel",
"->",
"getWriteProcResBegin",
"(",
"SC",
")",
",",
"PE",
"=",
"SchedModel",
"->",
"getWriteProcResEnd",
"(",
"SC",
")",
";",
"PI",
"!=",
"PE",
";",
"++",
"PI",
")",
"{",
"if",
"(",
"SchedModel",
"->",
"getProcResource",
"(",
"PI",
"->",
"ProcResourceIdx",
")",
"->",
"BufferSize",
"==",
"1",
")",
"continue",
";",
"int",
"&",
"CurrCounter",
"=",
"ProcResourceCounters",
"[",
"PI",
"->",
"ProcResourceIdx",
"]",
";",
"CurrCounter",
"+=",
"PI",
"->",
"Cycles",
";",
"if",
"(",
"(",
"CurrCounter",
">",
"ProcResCostLim",
")",
"&&",
"(",
"CriticalResourceIdx",
"==",
"UINT_MAX",
"||",
"(",
"PI",
"->",
"ProcResourceIdx",
"!=",
"CriticalResourceIdx",
"&&",
"CurrCounter",
">",
"ProcResourceCounters",
"[",
"CriticalResourceIdx",
"]",
")",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"++ New critical resource: \"",
"<<",
"SchedModel",
"->",
"getProcResource",
"(",
"PI",
"->",
"ProcResourceIdx",
")",
"->",
"Name",
"<<",
"\"\\n\"",
";",
")",
";",
"CriticalResourceIdx",
"=",
"PI",
"->",
"ProcResourceIdx",
";",
"}",
"}",
"if",
"(",
"SU",
"->",
"isUnbuffered",
")",
"{",
"LastFPdOpCycleIdx",
"=",
"getCurrCycleIdx",
"(",
"SU",
")",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"++ Last FPd cycle index: \"",
"<<",
"LastFPdOpCycleIdx",
"<<",
"\"\\n\"",
";",
")",
";",
"}",
"CurrGroupSize",
"+=",
"getNumDecoderSlots",
"(",
"SU",
")",
";",
"CurrGroupHas4RegOps",
"|=",
"has4RegOps",
"(",
"SU",
"->",
"getInstr",
"(",
")",
")",
";",
"unsigned",
"GroupLim",
"=",
"(",
"(",
"CurrGroupHas4RegOps",
"&&",
"getNumDecoderSlots",
"(",
"SU",
")",
"<",
"3",
")",
"?",
"2",
":",
"3",
")",
";",
"assert",
"(",
"CurrGroupSize",
"<=",
"GroupLim",
"&&",
"\"SU does not fit into decoder group!\"",
")",
";",
"if",
"(",
"CurrGroupSize",
"==",
"GroupLim",
"||",
"SC",
"->",
"EndGroup",
")",
"nextGroup",
"(",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"SystemZ",
"SystemZ",
"\"++ HazardRecognizer emitting \"",
"\"\\n\"",
"\"Decode group before emission\"",
"\", \"",
"\"++ Clearing state after call.\\n\"",
"1",
"\"++ New critical resource: \"",
"\"\\n\"",
"\"++ Last FPd cycle index: \"",
"\"\\n\"",
"3",
"2",
"3",
"\"SU does not fit into decoder group!\""
] | SystemZHazardRecognizer3 | EmitInstruction | SystemZ | CPU | LLVM | 20,389 | 352 | 1 | [] |
[
"<s>",
"static",
"tree",
"rs6000_fold_builtin",
"(",
"tree",
"fndecl",
"ATTRIBUTE_UNUSED",
",",
"int",
"n_args",
"ATTRIBUTE_UNUSED",
",",
"tree",
"*",
"args",
"ATTRIBUTE_UNUSED",
",",
"bool",
"ignore",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"SUBTARGET_FOLD_BUILTIN",
"(",
"fndecl",
",",
"n_args",
",",
"args",
",",
"ignore",
")",
";",
"return",
"NULL_TREE",
";",
"}",
"</s>"
] | [
"Target",
"hook",
"for",
"early",
"folding",
"of",
"built-ins",
",",
"shamelessly",
"stolen",
"from",
"ia64.cc",
"."
] | [
"rs6000"
] | rs60007 | rs6000_fold_builtin | rs6000 | CPU | GCC | 20,390 | 38 | 1 | [] |
[
"<s>",
"SDValue",
"BPFTargetLowering",
"::",
"LowerFormalArguments",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"const",
"SDLoc",
"&",
"DL",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"switch",
"(",
"CallConv",
")",
"{",
"default",
":",
"report_fatal_error",
"(",
"\"Unsupported calling convention\"",
")",
";",
"case",
"CallingConv",
"::",
"C",
":",
"case",
"CallingConv",
"::",
"Fast",
":",
"break",
";",
"}",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"RegInfo",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"ArgLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"MF",
",",
"ArgLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeFormalArguments",
"(",
"Ins",
",",
"CC_BPF64",
")",
";",
"for",
"(",
"auto",
"&",
"VA",
":",
"ArgLocs",
")",
"{",
"if",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
")",
"{",
"EVT",
"RegVT",
"=",
"VA",
".",
"getLocVT",
"(",
")",
";",
"switch",
"(",
"RegVT",
".",
"getSimpleVT",
"(",
")",
".",
"SimpleTy",
")",
"{",
"default",
":",
"{",
"errs",
"(",
")",
"<<",
"\"LowerFormalArguments Unhandled argument type: \"",
"<<",
"RegVT",
".",
"getEVTString",
"(",
")",
"<<",
"'\\n'",
";",
"llvm_unreachable",
"(",
"0",
")",
";",
"}",
"case",
"MVT",
"::",
"i64",
":",
"unsigned",
"VReg",
"=",
"RegInfo",
".",
"createVirtualRegister",
"(",
"&",
"BPF",
"::",
"GPRRegClass",
")",
";",
"RegInfo",
".",
"addLiveIn",
"(",
"VA",
".",
"getLocReg",
"(",
")",
",",
"VReg",
")",
";",
"SDValue",
"ArgValue",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"DL",
",",
"VReg",
",",
"RegVT",
")",
";",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"SExt",
")",
"ArgValue",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AssertSext",
",",
"DL",
",",
"RegVT",
",",
"ArgValue",
",",
"DAG",
".",
"getValueType",
"(",
"VA",
".",
"getValVT",
"(",
")",
")",
")",
";",
"else",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"ZExt",
")",
"ArgValue",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AssertZext",
",",
"DL",
",",
"RegVT",
",",
"ArgValue",
",",
"DAG",
".",
"getValueType",
"(",
"VA",
".",
"getValVT",
"(",
")",
")",
")",
";",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"!=",
"CCValAssign",
"::",
"Full",
")",
"ArgValue",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TRUNCATE",
",",
"DL",
",",
"VA",
".",
"getValVT",
"(",
")",
",",
"ArgValue",
")",
";",
"InVals",
".",
"push_back",
"(",
"ArgValue",
")",
";",
"}",
"}",
"else",
"{",
"fail",
"(",
"DL",
",",
"DAG",
",",
"\"defined with too many args\"",
")",
";",
"InVals",
".",
"push_back",
"(",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"DL",
",",
"VA",
".",
"getLocVT",
"(",
")",
")",
")",
";",
"}",
"}",
"if",
"(",
"IsVarArg",
"||",
"MF",
".",
"getFunction",
"(",
")",
"->",
"hasStructRetAttr",
"(",
")",
")",
"{",
"fail",
"(",
"DL",
",",
"DAG",
",",
"\"functions with VarArgs or StructRet are not supported\"",
")",
";",
"}",
"return",
"Chain",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"the",
"Ins",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"BPF",
"BPF",
"ISD::InputArg",
"\"Unsupported calling convention\"",
"16",
"BPF",
"\"LowerFormalArguments Unhandled argument type: \"",
"0",
"MVT::i64",
"BPF::GPRRegClass",
"ISD::AssertSext",
"ISD::AssertZext",
"ISD::TRUNCATE",
"\"defined with too many args\"",
"0",
"\"functions with VarArgs or StructRet are not supported\""
] | BPFISelLowering13 | LowerFormalArguments | BPF | Virtual ISA | LLVM | 20,391 | 418 | 1 | [] |
[
"<s>",
"static",
"bool",
"rx_function_ok_for_sibcall",
"(",
"tree",
"decl",
",",
"tree",
"exp",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"TARGET_JSR",
")",
"return",
"false",
";",
"if",
"(",
"decl",
"==",
"NULL",
")",
"return",
"false",
";",
"if",
"(",
"is_fast_interrupt_func",
"(",
"NULL_TREE",
")",
"||",
"is_interrupt_func",
"(",
"NULL_TREE",
")",
"||",
"is_naked_func",
"(",
"NULL_TREE",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"it",
"is",
"ok",
"to",
"make",
"a",
"tail-call",
"to",
"DECL",
",",
"a",
"function_decl",
"or",
"NULL",
"if",
"this",
"is",
"an",
"indirect",
"call",
",",
"using",
"EXP"
] | [
"rx"
] | rx | rx_function_ok_for_sibcall | rx | CPU | GCC | 20,392 | 52 | 1 | [] |
[
"<s>",
"static",
"rtx",
"arc_legitimize_address_0",
"(",
"rtx",
"x",
",",
"rtx",
"oldx",
"ATTRIBUTE_UNUSED",
",",
"machine_mode",
"mode",
")",
"{",
"rtx",
"addr",
",",
"inner",
";",
"if",
"(",
"flag_pic",
"&&",
"SYMBOLIC_CONST",
"(",
"x",
")",
")",
"(",
"x",
")",
"=",
"arc_legitimize_pic_address",
"(",
"x",
",",
"0",
")",
";",
"addr",
"=",
"x",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"CONST",
")",
"addr",
"=",
"XEXP",
"(",
"addr",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"PLUS",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
"&&",
"(",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
"==",
"SYMBOL_REF",
"&&",
"!",
"SYMBOL_REF_FUNCTION_P",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
")",
"||",
"(",
"REG_P",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
"&&",
"(",
"INTVAL",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
"&",
"252",
")",
")",
")",
")",
"{",
"HOST_WIDE_INT",
"offs",
",",
"upper",
";",
"int",
"size",
"=",
"GET_MODE_SIZE",
"(",
"mode",
")",
";",
"offs",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"addr",
",",
"1",
")",
")",
";",
"upper",
"=",
"(",
"offs",
"+",
"256",
"*",
"size",
")",
"&",
"~",
"511",
"*",
"size",
";",
"inner",
"=",
"plus_constant",
"(",
"Pmode",
",",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"upper",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST",
")",
"inner",
"=",
"gen_rtx_CONST",
"(",
"Pmode",
",",
"inner",
")",
";",
"addr",
"=",
"plus_constant",
"(",
"Pmode",
",",
"force_reg",
"(",
"Pmode",
",",
"inner",
")",
",",
"offs",
"-",
"upper",
")",
";",
"x",
"=",
"addr",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"SYMBOL_REF",
"&&",
"!",
"SYMBOL_REF_FUNCTION_P",
"(",
"addr",
")",
")",
"x",
"=",
"force_reg",
"(",
"Pmode",
",",
"x",
")",
";",
"if",
"(",
"memory_address_p",
"(",
"(",
"machine_mode",
")",
"mode",
",",
"x",
")",
")",
"return",
"x",
";",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"This",
"is",
"like",
"the",
"hook",
",",
"but",
"returns",
"NULL",
"when",
"it",
"ca",
"n't",
"/",
"wo",
"n't",
"generate",
"a",
"legitimate",
"address",
"."
] | [
"arc",
"0",
"0",
"1",
"0",
"0",
"0",
"1",
"252",
"1",
"256",
"511",
"0"
] | arc4 | arc_legitimize_address_0 | arc | MPU | GCC | 20,393 | 276 | 1 | [] |
[
"<s>",
"static",
"int64_t",
"getNullPointerValue",
"(",
"unsigned",
"AddrSpace",
")",
"{",
"return",
"(",
"AddrSpace",
"==",
"AMDGPUAS",
"::",
"LOCAL_ADDRESS",
"||",
"AddrSpace",
"==",
"AMDGPUAS",
"::",
"PRIVATE_ADDRESS",
"||",
"AddrSpace",
"==",
"AMDGPUAS",
"::",
"REGION_ADDRESS",
")",
"?",
"-",
"1",
":",
"0",
";",
"}",
"</s>"
] | [
"Get",
"the",
"integer",
"value",
"of",
"a",
"null",
"pointer",
"in",
"the",
"given",
"address",
"space",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"1",
"0"
] | AMDGPUTargetMachine15 | getNullPointerValue | AMDGPU | GPU | LLVM | 20,394 | 35 | 1 | [] |
[
"<s>",
"void",
"KudeyarRegisterInfo",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
";",
"if",
"(",
"!",
"TFI",
"->",
"hasReservedCallFrame",
"(",
"MF",
")",
")",
"{",
"MachineInstr",
"*",
"Old",
"=",
"I",
";",
"uint64_t",
"Amount",
"=",
"Old",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Amount",
"!=",
"0",
")",
"{",
"Amount",
"=",
"(",
"Amount",
"+",
"StackAlign",
"-",
"1",
")",
"/",
"StackAlign",
"*",
"StackAlign",
";",
"MachineInstr",
"*",
"New",
"=",
"0",
";",
"if",
"(",
"Old",
"->",
"getOpcode",
"(",
")",
"==",
"TII",
".",
"getCallFrameSetupOpcode",
"(",
")",
")",
"{",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"Old",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"Kudeyar",
"::",
"SUB_RR",
")",
",",
"Kudeyar",
"::",
"SP",
")",
".",
"addReg",
"(",
"Kudeyar",
"::",
"SP",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"Old",
"->",
"getOpcode",
"(",
")",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
")",
";",
"uint64_t",
"CalleeAmt",
"=",
"Old",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
";",
"Amount",
"-=",
"CalleeAmt",
";",
"if",
"(",
"Amount",
")",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"Old",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"Kudeyar",
"::",
"ADD_RR",
")",
",",
"Kudeyar",
"::",
"SP",
")",
".",
"addReg",
"(",
"Kudeyar",
"::",
"SP",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"}",
"if",
"(",
"New",
")",
"{",
"New",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"MBB",
".",
"insert",
"(",
"I",
",",
"New",
")",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
")",
"{",
"if",
"(",
"uint64_t",
"CalleeAmt",
"=",
"I",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
")",
"{",
"MachineInstr",
"*",
"Old",
"=",
"I",
";",
"MachineInstr",
"*",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"Old",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"Kudeyar",
"::",
"SUB_RR",
")",
",",
"Kudeyar",
"::",
"SP",
")",
".",
"addReg",
"(",
"Kudeyar",
"::",
"SP",
")",
".",
"addImm",
"(",
"CalleeAmt",
")",
";",
"New",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"MBB",
".",
"insert",
"(",
"I",
",",
"New",
")",
";",
"}",
"}",
"MBB",
".",
"erase",
"(",
"I",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] | [
"Kudeyar",
"Kudeyar",
"0",
"0",
"1",
"0",
"Kudeyar::SUB_RR",
"Kudeyar::SP",
"Kudeyar::SP",
"1",
"Kudeyar::ADD_RR",
"Kudeyar::SP",
"Kudeyar::SP",
"3",
"1",
"Kudeyar::SUB_RR",
"Kudeyar::SP",
"Kudeyar::SP",
"3"
] | KudeyarRegisterInfo | eliminateCallFramePseudoInstr | Kudeyar | CPU | LLVM | 20,395 | 362 | 1 | [] |
[
"<s>",
"SDValue",
"SITargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"AMDGPUTargetLowering",
"::",
"LowerOperation",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FrameIndex",
":",
"return",
"LowerFrameIndex",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BRCOND",
":",
"return",
"LowerBRCOND",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"{",
"SDValue",
"Result",
"=",
"LowerLOAD",
"(",
"Op",
",",
"DAG",
")",
";",
"assert",
"(",
"(",
"!",
"Result",
".",
"getNode",
"(",
")",
"||",
"Result",
".",
"getNode",
"(",
")",
"->",
"getNumValues",
"(",
")",
"==",
"2",
")",
"&&",
"\"Load should return a value and a chain\"",
")",
";",
"return",
"Result",
";",
"}",
"case",
"ISD",
"::",
"FSIN",
":",
"case",
"ISD",
"::",
"FCOS",
":",
"return",
"LowerTrig",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SELECT",
":",
"return",
"LowerSELECT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FDIV",
":",
"return",
"LowerFDIV",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"LowerSTORE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"{",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"return",
"LowerGlobalAddress",
"(",
"MFI",
",",
"Op",
",",
"DAG",
")",
";",
"}",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"LowerINTRINSIC_WO_CHAIN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_VOID",
":",
"return",
"LowerINTRINSIC_VOID",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU",
"ISD::FrameIndex",
"ISD::BRCOND",
"ISD::LOAD",
"2",
"\"Load should return a value and a chain\"",
"ISD::FSIN",
"ISD::FCOS",
"ISD::SELECT",
"ISD::FDIV",
"ISD::STORE",
"ISD::GlobalAddress",
"SI",
"SI",
"ISD::INTRINSIC_WO_CHAIN",
"SI",
"ISD::INTRINSIC_VOID",
"SI"
] | SIISelLowering (2) | LowerOperation | AMDGPU | GPU | LLVM | 20,396 | 237 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_default_align",
"(",
"struct",
"gcc_options",
"*",
"opts",
")",
"{",
"if",
"(",
"opts",
"->",
"x_align_loops",
"==",
"0",
")",
"{",
"opts",
"->",
"x_align_loops",
"=",
"processor_target_table",
"[",
"ix86_tune",
"]",
".",
"align_loop",
";",
"align_loops_max_skip",
"=",
"processor_target_table",
"[",
"ix86_tune",
"]",
".",
"align_loop_max_skip",
";",
"}",
"if",
"(",
"opts",
"->",
"x_align_jumps",
"==",
"0",
")",
"{",
"opts",
"->",
"x_align_jumps",
"=",
"processor_target_table",
"[",
"ix86_tune",
"]",
".",
"align_jump",
";",
"align_jumps_max_skip",
"=",
"processor_target_table",
"[",
"ix86_tune",
"]",
".",
"align_jump_max_skip",
";",
"}",
"if",
"(",
"opts",
"->",
"x_align_functions",
"==",
"0",
")",
"{",
"opts",
"->",
"x_align_functions",
"=",
"processor_target_table",
"[",
"ix86_tune",
"]",
".",
"align_func",
";",
"}",
"}",
"</s>"
] | [
"Default",
"align_",
"*",
"from",
"the",
"processor",
"table",
"."
] | [
"i386",
"0",
"0",
"0"
] | i3865 | ix86_default_align | i386 | CPU | GCC | 20,397 | 92 | 1 | [] |
[
"<s>",
"void",
"Cpu0SEInstrInfo",
"::",
"adjustStackPtr",
"(",
"unsigned",
"SP",
",",
"int64_t",
"Amount",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"DebugLoc",
"DL",
"=",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
"?",
"I",
"->",
"getDebugLoc",
"(",
")",
":",
"DebugLoc",
"(",
")",
";",
"unsigned",
"ADDu",
"=",
"Cpu0",
"::",
"ADDu",
";",
"unsigned",
"ADDiu",
"=",
"Cpu0",
"::",
"ADDiu",
";",
"if",
"(",
"isInt",
"<",
"16",
">",
"(",
"Amount",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ADDiu",
")",
",",
"SP",
")",
".",
"addReg",
"(",
"SP",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"}",
"else",
"{",
"unsigned",
"Reg",
"=",
"loadImmediate",
"(",
"Amount",
",",
"MBB",
",",
"I",
",",
"DL",
",",
"nullptr",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ADDu",
")",
",",
"SP",
")",
".",
"addReg",
"(",
"SP",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"Kill",
")",
";",
"}",
"}",
"</s>"
] | [
"Adjust",
"SP",
"by",
"Amount",
"bytes",
"."
] | [
"Cpu0",
"Cpu0",
"Cpu0::ADDu",
"Cpu0::ADDiu",
"16"
] | Cpu0SEInstrInfo | adjustStackPtr | Cpu0 | CPU | LLVM | 20,398 | 145 | 1 | [] |
[
"<s>",
"llvm",
"::",
"FastISel",
"*",
"AArch64",
"::",
"createFastISel",
"(",
"FunctionLoweringInfo",
"&",
"funcInfo",
",",
"const",
"TargetLibraryInfo",
"*",
"libInfo",
")",
"{",
"return",
"new",
"AArch64FastISel",
"(",
"funcInfo",
",",
"libInfo",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"returns",
"a",
"target",
"specific",
"FastISel",
"object",
",",
"or",
"null",
"if",
"the",
"target",
"does",
"not",
"support",
"``",
"fast",
"''",
"ISel",
"."
] | [
"AArch64",
"AArch64::createFastISel",
"AArch64"
] | AArch64FastISel1 | createFastISel | AArch64 | CPU | LLVM | 20,399 | 28 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.