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>",
"int",
"num_insns_constant",
"(",
"rtx",
"op",
",",
"machine_mode",
"mode",
")",
"{",
"HOST_WIDE_INT",
"low",
",",
"high",
";",
"switch",
"(",
"GET_CODE",
"(",
"op",
")",
")",
"{",
"case",
"CONST_INT",
":",
"if",
"(",
"(",
"INTVAL",
"(",
"op",
")",
">>",
"31",
")",
"!=",
"0",
"&&",
"(",
"INTVAL",
"(",
"op",
")",
">>",
"31",
")",
"!=",
"-",
"1",
"&&",
"mask64_operand",
"(",
"op",
",",
"mode",
")",
")",
"return",
"2",
";",
"else",
"return",
"num_insns_constant_wide",
"(",
"INTVAL",
"(",
"op",
")",
")",
";",
"case",
"CONST_WIDE_INT",
":",
"{",
"int",
"i",
";",
"int",
"ins",
"=",
"CONST_WIDE_INT_NUNITS",
"(",
"op",
")",
"-",
"1",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"CONST_WIDE_INT_NUNITS",
"(",
"op",
")",
";",
"i",
"++",
")",
"ins",
"+=",
"num_insns_constant_wide",
"(",
"CONST_WIDE_INT_ELT",
"(",
"op",
",",
"i",
")",
")",
";",
"return",
"ins",
";",
"}",
"case",
"CONST_DOUBLE",
":",
"if",
"(",
"mode",
"==",
"SFmode",
"||",
"mode",
"==",
"SDmode",
")",
"{",
"long",
"l",
";",
"REAL_VALUE_TYPE",
"rv",
";",
"REAL_VALUE_FROM_CONST_DOUBLE",
"(",
"rv",
",",
"op",
")",
";",
"if",
"(",
"DECIMAL_FLOAT_MODE_P",
"(",
"mode",
")",
")",
"REAL_VALUE_TO_TARGET_DECIMAL32",
"(",
"rv",
",",
"l",
")",
";",
"else",
"REAL_VALUE_TO_TARGET_SINGLE",
"(",
"rv",
",",
"l",
")",
";",
"return",
"num_insns_constant_wide",
"(",
"(",
"HOST_WIDE_INT",
")",
"l",
")",
";",
"}",
"long",
"l",
"[",
"2",
"]",
";",
"REAL_VALUE_TYPE",
"rv",
";",
"REAL_VALUE_FROM_CONST_DOUBLE",
"(",
"rv",
",",
"op",
")",
";",
"if",
"(",
"DECIMAL_FLOAT_MODE_P",
"(",
"mode",
")",
")",
"REAL_VALUE_TO_TARGET_DECIMAL64",
"(",
"rv",
",",
"l",
")",
";",
"else",
"REAL_VALUE_TO_TARGET_DOUBLE",
"(",
"rv",
",",
"l",
")",
";",
"high",
"=",
"l",
"[",
"WORDS_BIG_ENDIAN",
"==",
"0",
"]",
";",
"low",
"=",
"l",
"[",
"WORDS_BIG_ENDIAN",
"!=",
"0",
"]",
";",
"if",
"(",
"TARGET_32BIT",
")",
"return",
"(",
"num_insns_constant_wide",
"(",
"low",
")",
"+",
"num_insns_constant_wide",
"(",
"high",
")",
")",
";",
"else",
"{",
"if",
"(",
"(",
"high",
"==",
"0",
"&&",
"low",
">=",
"0",
")",
"||",
"(",
"high",
"==",
"-",
"1",
"&&",
"low",
"<",
"0",
")",
")",
"return",
"num_insns_constant_wide",
"(",
"low",
")",
";",
"else",
"if",
"(",
"mask64_operand",
"(",
"op",
",",
"mode",
")",
")",
"return",
"2",
";",
"else",
"if",
"(",
"low",
"==",
"0",
")",
"return",
"num_insns_constant_wide",
"(",
"high",
")",
"+",
"1",
";",
"else",
"return",
"(",
"num_insns_constant_wide",
"(",
"high",
")",
"+",
"num_insns_constant_wide",
"(",
"low",
")",
"+",
"1",
")",
";",
"}",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"instructions",
"it",
"takes",
"to",
"form",
"a",
"constant",
"in",
"as",
"many",
"gprs",
"are",
"needed",
"for",
"MODE",
"."
] | [
"rs6000",
"31",
"0",
"31",
"1",
"2",
"1",
"0",
"2",
"0",
"0",
"0",
"0",
"1",
"0",
"2",
"0",
"1",
"1"
] | rs60004 | num_insns_constant | rs6000 | CPU | GCC | 19,800 | 336 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"StringRef",
"IDVal",
"=",
"DirectiveID",
".",
"getString",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsa_code_object_version\"",
")",
"return",
"ParseDirectiveHSACodeObjectVersion",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsa_code_object_isa\"",
")",
"return",
"ParseDirectiveHSACodeObjectISA",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amd_kernel_code_t\"",
")",
"return",
"ParseDirectiveAMDKernelCodeT",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsatext\"",
")",
"return",
"ParseSectionDirectiveHSAText",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amdgpu_hsa_kernel\"",
")",
"return",
"ParseDirectiveAMDGPUHsaKernel",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amdgpu_hsa_module_global\"",
")",
"return",
"ParseDirectiveAMDGPUHsaModuleGlobal",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amdgpu_hsa_program_global\"",
")",
"return",
"ParseDirectiveAMDGPUHsaProgramGlobal",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsadata_global_agent\"",
")",
"return",
"ParseSectionDirectiveHSADataGlobalAgent",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsadata_global_program\"",
")",
"return",
"ParseSectionDirectiveHSADataGlobalProgram",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsarodata_readonly_agent\"",
")",
"return",
"ParseSectionDirectiveHSARodataReadonlyAgent",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"AMDGPU",
"AMDGPU",
"\".hsa_code_object_version\"",
"\".hsa_code_object_isa\"",
"\".amd_kernel_code_t\"",
"\".hsatext\"",
"\".amdgpu_hsa_kernel\"",
"AMDGPU",
"\".amdgpu_hsa_module_global\"",
"AMDGPU",
"\".amdgpu_hsa_program_global\"",
"AMDGPU",
"\".hsadata_global_agent\"",
"\".hsadata_global_program\"",
"\".hsarodata_readonly_agent\""
] | AMDGPUAsmParser10 | ParseDirective | AMDGPU | GPU | LLVM | 19,801 | 132 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"HexagonTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"(",
"HexagonISD",
"::",
"NodeType",
")",
"Opcode",
")",
"{",
"case",
"HexagonISD",
"::",
"ADDC",
":",
"return",
"\"HexagonISD::ADDC\"",
";",
"case",
"HexagonISD",
"::",
"SUBC",
":",
"return",
"\"HexagonISD::SUBC\"",
";",
"case",
"HexagonISD",
"::",
"ALLOCA",
":",
"return",
"\"HexagonISD::ALLOCA\"",
";",
"case",
"HexagonISD",
"::",
"AT_GOT",
":",
"return",
"\"HexagonISD::AT_GOT\"",
";",
"case",
"HexagonISD",
"::",
"AT_PCREL",
":",
"return",
"\"HexagonISD::AT_PCREL\"",
";",
"case",
"HexagonISD",
"::",
"BARRIER",
":",
"return",
"\"HexagonISD::BARRIER\"",
";",
"case",
"HexagonISD",
"::",
"CALL",
":",
"return",
"\"HexagonISD::CALL\"",
";",
"case",
"HexagonISD",
"::",
"CALLnr",
":",
"return",
"\"HexagonISD::CALLnr\"",
";",
"case",
"HexagonISD",
"::",
"CALLR",
":",
"return",
"\"HexagonISD::CALLR\"",
";",
"case",
"HexagonISD",
"::",
"COMBINE",
":",
"return",
"\"HexagonISD::COMBINE\"",
";",
"case",
"HexagonISD",
"::",
"CONST32_GP",
":",
"return",
"\"HexagonISD::CONST32_GP\"",
";",
"case",
"HexagonISD",
"::",
"CONST32",
":",
"return",
"\"HexagonISD::CONST32\"",
";",
"case",
"HexagonISD",
"::",
"CP",
":",
"return",
"\"HexagonISD::CP\"",
";",
"case",
"HexagonISD",
"::",
"DCFETCH",
":",
"return",
"\"HexagonISD::DCFETCH\"",
";",
"case",
"HexagonISD",
"::",
"EH_RETURN",
":",
"return",
"\"HexagonISD::EH_RETURN\"",
";",
"case",
"HexagonISD",
"::",
"TSTBIT",
":",
"return",
"\"HexagonISD::TSTBIT\"",
";",
"case",
"HexagonISD",
"::",
"EXTRACTU",
":",
"return",
"\"HexagonISD::EXTRACTU\"",
";",
"case",
"HexagonISD",
"::",
"INSERT",
":",
"return",
"\"HexagonISD::INSERT\"",
";",
"case",
"HexagonISD",
"::",
"JT",
":",
"return",
"\"HexagonISD::JT\"",
";",
"case",
"HexagonISD",
"::",
"RET_FLAG",
":",
"return",
"\"HexagonISD::RET_FLAG\"",
";",
"case",
"HexagonISD",
"::",
"TC_RETURN",
":",
"return",
"\"HexagonISD::TC_RETURN\"",
";",
"case",
"HexagonISD",
"::",
"VASL",
":",
"return",
"\"HexagonISD::VASL\"",
";",
"case",
"HexagonISD",
"::",
"VASR",
":",
"return",
"\"HexagonISD::VASR\"",
";",
"case",
"HexagonISD",
"::",
"VLSR",
":",
"return",
"\"HexagonISD::VLSR\"",
";",
"case",
"HexagonISD",
"::",
"VEXTRACTW",
":",
"return",
"\"HexagonISD::VEXTRACTW\"",
";",
"case",
"HexagonISD",
"::",
"VINSERTW0",
":",
"return",
"\"HexagonISD::VINSERTW0\"",
";",
"case",
"HexagonISD",
"::",
"VROR",
":",
"return",
"\"HexagonISD::VROR\"",
";",
"case",
"HexagonISD",
"::",
"READCYCLE",
":",
"return",
"\"HexagonISD::READCYCLE\"",
";",
"case",
"HexagonISD",
"::",
"PTRUE",
":",
"return",
"\"HexagonISD::PTRUE\"",
";",
"case",
"HexagonISD",
"::",
"PFALSE",
":",
"return",
"\"HexagonISD::PFALSE\"",
";",
"case",
"HexagonISD",
"::",
"D2P",
":",
"return",
"\"HexagonISD::D2P\"",
";",
"case",
"HexagonISD",
"::",
"P2D",
":",
"return",
"\"HexagonISD::P2D\"",
";",
"case",
"HexagonISD",
"::",
"V2Q",
":",
"return",
"\"HexagonISD::V2Q\"",
";",
"case",
"HexagonISD",
"::",
"Q2V",
":",
"return",
"\"HexagonISD::Q2V\"",
";",
"case",
"HexagonISD",
"::",
"QCAT",
":",
"return",
"\"HexagonISD::QCAT\"",
";",
"case",
"HexagonISD",
"::",
"QTRUE",
":",
"return",
"\"HexagonISD::QTRUE\"",
";",
"case",
"HexagonISD",
"::",
"QFALSE",
":",
"return",
"\"HexagonISD::QFALSE\"",
";",
"case",
"HexagonISD",
"::",
"TYPECAST",
":",
"return",
"\"HexagonISD::TYPECAST\"",
";",
"case",
"HexagonISD",
"::",
"VALIGN",
":",
"return",
"\"HexagonISD::VALIGN\"",
";",
"case",
"HexagonISD",
"::",
"VALIGNADDR",
":",
"return",
"\"HexagonISD::VALIGNADDR\"",
";",
"case",
"HexagonISD",
"::",
"VPACKL",
":",
"return",
"\"HexagonISD::VPACKL\"",
";",
"case",
"HexagonISD",
"::",
"VUNPACK",
":",
"return",
"\"HexagonISD::VUNPACK\"",
";",
"case",
"HexagonISD",
"::",
"VUNPACKU",
":",
"return",
"\"HexagonISD::VUNPACKU\"",
";",
"case",
"HexagonISD",
"::",
"ISEL",
":",
"return",
"\"HexagonISD::ISEL\"",
";",
"case",
"HexagonISD",
"::",
"OP_END",
":",
"break",
";",
"}",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"Hexagon",
"Hexagon",
"HexagonISD::NodeType",
"HexagonISD::ADDC",
"\"HexagonISD::ADDC\"",
"HexagonISD::SUBC",
"\"HexagonISD::SUBC\"",
"HexagonISD::ALLOCA",
"\"HexagonISD::ALLOCA\"",
"HexagonISD::AT_GOT",
"\"HexagonISD::AT_GOT\"",
"HexagonISD::AT_PCREL",
"\"HexagonISD::AT_PCREL\"",
"HexagonISD::BARRIER",
"\"HexagonISD::BARRIER\"",
"HexagonISD::CALL",
"\"HexagonISD::CALL\"",
"HexagonISD::CALLnr",
"\"HexagonISD::CALLnr\"",
"HexagonISD::CALLR",
"\"HexagonISD::CALLR\"",
"HexagonISD::COMBINE",
"\"HexagonISD::COMBINE\"",
"HexagonISD::CONST32_GP",
"\"HexagonISD::CONST32_GP\"",
"HexagonISD::CONST32",
"\"HexagonISD::CONST32\"",
"HexagonISD::CP",
"\"HexagonISD::CP\"",
"HexagonISD::DCFETCH",
"\"HexagonISD::DCFETCH\"",
"HexagonISD::EH_RETURN",
"\"HexagonISD::EH_RETURN\"",
"HexagonISD::TSTBIT",
"\"HexagonISD::TSTBIT\"",
"HexagonISD::EXTRACTU",
"\"HexagonISD::EXTRACTU\"",
"HexagonISD::INSERT",
"\"HexagonISD::INSERT\"",
"HexagonISD::JT",
"\"HexagonISD::JT\"",
"HexagonISD::RET_FLAG",
"\"HexagonISD::RET_FLAG\"",
"HexagonISD::TC_RETURN",
"\"HexagonISD::TC_RETURN\"",
"HexagonISD::VASL",
"\"HexagonISD::VASL\"",
"HexagonISD::VASR",
"\"HexagonISD::VASR\"",
"HexagonISD::VLSR",
"\"HexagonISD::VLSR\"",
"HexagonISD::VEXTRACTW",
"\"HexagonISD::VEXTRACTW\"",
"HexagonISD::VINSERTW0",
"\"HexagonISD::VINSERTW0\"",
"HexagonISD::VROR",
"\"HexagonISD::VROR\"",
"HexagonISD::READCYCLE",
"\"HexagonISD::READCYCLE\"",
"HexagonISD::PTRUE",
"\"HexagonISD::PTRUE\"",
"HexagonISD::PFALSE",
"\"HexagonISD::PFALSE\"",
"HexagonISD::D2P",
"\"HexagonISD::D2P\"",
"HexagonISD::P2D",
"\"HexagonISD::P2D\"",
"HexagonISD::V2Q",
"\"HexagonISD::V2Q\"",
"HexagonISD::Q2V",
"\"HexagonISD::Q2V\"",
"HexagonISD::QCAT",
"\"HexagonISD::QCAT\"",
"HexagonISD::QTRUE",
"\"HexagonISD::QTRUE\"",
"HexagonISD::QFALSE",
"\"HexagonISD::QFALSE\"",
"HexagonISD::TYPECAST",
"\"HexagonISD::TYPECAST\"",
"HexagonISD::VALIGN",
"\"HexagonISD::VALIGN\"",
"HexagonISD::VALIGNADDR",
"\"HexagonISD::VALIGNADDR\"",
"HexagonISD::VPACKL",
"\"HexagonISD::VPACKL\"",
"HexagonISD::VUNPACK",
"\"HexagonISD::VUNPACK\"",
"HexagonISD::VUNPACKU",
"\"HexagonISD::VUNPACKU\"",
"HexagonISD::ISEL",
"\"HexagonISD::ISEL\"",
"HexagonISD::OP_END"
] | HexagonISelLowering100 | getTargetNodeName | Hexagon | DSP | LLVM | 19,802 | 386 | 1 | [] |
[
"<s>",
"unsigned",
"BPFMCCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"const",
"MCOperand",
"&",
"MO",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"return",
"MRI",
".",
"getEncodingValue",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"static_cast",
"<",
"unsigned",
">",
"(",
"MO",
".",
"getImm",
"(",
")",
")",
";",
"assert",
"(",
"MO",
".",
"isExpr",
"(",
")",
")",
";",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MO",
".",
"getExpr",
"(",
")",
";",
"assert",
"(",
"Expr",
"->",
"getKind",
"(",
")",
"==",
"MCExpr",
"::",
"SymbolRef",
")",
";",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"BPF",
"::",
"JAL",
")",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"0",
",",
"Expr",
",",
"FK_SecRel_4",
")",
")",
";",
"else",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"BPF",
"::",
"LD_imm64",
")",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"0",
",",
"Expr",
",",
"FK_SecRel_8",
")",
")",
";",
"else",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"0",
",",
"Expr",
",",
"FK_PCRel_2",
")",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"BPF",
"BPF",
"BPF::JAL",
"0",
"BPF::LD_imm64",
"0",
"0",
"0"
] | BPFMCCodeEmitter | getMachineOpValue | BPF | Virtual ISA | LLVM | 19,803 | 181 | 1 | [] |
[
"<s>",
"CCAssignFn",
"*",
"ARMFastISel",
"::",
"CCAssignFnForCall",
"(",
"CallingConv",
"::",
"ID",
"CC",
",",
"bool",
"Return",
",",
"bool",
"isVarArg",
")",
"{",
"switch",
"(",
"CC",
")",
"{",
"default",
":",
"report_fatal_error",
"(",
"\"Unsupported calling convention\"",
")",
";",
"case",
"CallingConv",
"::",
"Fast",
":",
"if",
"(",
"Subtarget",
"->",
"hasVFP2",
"(",
")",
"&&",
"!",
"isVarArg",
")",
"{",
"if",
"(",
"!",
"Subtarget",
"->",
"isAAPCS_ABI",
"(",
")",
")",
"return",
"(",
"Return",
"?",
"RetFastCC_ARM_APCS",
":",
"FastCC_ARM_APCS",
")",
";",
"return",
"(",
"Return",
"?",
"RetCC_ARM_AAPCS_VFP",
":",
"CC_ARM_AAPCS_VFP",
")",
";",
"}",
"LLVM_FALLTHROUGH",
";",
"case",
"CallingConv",
"::",
"C",
":",
"case",
"CallingConv",
"::",
"CXX_FAST_TLS",
":",
"if",
"(",
"Subtarget",
"->",
"isAAPCS_ABI",
"(",
")",
")",
"{",
"if",
"(",
"Subtarget",
"->",
"hasVFP2",
"(",
")",
"&&",
"TM",
".",
"Options",
".",
"FloatABIType",
"==",
"FloatABI",
"::",
"Hard",
"&&",
"!",
"isVarArg",
")",
"return",
"(",
"Return",
"?",
"RetCC_ARM_AAPCS_VFP",
":",
"CC_ARM_AAPCS_VFP",
")",
";",
"else",
"return",
"(",
"Return",
"?",
"RetCC_ARM_AAPCS",
":",
"CC_ARM_AAPCS",
")",
";",
"}",
"else",
"{",
"return",
"(",
"Return",
"?",
"RetCC_ARM_APCS",
":",
"CC_ARM_APCS",
")",
";",
"}",
"case",
"CallingConv",
"::",
"ARM_AAPCS_VFP",
":",
"case",
"CallingConv",
"::",
"Swift",
":",
"if",
"(",
"!",
"isVarArg",
")",
"return",
"(",
"Return",
"?",
"RetCC_ARM_AAPCS_VFP",
":",
"CC_ARM_AAPCS_VFP",
")",
";",
"LLVM_FALLTHROUGH",
";",
"case",
"CallingConv",
"::",
"ARM_AAPCS",
":",
"return",
"(",
"Return",
"?",
"RetCC_ARM_AAPCS",
":",
"CC_ARM_AAPCS",
")",
";",
"case",
"CallingConv",
"::",
"ARM_APCS",
":",
"return",
"(",
"Return",
"?",
"RetCC_ARM_APCS",
":",
"CC_ARM_APCS",
")",
";",
"case",
"CallingConv",
"::",
"GHC",
":",
"if",
"(",
"Return",
")",
"report_fatal_error",
"(",
"\"Can't return in GHC call convention\"",
")",
";",
"else",
"return",
"CC_ARM_APCS_GHC",
";",
"}",
"}",
"</s>"
] | [
"Selects",
"the",
"correct",
"CCAssignFn",
"for",
"a",
"given",
"CallingConvention",
"value",
"."
] | [
"ARM",
"ARM",
"\"Unsupported calling convention\"",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"\"Can't return in GHC call convention\"",
"ARM"
] | ARMFastISel (2)2 | CCAssignFnForCall | ARM | CPU | LLVM | 19,804 | 223 | 1 | [] |
[
"<s>",
"bool",
"fixupNeedsRelaxation",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"uint64_t",
"Value",
",",
"const",
"MCRelaxableFragment",
"*",
"DF",
",",
"const",
"MCAsmLayout",
"&",
"Layout",
")",
"const",
"{",
"assert",
"(",
"0",
"&&",
"\"RelaxInstruction() is not implemented\"",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Simple",
"predicate",
"for",
"targets",
"where",
"!",
"Resolved",
"implies",
"requiring",
"relaxation",
"."
] | [
"TeeRISC",
"0",
"\"RelaxInstruction() is not implemented\""
] | TeeRISCAsmBackend | fixupNeedsRelaxation | TeeRISC | CPU | LLVM | 19,805 | 34 | 1 | [] |
[
"<s>",
"static",
"rtx_insn",
"*",
"aarch64_speculation_clobber_sp",
"(",
")",
"{",
"rtx",
"sp",
"=",
"gen_rtx_REG",
"(",
"DImode",
",",
"SP_REGNUM",
")",
";",
"rtx",
"tracker",
"=",
"gen_rtx_REG",
"(",
"DImode",
",",
"SPECULATION_TRACKER_REGNUM",
")",
";",
"rtx",
"scratch",
"=",
"gen_rtx_REG",
"(",
"DImode",
",",
"SPECULATION_SCRATCH_REGNUM",
")",
";",
"start_sequence",
"(",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"scratch",
",",
"sp",
")",
")",
";",
"emit_insn",
"(",
"gen_anddi3",
"(",
"scratch",
",",
"scratch",
",",
"tracker",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"sp",
",",
"scratch",
")",
")",
";",
"rtx_insn",
"*",
"seq",
"=",
"get_insns",
"(",
")",
";",
"end_sequence",
"(",
")",
";",
"return",
"seq",
";",
"}",
"</s>"
] | [
"Generate",
"a",
"code",
"sequence",
"to",
"clobber",
"SP",
"if",
"speculating",
"incorreclty",
"."
] | [
"aarch64"
] | aarch64-speculation | aarch64_speculation_clobber_sp | aarch64 | CPU | GCC | 19,806 | 89 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_function_ok_for_sibcall",
"(",
"tree",
"decl",
",",
"tree",
"exp",
")",
"{",
"tree",
"type",
",",
"decl_or_type",
";",
"rtx",
"a",
",",
"b",
";",
"bool",
"bind_global",
"=",
"decl",
"&&",
"!",
"targetm",
".",
"binds_local_p",
"(",
"decl",
")",
";",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"no_caller_saved_registers",
")",
"return",
"false",
";",
"if",
"(",
"!",
"TARGET_MACHO",
"&&",
"!",
"TARGET_64BIT",
"&&",
"flag_pic",
"&&",
"flag_plt",
"&&",
"bind_global",
")",
"return",
"false",
";",
"if",
"(",
"ix86_minimum_incoming_stack_boundary",
"(",
"true",
")",
"<",
"PREFERRED_STACK_BOUNDARY",
")",
"return",
"false",
";",
"if",
"(",
"decl",
")",
"{",
"decl_or_type",
"=",
"decl",
";",
"type",
"=",
"TREE_TYPE",
"(",
"decl",
")",
";",
"}",
"else",
"{",
"type",
"=",
"CALL_EXPR_FN",
"(",
"exp",
")",
";",
"type",
"=",
"TREE_TYPE",
"(",
"type",
")",
";",
"type",
"=",
"TREE_TYPE",
"(",
"type",
")",
";",
"decl_or_type",
"=",
"type",
";",
"}",
"a",
"=",
"ix86_function_value",
"(",
"TREE_TYPE",
"(",
"exp",
")",
",",
"decl_or_type",
",",
"false",
")",
";",
"b",
"=",
"ix86_function_value",
"(",
"TREE_TYPE",
"(",
"DECL_RESULT",
"(",
"cfun",
"->",
"decl",
")",
")",
",",
"cfun",
"->",
"decl",
",",
"false",
")",
";",
"if",
"(",
"STACK_REG_P",
"(",
"a",
")",
"||",
"STACK_REG_P",
"(",
"b",
")",
")",
"{",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"a",
",",
"b",
")",
")",
"return",
"false",
";",
"}",
"else",
"if",
"(",
"VOID_TYPE_P",
"(",
"TREE_TYPE",
"(",
"DECL_RESULT",
"(",
"cfun",
"->",
"decl",
")",
")",
")",
")",
";",
"else",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"a",
",",
"b",
")",
")",
"return",
"false",
";",
"if",
"(",
"TARGET_64BIT",
")",
"{",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"call_abi",
"==",
"MS_ABI",
"&&",
"ix86_function_type_abi",
"(",
"type",
")",
"==",
"SYSV_ABI",
")",
"return",
"false",
";",
"}",
"else",
"{",
"if",
"(",
"!",
"decl",
"||",
"(",
"bind_global",
"&&",
"flag_pic",
"&&",
"!",
"flag_plt",
")",
"||",
"(",
"TARGET_DLLIMPORT_DECL_ATTRIBUTES",
"&&",
"DECL_DLLIMPORT_P",
"(",
"decl",
")",
")",
")",
"{",
"if",
"(",
"ix86_function_regparm",
"(",
"type",
",",
"NULL",
")",
">=",
"3",
"&&",
"!",
"cfun",
"->",
"machine",
"->",
"arg_reg_available",
")",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Decide",
"whether",
"we",
"can",
"make",
"a",
"sibling",
"call",
"to",
"a",
"function",
".",
"DECL",
"is",
"the",
"declaration",
"of",
"the",
"function",
"being",
"targeted",
"by",
"the",
"call",
"and",
"EXP",
"is",
"the",
"CALL_EXPR",
"representing",
"the",
"call",
"."
] | [
"i386",
"3"
] | i3866 | ix86_function_ok_for_sibcall | i386 | CPU | GCC | 19,807 | 291 | 1 | [] |
[
"<s>",
"bool",
"shouldConvertConstantLoadToIntImm",
"(",
"const",
"APInt",
"&",
"Imm",
",",
"Type",
"*",
"Ty",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"it",
"is",
"beneficial",
"to",
"convert",
"a",
"load",
"of",
"a",
"constant",
"to",
"just",
"the",
"constant",
"itself",
"."
] | [
"CJG"
] | CJGISelLowering | shouldConvertConstantLoadToIntImm | CJG | CPU | LLVM | 19,808 | 19 | 1 | [] |
[
"<s>",
"bool",
"SIRegisterInfo",
"::",
"needsFrameBaseReg",
"(",
"MachineInstr",
"*",
"MI",
",",
"int64_t",
"Offset",
")",
"const",
"{",
"if",
"(",
"!",
"SIInstrInfo",
"::",
"isMUBUF",
"(",
"*",
"MI",
")",
"&&",
"!",
"SIInstrInfo",
"::",
"isFLATScratch",
"(",
"*",
"MI",
")",
")",
"return",
"false",
";",
"int64_t",
"FullOffset",
"=",
"Offset",
"+",
"getScratchInstrOffset",
"(",
"MI",
")",
";",
"if",
"(",
"SIInstrInfo",
"::",
"isMUBUF",
"(",
"*",
"MI",
")",
")",
"return",
"!",
"SIInstrInfo",
"::",
"isLegalMUBUFImmOffset",
"(",
"FullOffset",
")",
";",
"const",
"SIInstrInfo",
"*",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"return",
"!",
"TII",
"->",
"isLegalFLATOffset",
"(",
"FullOffset",
",",
"AMDGPUAS",
"::",
"PRIVATE_ADDRESS",
",",
"SIInstrFlags",
"::",
"FlatScratch",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"instruction",
"'s",
"frame",
"index",
"reference",
"would",
"be",
"better",
"served",
"by",
"a",
"base",
"register",
"other",
"than",
"FP",
"or",
"SP",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"SI",
"SI",
"AMDGPU",
"SIInstrFlags::FlatScratch"
] | SIRegisterInfo (3) | needsFrameBaseReg | AMDGPU | GPU | LLVM | 19,809 | 95 | 1 | [] |
[
"<s>",
"rtx",
"iq2000_legitimize_address",
"(",
"rtx",
"xinsn",
",",
"rtx",
"old_x",
"ATTRIBUTE_UNUSED",
",",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"TARGET_DEBUG_B_MODE",
")",
"{",
"GO_PRINTF",
"(",
"\"\\n========== LEGITIMIZE_ADDRESS\\n\"",
")",
";",
"GO_DEBUG_RTX",
"(",
"xinsn",
")",
";",
"}",
"if",
"(",
"iq2000_check_split",
"(",
"xinsn",
",",
"mode",
")",
")",
"{",
"return",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"copy_to_mode_reg",
"(",
"Pmode",
",",
"gen_rtx_HIGH",
"(",
"Pmode",
",",
"xinsn",
")",
")",
",",
"xinsn",
")",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"xinsn",
")",
"==",
"PLUS",
")",
"{",
"rtx",
"xplus0",
"=",
"XEXP",
"(",
"xinsn",
",",
"0",
")",
";",
"rtx",
"xplus1",
"=",
"XEXP",
"(",
"xinsn",
",",
"1",
")",
";",
"enum",
"rtx_code",
"code0",
"=",
"GET_CODE",
"(",
"xplus0",
")",
";",
"enum",
"rtx_code",
"code1",
"=",
"GET_CODE",
"(",
"xplus1",
")",
";",
"if",
"(",
"code0",
"!=",
"REG",
"&&",
"code1",
"==",
"REG",
")",
"{",
"xplus0",
"=",
"XEXP",
"(",
"xinsn",
",",
"1",
")",
";",
"xplus1",
"=",
"XEXP",
"(",
"xinsn",
",",
"0",
")",
";",
"code0",
"=",
"GET_CODE",
"(",
"xplus0",
")",
";",
"code1",
"=",
"GET_CODE",
"(",
"xplus1",
")",
";",
"}",
"if",
"(",
"code0",
"==",
"REG",
"&&",
"REG_MODE_OK_FOR_BASE_P",
"(",
"xplus0",
",",
"mode",
")",
"&&",
"code1",
"==",
"CONST_INT",
"&&",
"!",
"SMALL_INT",
"(",
"xplus1",
")",
")",
"{",
"rtx",
"int_reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"rtx",
"ptr_reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_move_insn",
"(",
"int_reg",
",",
"GEN_INT",
"(",
"INTVAL",
"(",
"xplus1",
")",
"&",
"~",
"0x7fff",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"ptr_reg",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"xplus0",
",",
"int_reg",
")",
")",
")",
";",
"return",
"plus_constant",
"(",
"Pmode",
",",
"ptr_reg",
",",
"INTVAL",
"(",
"xplus1",
")",
"&",
"0x7fff",
")",
";",
"}",
"}",
"if",
"(",
"TARGET_DEBUG_B_MODE",
")",
"GO_PRINTF",
"(",
"\"LEGITIMIZE_ADDRESS could not fix.\\n\"",
")",
";",
"return",
"xinsn",
";",
"}",
"</s>"
] | [
"For",
"the",
"IQ2000",
",",
"transform",
":",
"memory",
"(",
"X",
"+",
"<",
"large",
"int",
">",
")",
"into",
":",
"Y",
"=",
"<",
"large",
"int",
">",
"&",
"~0x7fff",
";",
"Z",
"=",
"X",
"+",
"Y",
"memory",
"(",
"Z",
"+",
"(",
"<",
"large",
"int",
">",
"&",
"0x7fff",
")",
")",
";"
] | [
"iq2000",
"\"\\n========== LEGITIMIZE_ADDRESS\\n\"",
"0",
"1",
"1",
"0",
"0x7fff",
"0x7fff",
"\"LEGITIMIZE_ADDRESS could not fix.\\n\""
] | iq20003 | iq2000_legitimize_address | iq2000 | CPU | GCC | 19,810 | 258 | 1 | [] |
[
"<s>",
"tree",
"aarch64_builtin_rsqrt",
"(",
"unsigned",
"int",
"fn",
")",
"{",
"if",
"(",
"fn",
"==",
"AARCH64_SIMD_BUILTIN_UNOP_sqrtv2df",
")",
"return",
"aarch64_builtin_decls",
"[",
"AARCH64_BUILTIN_RSQRT_V2DF",
"]",
";",
"if",
"(",
"fn",
"==",
"AARCH64_SIMD_BUILTIN_UNOP_sqrtv2sf",
")",
"return",
"aarch64_builtin_decls",
"[",
"AARCH64_BUILTIN_RSQRT_V2SF",
"]",
";",
"if",
"(",
"fn",
"==",
"AARCH64_SIMD_BUILTIN_UNOP_sqrtv4sf",
")",
"return",
"aarch64_builtin_decls",
"[",
"AARCH64_BUILTIN_RSQRT_V4SF",
"]",
";",
"return",
"NULL_TREE",
";",
"}",
"</s>"
] | [
"Return",
"builtin",
"for",
"reciprocal",
"square",
"root",
"."
] | [
"aarch64"
] | aarch64-builtins3 | aarch64_builtin_rsqrt | aarch64 | CPU | GCC | 19,811 | 48 | 1 | [] |
[
"<s>",
"bool",
"SystemZAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"SystemZ",
"SystemZ"
] | SystemZAsmParser (2) | ParseDirective | SystemZ | CPU | LLVM | 19,812 | 13 | 1 | [] |
[
"<s>",
"bool",
"HSAILRegisterInfo",
"::",
"requiresRegisterScavenging",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"requires",
"(",
"and",
"can",
"make",
"use",
"of",
")",
"the",
"register",
"scavenger",
"."
] | [
"HSAIL",
"HSAIL"
] | HSAILRegisterInfo | requiresRegisterScavenging | HSAIL | Virtual ISA | LLVM | 19,813 | 16 | 1 | [] |
[
"<s>",
"const",
"InstrItineraryData",
"&",
"getInstrItineraryData",
"(",
")",
"const",
"{",
"return",
"InstrItins",
";",
"}",
"</s>"
] | [
"getInstrItineraryData",
"-",
"Returns",
"instruction",
"itinerary",
"data",
"for",
"the",
"target",
"or",
"specific",
"subtarget",
"."
] | [
"TMS320C64X"
] | TMS320C64XSubtarget | getInstrItineraryData | TMS320C64X | VLIW | LLVM | 19,814 | 12 | 1 | [] |
[
"<s>",
"static",
"rtx",
"legitimize_pe_coff_extern_decl",
"(",
"rtx",
"symbol",
",",
"bool",
"want_reg",
")",
"{",
"tree",
"imp_decl",
";",
"rtx",
"x",
";",
"gcc_assert",
"(",
"SYMBOL_REF_DECL",
"(",
"symbol",
")",
")",
";",
"imp_decl",
"=",
"get_dllimport_decl",
"(",
"SYMBOL_REF_DECL",
"(",
"symbol",
")",
",",
"false",
")",
";",
"x",
"=",
"DECL_RTL",
"(",
"imp_decl",
")",
";",
"if",
"(",
"want_reg",
")",
"x",
"=",
"force_reg",
"(",
"Pmode",
",",
"x",
")",
";",
"return",
"x",
";",
"}",
"</s>"
] | [
"Expand",
"SYMBOL",
"into",
"its",
"corresponding",
"far-addresse",
"symbol",
".",
"WANT_REG",
"is",
"true",
"if",
"we",
"require",
"the",
"result",
"be",
"a",
"register",
"."
] | [
"i386"
] | i386 | legitimize_pe_coff_extern_decl | i386 | CPU | GCC | 19,815 | 61 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"mips_output_conditional_branch",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"*",
"operands",
",",
"const",
"char",
"*",
"branch_if_true",
",",
"const",
"char",
"*",
"branch_if_false",
")",
"{",
"unsigned",
"int",
"length",
";",
"rtx",
"taken",
";",
"gcc_assert",
"(",
"LABEL_P",
"(",
"operands",
"[",
"0",
"]",
")",
")",
";",
"length",
"=",
"get_attr_length",
"(",
"insn",
")",
";",
"if",
"(",
"length",
"<=",
"8",
")",
"{",
"mips_branch_likely",
"=",
"(",
"final_sequence",
"&&",
"INSN_ANNULLED_BRANCH_P",
"(",
"insn",
")",
")",
";",
"return",
"branch_if_true",
";",
"}",
"mips_branch_likely",
"=",
"false",
";",
"rtx_code_label",
"*",
"not_taken",
"=",
"gen_label_rtx",
"(",
")",
";",
"taken",
"=",
"operands",
"[",
"0",
"]",
";",
"operands",
"[",
"0",
"]",
"=",
"not_taken",
";",
"output_asm_insn",
"(",
"branch_if_false",
",",
"operands",
")",
";",
"if",
"(",
"final_sequence",
")",
"{",
"if",
"(",
"!",
"INSN_ANNULLED_BRANCH_P",
"(",
"insn",
")",
")",
"{",
"final_scan_insn",
"(",
"final_sequence",
"->",
"insn",
"(",
"1",
")",
",",
"asm_out_file",
",",
"optimize",
",",
"1",
",",
"NULL",
")",
";",
"final_sequence",
"->",
"insn",
"(",
"1",
")",
"->",
"set_deleted",
"(",
")",
";",
"}",
"else",
"output_asm_insn",
"(",
"\"nop\"",
",",
"0",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\n\"",
")",
";",
"}",
"if",
"(",
"TARGET_ABSOLUTE_JUMPS",
")",
"output_asm_insn",
"(",
"MIPS_ABSOLUTE_JUMP",
"(",
"\"j\\t%0%/\"",
")",
",",
"&",
"taken",
")",
";",
"else",
"{",
"mips_output_load_label",
"(",
"taken",
")",
";",
"output_asm_insn",
"(",
"\"jr\\t%@%]%/\"",
",",
"0",
")",
";",
"}",
"if",
"(",
"final_sequence",
")",
"{",
"if",
"(",
"INSN_ANNULLED_BRANCH_P",
"(",
"insn",
")",
")",
"{",
"final_scan_insn",
"(",
"final_sequence",
"->",
"insn",
"(",
"1",
")",
",",
"asm_out_file",
",",
"optimize",
",",
"1",
",",
"NULL",
")",
";",
"final_sequence",
"->",
"insn",
"(",
"1",
")",
"->",
"set_deleted",
"(",
")",
";",
"}",
"else",
"output_asm_insn",
"(",
"\"nop\"",
",",
"0",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\n\"",
")",
";",
"}",
"targetm",
".",
"asm_out",
".",
"internal_label",
"(",
"asm_out_file",
",",
"\"L\"",
",",
"CODE_LABEL_NUMBER",
"(",
"not_taken",
")",
")",
";",
"return",
"\"\"",
";",
"}",
"</s>"
] | [
"Output",
"assembly",
"instructions",
"to",
"peform",
"a",
"conditional",
"branch",
".",
"INSN",
"is",
"the",
"branch",
"instruction",
".",
"OPERANDS",
"[",
"0",
"]",
"is",
"the",
"condition",
".",
"OPERANDS",
"[",
"1",
"]",
"is",
"the",
"target",
"of",
"the",
"branch",
".",
"OPERANDS",
"[",
"2",
"]",
"is",
"the",
"target",
"of",
"the",
"first",
"operand",
"to",
"the",
"condition",
".",
"If",
"TWO_OPERANDS_P",
"is",
"nonzero",
"the",
"comparison",
"takes",
"two",
"operands",
";",
"OPERANDS",
"[",
"3",
"]",
"will",
"be",
"the",
"second",
"operand",
".",
"If",
"INVERTED_P",
"is",
"nonzero",
"we",
"are",
"to",
"branch",
"if",
"the",
"condition",
"does",
"not",
"hold",
".",
"If",
"FLOAT_P",
"is",
"nonzero",
"this",
"is",
"a",
"floating-point",
"comparison",
".",
"LENGTH",
"is",
"the",
"length",
"(",
"in",
"bytes",
")",
"of",
"the",
"sequence",
"we",
"are",
"to",
"generate",
".",
"That",
"tells",
"us",
"whether",
"to",
"generate",
"a",
"simple",
"conditional",
"branch",
",",
"or",
"a",
"reversed",
"conditional",
"branch",
"around",
"a",
"`",
"jr",
"'",
"instruction",
"."
] | [
"mips",
"0",
"8",
"0",
"0",
"1",
"1",
"1",
"\"nop\"",
"0",
"\"\\n\"",
"\"j\\t%0%/\"",
"\"jr\\t%@%]%/\"",
"0",
"1",
"1",
"1",
"\"nop\"",
"0",
"\"\\n\"",
"\"L\"",
"\"\""
] | mips4 | mips_output_conditional_branch | mips | CPU | GCC | 19,816 | 273 | 1 | [] |
[
"<s>",
"static",
"rtx",
"expand_set_or_movmem_prologue",
"(",
"rtx",
"destmem",
",",
"rtx",
"srcmem",
",",
"rtx",
"destptr",
",",
"rtx",
"srcptr",
",",
"rtx",
"value",
",",
"rtx",
"vec_value",
",",
"rtx",
"count",
",",
"int",
"align",
",",
"int",
"desired_alignment",
",",
"bool",
"issetmem",
")",
"{",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"1",
";",
"i",
"<",
"desired_alignment",
";",
"i",
"<<=",
"1",
")",
"{",
"if",
"(",
"align",
"<=",
"i",
")",
"{",
"rtx_code_label",
"*",
"label",
"=",
"ix86_expand_aligntest",
"(",
"destptr",
",",
"i",
",",
"false",
")",
";",
"if",
"(",
"issetmem",
")",
"{",
"if",
"(",
"vec_value",
"&&",
"i",
">",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"value",
")",
")",
")",
"destmem",
"=",
"emit_memset",
"(",
"destmem",
",",
"destptr",
",",
"vec_value",
",",
"i",
")",
";",
"else",
"destmem",
"=",
"emit_memset",
"(",
"destmem",
",",
"destptr",
",",
"value",
",",
"i",
")",
";",
"}",
"else",
"destmem",
"=",
"emit_memmov",
"(",
"destmem",
",",
"&",
"srcmem",
",",
"destptr",
",",
"srcptr",
",",
"i",
")",
";",
"ix86_adjust_counter",
"(",
"count",
",",
"i",
")",
";",
"emit_label",
"(",
"label",
")",
";",
"LABEL_NUSES",
"(",
"label",
")",
"=",
"1",
";",
"set_mem_align",
"(",
"destmem",
",",
"i",
"*",
"2",
"*",
"BITS_PER_UNIT",
")",
";",
"}",
"}",
"return",
"destmem",
";",
"}",
"</s>"
] | [
"Depending",
"on",
"ISSETMEM",
",",
"copy",
"enough",
"from",
"SRCMEM",
"to",
"DESTMEM",
"or",
"set",
"enough",
"to",
"DESTMEM",
"to",
"align",
"it",
"to",
"DESIRED_ALIGNMENT",
".",
"Original",
"alignment",
"is",
"ALIGN",
".",
"Depending",
"on",
"ISSETMEM",
",",
"either",
"arguments",
"SRCMEM/SRCPTR",
"or",
"VALUE/VEC_VALUE",
"are",
"ignored",
".",
"Return",
"value",
"is",
"updated",
"DESTMEM",
"."
] | [
"i386",
"1",
"1",
"1",
"2"
] | i3864 | expand_set_or_movmem_prologue | i386 | CPU | GCC | 19,817 | 173 | 1 | [] |
[
"<s>",
"BitVector",
"ARCompactRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"ARC",
"::",
"GP",
")",
";",
"Reserved",
".",
"set",
"(",
"ARC",
"::",
"SP",
")",
";",
"Reserved",
".",
"set",
"(",
"ARC",
"::",
"FP",
")",
";",
"Reserved",
".",
"set",
"(",
"ARC",
"::",
"BLINK",
")",
";",
"Reserved",
".",
"set",
"(",
"ARC",
"::",
"ILINK1",
")",
";",
"Reserved",
".",
"set",
"(",
"ARC",
"::",
"ILINK2",
")",
";",
"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",
"."
] | [
"ARCompact",
"ARC",
"ARC::GP",
"ARC::SP",
"ARC::FP",
"ARC::BLINK",
"ARC::ILINK1",
"ARC::ILINK2"
] | ARCompactRegisterInfo | getReservedRegs | ARCompact | MPU | LLVM | 19,818 | 78 | 1 | [] |
[
"<s>",
"void",
"Thumb1InstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"DestReg",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"assert",
"(",
"(",
"RC",
"==",
"ARM",
"::",
"tGPRRegisterClass",
"||",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"DestReg",
")",
"&&",
"isARMLowRegister",
"(",
"DestReg",
")",
")",
")",
"&&",
"\"Unknown regclass!\"",
")",
";",
"if",
"(",
"RC",
"==",
"ARM",
"::",
"tGPRRegisterClass",
"||",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"DestReg",
")",
"&&",
"isARMLowRegister",
"(",
"DestReg",
")",
")",
")",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"(",
"PseudoSourceValue",
"::",
"getFixedStack",
"(",
"FI",
")",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"MFI",
".",
"getObjectSize",
"(",
"FI",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
")",
";",
"AddDefaultPred",
"(",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ARM",
"::",
"tLDRspi",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"ARM",
"ARM::tGPRRegisterClass",
"ARM",
"\"Unknown regclass!\"",
"ARM::tGPRRegisterClass",
"ARM",
"ARM::tLDRspi",
"0"
] | Thumb1InstrInfo41 | loadRegFromStackSlot | ARM | CPU | LLVM | 19,819 | 200 | 1 | [] |
[
"<s>",
"ARMSubtarget",
"::",
"ARMSubtarget",
"(",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"const",
"ARMBaseTargetMachine",
"&",
"TM",
",",
"bool",
"IsLittle",
")",
":",
"ARMGenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"ARMProcFamily",
"(",
"Others",
")",
",",
"ARMProcClass",
"(",
"None",
")",
",",
"stackAlignment",
"(",
"4",
")",
",",
"CPUString",
"(",
"CPU",
")",
",",
"IsLittle",
"(",
"IsLittle",
")",
",",
"TargetTriple",
"(",
"TT",
")",
",",
"Options",
"(",
"TM",
".",
"Options",
")",
",",
"TM",
"(",
"TM",
")",
",",
"DL",
"(",
"computeDataLayout",
"(",
"initializeSubtargetDependencies",
"(",
"CPU",
",",
"FS",
")",
")",
")",
",",
"TSInfo",
"(",
"DL",
")",
",",
"InstrInfo",
"(",
"isThumb1Only",
"(",
")",
"?",
"(",
"ARMBaseInstrInfo",
"*",
")",
"new",
"Thumb1InstrInfo",
"(",
"*",
"this",
")",
":",
"!",
"isThumb",
"(",
")",
"?",
"(",
"ARMBaseInstrInfo",
"*",
")",
"new",
"ARMInstrInfo",
"(",
"*",
"this",
")",
":",
"(",
"ARMBaseInstrInfo",
"*",
")",
"new",
"Thumb2InstrInfo",
"(",
"*",
"this",
")",
")",
",",
"TLInfo",
"(",
"TM",
")",
",",
"FrameLowering",
"(",
"!",
"isThumb1Only",
"(",
")",
"?",
"new",
"ARMFrameLowering",
"(",
"*",
"this",
")",
":",
"(",
"ARMFrameLowering",
"*",
")",
"new",
"Thumb1FrameLowering",
"(",
"*",
"this",
")",
")",
"{",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"4",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM"
] | ARMSubtarget40 | ARMSubtarget | ARM | CPU | LLVM | 19,820 | 180 | 1 | [] |
[
"<s>",
"void",
"RISCVDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"Node",
")",
"{",
"if",
"(",
"Node",
"->",
"isMachineOpcode",
"(",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"== \"",
";",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
";",
"dbgs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"Node",
"->",
"setNodeId",
"(",
"-",
"1",
")",
";",
"return",
";",
"}",
"unsigned",
"Opcode",
"=",
"Node",
"->",
"getOpcode",
"(",
")",
";",
"MVT",
"XLenVT",
"=",
"Subtarget",
"->",
"getXLenVT",
"(",
")",
";",
"SDLoc",
"DL",
"(",
"Node",
")",
";",
"EVT",
"VT",
"=",
"Node",
"->",
"getValueType",
"(",
"0",
")",
";",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"ISD",
"::",
"Constant",
":",
"{",
"auto",
"ConstNode",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"Node",
")",
";",
"if",
"(",
"VT",
"==",
"XLenVT",
"&&",
"ConstNode",
"->",
"isNullValue",
"(",
")",
")",
"{",
"SDValue",
"New",
"=",
"CurDAG",
"->",
"getCopyFromReg",
"(",
"CurDAG",
"->",
"getEntryNode",
"(",
")",
",",
"SDLoc",
"(",
"Node",
")",
",",
"RISCV",
"::",
"X0",
",",
"XLenVT",
")",
";",
"ReplaceNode",
"(",
"Node",
",",
"New",
".",
"getNode",
"(",
")",
")",
";",
"return",
";",
"}",
"int64_t",
"Imm",
"=",
"ConstNode",
"->",
"getSExtValue",
"(",
")",
";",
"if",
"(",
"XLenVT",
"==",
"MVT",
"::",
"i64",
")",
"{",
"ReplaceNode",
"(",
"Node",
",",
"selectImm",
"(",
"CurDAG",
",",
"SDLoc",
"(",
"Node",
")",
",",
"Imm",
",",
"XLenVT",
")",
")",
";",
"return",
";",
"}",
"break",
";",
"}",
"case",
"ISD",
"::",
"FrameIndex",
":",
"{",
"SDValue",
"Imm",
"=",
"CurDAG",
"->",
"getTargetConstant",
"(",
"0",
",",
"DL",
",",
"XLenVT",
")",
";",
"int",
"FI",
"=",
"cast",
"<",
"FrameIndexSDNode",
">",
"(",
"Node",
")",
"->",
"getIndex",
"(",
")",
";",
"SDValue",
"TFI",
"=",
"CurDAG",
"->",
"getTargetFrameIndex",
"(",
"FI",
",",
"VT",
")",
";",
"ReplaceNode",
"(",
"Node",
",",
"CurDAG",
"->",
"getMachineNode",
"(",
"RISCV",
"::",
"ADDI",
",",
"DL",
",",
"VT",
",",
"TFI",
",",
"Imm",
")",
")",
";",
"return",
";",
"}",
"case",
"ISD",
"::",
"SRL",
":",
"{",
"if",
"(",
"!",
"Subtarget",
"->",
"is64Bit",
"(",
")",
")",
"break",
";",
"SDValue",
"Op0",
"=",
"Node",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"Op1",
"=",
"Node",
"->",
"getOperand",
"(",
"1",
")",
";",
"uint64_t",
"Mask",
";",
"if",
"(",
"Op1",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"Constant",
"&&",
"isConstantMask",
"(",
"Op0",
".",
"getNode",
"(",
")",
",",
"Mask",
")",
")",
"{",
"uint64_t",
"ShAmt",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"Op1",
".",
"getNode",
"(",
")",
")",
"->",
"getZExtValue",
"(",
")",
";",
"if",
"(",
"(",
"Mask",
"|",
"maskTrailingOnes",
"<",
"uint64_t",
">",
"(",
"ShAmt",
")",
")",
"==",
"0xffffffff",
")",
"{",
"SDValue",
"ShAmtVal",
"=",
"CurDAG",
"->",
"getTargetConstant",
"(",
"ShAmt",
",",
"SDLoc",
"(",
"Node",
")",
",",
"XLenVT",
")",
";",
"CurDAG",
"->",
"SelectNodeTo",
"(",
"Node",
",",
"RISCV",
"::",
"SRLIW",
",",
"XLenVT",
",",
"Op0",
".",
"getOperand",
"(",
"0",
")",
",",
"ShAmtVal",
")",
";",
"return",
";",
"}",
"}",
"break",
";",
"}",
"}",
"SelectCode",
"(",
"Node",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"RISCV",
"RISCV",
"\"== \"",
"\"\\n\"",
"1",
"0",
"ISD::Constant",
"RISCV::X0",
"MVT::i64",
"ISD::FrameIndex",
"0",
"RISCV::ADDI",
"ISD::SRL",
"0",
"1",
"ISD::Constant",
"0xffffffff",
"RISCV::SRLIW",
"0"
] | RISCVISelDAGToDAG36 | Select | RISCV | CPU | LLVM | 19,821 | 428 | 1 | [] |
[
"<s>",
"static",
"bool",
"has_dispatch",
"(",
"rtx_insn",
"*",
"insn",
",",
"int",
"action",
")",
"{",
"if",
"(",
"(",
"TARGET_BDVER1",
"||",
"TARGET_BDVER2",
"||",
"TARGET_BDVER3",
"||",
"TARGET_BDVER4",
"||",
"TARGET_ZNVER1",
")",
"&&",
"flag_dispatch_scheduler",
")",
"switch",
"(",
"action",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"IS_DISPATCH_ON",
":",
"return",
"true",
";",
"break",
";",
"case",
"IS_CMP",
":",
"return",
"is_cmp",
"(",
"insn",
")",
";",
"case",
"DISPATCH_VIOLATION",
":",
"return",
"dispatch_violation",
"(",
")",
";",
"case",
"FITS_DISPATCH_WINDOW",
":",
"return",
"fits_dispatch_window",
"(",
"insn",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"TRUE",
"if",
"Dispatch",
"Scheduling",
"is",
"supported",
"."
] | [
"i386"
] | i3865 | has_dispatch | i386 | CPU | GCC | 19,822 | 77 | 1 | [] |
[
"<s>",
"int",
"X86FrameLowering",
"::",
"mergeSPUpdates",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"MBBI",
",",
"unsigned",
"StackPtr",
",",
"bool",
"doMergeWithPrevious",
")",
"{",
"if",
"(",
"(",
"doMergeWithPrevious",
"&&",
"MBBI",
"==",
"MBB",
".",
"begin",
"(",
")",
")",
"||",
"(",
"!",
"doMergeWithPrevious",
"&&",
"MBBI",
"==",
"MBB",
".",
"end",
"(",
")",
")",
")",
"return",
"0",
";",
"MachineBasicBlock",
"::",
"iterator",
"PI",
"=",
"doMergeWithPrevious",
"?",
"std",
"::",
"prev",
"(",
"MBBI",
")",
":",
"MBBI",
";",
"MachineBasicBlock",
"::",
"iterator",
"NI",
"=",
"doMergeWithPrevious",
"?",
"nullptr",
":",
"std",
"::",
"next",
"(",
"MBBI",
")",
";",
"unsigned",
"Opc",
"=",
"PI",
"->",
"getOpcode",
"(",
")",
";",
"int",
"Offset",
"=",
"0",
";",
"if",
"(",
"(",
"Opc",
"==",
"X86",
"::",
"ADD64ri32",
"||",
"Opc",
"==",
"X86",
"::",
"ADD64ri8",
"||",
"Opc",
"==",
"X86",
"::",
"ADD32ri",
"||",
"Opc",
"==",
"X86",
"::",
"ADD32ri8",
"||",
"Opc",
"==",
"X86",
"::",
"LEA32r",
"||",
"Opc",
"==",
"X86",
"::",
"LEA64_32r",
")",
"&&",
"PI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
"==",
"StackPtr",
")",
"{",
"Offset",
"+=",
"PI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"MBB",
".",
"erase",
"(",
"PI",
")",
";",
"if",
"(",
"!",
"doMergeWithPrevious",
")",
"MBBI",
"=",
"NI",
";",
"}",
"else",
"if",
"(",
"(",
"Opc",
"==",
"X86",
"::",
"SUB64ri32",
"||",
"Opc",
"==",
"X86",
"::",
"SUB64ri8",
"||",
"Opc",
"==",
"X86",
"::",
"SUB32ri",
"||",
"Opc",
"==",
"X86",
"::",
"SUB32ri8",
")",
"&&",
"PI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
"==",
"StackPtr",
")",
"{",
"Offset",
"-=",
"PI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"MBB",
".",
"erase",
"(",
"PI",
")",
";",
"if",
"(",
"!",
"doMergeWithPrevious",
")",
"MBBI",
"=",
"NI",
";",
"}",
"return",
"Offset",
";",
"}",
"</s>"
] | [
"Check",
"the",
"instruction",
"before/after",
"the",
"passed",
"instruction",
"."
] | [
"X86",
"X86",
"0",
"0",
"X86::ADD64ri32",
"X86::ADD64ri8",
"X86::ADD32ri",
"X86::ADD32ri8",
"X86::LEA32r",
"X86::LEA64_32r",
"0",
"2",
"X86::SUB64ri32",
"X86::SUB64ri8",
"X86::SUB32ri",
"X86::SUB32ri8",
"0",
"2"
] | X86FrameLowering90 | mergeSPUpdates | X86 | CPU | LLVM | 19,823 | 259 | 1 | [] |
[
"<s>",
"bool",
"AArch64RegisterInfo",
"::",
"isArgumentRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"MCRegister",
"Reg",
")",
"const",
"{",
"CallingConv",
"::",
"ID",
"CC",
"=",
"MF",
".",
"getFunction",
"(",
")",
".",
"getCallingConv",
"(",
")",
";",
"const",
"AArch64Subtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
";",
"bool",
"IsVarArg",
"=",
"STI",
".",
"isCallingConvWin64",
"(",
"MF",
".",
"getFunction",
"(",
")",
".",
"getCallingConv",
"(",
")",
")",
";",
"auto",
"HasReg",
"=",
"[",
"]",
"(",
"ArrayRef",
"<",
"MCRegister",
">",
"RegList",
",",
"MCRegister",
"Reg",
")",
"{",
"return",
"llvm",
"::",
"any_of",
"(",
"RegList",
",",
"[",
"Reg",
"]",
"(",
"const",
"MCRegister",
"R",
")",
"{",
"return",
"R",
"==",
"Reg",
";",
"}",
")",
";",
"}",
";",
"switch",
"(",
"CC",
")",
"{",
"default",
":",
"report_fatal_error",
"(",
"\"Unsupported calling convention.\"",
")",
";",
"case",
"CallingConv",
"::",
"WebKit_JS",
":",
"return",
"HasReg",
"(",
"CC_AArch64_WebKit_JS_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"GHC",
":",
"return",
"HasReg",
"(",
"CC_AArch64_GHC_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"C",
":",
"case",
"CallingConv",
"::",
"Fast",
":",
"case",
"CallingConv",
"::",
"PreserveMost",
":",
"case",
"CallingConv",
"::",
"CXX_FAST_TLS",
":",
"case",
"CallingConv",
"::",
"Swift",
":",
"case",
"CallingConv",
"::",
"SwiftTail",
":",
"case",
"CallingConv",
"::",
"Tail",
":",
"if",
"(",
"STI",
".",
"isTargetWindows",
"(",
")",
"&&",
"IsVarArg",
")",
"return",
"HasReg",
"(",
"CC_AArch64_Win64_VarArg_ArgRegs",
",",
"Reg",
")",
";",
"if",
"(",
"!",
"STI",
".",
"isTargetDarwin",
"(",
")",
")",
"{",
"switch",
"(",
"CC",
")",
"{",
"default",
":",
"return",
"HasReg",
"(",
"CC_AArch64_AAPCS_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"Swift",
":",
"case",
"CallingConv",
"::",
"SwiftTail",
":",
"return",
"HasReg",
"(",
"CC_AArch64_AAPCS_ArgRegs",
",",
"Reg",
")",
"||",
"HasReg",
"(",
"CC_AArch64_AAPCS_Swift_ArgRegs",
",",
"Reg",
")",
";",
"}",
"}",
"if",
"(",
"!",
"IsVarArg",
")",
"{",
"switch",
"(",
"CC",
")",
"{",
"default",
":",
"return",
"HasReg",
"(",
"CC_AArch64_DarwinPCS_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"Swift",
":",
"case",
"CallingConv",
"::",
"SwiftTail",
":",
"return",
"HasReg",
"(",
"CC_AArch64_DarwinPCS_ArgRegs",
",",
"Reg",
")",
"||",
"HasReg",
"(",
"CC_AArch64_DarwinPCS_Swift_ArgRegs",
",",
"Reg",
")",
";",
"}",
"}",
"if",
"(",
"STI",
".",
"isTargetILP32",
"(",
")",
")",
"return",
"HasReg",
"(",
"CC_AArch64_DarwinPCS_ILP32_VarArg_ArgRegs",
",",
"Reg",
")",
";",
"return",
"HasReg",
"(",
"CC_AArch64_DarwinPCS_VarArg_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"Win64",
":",
"if",
"(",
"IsVarArg",
")",
"HasReg",
"(",
"CC_AArch64_Win64_VarArg_ArgRegs",
",",
"Reg",
")",
";",
"return",
"HasReg",
"(",
"CC_AArch64_AAPCS_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"CFGuard_Check",
":",
"return",
"HasReg",
"(",
"CC_AArch64_Win64_CFGuard_Check_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"AArch64_VectorCall",
":",
"case",
"CallingConv",
"::",
"AArch64_SVE_VectorCall",
":",
"return",
"HasReg",
"(",
"CC_AArch64_AAPCS_ArgRegs",
",",
"Reg",
")",
";",
"}",
"}",
"</s>"
] | [
"isArgumentReg",
"-",
"Returns",
"true",
"if",
"Reg",
"can",
"be",
"used",
"as",
"an",
"argument",
"to",
"a",
"function",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"\"Unsupported calling convention.\"",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64RegisterInfo30 | isArgumentRegister | AArch64 | CPU | LLVM | 19,824 | 376 | 1 | [] |
[
"<s>",
"XCoreTargetMachine",
"::",
"XCoreTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"StringRef",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Reloc",
"::",
"Model",
"RM",
",",
"CodeModel",
"::",
"Model",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32\"",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"RM",
",",
"CM",
",",
"OL",
")",
",",
"TLOF",
"(",
"make_unique",
"<",
"XCoreTargetObjectFile",
">",
"(",
")",
")",
",",
"Subtarget",
"(",
"TT",
",",
"CPU",
",",
"FS",
",",
"*",
"this",
")",
"{",
"initAsmInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"Create",
"an",
"ILP32",
"architecture",
"model",
"."
] | [
"XCore",
"XCore",
"XCore",
"\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32\"",
"XCore"
] | XCoreTargetMachine47 | XCoreTargetMachine | XCore | MPU | LLVM | 19,825 | 87 | 1 | [] |
[
"<s>",
"const",
"X86InstrInfo",
"*",
"getInstrInfo",
"(",
")",
"const",
"{",
"return",
"getTargetMachine",
"(",
")",
"->",
"getInstrInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"TargetInstrInfo",
"getter",
"."
] | [
"X86",
"X86"
] | X86FastISel (2) | getInstrInfo | X86 | CPU | LLVM | 19,826 | 18 | 1 | [] |
[
"<s>",
"unsigned",
"AMDGPUAsmBackend",
"::",
"getMinimumNopSize",
"(",
")",
"const",
"{",
"return",
"4",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"minimum",
"size",
"of",
"a",
"nop",
"in",
"bytes",
"on",
"this",
"target",
"."
] | [
"AMDGPU",
"AMDGPU",
"4"
] | AMDGPUAsmBackend (2)1 | getMinimumNopSize | AMDGPU | GPU | LLVM | 19,827 | 12 | 1 | [] |
[
"<s>",
"void",
"ARMTargetLowering",
"::",
"AdjustInstrPostInstrSelection",
"(",
"MachineInstr",
"*",
"MI",
",",
"SDNode",
"*",
"Node",
")",
"const",
"{",
"if",
"(",
"!",
"MI",
"->",
"hasPostISelHook",
"(",
")",
")",
"{",
"assert",
"(",
"!",
"convertAddSubFlagsOpcode",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"&&",
"\"Pseudo flag-setting opcodes must be marked with 'hasPostISelHook'\"",
")",
";",
"return",
";",
"}",
"const",
"MCInstrDesc",
"*",
"MCID",
"=",
"&",
"MI",
"->",
"getDesc",
"(",
")",
";",
"unsigned",
"NewOpc",
"=",
"convertAddSubFlagsOpcode",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"NewOpc",
")",
"{",
"const",
"ARMBaseInstrInfo",
"*",
"TII",
"=",
"static_cast",
"<",
"const",
"ARMBaseInstrInfo",
"*",
">",
"(",
"getTargetMachine",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"MCID",
"=",
"&",
"TII",
"->",
"get",
"(",
"NewOpc",
")",
";",
"assert",
"(",
"MCID",
"->",
"getNumOperands",
"(",
")",
"==",
"MI",
"->",
"getDesc",
"(",
")",
".",
"getNumOperands",
"(",
")",
"+",
"1",
"&&",
"\"converted opcode should be the same except for cc_out\"",
")",
";",
"MI",
"->",
"setDesc",
"(",
"*",
"MCID",
")",
";",
"MI",
"->",
"addOperand",
"(",
"MachineOperand",
"::",
"CreateReg",
"(",
"0",
",",
"true",
")",
")",
";",
"}",
"unsigned",
"ccOutIdx",
"=",
"MCID",
"->",
"getNumOperands",
"(",
")",
"-",
"1",
";",
"if",
"(",
"!",
"MI",
"->",
"hasOptionalDef",
"(",
")",
"||",
"!",
"MCID",
"->",
"OpInfo",
"[",
"ccOutIdx",
"]",
".",
"isOptionalDef",
"(",
")",
")",
"{",
"assert",
"(",
"!",
"NewOpc",
"&&",
"\"Optional cc_out operand required\"",
")",
";",
"return",
";",
"}",
"bool",
"definesCPSR",
"=",
"false",
";",
"bool",
"deadCPSR",
"=",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"MCID",
"->",
"getNumOperands",
"(",
")",
",",
"e",
"=",
"MI",
"->",
"getNumOperands",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"i",
")",
";",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
"&&",
"MO",
".",
"isDef",
"(",
")",
"&&",
"MO",
".",
"getReg",
"(",
")",
"==",
"ARM",
"::",
"CPSR",
")",
"{",
"definesCPSR",
"=",
"true",
";",
"if",
"(",
"MO",
".",
"isDead",
"(",
")",
")",
"deadCPSR",
"=",
"true",
";",
"MI",
"->",
"RemoveOperand",
"(",
"i",
")",
";",
"break",
";",
"}",
"}",
"if",
"(",
"!",
"definesCPSR",
")",
"{",
"assert",
"(",
"!",
"NewOpc",
"&&",
"\"Optional cc_out operand required\"",
")",
";",
"return",
";",
"}",
"assert",
"(",
"deadCPSR",
"==",
"!",
"Node",
"->",
"hasAnyUseOfValue",
"(",
"1",
")",
"&&",
"\"inconsistent dead flag\"",
")",
";",
"if",
"(",
"deadCPSR",
")",
"{",
"assert",
"(",
"!",
"MI",
"->",
"getOperand",
"(",
"ccOutIdx",
")",
".",
"getReg",
"(",
")",
"&&",
"\"expect uninitialized optional cc_out operand\"",
")",
";",
"return",
";",
"}",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"ccOutIdx",
")",
";",
"MO",
".",
"setReg",
"(",
"ARM",
"::",
"CPSR",
")",
";",
"MO",
".",
"setIsDef",
"(",
"true",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"should",
"be",
"implemented",
"by",
"targets",
"that",
"mark",
"instructions",
"with",
"the",
"'hasPostISelHook",
"'",
"flag",
"."
] | [
"ARM",
"ARM",
"\"Pseudo flag-setting opcodes must be marked with 'hasPostISelHook'\"",
"ARM",
"ARM",
"1",
"\"converted opcode should be the same except for cc_out\"",
"0",
"1",
"\"Optional cc_out operand required\"",
"ARM::CPSR",
"\"Optional cc_out operand required\"",
"1",
"\"inconsistent dead flag\"",
"\"expect uninitialized optional cc_out operand\"",
"ARM::CPSR"
] | ARMISelLowering (2) | AdjustInstrPostInstrSelection | ARM | CPU | LLVM | 19,828 | 379 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"X86InstrInfo",
"::",
"insertOutlinedCall",
"(",
"Module",
"&",
"M",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"It",
",",
"MachineFunction",
"&",
"MF",
",",
"bool",
"IsTailCall",
")",
"const",
"{",
"if",
"(",
"IsTailCall",
")",
"{",
"It",
"=",
"MBB",
".",
"insert",
"(",
"It",
",",
"BuildMI",
"(",
"MF",
",",
"DebugLoc",
"(",
")",
",",
"get",
"(",
"X86",
"::",
"JMP_1",
")",
")",
".",
"addGlobalAddress",
"(",
"M",
".",
"getNamedValue",
"(",
"MF",
".",
"getName",
"(",
")",
")",
")",
")",
";",
"}",
"else",
"{",
"It",
"=",
"MBB",
".",
"insert",
"(",
"It",
",",
"BuildMI",
"(",
"MF",
",",
"DebugLoc",
"(",
")",
",",
"get",
"(",
"X86",
"::",
"CALL64pcrel32",
")",
")",
".",
"addGlobalAddress",
"(",
"M",
".",
"getNamedValue",
"(",
"MF",
".",
"getName",
"(",
")",
")",
")",
")",
";",
"}",
"return",
"It",
";",
"}",
"</s>"
] | [
"Insert",
"a",
"call",
"to",
"an",
"outlined",
"function",
"into",
"the",
"program",
"."
] | [
"X86",
"X86",
"X86::JMP_1",
"X86::CALL64pcrel32"
] | X86InstrInfo114 | insertOutlinedCall | X86 | CPU | LLVM | 19,829 | 121 | 1 | [] |
[
"<s>",
"bool",
"X86AsmParser",
"::",
"processInstruction",
"(",
"MCInst",
"&",
"Inst",
",",
"const",
"SmallVectorImpl",
"<",
"MCParsedAsmOperand",
"*",
">",
"&",
"Ops",
")",
"{",
"switch",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"X86",
"::",
"AND16i16",
":",
"return",
"convert16i16to16ri8",
"(",
"Inst",
",",
"X86",
"::",
"AND16ri8",
")",
";",
"case",
"X86",
"::",
"AND32i32",
":",
"return",
"convert32i32to32ri8",
"(",
"Inst",
",",
"X86",
"::",
"AND32ri8",
")",
";",
"case",
"X86",
"::",
"AND64i32",
":",
"return",
"convert64i32to64ri8",
"(",
"Inst",
",",
"X86",
"::",
"AND64ri8",
")",
";",
"case",
"X86",
"::",
"XOR16i16",
":",
"return",
"convert16i16to16ri8",
"(",
"Inst",
",",
"X86",
"::",
"XOR16ri8",
")",
";",
"case",
"X86",
"::",
"XOR32i32",
":",
"return",
"convert32i32to32ri8",
"(",
"Inst",
",",
"X86",
"::",
"XOR32ri8",
")",
";",
"case",
"X86",
"::",
"XOR64i32",
":",
"return",
"convert64i32to64ri8",
"(",
"Inst",
",",
"X86",
"::",
"XOR64ri8",
")",
";",
"case",
"X86",
"::",
"OR16i16",
":",
"return",
"convert16i16to16ri8",
"(",
"Inst",
",",
"X86",
"::",
"OR16ri8",
")",
";",
"case",
"X86",
"::",
"OR32i32",
":",
"return",
"convert32i32to32ri8",
"(",
"Inst",
",",
"X86",
"::",
"OR32ri8",
")",
";",
"case",
"X86",
"::",
"OR64i32",
":",
"return",
"convert64i32to64ri8",
"(",
"Inst",
",",
"X86",
"::",
"OR64ri8",
")",
";",
"case",
"X86",
"::",
"CMP16i16",
":",
"return",
"convert16i16to16ri8",
"(",
"Inst",
",",
"X86",
"::",
"CMP16ri8",
",",
"true",
")",
";",
"case",
"X86",
"::",
"CMP32i32",
":",
"return",
"convert32i32to32ri8",
"(",
"Inst",
",",
"X86",
"::",
"CMP32ri8",
",",
"true",
")",
";",
"case",
"X86",
"::",
"CMP64i32",
":",
"return",
"convert64i32to64ri8",
"(",
"Inst",
",",
"X86",
"::",
"CMP64ri8",
",",
"true",
")",
";",
"case",
"X86",
"::",
"ADD16i16",
":",
"return",
"convert16i16to16ri8",
"(",
"Inst",
",",
"X86",
"::",
"ADD16ri8",
")",
";",
"case",
"X86",
"::",
"ADD32i32",
":",
"return",
"convert32i32to32ri8",
"(",
"Inst",
",",
"X86",
"::",
"ADD32ri8",
")",
";",
"case",
"X86",
"::",
"ADD64i32",
":",
"return",
"convert64i32to64ri8",
"(",
"Inst",
",",
"X86",
"::",
"ADD64ri8",
")",
";",
"case",
"X86",
"::",
"SUB16i16",
":",
"return",
"convert16i16to16ri8",
"(",
"Inst",
",",
"X86",
"::",
"SUB16ri8",
")",
";",
"case",
"X86",
"::",
"SUB32i32",
":",
"return",
"convert32i32to32ri8",
"(",
"Inst",
",",
"X86",
"::",
"SUB32ri8",
")",
";",
"case",
"X86",
"::",
"SUB64i32",
":",
"return",
"convert64i32to64ri8",
"(",
"Inst",
",",
"X86",
"::",
"SUB64ri8",
")",
";",
"case",
"X86",
"::",
"ADC16i16",
":",
"return",
"convert16i16to16ri8",
"(",
"Inst",
",",
"X86",
"::",
"ADC16ri8",
")",
";",
"case",
"X86",
"::",
"ADC32i32",
":",
"return",
"convert32i32to32ri8",
"(",
"Inst",
",",
"X86",
"::",
"ADC32ri8",
")",
";",
"case",
"X86",
"::",
"ADC64i32",
":",
"return",
"convert64i32to64ri8",
"(",
"Inst",
",",
"X86",
"::",
"ADC64ri8",
")",
";",
"case",
"X86",
"::",
"SBB16i16",
":",
"return",
"convert16i16to16ri8",
"(",
"Inst",
",",
"X86",
"::",
"SBB16ri8",
")",
";",
"case",
"X86",
"::",
"SBB32i32",
":",
"return",
"convert32i32to32ri8",
"(",
"Inst",
",",
"X86",
"::",
"SBB32ri8",
")",
";",
"case",
"X86",
"::",
"SBB64i32",
":",
"return",
"convert64i32to64ri8",
"(",
"Inst",
",",
"X86",
"::",
"SBB64ri8",
")",
";",
"}",
"}",
"</s>"
] | [
"Process",
"a",
"single",
"instruction",
"and",
"collect",
"debug",
"info",
"anchors",
"."
] | [
"X86",
"X86",
"X86::AND16i16",
"X86::AND16ri8",
"X86::AND32i32",
"X86::AND32ri8",
"X86::AND64i32",
"X86::AND64ri8",
"X86::XOR16i16",
"X86::XOR16ri8",
"X86::XOR32i32",
"X86::XOR32ri8",
"X86::XOR64i32",
"X86::XOR64ri8",
"X86::OR16i16",
"X86::OR16ri8",
"X86::OR32i32",
"X86::OR32ri8",
"X86::OR64i32",
"X86::OR64ri8",
"X86::CMP16i16",
"X86::CMP16ri8",
"X86::CMP32i32",
"X86::CMP32ri8",
"X86::CMP64i32",
"X86::CMP64ri8",
"X86::ADD16i16",
"X86::ADD16ri8",
"X86::ADD32i32",
"X86::ADD32ri8",
"X86::ADD64i32",
"X86::ADD64ri8",
"X86::SUB16i16",
"X86::SUB16ri8",
"X86::SUB32i32",
"X86::SUB32ri8",
"X86::SUB64i32",
"X86::SUB64ri8",
"X86::ADC16i16",
"X86::ADC16ri8",
"X86::ADC32i32",
"X86::ADC32ri8",
"X86::ADC64i32",
"X86::ADC64ri8",
"X86::SBB16i16",
"X86::SBB16ri8",
"X86::SBB32i32",
"X86::SBB32ri8",
"X86::SBB64i32",
"X86::SBB64ri8"
] | X86AsmParser (2)2 | processInstruction | X86 | CPU | LLVM | 19,830 | 401 | 1 | [] |
[
"<s>",
"void",
"AArch64Operand",
"::",
"print",
"(",
"raw_ostream",
"&",
"OS",
")",
"const",
"{",
"switch",
"(",
"Kind",
")",
"{",
"case",
"k_FPImm",
":",
"OS",
"<<",
"\"<fpimm \"",
"<<",
"getFPImm",
"(",
")",
".",
"bitcastToAPInt",
"(",
")",
".",
"getZExtValue",
"(",
")",
";",
"if",
"(",
"!",
"getFPImmIsExact",
"(",
")",
")",
"OS",
"<<",
"\" (inexact)\"",
";",
"OS",
"<<",
"\">\"",
";",
"break",
";",
"case",
"k_Barrier",
":",
"{",
"StringRef",
"Name",
"=",
"getBarrierName",
"(",
")",
";",
"if",
"(",
"!",
"Name",
".",
"empty",
"(",
")",
")",
"OS",
"<<",
"\"<barrier \"",
"<<",
"Name",
"<<",
"\">\"",
";",
"else",
"OS",
"<<",
"\"<barrier invalid #\"",
"<<",
"getBarrier",
"(",
")",
"<<",
"\">\"",
";",
"break",
";",
"}",
"case",
"k_Immediate",
":",
"OS",
"<<",
"*",
"getImm",
"(",
")",
";",
"break",
";",
"case",
"k_ShiftedImm",
":",
"{",
"unsigned",
"Shift",
"=",
"getShiftedImmShift",
"(",
")",
";",
"OS",
"<<",
"\"<shiftedimm \"",
";",
"OS",
"<<",
"*",
"getShiftedImmVal",
"(",
")",
";",
"OS",
"<<",
"\", lsl #\"",
"<<",
"AArch64_AM",
"::",
"getShiftValue",
"(",
"Shift",
")",
"<<",
"\">\"",
";",
"break",
";",
"}",
"case",
"k_CondCode",
":",
"OS",
"<<",
"\"<condcode \"",
"<<",
"getCondCode",
"(",
")",
"<<",
"\">\"",
";",
"break",
";",
"case",
"k_VectorList",
":",
"{",
"OS",
"<<",
"\"<vectorlist \"",
";",
"unsigned",
"Reg",
"=",
"getVectorListStart",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"getVectorListCount",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"OS",
"<<",
"Reg",
"+",
"i",
"<<",
"\" \"",
";",
"OS",
"<<",
"\">\"",
";",
"break",
";",
"}",
"case",
"k_VectorIndex",
":",
"OS",
"<<",
"\"<vectorindex \"",
"<<",
"getVectorIndex",
"(",
")",
"<<",
"\">\"",
";",
"break",
";",
"case",
"k_SysReg",
":",
"OS",
"<<",
"\"<sysreg: \"",
"<<",
"getSysReg",
"(",
")",
"<<",
"'>'",
";",
"break",
";",
"case",
"k_Token",
":",
"OS",
"<<",
"\"'\"",
"<<",
"getToken",
"(",
")",
"<<",
"\"'\"",
";",
"break",
";",
"case",
"k_SysCR",
":",
"OS",
"<<",
"\"c\"",
"<<",
"getSysCR",
"(",
")",
";",
"break",
";",
"case",
"k_Prefetch",
":",
"{",
"StringRef",
"Name",
"=",
"getPrefetchName",
"(",
")",
";",
"if",
"(",
"!",
"Name",
".",
"empty",
"(",
")",
")",
"OS",
"<<",
"\"<prfop \"",
"<<",
"Name",
"<<",
"\">\"",
";",
"else",
"OS",
"<<",
"\"<prfop invalid #\"",
"<<",
"getPrefetch",
"(",
")",
"<<",
"\">\"",
";",
"break",
";",
"}",
"case",
"k_PSBHint",
":",
"OS",
"<<",
"getPSBHintName",
"(",
")",
";",
"break",
";",
"case",
"k_Register",
":",
"OS",
"<<",
"\"<register \"",
"<<",
"getReg",
"(",
")",
"<<",
"\">\"",
";",
"if",
"(",
"!",
"getShiftExtendAmount",
"(",
")",
"&&",
"!",
"hasShiftExtendAmount",
"(",
")",
")",
"break",
";",
"LLVM_FALLTHROUGH",
";",
"case",
"k_BTIHint",
":",
"OS",
"<<",
"getBTIHintName",
"(",
")",
";",
"break",
";",
"case",
"k_ShiftExtend",
":",
"OS",
"<<",
"\"<\"",
"<<",
"AArch64_AM",
"::",
"getShiftExtendName",
"(",
"getShiftExtendType",
"(",
")",
")",
"<<",
"\" #\"",
"<<",
"getShiftExtendAmount",
"(",
")",
";",
"if",
"(",
"!",
"hasShiftExtendAmount",
"(",
")",
")",
"OS",
"<<",
"\"<imp>\"",
";",
"OS",
"<<",
"'>'",
";",
"break",
";",
"}",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"AArch64",
"AArch64",
"\"<fpimm \"",
"\" (inexact)\"",
"\">\"",
"\"<barrier \"",
"\">\"",
"\"<barrier invalid #\"",
"\">\"",
"\"<shiftedimm \"",
"\", lsl #\"",
"AArch64_AM::getShiftValue",
"\">\"",
"\"<condcode \"",
"\">\"",
"\"<vectorlist \"",
"0",
"\" \"",
"\">\"",
"\"<vectorindex \"",
"\">\"",
"\"<sysreg: \"",
"\"'\"",
"\"'\"",
"\"c\"",
"\"<prfop \"",
"\">\"",
"\"<prfop invalid #\"",
"\">\"",
"\"<register \"",
"\">\"",
"\"<\"",
"AArch64_AM::getShiftExtendName",
"\" #\"",
"\"<imp>\""
] | AArch64AsmParser (2)2 | print | AArch64 | CPU | LLVM | 19,831 | 401 | 1 | [] |
[
"<s>",
"TargetTransformInfo",
"AArch64TargetMachine",
"::",
"getTargetTransformInfo",
"(",
"const",
"Function",
"&",
"F",
")",
"const",
"{",
"return",
"TargetTransformInfo",
"(",
"AArch64TTIImpl",
"(",
"this",
",",
"F",
")",
")",
";",
"}",
"</s>"
] | [
"Get",
"a",
"TargetTransformInfo",
"implementation",
"for",
"the",
"target",
"."
] | [
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine32 | getTargetTransformInfo | AArch64 | CPU | LLVM | 19,832 | 24 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"isSchedulingBoundary",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"MachineBasicBlock",
"*",
"MBB",
",",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"Opcode",
"==",
"X86",
"::",
"ENDBR64",
"||",
"Opcode",
"==",
"X86",
"::",
"ENDBR32",
")",
"return",
"true",
";",
"return",
"TargetInstrInfo",
"::",
"isSchedulingBoundary",
"(",
"MI",
",",
"MBB",
",",
"MF",
")",
";",
"}",
"</s>"
] | [
"isSchedulingBoundary",
"-",
"Overrides",
"the",
"isSchedulingBoundary",
"from",
"Codegen/TargetInstrInfo.cpp",
"to",
"make",
"it",
"capable",
"of",
"identifying",
"ENDBR",
"intructions",
"and",
"prevent",
"it",
"from",
"being",
"re-scheduled",
"."
] | [
"X86",
"X86",
"X86::ENDBR64",
"X86::ENDBR32"
] | X86InstrInfo136 | isSchedulingBoundary | X86 | CPU | LLVM | 19,833 | 61 | 1 | [] |
[
"<s>",
"int",
"pdp10_starting_frame_offset",
"(",
")",
"{",
"return",
"0",
";",
"}",
"</s>"
] | [
"Called",
"by",
"the",
"STARTING_FRAME_OFFSET",
"macro",
"."
] | [
"pdp10",
"0"
] | pdp10 | pdp10_starting_frame_offset | pdp10 | MPU | GCC | 19,834 | 9 | 1 | [] |
[
"<s>",
"bool",
"arm_valid_symbolic_address_p",
"(",
"rtx",
"addr",
")",
"{",
"rtx",
"xop0",
",",
"xop1",
"=",
"NULL_RTX",
";",
"rtx",
"tmp",
"=",
"addr",
";",
"if",
"(",
"GET_CODE",
"(",
"tmp",
")",
"==",
"SYMBOL_REF",
"||",
"GET_CODE",
"(",
"tmp",
")",
"==",
"LABEL_REF",
")",
"return",
"true",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"CONST",
")",
"tmp",
"=",
"XEXP",
"(",
"addr",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"tmp",
")",
"==",
"PLUS",
")",
"{",
"xop0",
"=",
"XEXP",
"(",
"tmp",
",",
"0",
")",
";",
"xop1",
"=",
"XEXP",
"(",
"tmp",
",",
"1",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"xop0",
")",
"==",
"SYMBOL_REF",
"&&",
"CONST_INT_P",
"(",
"xop1",
")",
")",
"return",
"IN_RANGE",
"(",
"INTVAL",
"(",
"xop1",
")",
",",
"-",
"0x8000",
",",
"0x7fff",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"pattern",
"is",
"a",
"valid",
"symbolic",
"address",
",",
"which",
"is",
"either",
"a",
"symbol_ref",
"or",
"(",
"symbol_ref",
"+",
"addend",
")",
".",
"According",
"to",
"the",
"ARM",
"ELF",
"ABI",
",",
"the",
"initial",
"addend",
"of",
"REL-type",
"relocations",
"processing",
"MOVW",
"and",
"MOVT",
"instructions",
"is",
"formed",
"by",
"interpreting",
"the",
"16-bit",
"literal",
"field",
"of",
"the",
"instruction",
"as",
"a",
"16-bit",
"signed",
"value",
"in",
"the",
"range",
"-32768",
"<",
"=",
"A",
"<",
"32768",
".",
"In",
"Thumb-1",
"mode",
",",
"we",
"use",
"upper/lower",
"relocations",
"which",
"have",
"an",
"8-bit",
"unsigned",
"range",
"of",
"0",
"<",
"=",
"A",
"<",
"256",
"as",
"described",
"in",
"the",
"AAELF32",
"relocation",
"handling",
"documentation",
":",
"REL-type",
"relocations",
"are",
"encoded",
"as",
"unsigned",
"in",
"this",
"case",
"."
] | [
"arm",
"0",
"0",
"1",
"0x8000",
"0x7fff"
] | arm5 | arm_valid_symbolic_address_p | arm | CPU | GCC | 19,835 | 117 | 1 | [] |
[
"<s>",
"const",
"MCExpr",
"*",
"VEAsmParser",
"::",
"parseIdentifier",
"(",
"StringRef",
"Identifier",
")",
"{",
"StringRef",
"Modifier",
";",
"size_t",
"at",
"=",
"Identifier",
".",
"rfind",
"(",
"'@'",
")",
";",
"if",
"(",
"at",
"!=",
"0",
"||",
"at",
"!=",
"StringRef",
"::",
"npos",
")",
"{",
"std",
"::",
"pair",
"<",
"StringRef",
",",
"StringRef",
">",
"Pair",
"=",
"Identifier",
".",
"rsplit",
"(",
"\"@\"",
")",
";",
"if",
"(",
"!",
"Pair",
".",
"first",
".",
"empty",
"(",
")",
"&&",
"!",
"Pair",
".",
"second",
".",
"empty",
"(",
")",
")",
"{",
"Identifier",
"=",
"Pair",
".",
"first",
";",
"Modifier",
"=",
"Pair",
".",
"second",
";",
"}",
"}",
"MCSymbol",
"*",
"Sym",
"=",
"getContext",
"(",
")",
".",
"getOrCreateSymbol",
"(",
"Identifier",
")",
";",
"const",
"MCExpr",
"*",
"Res",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"Sym",
",",
"MCSymbolRefExpr",
"::",
"VK_None",
",",
"getContext",
"(",
")",
")",
";",
"VEMCExpr",
"::",
"VariantKind",
"VK",
"=",
"VEMCExpr",
"::",
"parseVariantKind",
"(",
"Modifier",
")",
";",
"if",
"(",
"VK",
"==",
"VEMCExpr",
"::",
"VK_VE_None",
")",
"{",
"VEMCExpr",
"::",
"VariantKind",
"Kind",
"=",
"VEMCExpr",
"::",
"VK_VE_REFLONG",
";",
"return",
"VEMCExpr",
"::",
"create",
"(",
"Kind",
",",
"Res",
",",
"getContext",
"(",
")",
")",
";",
"}",
"return",
"VEMCExpr",
"::",
"create",
"(",
"VK",
",",
"Res",
",",
"getContext",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Parse",
"an",
"identifier",
"or",
"string",
"(",
"as",
"a",
"quoted",
"identifier",
")",
"and",
"set",
"Res",
"to",
"the",
"identifier",
"contents",
"."
] | [
"VE",
"VE",
"0",
"\"@\"",
"VE",
"VE",
"VE",
"VE",
"VE",
"VE",
"VE",
"VE",
"VE"
] | VEAsmParser1 | parseIdentifier | VE | CPU | LLVM | 19,836 | 182 | 1 | [] |
[
"<s>",
"void",
"ix86_rewrite_tls_address_1",
"(",
"rtx",
"*",
"loc",
")",
"{",
"subrtx_ptr_iterator",
"::",
"array_type",
"array",
";",
"FOR_EACH_SUBRTX_PTR",
"(",
"iter",
",",
"array",
",",
"loc",
",",
"ALL",
")",
"{",
"rtx",
"*",
"loc",
"=",
"*",
"iter",
";",
"if",
"(",
"MEM_P",
"(",
"*",
"loc",
")",
")",
"{",
"rtx",
"addr",
"=",
"XEXP",
"(",
"*",
"loc",
",",
"0",
")",
";",
"rtx",
"*",
"x",
"=",
"&",
"addr",
";",
"while",
"(",
"GET_CODE",
"(",
"*",
"x",
")",
"==",
"PLUS",
")",
"{",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"2",
";",
"i",
"++",
")",
"{",
"rtx",
"u",
"=",
"XEXP",
"(",
"*",
"x",
",",
"i",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"u",
")",
"==",
"ZERO_EXTEND",
")",
"u",
"=",
"XEXP",
"(",
"u",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"u",
")",
"==",
"UNSPEC",
"&&",
"XINT",
"(",
"u",
",",
"1",
")",
"==",
"UNSPEC_TP",
")",
"{",
"addr_space_t",
"as",
"=",
"DEFAULT_TLS_SEG_REG",
";",
"*",
"x",
"=",
"XEXP",
"(",
"*",
"x",
",",
"1",
"-",
"i",
")",
";",
"*",
"loc",
"=",
"replace_equiv_address_nv",
"(",
"*",
"loc",
",",
"addr",
",",
"true",
")",
";",
"set_mem_addr_space",
"(",
"*",
"loc",
",",
"as",
")",
";",
"return",
";",
"}",
"}",
"x",
"=",
"&",
"XEXP",
"(",
"*",
"x",
",",
"0",
")",
";",
"}",
"iter",
".",
"skip_subrtxes",
"(",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Rewrite",
"*",
"LOC",
"so",
"that",
"it",
"refers",
"to",
"a",
"default",
"TLS",
"address",
"space",
"."
] | [
"i386",
"0",
"0",
"2",
"0",
"1",
"1",
"0"
] | i386 | ix86_rewrite_tls_address_1 | i386 | CPU | GCC | 19,837 | 198 | 1 | [] |
[
"<s>",
"enum",
"arc_function_type",
"arc_compute_function_type",
"(",
"struct",
"function",
"*",
"fun",
")",
"{",
"tree",
"decl",
"=",
"fun",
"->",
"decl",
";",
"tree",
"a",
";",
"enum",
"arc_function_type",
"fn_type",
"=",
"fun",
"->",
"machine",
"->",
"fn_type",
";",
"if",
"(",
"fn_type",
"!=",
"ARC_FUNCTION_UNKNOWN",
")",
"return",
"fn_type",
";",
"fn_type",
"=",
"ARC_FUNCTION_NORMAL",
";",
"for",
"(",
"a",
"=",
"DECL_ATTRIBUTES",
"(",
"decl",
")",
";",
"a",
";",
"a",
"=",
"TREE_CHAIN",
"(",
"a",
")",
")",
"{",
"tree",
"name",
"=",
"TREE_PURPOSE",
"(",
"a",
")",
",",
"args",
"=",
"TREE_VALUE",
"(",
"a",
")",
";",
"if",
"(",
"name",
"==",
"get_identifier",
"(",
"\"interrupt\"",
")",
"&&",
"list_length",
"(",
"args",
")",
"==",
"1",
"&&",
"TREE_CODE",
"(",
"TREE_VALUE",
"(",
"args",
")",
")",
"==",
"STRING_CST",
")",
"{",
"tree",
"value",
"=",
"TREE_VALUE",
"(",
"args",
")",
";",
"if",
"(",
"!",
"strcmp",
"(",
"TREE_STRING_POINTER",
"(",
"value",
")",
",",
"\"ilink1\"",
")",
")",
"fn_type",
"=",
"ARC_FUNCTION_ILINK1",
";",
"else",
"if",
"(",
"!",
"strcmp",
"(",
"TREE_STRING_POINTER",
"(",
"value",
")",
",",
"\"ilink2\"",
")",
")",
"fn_type",
"=",
"ARC_FUNCTION_ILINK2",
";",
"else",
"gcc_unreachable",
"(",
")",
";",
"break",
";",
"}",
"}",
"return",
"fun",
"->",
"machine",
"->",
"fn_type",
"=",
"fn_type",
";",
"}",
"</s>"
] | [
"Type",
"of",
"function",
"DECL",
".",
"The",
"result",
"is",
"cached",
".",
"To",
"reset",
"the",
"cache",
"at",
"the",
"end",
"of",
"a",
"function",
",",
"call",
"with",
"DECL",
"=",
"NULL_TREE",
"."
] | [
"arc",
"\"interrupt\"",
"1",
"\"ilink1\"",
"\"ilink2\""
] | arc4 | arc_compute_function_type | arc | MPU | GCC | 19,838 | 166 | 1 | [] |
[
"<s>",
"void",
"TriCoreCallingConvHook",
"::",
"init",
"(",
")",
"{",
"curPos",
"=",
"0",
";",
"curArg",
"=",
"0",
";",
"}",
"</s>"
] | [
"Initialize",
"the",
"machine",
"model",
"for",
"instruction",
"scheduling",
"."
] | [
"TriCore",
"TriCore",
"0",
"0"
] | TriCoreCallingConvHook | init | TriCore | MPU | LLVM | 19,839 | 16 | 1 | [] |
[
"<s>",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"override",
"{",
"initialize",
"(",
"MF",
")",
";",
"unskipableSimplifyCode",
"(",
")",
";",
"if",
"(",
"skipFunction",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"return",
"simplifyCode",
"(",
")",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"PowerPC"
] | PPCMIPeephole5 | runOnMachineFunction | PowerPC | CPU | LLVM | 19,840 | 38 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"RISCVRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"auto",
"&",
"Subtarget",
"=",
"MF",
"->",
"getSubtarget",
"<",
"RISCVSubtarget",
">",
"(",
")",
";",
"if",
"(",
"MF",
"->",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"\"interrupt\"",
")",
")",
"{",
"if",
"(",
"Subtarget",
".",
"hasStdExtD",
"(",
")",
")",
"return",
"CSR_XLEN_F64_Interrupt_SaveList",
";",
"if",
"(",
"Subtarget",
".",
"hasStdExtF",
"(",
")",
")",
"return",
"CSR_XLEN_F32_Interrupt_SaveList",
";",
"return",
"CSR_Interrupt_SaveList",
";",
"}",
"switch",
"(",
"Subtarget",
".",
"getTargetABI",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unrecognized ABI\"",
")",
";",
"case",
"RISCVABI",
"::",
"ABI_ILP32",
":",
"case",
"RISCVABI",
"::",
"ABI_LP64",
":",
"return",
"CSR_ILP32_LP64_SaveList",
";",
"case",
"RISCVABI",
"::",
"ABI_ILP32F",
":",
"case",
"RISCVABI",
"::",
"ABI_LP64F",
":",
"return",
"CSR_ILP32F_LP64F_SaveList",
";",
"case",
"RISCVABI",
"::",
"ABI_ILP32D",
":",
"case",
"RISCVABI",
"::",
"ABI_LP64D",
":",
"return",
"CSR_ILP32D_LP64D_SaveList",
";",
"}",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"RISCV",
"RISCV",
"RISCV",
"\"interrupt\"",
"\"Unrecognized ABI\"",
"RISCVABI::ABI_ILP32",
"RISCVABI::ABI_LP64",
"RISCVABI::ABI_ILP32F",
"RISCVABI::ABI_LP64F",
"RISCVABI::ABI_ILP32D",
"RISCVABI::ABI_LP64D"
] | RISCVRegisterInfo10 | getCalleeSavedRegs | RISCV | CPU | LLVM | 19,841 | 124 | 1 | [] |
[
"<s>",
"bool",
"BlackfinFrameInfo",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"return",
"DisableFramePointerElim",
"(",
"MF",
")",
"||",
"MFI",
"->",
"adjustsStack",
"(",
")",
"||",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"Blackfin"
] | BlackfinFrameInfo | hasFP | Blackfin | DSP | LLVM | 19,842 | 42 | 1 | [] |
[
"<s>",
"MCELFStreamer",
"&",
"VETargetELFStreamer",
"::",
"getStreamer",
"(",
")",
"{",
"return",
"static_cast",
"<",
"MCELFStreamer",
"&",
">",
"(",
"Streamer",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"output",
"streamer",
"for",
"the",
"assembler",
"."
] | [
"VE",
"VE"
] | VETargetStreamer | getStreamer | VE | CPU | LLVM | 19,843 | 19 | 1 | [] |
[
"<s>",
"static",
"bool",
"arm_cannot_force_const_mem",
"(",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"rtx",
"x",
")",
"{",
"rtx",
"base",
",",
"offset",
";",
"if",
"(",
"ARM_OFFSETS_MUST_BE_WITHIN_SECTIONS_P",
")",
"{",
"split_const",
"(",
"x",
",",
"&",
"base",
",",
"&",
"offset",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"base",
")",
"==",
"SYMBOL_REF",
"&&",
"!",
"offset_within_block_p",
"(",
"base",
",",
"INTVAL",
"(",
"offset",
")",
")",
")",
"return",
"true",
";",
"}",
"return",
"arm_tls_referenced_p",
"(",
"x",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_CANNOT_FORCE_CONST_MEM",
"."
] | [
"arm"
] | arm4 | arm_cannot_force_const_mem | arm | CPU | GCC | 19,844 | 64 | 1 | [] |
[
"<s>",
"void",
"AGCAsmBackend",
"::",
"applyFixup",
"(",
"const",
"MCAssembler",
"&",
"Asm",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
"Target",
",",
"MutableArrayRef",
"<",
"char",
">",
"Data",
",",
"uint64_t",
"Value",
",",
"bool",
"IsResolved",
",",
"const",
"MCSubtargetInfo",
"*",
"STI",
")",
"const",
"{",
"return",
";",
"}",
"</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",
"."
] | [
"AGC",
"AGC"
] | AGCAsmBackend | applyFixup | AGC | MPU | LLVM | 19,845 | 42 | 1 | [] |
[
"<s>",
"const",
"BPFInstrInfo",
"*",
"getInstrInfo",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"InstrInfo",
";",
"}",
"</s>"
] | [
"TargetInstrInfo",
"getter",
"."
] | [
"BPF",
"BPF"
] | BPFSubtarget | getInstrInfo | BPF | Virtual ISA | LLVM | 19,846 | 14 | 1 | [] |
[
"<s>",
"bool",
"WinEHStatePass",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"if",
"(",
"F",
".",
"hasAvailableExternallyLinkage",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"F",
".",
"hasPersonalityFn",
"(",
")",
")",
"return",
"false",
";",
"PersonalityFn",
"=",
"dyn_cast",
"<",
"Function",
">",
"(",
"F",
".",
"getPersonalityFn",
"(",
")",
"->",
"stripPointerCastsSafe",
"(",
")",
")",
";",
"if",
"(",
"!",
"PersonalityFn",
")",
"return",
"false",
";",
"Personality",
"=",
"classifyEHPersonality",
"(",
"PersonalityFn",
")",
";",
"if",
"(",
"!",
"isFuncletEHPersonality",
"(",
"Personality",
")",
")",
"return",
"false",
";",
"bool",
"HasPads",
"=",
"false",
";",
"for",
"(",
"BasicBlock",
"&",
"BB",
":",
"F",
")",
"{",
"if",
"(",
"BB",
".",
"isEHPad",
"(",
")",
")",
"{",
"HasPads",
"=",
"true",
";",
"break",
";",
"}",
"}",
"if",
"(",
"!",
"HasPads",
")",
"return",
"false",
";",
"Type",
"*",
"Int8PtrType",
"=",
"Type",
"::",
"getInt8PtrTy",
"(",
"TheModule",
"->",
"getContext",
"(",
")",
")",
";",
"SetJmp3",
"=",
"TheModule",
"->",
"getOrInsertFunction",
"(",
"\"_setjmp3\"",
",",
"FunctionType",
"::",
"get",
"(",
"Type",
"::",
"getInt32Ty",
"(",
"TheModule",
"->",
"getContext",
"(",
")",
")",
",",
"{",
"Int8PtrType",
",",
"Type",
"::",
"getInt32Ty",
"(",
"TheModule",
"->",
"getContext",
"(",
")",
")",
"}",
",",
"true",
")",
")",
";",
"emitExceptionRegistrationRecord",
"(",
"&",
"F",
")",
";",
"WinEHFuncInfo",
"FuncInfo",
";",
"addStateStores",
"(",
"F",
",",
"FuncInfo",
")",
";",
"PersonalityFn",
"=",
"nullptr",
";",
"Personality",
"=",
"EHPersonality",
"::",
"Unknown",
";",
"UseStackGuard",
"=",
"false",
";",
"RegNode",
"=",
"nullptr",
";",
"EHGuardNode",
"=",
"nullptr",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"X86",
"\"_setjmp3\""
] | X86WinEHState1 | runOnFunction | X86 | CPU | LLVM | 19,847 | 215 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_member_type_forces_blk",
"(",
"const_tree",
"field",
",",
"machine_mode",
"mode",
")",
"{",
"return",
"(",
"mode",
"==",
"XFmode",
"&&",
"(",
"TREE_CODE",
"(",
"DECL_FIELD_CONTEXT",
"(",
"field",
")",
")",
"==",
"UNION_TYPE",
"||",
"TREE_CODE",
"(",
"DECL_FIELD_CONTEXT",
"(",
"field",
")",
")",
"==",
"QUAL_UNION_TYPE",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"a",
"structure",
",",
"union",
"or",
"array",
"with",
"MODE",
"containing",
"FIELD",
"should",
"be",
"accessed",
"using",
"BLKmode",
"."
] | [
"i386"
] | i386 | ix86_member_type_forces_blk | i386 | CPU | GCC | 19,848 | 41 | 1 | [] |
[
"<s>",
"unsigned",
"SparcInstrInfo",
"::",
"isStoreToStackSlot",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"SP",
"::",
"STri",
"||",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"SP",
"::",
"STFri",
"||",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"SP",
"::",
"STDFri",
")",
"{",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"isFI",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
"{",
"FrameIndex",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
";",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isStoreToStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"store",
"to",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"source",
"reg",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"Sparc",
"Sparc",
"SP::STri",
"SP::STFri",
"SP::STDFri",
"0",
"1",
"1",
"0",
"0",
"2",
"0"
] | SparcInstrInfo16 | isStoreToStackSlot | Sparc | CPU | LLVM | 19,849 | 118 | 1 | [] |
[
"<s>",
"bool",
"PPCInstrInfo",
"::",
"shouldClusterMemOps",
"(",
"ArrayRef",
"<",
"const",
"MachineOperand",
"*",
">",
"BaseOps1",
",",
"ArrayRef",
"<",
"const",
"MachineOperand",
"*",
">",
"BaseOps2",
",",
"unsigned",
"NumLoads",
",",
"unsigned",
"NumBytes",
")",
"const",
"{",
"assert",
"(",
"BaseOps1",
".",
"size",
"(",
")",
"==",
"1",
"&&",
"BaseOps2",
".",
"size",
"(",
")",
"==",
"1",
")",
";",
"const",
"MachineOperand",
"&",
"BaseOp1",
"=",
"*",
"BaseOps1",
".",
"front",
"(",
")",
";",
"const",
"MachineOperand",
"&",
"BaseOp2",
"=",
"*",
"BaseOps2",
".",
"front",
"(",
")",
";",
"assert",
"(",
"(",
"BaseOp1",
".",
"isReg",
"(",
")",
"||",
"BaseOp1",
".",
"isFI",
"(",
")",
")",
"&&",
"\"Only base registers and frame indices are supported.\"",
")",
";",
"if",
"(",
"NumLoads",
">",
"2",
")",
"return",
"false",
";",
"if",
"(",
"(",
"BaseOp1",
".",
"isReg",
"(",
")",
"!=",
"BaseOp2",
".",
"isReg",
"(",
")",
")",
"||",
"(",
"BaseOp1",
".",
"isReg",
"(",
")",
"&&",
"BaseOp1",
".",
"getReg",
"(",
")",
"!=",
"BaseOp2",
".",
"getReg",
"(",
")",
")",
"||",
"(",
"BaseOp1",
".",
"isFI",
"(",
")",
"&&",
"BaseOp1",
".",
"getIndex",
"(",
")",
"!=",
"BaseOp2",
".",
"getIndex",
"(",
")",
")",
")",
"return",
"false",
";",
"const",
"MachineInstr",
"&",
"FirstLdSt",
"=",
"*",
"BaseOp1",
".",
"getParent",
"(",
")",
";",
"const",
"MachineInstr",
"&",
"SecondLdSt",
"=",
"*",
"BaseOp2",
".",
"getParent",
"(",
")",
";",
"unsigned",
"FirstOpc",
"=",
"FirstLdSt",
".",
"getOpcode",
"(",
")",
";",
"unsigned",
"SecondOpc",
"=",
"SecondLdSt",
".",
"getOpcode",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"&",
"getRegisterInfo",
"(",
")",
";",
"if",
"(",
"!",
"isClusterableLdStOpcPair",
"(",
"FirstOpc",
",",
"SecondOpc",
",",
"Subtarget",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"isLdStSafeToCluster",
"(",
"FirstLdSt",
",",
"TRI",
")",
"||",
"!",
"isLdStSafeToCluster",
"(",
"SecondLdSt",
",",
"TRI",
")",
")",
"return",
"false",
";",
"int64_t",
"Offset1",
"=",
"0",
",",
"Offset2",
"=",
"0",
";",
"unsigned",
"Width1",
"=",
"0",
",",
"Width2",
"=",
"0",
";",
"const",
"MachineOperand",
"*",
"Base1",
"=",
"nullptr",
",",
"*",
"Base2",
"=",
"nullptr",
";",
"if",
"(",
"!",
"getMemOperandWithOffsetWidth",
"(",
"FirstLdSt",
",",
"Base1",
",",
"Offset1",
",",
"Width1",
",",
"TRI",
")",
"||",
"!",
"getMemOperandWithOffsetWidth",
"(",
"SecondLdSt",
",",
"Base2",
",",
"Offset2",
",",
"Width2",
",",
"TRI",
")",
"||",
"Width1",
"!=",
"Width2",
")",
"return",
"false",
";",
"assert",
"(",
"Base1",
"==",
"&",
"BaseOp1",
"&&",
"Base2",
"==",
"&",
"BaseOp2",
"&&",
"\"getMemOperandWithOffsetWidth return incorrect base op\"",
")",
";",
"assert",
"(",
"Offset1",
"<=",
"Offset2",
"&&",
"\"Caller should have ordered offsets.\"",
")",
";",
"return",
"Offset1",
"+",
"Width1",
"==",
"Offset2",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"two",
"given",
"memory",
"operations",
"should",
"be",
"scheduled",
"adjacent",
"."
] | [
"PowerPC",
"PPC",
"1",
"1",
"\"Only base registers and frame indices are supported.\"",
"2",
"0",
"0",
"0",
"0",
"\"getMemOperandWithOffsetWidth return incorrect base op\"",
"\"Caller should have ordered offsets.\""
] | PPCInstrInfo | shouldClusterMemOps | PowerPC | CPU | LLVM | 19,850 | 346 | 1 | [] |
[
"<s>",
"InstructionCost",
"HexagonTTIImpl",
"::",
"getOperandsScalarizationOverhead",
"(",
"ArrayRef",
"<",
"const",
"Value",
"*",
">",
"Args",
",",
"ArrayRef",
"<",
"Type",
"*",
">",
"Tys",
")",
"{",
"return",
"BaseT",
"::",
"getOperandsScalarizationOverhead",
"(",
"Args",
",",
"Tys",
")",
";",
"}",
"</s>"
] | [
"Estimate",
"the",
"overhead",
"of",
"scalarizing",
"an",
"instructions",
"unique",
"non-constant",
"operands",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonTargetTransformInfo16 | getOperandsScalarizationOverhead | Hexagon | DSP | LLVM | 19,851 | 32 | 1 | [] |
[
"<s>",
"SMLoc",
"getEndLoc",
"(",
")",
"const",
"{",
"return",
"EndLoc",
";",
"}",
"</s>"
] | [
"getEndLoc",
"-",
"Get",
"the",
"location",
"of",
"the",
"last",
"token",
"of",
"this",
"operand",
"."
] | [
"Sparc"
] | SparcAsmParser11 | getEndLoc | Sparc | CPU | LLVM | 19,852 | 10 | 1 | [] |
[
"<s>",
"std",
"::",
"unique_ptr",
"<",
"DLXOperand",
">",
"DLXAsmParser",
"::",
"parseIdentifier",
"(",
")",
"{",
"SMLoc",
"Start",
"=",
"Parser",
".",
"getTok",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"SMLoc",
"End",
"=",
"SMLoc",
"::",
"getFromPointer",
"(",
"Parser",
".",
"getTok",
"(",
")",
".",
"getLoc",
"(",
")",
".",
"getPointer",
"(",
")",
"-",
"1",
")",
";",
"const",
"MCExpr",
"*",
"Res",
",",
"*",
"RHS",
"=",
"nullptr",
";",
"DLXMCExpr",
"::",
"VariantKind",
"Kind",
"=",
"DLXMCExpr",
"::",
"VK_DLX_None",
";",
"if",
"(",
"Lexer",
".",
"getKind",
"(",
")",
"!=",
"AsmToken",
"::",
"Identifier",
")",
"return",
"nullptr",
";",
"StringRef",
"Identifier",
";",
"if",
"(",
"Parser",
".",
"parseIdentifier",
"(",
"Identifier",
")",
")",
"return",
"nullptr",
";",
"if",
"(",
"Identifier",
".",
"equals_lower",
"(",
"\"hi\"",
")",
")",
"Kind",
"=",
"DLXMCExpr",
"::",
"VK_DLX_ABS_HI",
";",
"else",
"if",
"(",
"Identifier",
".",
"equals_lower",
"(",
"\"lo\"",
")",
")",
"Kind",
"=",
"DLXMCExpr",
"::",
"VK_DLX_ABS_LO",
";",
"if",
"(",
"Kind",
"!=",
"DLXMCExpr",
"::",
"VK_DLX_None",
")",
"{",
"if",
"(",
"Lexer",
".",
"getKind",
"(",
")",
"!=",
"AsmToken",
"::",
"LParen",
")",
"{",
"Error",
"(",
"Lexer",
".",
"getLoc",
"(",
")",
",",
"\"Expected '('\"",
")",
";",
"return",
"nullptr",
";",
"}",
"Lexer",
".",
"Lex",
"(",
")",
";",
"if",
"(",
"Parser",
".",
"parseIdentifier",
"(",
"Identifier",
")",
")",
"return",
"nullptr",
";",
"}",
"if",
"(",
"Lexer",
".",
"getKind",
"(",
")",
"==",
"AsmToken",
"::",
"Plus",
"&&",
"Parser",
".",
"parseExpression",
"(",
"RHS",
")",
")",
"return",
"nullptr",
";",
"if",
"(",
"Kind",
"!=",
"DLXMCExpr",
"::",
"VK_DLX_None",
")",
"{",
"if",
"(",
"Lexer",
".",
"getKind",
"(",
")",
"!=",
"AsmToken",
"::",
"RParen",
")",
"{",
"Error",
"(",
"Lexer",
".",
"getLoc",
"(",
")",
",",
"\"Expected ')'\"",
")",
";",
"return",
"nullptr",
";",
"}",
"Lexer",
".",
"Lex",
"(",
")",
";",
"}",
"End",
"=",
"SMLoc",
"::",
"getFromPointer",
"(",
"Parser",
".",
"getTok",
"(",
")",
".",
"getLoc",
"(",
")",
".",
"getPointer",
"(",
")",
"-",
"1",
")",
";",
"MCSymbol",
"*",
"Sym",
"=",
"getContext",
"(",
")",
".",
"getOrCreateSymbol",
"(",
"Identifier",
")",
";",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"Sym",
",",
"getContext",
"(",
")",
")",
";",
"Res",
"=",
"DLXMCExpr",
"::",
"create",
"(",
"Kind",
",",
"Expr",
",",
"getContext",
"(",
")",
")",
";",
"if",
"(",
"RHS",
")",
"Res",
"=",
"MCBinaryExpr",
"::",
"createAdd",
"(",
"Res",
",",
"RHS",
",",
"getContext",
"(",
")",
")",
";",
"return",
"DLXOperand",
"::",
"createImm",
"(",
"Res",
",",
"Start",
",",
"End",
")",
";",
"}",
"</s>"
] | [
"Parse",
"an",
"identifier",
"or",
"string",
"(",
"as",
"a",
"quoted",
"identifier",
")",
"and",
"set",
"Res",
"to",
"the",
"identifier",
"contents",
"."
] | [
"DLX",
"DLX",
"DLX",
"1",
"DLX",
"DLX",
"DLX",
"\"hi\"",
"DLX",
"DLX",
"\"lo\"",
"DLX",
"DLX",
"DLX",
"DLX",
"\"Expected '('\"",
"DLX",
"DLX",
"\"Expected ')'\"",
"1",
"DLX",
"DLXOperand::createImm"
] | DLXAsmParser | parseIdentifier | DLX | CPU | LLVM | 19,853 | 350 | 1 | [] |
[
"<s>",
"void",
"MSP430InstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIdx",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"FrameIdx",
")",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"MFI",
".",
"getObjectSize",
"(",
"FrameIdx",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FrameIdx",
")",
")",
";",
"if",
"(",
"RC",
"==",
"&",
"MSP430",
"::",
"GR16RegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"MSP430",
"::",
"MOV16mr",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"MSP430",
"::",
"GR8RegClass",
")",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"MSP430",
"::",
"MOV8mr",
")",
")",
".",
"addFrameIndex",
"(",
"FrameIdx",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"else",
"llvm_unreachable",
"(",
"\"Cannot store this register to stack slot!\"",
")",
";",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"MSP430",
"MSP430",
"MSP430::GR16RegClass",
"MSP430::MOV16mr",
"0",
"MSP430::GR8RegClass",
"MSP430::MOV8mr",
"0",
"\"Cannot store this register to stack slot!\""
] | MSP430InstrInfo31 | storeRegToStackSlot | MSP430 | MPU | LLVM | 19,854 | 222 | 1 | [] |
[
"<s>",
"bool",
"RISCVCallLowering",
"::",
"lowerCall",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"CallLoweringInfo",
"&",
"Info",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"given",
"call",
"instruction",
",",
"including",
"argument",
"and",
"return",
"value",
"marshalling",
"."
] | [
"RISCV",
"RISCV"
] | RISCVCallLowering | lowerCall | RISCV | CPU | LLVM | 19,855 | 19 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"RISCV_OPTIMIZE_VSETVL_USES_NAME",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"RISCV",
"RISCV"
] | RISCVOptimizeVSETVLUses | getPassName | RISCV | CPU | LLVM | 19,856 | 11 | 1 | [] |
[
"<s>",
"Relocator",
"::",
"Result",
"none",
"(",
"Relocation",
"&",
"pReloc",
",",
"X86_64Relocator",
"&",
"pParent",
")",
"{",
"return",
"Relocator",
"::",
"OK",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"none",
"of",
"the",
"bits",
"are",
"set",
"."
] | [
"X86",
"X86"
] | X86Relocator | none | X86 | CPU | LLVM | 19,857 | 20 | 1 | [] |
[
"<s>",
"const",
"RegisterBankInfo",
"*",
"RISCVSubtarget",
"::",
"getRegBankInfo",
"(",
")",
"const",
"{",
"return",
"RegBankInfo",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"If",
"the",
"information",
"for",
"the",
"register",
"banks",
"is",
"available",
",",
"return",
"it",
"."
] | [
"RI5CY",
"RISCV"
] | RISCVSubtarget | getRegBankInfo | RI5CY | CPU | LLVM | 19,858 | 18 | 1 | [] |
[
"<s>",
"void",
"M68kOperand",
"::",
"print",
"(",
"raw_ostream",
"&",
"OS",
")",
"const",
"{",
"switch",
"(",
"Kind",
")",
"{",
"case",
"Kind",
"::",
"Invalid",
":",
"OS",
"<<",
"\"invalid\"",
";",
"break",
";",
"case",
"Kind",
"::",
"Token",
":",
"OS",
"<<",
"\"token '\"",
"<<",
"Token",
"<<",
"\"'\"",
";",
"break",
";",
"case",
"Kind",
"::",
"Imm",
":",
"OS",
"<<",
"\"immediate \"",
"<<",
"Imm",
";",
"break",
";",
"case",
"Kind",
"::",
"MemOp",
":",
"MemOp",
".",
"print",
"(",
"OS",
")",
";",
"break",
";",
"}",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"M68k",
"M68k",
"\"invalid\"",
"\"token '\"",
"\"'\"",
"\"immediate \""
] | M68kAsmParser3 | print | M68k | MPU | LLVM | 19,859 | 71 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_add_new_builtins",
"(",
"HOST_WIDE_INT",
"isa",
",",
"HOST_WIDE_INT",
"isa2",
")",
"{",
"isa",
"&=",
"~",
"OPTION_MASK_ISA_64BIT",
";",
"if",
"(",
"(",
"isa",
"&",
"deferred_isa_values",
")",
"==",
"0",
"&&",
"(",
"isa2",
"&",
"deferred_isa_values2",
")",
"==",
"0",
")",
"return",
";",
"deferred_isa_values",
"&=",
"~",
"isa",
";",
"deferred_isa_values2",
"&=",
"~",
"isa2",
";",
"int",
"i",
";",
"tree",
"saved_current_target_pragma",
"=",
"current_target_pragma",
";",
"current_target_pragma",
"=",
"NULL_TREE",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"(",
"int",
")",
"IX86_BUILTIN_MAX",
";",
"i",
"++",
")",
"{",
"if",
"(",
"(",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"isa",
"&",
"isa",
")",
"!=",
"0",
"||",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"isa2",
"&",
"isa2",
")",
"!=",
"0",
")",
"&&",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"set_and_not_built_p",
")",
"{",
"tree",
"decl",
",",
"type",
";",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"set_and_not_built_p",
"=",
"false",
";",
"type",
"=",
"ix86_get_builtin_func_type",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"tcode",
")",
";",
"decl",
"=",
"add_builtin_function_ext_scope",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"name",
",",
"type",
",",
"i",
",",
"BUILT_IN_MD",
",",
"NULL",
",",
"NULL_TREE",
")",
";",
"ix86_builtins",
"[",
"i",
"]",
"=",
"decl",
";",
"if",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"const_p",
")",
"TREE_READONLY",
"(",
"decl",
")",
"=",
"1",
";",
"}",
"}",
"current_target_pragma",
"=",
"saved_current_target_pragma",
";",
"}",
"</s>"
] | [
"Add",
"any",
"new",
"builtin",
"functions",
"for",
"a",
"given",
"ISA",
"that",
"may",
"not",
"have",
"been",
"declared",
".",
"This",
"saves",
"a",
"bit",
"of",
"space",
"compared",
"to",
"adding",
"all",
"of",
"the",
"declarations",
"to",
"the",
"tree",
",",
"even",
"if",
"we",
"did",
"n't",
"use",
"them",
"."
] | [
"i386",
"0",
"0",
"0",
"0",
"0",
"1"
] | i3868 | ix86_add_new_builtins | i386 | CPU | GCC | 19,860 | 191 | 1 | [] |
[
"<s>",
"enum",
"attr_opx_type",
"m68k_sched_attr_opx_type",
"(",
"rtx_insn",
"*",
"insn",
",",
"int",
"address_p",
")",
"{",
"switch",
"(",
"sched_attr_op_type",
"(",
"insn",
",",
"true",
",",
"address_p",
"!=",
"0",
")",
")",
"{",
"case",
"OP_TYPE_RN",
":",
"return",
"OPX_TYPE_RN",
";",
"case",
"OP_TYPE_FPN",
":",
"return",
"OPX_TYPE_FPN",
";",
"case",
"OP_TYPE_MEM1",
":",
"return",
"OPX_TYPE_MEM1",
";",
"case",
"OP_TYPE_MEM234",
":",
"return",
"OPX_TYPE_MEM234",
";",
"case",
"OP_TYPE_MEM5",
":",
"return",
"OPX_TYPE_MEM5",
";",
"case",
"OP_TYPE_MEM6",
":",
"return",
"OPX_TYPE_MEM6",
";",
"case",
"OP_TYPE_MEM7",
":",
"return",
"OPX_TYPE_MEM7",
";",
"case",
"OP_TYPE_IMM_Q",
":",
"return",
"OPX_TYPE_IMM_Q",
";",
"case",
"OP_TYPE_IMM_W",
":",
"return",
"OPX_TYPE_IMM_W",
";",
"case",
"OP_TYPE_IMM_L",
":",
"return",
"OPX_TYPE_IMM_L",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Implement",
"opx_type",
"attribute",
".",
"Return",
"type",
"of",
"INSN",
"'s",
"operand",
"X",
".",
"If",
"ADDRESS_P",
"is",
"true",
",",
"return",
"type",
"of",
"memory",
"location",
"operand",
"refers",
"to",
"."
] | [
"m68k",
"0"
] | m68k | m68k_sched_attr_opx_type | m68k | MPU | GCC | 19,861 | 94 | 1 | [] |
[
"<s>",
"rtx",
"xtensa_function_value",
"(",
"const_tree",
"valtype",
",",
"const_tree",
"func",
"ATTRIBUTE_UNUSED",
",",
"bool",
"outgoing",
")",
"{",
"return",
"gen_rtx_REG",
"(",
"(",
"INTEGRAL_TYPE_P",
"(",
"valtype",
")",
"&&",
"TYPE_PRECISION",
"(",
"valtype",
")",
"<",
"BITS_PER_WORD",
")",
"?",
"SImode",
":",
"TYPE_MODE",
"(",
"valtype",
")",
",",
"outgoing",
"?",
"GP_OUTGOING_RETURN",
":",
"GP_RETURN_FIRST",
")",
";",
"}",
"</s>"
] | [
"Worker",
"function",
"for",
"TARGET_FUNCTION_VALUE",
"."
] | [
"xtensa"
] | xtensa1 | xtensa_function_value | xtensa | MPU | GCC | 19,862 | 46 | 1 | [] |
[
"<s>",
"AMDGPUSubtarget",
"&",
"AMDGPUSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"TT",
",",
"StringRef",
"GPU",
",",
"StringRef",
"FS",
")",
"{",
"SmallString",
"<",
"256",
">",
"FullFS",
"(",
"\"+promote-alloca,+fp64-denormals,\"",
")",
";",
"FullFS",
"+=",
"FS",
";",
"if",
"(",
"GPU",
"==",
"\"\"",
"&&",
"Triple",
"(",
"TT",
")",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"amdgcn",
")",
"GPU",
"=",
"\"SI\"",
";",
"ParseSubtargetFeatures",
"(",
"GPU",
",",
"FullFS",
")",
";",
"if",
"(",
"getGeneration",
"(",
")",
"<=",
"AMDGPUSubtarget",
"::",
"NORTHERN_ISLANDS",
")",
"{",
"FP32Denormals",
"=",
"false",
";",
"FP64Denormals",
"=",
"false",
";",
"}",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"R600",
"256",
"\"+promote-alloca,+fp64-denormals,\"",
"\"\"",
"\"SI\""
] | AMDGPUSubtarget26 | initializeSubtargetDependencies | R600 | GPU | LLVM | 19,863 | 84 | 1 | [] |
[
"<s>",
"static",
"rtx",
"aapcs_vfp_allocate_return_reg",
"(",
"enum",
"arm_pcs",
"pcs_variant",
"ATTRIBUTE_UNUSED",
",",
"machine_mode",
"mode",
",",
"const_tree",
"type",
"ATTRIBUTE_UNUSED",
")",
"{",
"if",
"(",
"!",
"use_vfp_abi",
"(",
"pcs_variant",
",",
"false",
")",
")",
"return",
"NULL",
";",
"if",
"(",
"mode",
"==",
"BLKmode",
"||",
"(",
"GET_MODE_CLASS",
"(",
"mode",
")",
"==",
"MODE_INT",
"&&",
"GET_MODE_SIZE",
"(",
"mode",
")",
">=",
"GET_MODE_SIZE",
"(",
"TImode",
")",
"&&",
"!",
"(",
"TARGET_NEON",
"||",
"TARGET_HAVE_MVE",
")",
")",
")",
"{",
"int",
"count",
";",
"machine_mode",
"ag_mode",
";",
"int",
"i",
";",
"rtx",
"par",
";",
"int",
"shift",
";",
"aapcs_vfp_is_call_or_return_candidate",
"(",
"pcs_variant",
",",
"mode",
",",
"type",
",",
"&",
"ag_mode",
",",
"&",
"count",
")",
";",
"if",
"(",
"!",
"(",
"TARGET_NEON",
"||",
"TARGET_HAVE_MVE",
")",
")",
"{",
"if",
"(",
"ag_mode",
"==",
"V2SImode",
")",
"ag_mode",
"=",
"DImode",
";",
"else",
"if",
"(",
"ag_mode",
"==",
"V4SImode",
")",
"{",
"ag_mode",
"=",
"DImode",
";",
"count",
"*=",
"2",
";",
"}",
"}",
"shift",
"=",
"GET_MODE_SIZE",
"(",
"ag_mode",
")",
"/",
"GET_MODE_SIZE",
"(",
"SFmode",
")",
";",
"par",
"=",
"gen_rtx_PARALLEL",
"(",
"mode",
",",
"rtvec_alloc",
"(",
"count",
")",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"count",
";",
"i",
"++",
")",
"{",
"rtx",
"tmp",
"=",
"gen_rtx_REG",
"(",
"ag_mode",
",",
"FIRST_VFP_REGNUM",
"+",
"i",
"*",
"shift",
")",
";",
"tmp",
"=",
"gen_rtx_EXPR_LIST",
"(",
"VOIDmode",
",",
"tmp",
",",
"GEN_INT",
"(",
"i",
"*",
"GET_MODE_SIZE",
"(",
"ag_mode",
")",
")",
")",
";",
"XVECEXP",
"(",
"par",
",",
"0",
",",
"i",
")",
"=",
"tmp",
";",
"}",
"return",
"par",
";",
"}",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"FIRST_VFP_REGNUM",
")",
";",
"}",
"</s>"
] | [
"Implement",
"the",
"allocate_return_reg",
"field",
"in",
"aapcs_cp_arg_layout",
".",
"See",
"the",
"comment",
"there",
"for",
"the",
"behaviour",
"of",
"this",
"function",
"."
] | [
"arm",
"2",
"0",
"0"
] | arm | aapcs_vfp_allocate_return_reg | arm | CPU | GCC | 19,864 | 227 | 1 | [] |
[
"<s>",
"bool",
"AAPAsmParser",
"::",
"MatchAndEmitInstruction",
"(",
"SMLoc",
"IDLoc",
",",
"unsigned",
"&",
"Opcode",
",",
"OperandVector",
"&",
"Operands",
",",
"MCStreamer",
"&",
"Out",
",",
"uint64_t",
"&",
"ErrorInfo",
",",
"bool",
"matchingInlineAsm",
")",
"{",
"MCInst",
"Inst",
";",
"SMLoc",
"ErrorLoc",
";",
"switch",
"(",
"MatchInstructionImpl",
"(",
"Operands",
",",
"Inst",
",",
"ErrorInfo",
",",
"matchingInlineAsm",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Match_Success",
":",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
",",
"getSTI",
"(",
")",
")",
";",
"return",
"false",
";",
"case",
"Match_MissingFeature",
":",
"{",
"assert",
"(",
"ErrorInfo",
"&&",
"\"Unknown missing feature!\"",
")",
";",
"std",
"::",
"string",
"Msg",
"=",
"\"Use of this instruction requires:\"",
";",
"unsigned",
"Mask",
"=",
"1",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"(",
"sizeof",
"(",
"ErrorInfo",
")",
"*",
"8",
"-",
"1",
")",
";",
"++",
"i",
")",
"{",
"if",
"(",
"ErrorInfo",
"&",
"Mask",
")",
"{",
"Msg",
"+=",
"\" \"",
";",
"Msg",
"+=",
"getSubtargetFeatureName",
"(",
"ErrorInfo",
"&",
"Mask",
")",
";",
"}",
"Mask",
"<<=",
"1",
";",
"}",
"return",
"Error",
"(",
"IDLoc",
",",
"Msg",
")",
";",
"}",
"case",
"Match_MnemonicFail",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"\"Unrecognized instruction mnemonic\"",
")",
";",
"case",
"Match_InvalidOperand",
":",
"ErrorLoc",
"=",
"IDLoc",
";",
"if",
"(",
"ErrorInfo",
"!=",
"~",
"0U",
")",
"{",
"if",
"(",
"ErrorInfo",
">=",
"Operands",
".",
"size",
"(",
")",
")",
"return",
"Error",
"(",
"IDLoc",
",",
"\"Too few operands for instruction\"",
")",
";",
"ErrorLoc",
"=",
"(",
"(",
"AAPOperand",
"&",
")",
"*",
"Operands",
"[",
"ErrorInfo",
"]",
")",
".",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"}",
"return",
"Error",
"(",
"IDLoc",
",",
"\"Invalid operand for instruction\"",
")",
";",
"}",
"llvm_unreachable",
"(",
"\"Unknown match type detected!\"",
")",
";",
"}",
"</s>"
] | [
"MatchAndEmitInstruction",
"-",
"Recognize",
"a",
"series",
"of",
"operands",
"of",
"a",
"parsed",
"instruction",
"as",
"an",
"actual",
"MCInst",
"and",
"emit",
"it",
"to",
"the",
"specified",
"MCStreamer",
"."
] | [
"AAP",
"AAP",
"\"Unknown missing feature!\"",
"\"Use of this instruction requires:\"",
"1",
"0",
"8",
"1",
"\" \"",
"1",
"\"Unrecognized instruction mnemonic\"",
"0U",
"\"Too few operands for instruction\"",
"AAP",
"\"Invalid operand for instruction\"",
"\"Unknown match type detected!\""
] | AAPAsmParser | MatchAndEmitInstruction | AAP | MPU | LLVM | 19,865 | 241 | 1 | [] |
[
"<s>",
"void",
"applyFixup",
"(",
"const",
"MCAssembler",
"&",
"Asm",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
"Target",
",",
"MutableArrayRef",
"<",
"char",
">",
"Data",
",",
"uint64_t",
"Value",
",",
"bool",
"IsResolved",
")",
"const",
"override",
"{",
"Value",
"=",
"adjustFixupValue",
"(",
"Fixup",
".",
"getKind",
"(",
")",
",",
"Value",
")",
";",
"if",
"(",
"!",
"Value",
")",
"return",
";",
"unsigned",
"Offset",
"=",
"Fixup",
".",
"getOffset",
"(",
")",
";",
"unsigned",
"NumBytes",
"=",
"getFixupKindNumBytes",
"(",
"Fixup",
".",
"getKind",
"(",
")",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"NumBytes",
";",
"++",
"i",
")",
"{",
"unsigned",
"Idx",
"=",
"IsLittleEndian",
"?",
"i",
":",
"(",
"NumBytes",
"-",
"1",
"-",
"i",
")",
";",
"Data",
"[",
"Offset",
"+",
"i",
"]",
"|=",
"uint8_t",
"(",
"(",
"Value",
">>",
"(",
"Idx",
"*",
"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",
"."
] | [
"PowerPC",
"0",
"1",
"8",
"0xff"
] | PPCAsmBackend13 | applyFixup | PowerPC | CPU | LLVM | 19,866 | 128 | 1 | [] |
[
"<s>",
"static",
"rtx",
"m68k_call_tls_get_addr",
"(",
"rtx",
"x",
",",
"rtx",
"eqv",
",",
"enum",
"m68k_reloc",
"reloc",
")",
"{",
"rtx",
"a0",
";",
"rtx_insn",
"*",
"insns",
";",
"rtx",
"dest",
";",
"start_sequence",
"(",
")",
";",
"x",
"=",
"m68k_wrap_symbol",
"(",
"x",
",",
"reloc",
",",
"m68k_get_gp",
"(",
")",
",",
"NULL_RTX",
")",
";",
"m68k_libcall_value_in_a0_p",
"=",
"true",
";",
"a0",
"=",
"emit_library_call_value",
"(",
"m68k_get_tls_get_addr",
"(",
")",
",",
"NULL_RTX",
",",
"LCT_PURE",
",",
"Pmode",
",",
"x",
",",
"Pmode",
")",
";",
"m68k_libcall_value_in_a0_p",
"=",
"false",
";",
"insns",
"=",
"get_insns",
"(",
")",
";",
"end_sequence",
"(",
")",
";",
"gcc_assert",
"(",
"can_create_pseudo_p",
"(",
")",
")",
";",
"dest",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_libcall_block",
"(",
"insns",
",",
"dest",
",",
"a0",
",",
"eqv",
")",
";",
"return",
"dest",
";",
"}",
"</s>"
] | [
"Emit",
"instruction",
"sequence",
"that",
"calls",
"__tls_get_addr",
".",
"X",
"is",
"the",
"TLS",
"symbol",
"we",
"are",
"referencing",
"and",
"RELOC",
"is",
"the",
"symbol",
"type",
"to",
"use",
"(",
"either",
"TLSGD",
"or",
"TLSLDM",
")",
".",
"EQV",
"is",
"the",
"REG_EQUAL",
"note",
"for",
"the",
"sequence",
"emitted",
".",
"A",
"pseudo",
"register",
"with",
"result",
"of",
"__tls_get_addr",
"call",
"is",
"returned",
"."
] | [
"m68k"
] | m68k | m68k_call_tls_get_addr | m68k | MPU | GCC | 19,867 | 110 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"hasUnwantedEffectsWhenEXECEmpty",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"MI",
".",
"mayStore",
"(",
")",
"&&",
"isSMRD",
"(",
"MI",
")",
")",
"return",
"true",
";",
"if",
"(",
"Opcode",
"==",
"AMDGPU",
"::",
"S_SENDMSG",
"||",
"Opcode",
"==",
"AMDGPU",
"::",
"S_SENDMSGHALT",
"||",
"Opcode",
"==",
"AMDGPU",
"::",
"EXP",
"||",
"Opcode",
"==",
"AMDGPU",
"::",
"EXP_DONE",
")",
"return",
"true",
";",
"if",
"(",
"MI",
".",
"isInlineAsm",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"Opcode",
"==",
"AMDGPU",
"::",
"V_READFIRSTLANE_B32",
"||",
"Opcode",
"==",
"AMDGPU",
"::",
"V_READLANE_B32",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Whether",
"we",
"must",
"prevent",
"this",
"instruction",
"from",
"executing",
"with",
"EXEC",
"=",
"0",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::S_SENDMSG",
"AMDGPU::S_SENDMSGHALT",
"AMDGPU::EXP",
"AMDGPU::EXP_DONE",
"AMDGPU::V_READFIRSTLANE_B32",
"AMDGPU::V_READLANE_B32"
] | SIInstrInfo10 | hasUnwantedEffectsWhenEXECEmpty | AMDGPU | GPU | LLVM | 19,868 | 98 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"MipsRegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
")",
"const",
"{",
"const",
"MipsSubtarget",
"&",
"Subtarget",
"=",
"MF",
".",
"getSubtarget",
"<",
"MipsSubtarget",
">",
"(",
")",
";",
"if",
"(",
"Subtarget",
".",
"isSingleFloat",
"(",
")",
")",
"return",
"CSR_SingleFloatOnly_RegMask",
";",
"if",
"(",
"Subtarget",
".",
"isABI_CheriPureCap",
"(",
")",
")",
"return",
"CSR_Cheri_Purecap_RegMask",
";",
"if",
"(",
"Subtarget",
".",
"isCheri",
"(",
")",
")",
"return",
"CSR_N64_Cheri_RegMask",
";",
"if",
"(",
"Subtarget",
".",
"isABI_N64",
"(",
")",
")",
"return",
"CSR_N64_RegMask",
";",
"if",
"(",
"Subtarget",
".",
"isABI_N32",
"(",
")",
")",
"return",
"CSR_N32_RegMask",
";",
"if",
"(",
"Subtarget",
".",
"isFP64bit",
"(",
")",
")",
"return",
"CSR_O32_FP64_RegMask",
";",
"if",
"(",
"Subtarget",
".",
"isFPXX",
"(",
")",
")",
"return",
"CSR_O32_FPXX_RegMask",
";",
"return",
"CSR_O32_RegMask",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"Mips",
"Mips",
"Mips",
"Mips"
] | MipsRegisterInfo35 | getCallPreservedMask | Mips | CPU | LLVM | 19,869 | 113 | 1 | [] |
[
"<s>",
"struct",
"xstormy16_stack_layout",
"xstormy16_compute_stack_layout",
"(",
")",
"{",
"struct",
"xstormy16_stack_layout",
"layout",
";",
"int",
"regno",
";",
"const",
"int",
"ifun",
"=",
"xstormy16_interrupt_function_p",
"(",
")",
";",
"layout",
".",
"locals_size",
"=",
"get_frame_size",
"(",
")",
";",
"layout",
".",
"register_save_size",
"=",
"0",
";",
"for",
"(",
"regno",
"=",
"0",
";",
"regno",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"regno",
"++",
")",
"if",
"(",
"REG_NEEDS_SAVE",
"(",
"regno",
",",
"ifun",
")",
")",
"layout",
".",
"register_save_size",
"+=",
"UNITS_PER_WORD",
";",
"if",
"(",
"current_function_varargs",
"||",
"current_function_stdarg",
")",
"layout",
".",
"stdarg_save_size",
"=",
"NUM_ARGUMENT_REGISTERS",
"*",
"UNITS_PER_WORD",
";",
"else",
"layout",
".",
"stdarg_save_size",
"=",
"0",
";",
"layout",
".",
"frame_size",
"=",
"(",
"layout",
".",
"locals_size",
"+",
"layout",
".",
"register_save_size",
"+",
"layout",
".",
"stdarg_save_size",
")",
";",
"if",
"(",
"current_function_args_size",
"<=",
"2048",
"&&",
"current_function_args_size",
"!=",
"-",
"1",
")",
"{",
"if",
"(",
"layout",
".",
"frame_size",
"+",
"INCOMING_FRAME_SP_OFFSET",
"+",
"current_function_args_size",
"<=",
"2048",
")",
"layout",
".",
"fp_minus_ap",
"=",
"layout",
".",
"frame_size",
"+",
"INCOMING_FRAME_SP_OFFSET",
";",
"else",
"layout",
".",
"fp_minus_ap",
"=",
"2048",
"-",
"current_function_args_size",
";",
"}",
"else",
"layout",
".",
"fp_minus_ap",
"=",
"(",
"layout",
".",
"stdarg_save_size",
"+",
"layout",
".",
"register_save_size",
"+",
"INCOMING_FRAME_SP_OFFSET",
")",
";",
"layout",
".",
"sp_minus_fp",
"=",
"(",
"layout",
".",
"frame_size",
"+",
"INCOMING_FRAME_SP_OFFSET",
"-",
"layout",
".",
"fp_minus_ap",
")",
";",
"layout",
".",
"first_local_minus_ap",
"=",
"layout",
".",
"sp_minus_fp",
"-",
"layout",
".",
"locals_size",
";",
"return",
"layout",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"stack",
"layout",
"."
] | [
"stormy16",
"0",
"0",
"0",
"2048",
"1",
"2048",
"2048"
] | stormy162 | xstormy16_compute_stack_layout | stormy16 | CPU | GCC | 19,870 | 195 | 1 | [] |
[
"<s>",
"static",
"bool",
"sparc_legitimate_constant_p",
"(",
"machine_mode",
"mode",
",",
"rtx",
"x",
")",
"{",
"switch",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"{",
"case",
"CONST",
":",
"case",
"SYMBOL_REF",
":",
"if",
"(",
"sparc_tls_referenced_p",
"(",
"x",
")",
")",
"return",
"false",
";",
"break",
";",
"case",
"CONST_DOUBLE",
":",
"if",
"(",
"TARGET_VIS",
"&&",
"SCALAR_FLOAT_MODE_P",
"(",
"mode",
")",
"&&",
"(",
"const_zero_operand",
"(",
"x",
",",
"mode",
")",
"||",
"const_all_ones_operand",
"(",
"x",
",",
"mode",
")",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"case",
"CONST_VECTOR",
":",
"if",
"(",
"TARGET_VIS",
"&&",
"(",
"const_zero_operand",
"(",
"x",
",",
"mode",
")",
"||",
"const_all_ones_operand",
"(",
"x",
",",
"mode",
")",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"default",
":",
"break",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Determine",
"if",
"a",
"given",
"RTX",
"is",
"a",
"valid",
"constant",
".",
"We",
"already",
"know",
"this",
"satisfies",
"CONSTANT_P",
"."
] | [
"sparc"
] | sparc | sparc_legitimate_constant_p | sparc | CPU | GCC | 19,871 | 109 | 1 | [] |
[
"<s>",
"void",
"SIInstrInfo",
"::",
"legalizeOpWithMove",
"(",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpIdx",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MI",
";",
"MachineBasicBlock",
"*",
"MBB",
"=",
"MI",
"->",
"getParent",
"(",
")",
";",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"OpIdx",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MBB",
"->",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"unsigned",
"RCID",
"=",
"get",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
".",
"OpInfo",
"[",
"OpIdx",
"]",
".",
"RegClass",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"RI",
".",
"getRegClass",
"(",
"RCID",
")",
";",
"unsigned",
"Opcode",
"=",
"AMDGPU",
"::",
"V_MOV_B32_e32",
";",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"Opcode",
"=",
"AMDGPU",
"::",
"COPY",
";",
"else",
"if",
"(",
"RI",
".",
"isSGPRClass",
"(",
"RC",
")",
")",
"Opcode",
"=",
"AMDGPU",
"::",
"S_MOV_B32",
";",
"const",
"TargetRegisterClass",
"*",
"VRC",
"=",
"RI",
".",
"getEquivalentVGPRClass",
"(",
"RC",
")",
";",
"if",
"(",
"RI",
".",
"getCommonSubClass",
"(",
"&",
"AMDGPU",
"::",
"VReg_64RegClass",
",",
"VRC",
")",
")",
"VRC",
"=",
"&",
"AMDGPU",
"::",
"VReg_64RegClass",
";",
"else",
"VRC",
"=",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
";",
"unsigned",
"Reg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"VRC",
")",
";",
"DebugLoc",
"DL",
"=",
"MBB",
"->",
"findDebugLoc",
"(",
"I",
")",
";",
"BuildMI",
"(",
"*",
"MI",
"->",
"getParent",
"(",
")",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
",",
"Reg",
")",
".",
"addOperand",
"(",
"MO",
")",
";",
"MO",
".",
"ChangeToRegister",
"(",
"Reg",
",",
"false",
")",
";",
"}",
"</s>"
] | [
"Legalize",
"the",
"OpIndex",
"operand",
"of",
"this",
"instruction",
"by",
"inserting",
"a",
"MOV",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::V_MOV_B32_e32",
"AMDGPU::COPY",
"AMDGPU::S_MOV_B32",
"AMDGPU::VReg_64RegClass",
"AMDGPU::VReg_64RegClass",
"AMDGPU::VGPR_32RegClass"
] | SIInstrInfo (3) | legalizeOpWithMove | AMDGPU | GPU | LLVM | 19,872 | 221 | 1 | [] |
[
"<s>",
"MachineInstr",
"*",
"SIInstrInfo",
"::",
"convertToThreeAddress",
"(",
"MachineFunction",
"::",
"iterator",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"MI",
",",
"LiveVariables",
"*",
"LV",
")",
"const",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"nullptr",
";",
"case",
"AMDGPU",
"::",
"V_MAC_F32_e64",
":",
"break",
";",
"case",
"AMDGPU",
"::",
"V_MAC_F32_e32",
":",
"{",
"const",
"MachineOperand",
"*",
"Src0",
"=",
"getNamedOperand",
"(",
"*",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src0",
")",
";",
"if",
"(",
"Src0",
"->",
"isImm",
"(",
")",
"&&",
"!",
"isInlineConstant",
"(",
"*",
"Src0",
",",
"4",
")",
")",
"return",
"nullptr",
";",
"break",
";",
"}",
"}",
"const",
"MachineOperand",
"*",
"Dst",
"=",
"getNamedOperand",
"(",
"*",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"vdst",
")",
";",
"const",
"MachineOperand",
"*",
"Src0",
"=",
"getNamedOperand",
"(",
"*",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src0",
")",
";",
"const",
"MachineOperand",
"*",
"Src1",
"=",
"getNamedOperand",
"(",
"*",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src1",
")",
";",
"const",
"MachineOperand",
"*",
"Src2",
"=",
"getNamedOperand",
"(",
"*",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src2",
")",
";",
"return",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"AMDGPU",
"::",
"V_MAD_F32",
")",
")",
".",
"addOperand",
"(",
"*",
"Dst",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addOperand",
"(",
"*",
"Src0",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addOperand",
"(",
"*",
"Src1",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addOperand",
"(",
"*",
"Src2",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addImm",
"(",
"0",
")",
";",
"}",
"</s>"
] | [
"convertToThreeAddress",
"-",
"This",
"method",
"must",
"be",
"implemented",
"by",
"targets",
"that",
"set",
"the",
"M_CONVERTIBLE_TO_3_ADDR",
"flag",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::V_MAC_F32_e64",
"AMDGPU::V_MAC_F32_e32",
"AMDGPU::OpName",
"4",
"AMDGPU::OpName",
"AMDGPU::OpName",
"AMDGPU::OpName",
"AMDGPU::OpName",
"AMDGPU::V_MAD_F32",
"0",
"0",
"0",
"0",
"0"
] | SIInstrInfo128 | convertToThreeAddress | AMDGPU | GPU | LLVM | 19,873 | 232 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyPassConfig",
"::",
"addPostRegAlloc",
"(",
")",
"{",
"disablePass",
"(",
"&",
"PrologEpilogCodeInserterID",
")",
";",
"disablePass",
"(",
"&",
"MachineCopyPropagationID",
")",
";",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"{",
"addPass",
"(",
"createWebAssemblyRegStackify",
"(",
")",
")",
";",
"addPass",
"(",
"createWebAssemblyRegColoring",
"(",
")",
")",
";",
"}",
"TargetPassConfig",
"::",
"addPostRegAlloc",
"(",
")",
";",
"addPass",
"(",
"createWebAssemblyPEI",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"after",
"register",
"allocation",
"pass",
"pipeline",
"but",
"before",
"prolog-epilog",
"insertion",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly",
"WebAssembly",
"WebAssembly"
] | WebAssemblyTargetMachine4 | addPostRegAlloc | WebAssembly | Virtual ISA | LLVM | 19,874 | 59 | 1 | [] |
[
"<s>",
"bool",
"M68kInstrInfo",
"::",
"ExpandCCR",
"(",
"MachineInstrBuilder",
"&",
"MIB",
",",
"bool",
"IsToCCR",
")",
"const",
"{",
"if",
"(",
"IsToCCR",
")",
"MIB",
"->",
"setDesc",
"(",
"get",
"(",
"M68k",
"::",
"MOV16cd",
")",
")",
";",
"else",
"MIB",
"->",
"setDesc",
"(",
"get",
"(",
"M68k",
"::",
"MOV16dc",
")",
")",
";",
"auto",
"&",
"Opd",
"=",
"MIB",
"->",
"getOperand",
"(",
"1",
")",
";",
"Opd",
".",
"setReg",
"(",
"getRegisterInfo",
"(",
")",
".",
"getMatchingSuperReg",
"(",
"Opd",
".",
"getReg",
"(",
")",
",",
"M68k",
"::",
"MxSubRegIndex8Lo",
",",
"&",
"M68k",
"::",
"DR16RegClass",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Moves",
"to/from",
"CCR",
"."
] | [
"M68k",
"M68k",
"M68k::MOV16cd",
"M68k::MOV16dc",
"1",
"M68k::MxSubRegIndex8Lo",
"M68k::DR16RegClass"
] | M68kInstrInfo (2) | ExpandCCR | M68k | MPU | LLVM | 19,875 | 85 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"elf_platform",
"(",
"void",
")",
"{",
"static",
"const",
"char",
"*",
"cpu",
"=",
"NULL",
";",
"if",
"(",
"cpu",
"!=",
"NULL",
")",
"return",
"cpu",
";",
"int",
"fd",
"=",
"open",
"(",
"\"/proc/self/auxv\"",
",",
"O_RDONLY",
")",
";",
"if",
"(",
"fd",
"!=",
"-",
"1",
")",
"{",
"char",
"buf",
"[",
"1024",
"]",
";",
"ElfW",
"(",
"auxv_t",
")",
"*",
"av",
";",
"ssize_t",
"n",
";",
"n",
"=",
"read",
"(",
"fd",
",",
"buf",
",",
"sizeof",
"(",
"buf",
")",
")",
";",
"close",
"(",
"fd",
")",
";",
"if",
"(",
"n",
">",
"0",
")",
"{",
"for",
"(",
"av",
"=",
"(",
"ElfW",
"(",
"auxv_t",
")",
"*",
")",
"buf",
";",
"av",
"->",
"a_type",
"!=",
"AT_NULL",
";",
"++",
"av",
")",
"if",
"(",
"av",
"->",
"a_type",
"==",
"AT_PLATFORM",
")",
"{",
"cpu",
"=",
"(",
"const",
"char",
"*",
")",
"av",
"->",
"a_un",
".",
"a_val",
";",
"break",
";",
"}",
"}",
"if",
"(",
"cpu",
"!=",
"NULL",
")",
"{",
"size_t",
"i",
",",
"j",
";",
"char",
"*",
"s",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"rs6000_supported_cpu_names",
")",
";",
"i",
"++",
")",
"if",
"(",
"!",
"strcmp",
"(",
"cpu",
",",
"rs6000_supported_cpu_names",
"[",
"i",
"]",
")",
")",
"return",
"cpu",
";",
"for",
"(",
"i",
"=",
"0",
";",
"linux_cpu_translation_table",
"[",
"i",
"]",
"[",
"0",
"]",
"!=",
"NULL",
";",
"i",
"++",
")",
"{",
"const",
"char",
"*",
"canonical",
"=",
"linux_cpu_translation_table",
"[",
"i",
"]",
"[",
"0",
"]",
";",
"for",
"(",
"j",
"=",
"1",
";",
"linux_cpu_translation_table",
"[",
"i",
"]",
"[",
"j",
"]",
"!=",
"NULL",
";",
"j",
"++",
")",
"if",
"(",
"!",
"strcmp",
"(",
"cpu",
",",
"linux_cpu_translation_table",
"[",
"i",
"]",
"[",
"j",
"]",
")",
")",
"{",
"cpu",
"=",
"canonical",
";",
"return",
"cpu",
";",
"}",
"}",
"auto_vec",
"<",
"const",
"char",
"*",
">",
"candidates",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"rs6000_supported_cpu_names",
")",
";",
"i",
"++",
")",
"candidates",
".",
"safe_push",
"(",
"rs6000_supported_cpu_names",
"[",
"i",
"]",
")",
";",
"candidates_list_and_hint",
"(",
"cpu",
",",
"s",
",",
"candidates",
")",
";",
"error",
"(",
"\"unsupported cpu name returned from kernel \"",
"\"for %<-mcpu=native%>: %s\"",
",",
"cpu",
")",
";",
"fatal_error",
"(",
"input_location",
",",
"\"please use an explicit cpu name; \"",
"\"valid cpu names are: %s\"",
",",
"s",
")",
";",
"}",
"}",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"canonical",
"AT_PLATFORM",
"if",
"present",
",",
"otherwise",
"NULL",
"."
] | [
"rs6000",
"\"/proc/self/auxv\"",
"1",
"1024",
"0",
"0",
"0",
"0",
"0",
"1",
"0",
"\"unsupported cpu name returned from kernel \"",
"\"for %<-mcpu=native%>: %s\"",
"\"please use an explicit cpu name; \"",
"\"valid cpu names are: %s\""
] | driver-rs6000 | elf_platform | rs6000 | CPU | GCC | 19,876 | 327 | 1 | [] |
[
"<s>",
"unsigned",
"R600InstrInfo",
"::",
"insertBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"TBB",
",",
"MachineBasicBlock",
"*",
"FBB",
",",
"ArrayRef",
"<",
"MachineOperand",
">",
"Cond",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"int",
"*",
"BytesAdded",
")",
"const",
"{",
"assert",
"(",
"TBB",
"&&",
"\"insertBranch must not be told to insert a fallthrough\"",
")",
";",
"assert",
"(",
"!",
"BytesAdded",
"&&",
"\"code size not handled\"",
")",
";",
"if",
"(",
"!",
"FBB",
")",
"{",
"if",
"(",
"Cond",
".",
"empty",
"(",
")",
")",
"{",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"R600",
"::",
"JUMP",
")",
")",
".",
"addMBB",
"(",
"TBB",
")",
";",
"return",
"1",
";",
"}",
"else",
"{",
"MachineInstr",
"*",
"PredSet",
"=",
"findFirstPredicateSetterFrom",
"(",
"MBB",
",",
"MBB",
".",
"end",
"(",
")",
")",
";",
"assert",
"(",
"PredSet",
"&&",
"\"No previous predicate !\"",
")",
";",
"addFlag",
"(",
"*",
"PredSet",
",",
"0",
",",
"MO_FLAG_PUSH",
")",
";",
"PredSet",
"->",
"getOperand",
"(",
"2",
")",
".",
"setImm",
"(",
"Cond",
"[",
"1",
"]",
".",
"getImm",
"(",
")",
")",
";",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"R600",
"::",
"JUMP_COND",
")",
")",
".",
"addMBB",
"(",
"TBB",
")",
".",
"addReg",
"(",
"R600",
"::",
"PREDICATE_BIT",
",",
"RegState",
"::",
"Kill",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"CfAlu",
"=",
"FindLastAluClause",
"(",
"MBB",
")",
";",
"if",
"(",
"CfAlu",
"==",
"MBB",
".",
"end",
"(",
")",
")",
"return",
"1",
";",
"assert",
"(",
"CfAlu",
"->",
"getOpcode",
"(",
")",
"==",
"R600",
"::",
"CF_ALU",
")",
";",
"CfAlu",
"->",
"setDesc",
"(",
"get",
"(",
"R600",
"::",
"CF_ALU_PUSH_BEFORE",
")",
")",
";",
"return",
"1",
";",
"}",
"}",
"else",
"{",
"MachineInstr",
"*",
"PredSet",
"=",
"findFirstPredicateSetterFrom",
"(",
"MBB",
",",
"MBB",
".",
"end",
"(",
")",
")",
";",
"assert",
"(",
"PredSet",
"&&",
"\"No previous predicate !\"",
")",
";",
"addFlag",
"(",
"*",
"PredSet",
",",
"0",
",",
"MO_FLAG_PUSH",
")",
";",
"PredSet",
"->",
"getOperand",
"(",
"2",
")",
".",
"setImm",
"(",
"Cond",
"[",
"1",
"]",
".",
"getImm",
"(",
")",
")",
";",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"R600",
"::",
"JUMP_COND",
")",
")",
".",
"addMBB",
"(",
"TBB",
")",
".",
"addReg",
"(",
"R600",
"::",
"PREDICATE_BIT",
",",
"RegState",
"::",
"Kill",
")",
";",
"BuildMI",
"(",
"&",
"MBB",
",",
"DL",
",",
"get",
"(",
"R600",
"::",
"JUMP",
")",
")",
".",
"addMBB",
"(",
"FBB",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"CfAlu",
"=",
"FindLastAluClause",
"(",
"MBB",
")",
";",
"if",
"(",
"CfAlu",
"==",
"MBB",
".",
"end",
"(",
")",
")",
"return",
"2",
";",
"assert",
"(",
"CfAlu",
"->",
"getOpcode",
"(",
")",
"==",
"R600",
"::",
"CF_ALU",
")",
";",
"CfAlu",
"->",
"setDesc",
"(",
"get",
"(",
"R600",
"::",
"CF_ALU_PUSH_BEFORE",
")",
")",
";",
"return",
"2",
";",
"}",
"}",
"</s>"
] | [
"Insert",
"branch",
"code",
"into",
"the",
"end",
"of",
"the",
"specified",
"MachineBasicBlock",
"."
] | [
"AMDGPU",
"R600",
"\"insertBranch must not be told to insert a fallthrough\"",
"\"code size not handled\"",
"R600::JUMP",
"1",
"\"No previous predicate !\"",
"0",
"2",
"1",
"R600::JUMP_COND",
"R600::PREDICATE_BIT",
"1",
"R600::CF_ALU",
"R600::CF_ALU_PUSH_BEFORE",
"1",
"\"No previous predicate !\"",
"0",
"2",
"1",
"R600::JUMP_COND",
"R600::PREDICATE_BIT",
"R600::JUMP",
"2",
"R600::CF_ALU",
"R600::CF_ALU_PUSH_BEFORE",
"2"
] | R600InstrInfo (2)1 | insertBranch | AMDGPU | GPU | LLVM | 19,877 | 382 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"LEGTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"return",
"NULL",
";",
"case",
"LEGISD",
"::",
"RET_FLAG",
":",
"return",
"\"RetFlag\"",
";",
"case",
"LEGISD",
"::",
"LOAD_SYM",
":",
"return",
"\"LOAD_SYM\"",
";",
"case",
"LEGISD",
"::",
"MOVEi32",
":",
"return",
"\"MOVEi32\"",
";",
"case",
"LEGISD",
"::",
"CALL",
":",
"return",
"\"CALL\"",
";",
"}",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"LEG",
"LEG",
"LEGISD::RET_FLAG",
"\"RetFlag\"",
"LEGISD::LOAD_SYM",
"\"LOAD_SYM\"",
"LEGISD::MOVEi32",
"\"MOVEi32\"",
"LEGISD::CALL",
"\"CALL\""
] | LEGISelLowering | getTargetNodeName | LEG | CPU | LLVM | 19,878 | 56 | 1 | [] |
[
"<s>",
"bool",
"MipsAsmParser",
"::",
"ParseInstruction",
"(",
"ParseInstructionInfo",
"&",
"Info",
",",
"StringRef",
"Name",
",",
"SMLoc",
"NameLoc",
",",
"OperandVector",
"&",
"Operands",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"ParseInstruction\\n\"",
")",
";",
"getTargetStreamer",
"(",
")",
".",
"forbidModuleDirective",
"(",
")",
";",
"if",
"(",
"!",
"mnemonicIsValid",
"(",
"Name",
",",
"0",
")",
")",
"{",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"Error",
"(",
"NameLoc",
",",
"\"Unknown instruction\"",
")",
";",
"}",
"Operands",
".",
"push_back",
"(",
"MipsOperand",
"::",
"CreateToken",
"(",
"Name",
",",
"NameLoc",
",",
"*",
"this",
")",
")",
";",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"if",
"(",
"ParseOperand",
"(",
"Operands",
",",
"Name",
")",
")",
"{",
"SMLoc",
"Loc",
"=",
"getLexer",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"Error",
"(",
"Loc",
",",
"\"unexpected token in argument list\"",
")",
";",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"LBrac",
")",
"&&",
"ParseBracketSuffix",
"(",
"Name",
",",
"Operands",
")",
")",
"return",
"true",
";",
"while",
"(",
"getLexer",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Comma",
")",
")",
"{",
"Parser",
".",
"Lex",
"(",
")",
";",
"if",
"(",
"ParseOperand",
"(",
"Operands",
",",
"Name",
")",
")",
"{",
"SMLoc",
"Loc",
"=",
"getLexer",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"Error",
"(",
"Loc",
",",
"\"unexpected token in argument list\"",
")",
";",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"LBrac",
")",
")",
"{",
"if",
"(",
"ParseBracketSuffix",
"(",
"Name",
",",
"Operands",
")",
")",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"getLexer",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"LParen",
")",
"&&",
"ParseParenSuffix",
"(",
"Name",
",",
"Operands",
")",
")",
"return",
"true",
";",
"}",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"SMLoc",
"Loc",
"=",
"getLexer",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"Error",
"(",
"Loc",
",",
"\"unexpected token in argument list\"",
")",
";",
"}",
"Parser",
".",
"Lex",
"(",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"ParseInstruction",
"-",
"Parse",
"one",
"assembly",
"instruction",
"."
] | [
"Mips",
"Mips",
"\"ParseInstruction\\n\"",
"0",
"\"Unknown instruction\"",
"MipsOperand::CreateToken",
"\"unexpected token in argument list\"",
"\"unexpected token in argument list\"",
"\"unexpected token in argument list\""
] | MipsAsmParser92 | ParseInstruction | Mips | CPU | LLVM | 19,879 | 312 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"signExtendConstant",
"(",
"const",
"ConstantInt",
"*",
"CI",
")",
"const",
"{",
"return",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"CI",
"->",
"getType",
"(",
")",
"->",
"isIntegerTy",
"(",
"32",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"this",
"constant",
"should",
"be",
"sign",
"extended",
"when",
"promoting",
"to",
"a",
"larger",
"type",
"."
] | [
"RISCV",
"RISCV",
"32"
] | RISCVISelLowering33 | signExtendConstant | RISCV | CPU | LLVM | 19,880 | 31 | 1 | [] |
[
"<s>",
"bool",
"MLxExpansion",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"TII",
"=",
"static_cast",
"<",
"const",
"ARMBaseInstrInfo",
"*",
">",
"(",
"Fn",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"TRI",
"=",
"Fn",
".",
"getTarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"MRI",
"=",
"&",
"Fn",
".",
"getRegInfo",
"(",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MFI",
"=",
"Fn",
".",
"begin",
"(",
")",
",",
"E",
"=",
"Fn",
".",
"end",
"(",
")",
";",
"MFI",
"!=",
"E",
";",
"++",
"MFI",
")",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MFI",
";",
"Modified",
"|=",
"ExpandFPMLxInstructions",
"(",
"MBB",
")",
";",
"}",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM"
] | MLxExpansionPass10 | runOnMachineFunction | ARM | CPU | LLVM | 19,881 | 104 | 1 | [] |
[
"<s>",
"int",
"initial_elimination_offset",
"(",
"int",
"from",
",",
"int",
"to",
")",
"{",
"int",
"regs_saved",
";",
"int",
"regs_saved_rounding",
"=",
"0",
";",
"int",
"total_saved_regs_space",
";",
"int",
"total_auto_space",
";",
"int",
"save_flags",
"=",
"target_flags",
";",
"int",
"copy_flags",
";",
"HARD_REG_SET",
"live_regs_mask",
";",
"shmedia_space_reserved_for_target_registers",
"=",
"false",
";",
"regs_saved",
"=",
"calc_live_regs",
"(",
"&",
"live_regs_mask",
")",
";",
"regs_saved",
"+=",
"SHMEDIA_REGS_STACK_ADJUST",
"(",
")",
";",
"if",
"(",
"shmedia_reserve_space_for_target_registers_p",
"(",
"regs_saved",
",",
"&",
"live_regs_mask",
")",
")",
"{",
"shmedia_space_reserved_for_target_registers",
"=",
"true",
";",
"regs_saved",
"+=",
"shmedia_target_regs_stack_adjust",
"(",
"&",
"live_regs_mask",
")",
";",
"}",
"if",
"(",
"TARGET_SH5",
"&&",
"regs_saved",
"%",
"(",
"STACK_BOUNDARY",
"/",
"BITS_PER_UNIT",
")",
")",
"regs_saved_rounding",
"=",
"(",
"(",
"STACK_BOUNDARY",
"/",
"BITS_PER_UNIT",
")",
"-",
"regs_saved",
"%",
"(",
"STACK_BOUNDARY",
"/",
"BITS_PER_UNIT",
")",
")",
";",
"total_auto_space",
"=",
"rounded_frame_size",
"(",
"regs_saved",
")",
"-",
"regs_saved_rounding",
";",
"copy_flags",
"=",
"target_flags",
";",
"target_flags",
"=",
"save_flags",
";",
"total_saved_regs_space",
"=",
"regs_saved",
"+",
"regs_saved_rounding",
";",
"if",
"(",
"from",
"==",
"ARG_POINTER_REGNUM",
"&&",
"to",
"==",
"HARD_FRAME_POINTER_REGNUM",
")",
"return",
"total_saved_regs_space",
"+",
"total_auto_space",
"+",
"crtl",
"->",
"args",
".",
"info",
".",
"byref_regs",
"*",
"8",
";",
"if",
"(",
"from",
"==",
"ARG_POINTER_REGNUM",
"&&",
"to",
"==",
"STACK_POINTER_REGNUM",
")",
"return",
"total_saved_regs_space",
"+",
"total_auto_space",
"+",
"crtl",
"->",
"args",
".",
"info",
".",
"byref_regs",
"*",
"8",
";",
"if",
"(",
"from",
"==",
"HARD_FRAME_POINTER_REGNUM",
"&&",
"to",
"==",
"STACK_POINTER_REGNUM",
")",
"return",
"0",
";",
"if",
"(",
"from",
"==",
"FRAME_POINTER_REGNUM",
"&&",
"to",
"==",
"STACK_POINTER_REGNUM",
")",
"return",
"rounded_frame_size",
"(",
"0",
")",
";",
"if",
"(",
"from",
"==",
"FRAME_POINTER_REGNUM",
"&&",
"to",
"==",
"HARD_FRAME_POINTER_REGNUM",
")",
"return",
"rounded_frame_size",
"(",
"0",
")",
";",
"gcc_assert",
"(",
"from",
"==",
"RETURN_ADDRESS_POINTER_REGNUM",
"&&",
"(",
"to",
"==",
"HARD_FRAME_POINTER_REGNUM",
"||",
"to",
"==",
"STACK_POINTER_REGNUM",
")",
")",
";",
"if",
"(",
"TARGET_SH5",
")",
"{",
"int",
"n",
"=",
"total_saved_regs_space",
";",
"int",
"pr_reg",
"=",
"TARGET_SHMEDIA",
"?",
"PR_MEDIA_REG",
":",
"PR_REG",
";",
"save_schedule",
"schedule",
";",
"save_entry",
"*",
"entry",
";",
"n",
"+=",
"total_auto_space",
";",
"if",
"(",
"!",
"TEST_HARD_REG_BIT",
"(",
"live_regs_mask",
",",
"pr_reg",
")",
")",
"return",
"n",
";",
"target_flags",
"=",
"copy_flags",
";",
"sh5_schedule_saves",
"(",
"&",
"live_regs_mask",
",",
"&",
"schedule",
",",
"n",
")",
";",
"for",
"(",
"entry",
"=",
"&",
"schedule",
".",
"entries",
"[",
"1",
"]",
";",
"entry",
"->",
"mode",
"!=",
"VOIDmode",
";",
"entry",
"++",
")",
"if",
"(",
"entry",
"->",
"reg",
"==",
"pr_reg",
")",
"{",
"target_flags",
"=",
"save_flags",
";",
"return",
"entry",
"->",
"offset",
";",
"}",
"gcc_unreachable",
"(",
")",
";",
"}",
"else",
"return",
"total_auto_space",
";",
"}",
"</s>"
] | [
"Define",
"the",
"offset",
"between",
"two",
"registers",
",",
"one",
"to",
"be",
"eliminated",
",",
"and",
"the",
"other",
"its",
"replacement",
",",
"at",
"the",
"start",
"of",
"a",
"routine",
"."
] | [
"sh",
"0",
"8",
"8",
"0",
"0",
"0",
"1"
] | sh4 | initial_elimination_offset | sh | CPU | GCC | 19,882 | 350 | 1 | [] |
[
"<s>",
"rtx",
"sh_remove_overlapping_post_inc",
"(",
"rtx",
"dst",
",",
"rtx",
"src",
")",
"{",
"if",
"(",
"!",
"MEM_P",
"(",
"src",
")",
")",
"return",
"src",
";",
"rtx",
"addr",
"=",
"XEXP",
"(",
"src",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"POST_INC",
"&&",
"reg_overlap_mentioned_p",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"dst",
")",
")",
"return",
"replace_equiv_address",
"(",
"src",
",",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"addr",
")",
"!=",
"POST_MODIFY",
")",
";",
"return",
"src",
";",
"}",
"</s>"
] | [
"Given",
"a",
"move",
"insn",
"destiation",
"and",
"a",
"source",
",",
"make",
"sure",
"that",
"the",
"move",
"source",
"operand",
"is",
"not",
"a",
"post-inc",
"mem",
"load",
"with",
"the",
"same",
"address",
"reg",
"as",
"the",
"destination",
".",
"Returns",
"the",
"modified",
"source",
"operand",
"with",
"the",
"post-inc",
"removed",
"if",
"necessary",
"."
] | [
"sh",
"0",
"0",
"0"
] | sh | sh_remove_overlapping_post_inc | sh | CPU | GCC | 19,883 | 79 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"setPreservesCFG",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"TargetLibraryInfoWrapperPass",
">",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"WebAssembly"
] | WebAssemblyPeephole | getAnalysisUsage | WebAssembly | Virtual ISA | LLVM | 19,884 | 33 | 1 | [] |
[
"<s>",
"bool",
"isMem",
"(",
")",
"const",
"override",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"isMem",
"-",
"Is",
"this",
"a",
"memory",
"operand",
"?"
] | [
"RISCV"
] | RISCVAsmParser (2) | isMem | RISCV | CPU | LLVM | 19,885 | 11 | 1 | [] |
[
"<s>",
"bool",
"s390_decompose_shift_count",
"(",
"rtx",
"op",
",",
"rtx",
"*",
"base",
",",
"HOST_WIDE_INT",
"*",
"offset",
")",
"{",
"HOST_WIDE_INT",
"off",
"=",
"0",
";",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"CONST_INT",
")",
"{",
"off",
"=",
"INTVAL",
"(",
"op",
")",
";",
"op",
"=",
"NULL_RTX",
";",
"}",
"if",
"(",
"op",
"&&",
"GET_CODE",
"(",
"op",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
")",
"==",
"CONST_INT",
")",
"{",
"off",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
")",
";",
"op",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"}",
"while",
"(",
"op",
"&&",
"GET_CODE",
"(",
"op",
")",
"==",
"SUBREG",
")",
"op",
"=",
"SUBREG_REG",
"(",
"op",
")",
";",
"if",
"(",
"op",
"&&",
"GET_CODE",
"(",
"op",
")",
"!=",
"REG",
")",
"return",
"false",
";",
"if",
"(",
"offset",
")",
"*",
"offset",
"=",
"off",
";",
"if",
"(",
"base",
")",
"*",
"base",
"=",
"op",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Decompose",
"a",
"RTL",
"expression",
"OP",
"for",
"a",
"shift",
"count",
"into",
"its",
"components",
",",
"and",
"return",
"the",
"base",
"register",
"in",
"BASE",
"and",
"the",
"offset",
"in",
"OFFSET",
".",
"Return",
"true",
"if",
"OP",
"is",
"a",
"valid",
"shift",
"count",
",",
"false",
"if",
"not",
"."
] | [
"s390",
"0",
"1",
"1",
"0"
] | s3903 | s390_decompose_shift_count | s390 | MPU | GCC | 19,886 | 142 | 1 | [] |
[
"<s>",
"bool",
"AArch64RegisterInfo",
"::",
"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!\"",
")",
";",
"if",
"(",
"!",
"MI",
"->",
"mayLoad",
"(",
")",
"&&",
"!",
"MI",
"->",
"mayStore",
"(",
")",
")",
"return",
"false",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
";",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"int64_t",
"FPOffset",
"=",
"Offset",
"-",
"16",
"*",
"20",
";",
"Offset",
"+=",
"MFI",
"->",
"getLocalFrameSize",
"(",
")",
";",
"Offset",
"+=",
"128",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"&&",
"isFrameOffsetLegal",
"(",
"MI",
",",
"FPOffset",
")",
")",
"return",
"false",
";",
"if",
"(",
"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",
"."
] | [
"AArch64",
"AArch64",
"0",
"\"Instr doesn't have FrameIndex operand!\"",
"16",
"20",
"128"
] | AArch64RegisterInfo47 | needsFrameBaseReg | AArch64 | CPU | LLVM | 19,887 | 164 | 1 | [] |
[
"<s>",
"void",
"replace_arg_pushes",
"(",
")",
"{",
"}",
"</s>"
] | [
"Here",
"during",
"RTL",
"generation",
"of",
"return",
".",
"If",
"we",
"are",
"at",
"the",
"final",
"return",
"in",
"a",
"function",
",",
"go",
"through",
"the",
"function",
"and",
"replace",
"pushes",
"with",
"stores",
"into",
"a",
"frame",
"arg",
"block",
".",
"This",
"is",
"similar",
"to",
"what",
"ACCUMULATE_OUTGOING_ARGS",
"does",
",",
"but",
"we",
"must",
"index",
"off",
"the",
"frame",
"pointer",
",",
"not",
"the",
"stack",
"pointer",
",",
"and",
"the",
"calling",
"sequence",
"does",
"not",
"require",
"the",
"arg",
"block",
"to",
"be",
"at",
"the",
"top",
"of",
"the",
"stack",
"."
] | [
"convex"
] | convex | replace_arg_pushes | convex | VLIW | GCC | 19,888 | 6 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseRegisterInfo",
"::",
"requiresFrameIndexScavenging",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"requires",
"post",
"PEI",
"scavenging",
"of",
"registers",
"for",
"materializing",
"frame",
"index",
"constants",
"."
] | [
"ARM",
"ARM"
] | ARMBaseRegisterInfo | requiresFrameIndexScavenging | ARM | CPU | LLVM | 19,889 | 16 | 1 | [] |
[
"<s>",
"void",
"BT",
"::",
"run",
"(",
")",
"{",
"reset",
"(",
")",
";",
"assert",
"(",
"FlowQ",
".",
"empty",
"(",
")",
")",
";",
"using",
"MachineFlowGraphTraits",
"=",
"GraphTraits",
"<",
"const",
"MachineFunction",
"*",
">",
";",
"const",
"MachineBasicBlock",
"*",
"Entry",
"=",
"MachineFlowGraphTraits",
"::",
"getEntryNode",
"(",
"&",
"MF",
")",
";",
"unsigned",
"MaxBN",
"=",
"0",
";",
"for",
"(",
"const",
"MachineBasicBlock",
"&",
"B",
":",
"MF",
")",
"{",
"assert",
"(",
"B",
".",
"getNumber",
"(",
")",
">=",
"0",
"&&",
"\"Disconnected block\"",
")",
";",
"unsigned",
"BN",
"=",
"B",
".",
"getNumber",
"(",
")",
";",
"if",
"(",
"BN",
">",
"MaxBN",
")",
"MaxBN",
"=",
"BN",
";",
"}",
"BitVector",
"BlockScanned",
"(",
"MaxBN",
"+",
"1",
")",
";",
"int",
"EntryN",
"=",
"Entry",
"->",
"getNumber",
"(",
")",
";",
"FlowQ",
".",
"push",
"(",
"CFGEdge",
"(",
"-",
"1",
",",
"EntryN",
")",
")",
";",
"while",
"(",
"!",
"FlowQ",
".",
"empty",
"(",
")",
")",
"{",
"CFGEdge",
"Edge",
"=",
"FlowQ",
".",
"front",
"(",
")",
";",
"FlowQ",
".",
"pop",
"(",
")",
";",
"if",
"(",
"EdgeExec",
".",
"count",
"(",
"Edge",
")",
")",
"continue",
";",
"EdgeExec",
".",
"insert",
"(",
"Edge",
")",
";",
"ReachedBB",
".",
"insert",
"(",
"Edge",
".",
"second",
")",
";",
"const",
"MachineBasicBlock",
"&",
"B",
"=",
"*",
"MF",
".",
"getBlockNumbered",
"(",
"Edge",
".",
"second",
")",
";",
"MachineBasicBlock",
"::",
"const_iterator",
"It",
"=",
"B",
".",
"begin",
"(",
")",
",",
"End",
"=",
"B",
".",
"end",
"(",
")",
";",
"while",
"(",
"It",
"!=",
"End",
"&&",
"It",
"->",
"isPHI",
"(",
")",
")",
"{",
"const",
"MachineInstr",
"&",
"PI",
"=",
"*",
"It",
"++",
";",
"InstrExec",
".",
"insert",
"(",
"&",
"PI",
")",
";",
"visitPHI",
"(",
"PI",
")",
";",
"}",
"if",
"(",
"BlockScanned",
"[",
"Edge",
".",
"second",
"]",
")",
"continue",
";",
"BlockScanned",
"[",
"Edge",
".",
"second",
"]",
"=",
"true",
";",
"while",
"(",
"It",
"!=",
"End",
"&&",
"!",
"It",
"->",
"isBranch",
"(",
")",
")",
"{",
"const",
"MachineInstr",
"&",
"MI",
"=",
"*",
"It",
"++",
";",
"InstrExec",
".",
"insert",
"(",
"&",
"MI",
")",
";",
"visitNonBranch",
"(",
"MI",
")",
";",
"}",
"if",
"(",
"It",
"==",
"End",
")",
"{",
"MachineFunction",
"::",
"const_iterator",
"BIt",
"=",
"B",
".",
"getIterator",
"(",
")",
";",
"MachineFunction",
"::",
"const_iterator",
"Next",
"=",
"std",
"::",
"next",
"(",
"BIt",
")",
";",
"if",
"(",
"Next",
"!=",
"MF",
".",
"end",
"(",
")",
"&&",
"B",
".",
"isSuccessor",
"(",
"&",
"*",
"Next",
")",
")",
"{",
"int",
"ThisN",
"=",
"B",
".",
"getNumber",
"(",
")",
";",
"int",
"NextN",
"=",
"Next",
"->",
"getNumber",
"(",
")",
";",
"FlowQ",
".",
"push",
"(",
"CFGEdge",
"(",
"ThisN",
",",
"NextN",
")",
")",
";",
"}",
"}",
"else",
"{",
"visitBranchesFrom",
"(",
"*",
"It",
")",
";",
"}",
"}",
"if",
"(",
"Trace",
")",
"print_cells",
"(",
"dbgs",
"(",
")",
"<<",
"\"Cells after propagation:\\n\"",
")",
";",
"}",
"</s>"
] | [
"Run",
"the",
"analysis",
"pass",
"over",
"a",
"function",
"and",
"produce",
"a",
"dominator",
"tree",
"."
] | [
"Hexagon",
"0",
"0",
"\"Disconnected block\"",
"1",
"1",
"\"Cells after propagation:\\n\""
] | BitTracker15 | run | Hexagon | DSP | LLVM | 19,890 | 406 | 1 | [] |
[
"<s>",
"virtual",
"const",
"TargetRegisterInfo",
"&",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"RI",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"MSP430"
] | MSP430InstrInfo10 | getRegisterInfo | MSP430 | MPU | LLVM | 19,891 | 13 | 1 | [] |
[
"<s>",
"gimple",
"*",
"gimple_fold_builtin",
"(",
"unsigned",
"int",
"code",
",",
"gimple_stmt_iterator",
"*",
"gsi",
",",
"gcall",
"*",
"stmt",
")",
"{",
"registered_function",
"&",
"rfn",
"=",
"*",
"(",
"*",
"registered_functions",
")",
"[",
"code",
"]",
";",
"return",
"gimple_folder",
"(",
"rfn",
".",
"instance",
",",
"rfn",
".",
"decl",
",",
"gsi",
",",
"stmt",
")",
".",
"fold",
"(",
")",
";",
"}",
"</s>"
] | [
"Attempt",
"to",
"fold",
"STMT",
",",
"given",
"that",
"it",
"'s",
"a",
"call",
"to",
"the",
"SVE",
"function",
"with",
"subcode",
"CODE",
".",
"Return",
"the",
"new",
"statement",
"on",
"success",
"and",
"null",
"on",
"failure",
".",
"Insert",
"any",
"other",
"new",
"statements",
"at",
"GSI",
"."
] | [
"riscv"
] | riscv-vector-builtins | gimple_fold_builtin | riscv | CPU | GCC | 19,892 | 51 | 1 | [] |
[
"<s>",
"static",
"void",
"csky_print_operand",
"(",
"FILE",
"*",
"stream",
",",
"rtx",
"x",
",",
"int",
"code",
")",
"{",
"switch",
"(",
"code",
")",
"{",
"case",
"'N'",
":",
"if",
"(",
"(",
"INTVAL",
"(",
"x",
")",
"&",
"0xffffffff",
")",
"==",
"0xffffffff",
")",
"fprintf",
"(",
"stream",
",",
"\"0\"",
")",
";",
"else",
"fprintf",
"(",
"stream",
",",
"\"%d\"",
",",
"(",
"int",
")",
"exact_log2",
"(",
"(",
"INTVAL",
"(",
"x",
")",
"&",
"0xffffffff",
")",
"+",
"1",
")",
"%",
"32",
")",
";",
"break",
";",
"case",
"'P'",
":",
"fprintf",
"(",
"stream",
",",
"\"%d\"",
",",
"(",
"int",
")",
"exact_log2",
"(",
"INTVAL",
"(",
"x",
")",
"&",
"0xffffffff",
")",
")",
";",
"break",
";",
"case",
"'Q'",
":",
"fprintf",
"(",
"stream",
",",
"\"%d\"",
",",
"(",
"int",
")",
"exact_log2",
"(",
"~",
"INTVAL",
"(",
"x",
")",
"&",
"0xffffffff",
")",
")",
";",
"break",
";",
"case",
"'O'",
":",
"fprintf",
"(",
"stream",
",",
"\"%d\"",
",",
"(",
"int",
")",
"INTVAL",
"(",
"x",
")",
")",
";",
"break",
";",
"case",
"'M'",
":",
"fprintf",
"(",
"stream",
",",
"\"%d\"",
",",
"(",
"int",
")",
"(",
"-",
"INTVAL",
"(",
"x",
")",
")",
")",
";",
"break",
";",
"case",
"'R'",
":",
"switch",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"{",
"case",
"REG",
":",
"fputs",
"(",
"reg_names",
"[",
"REGNO",
"(",
"x",
")",
"+",
"1",
"]",
",",
"stream",
")",
";",
"break",
";",
"case",
"MEM",
":",
"csky_print_operand_address",
"(",
"stream",
",",
"GET_MODE",
"(",
"x",
")",
",",
"XEXP",
"(",
"adjust_address",
"(",
"x",
",",
"SImode",
",",
"4",
")",
",",
"0",
")",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"break",
";",
"case",
"'H'",
":",
"fprintf",
"(",
"stream",
",",
"\"%ld\"",
",",
"(",
"long",
")",
"(",
"(",
"INTVAL",
"(",
"x",
")",
"&",
"0xFFFF0000",
")",
">>",
"16",
")",
")",
";",
"break",
";",
"default",
":",
"switch",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"{",
"case",
"REG",
":",
"fputs",
"(",
"reg_names",
"[",
"REGNO",
"(",
"x",
")",
"]",
",",
"stream",
")",
";",
"break",
";",
"case",
"MEM",
":",
"output_address",
"(",
"GET_MODE",
"(",
"x",
")",
",",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
";",
"break",
";",
"case",
"UNSPEC",
":",
"csky_output_pic_addr_const",
"(",
"stream",
",",
"x",
",",
"code",
")",
";",
"break",
";",
"case",
"CONST_DOUBLE",
":",
"{",
"char",
"fpstr",
"[",
"20",
"]",
";",
"real_to_decimal",
"(",
"fpstr",
",",
"CONST_DOUBLE_REAL_VALUE",
"(",
"x",
")",
",",
"sizeof",
"(",
"fpstr",
")",
",",
"0",
",",
"1",
")",
";",
"fprintf",
"(",
"stream",
",",
"\"%s\"",
",",
"fpstr",
")",
";",
"}",
"break",
";",
"default",
":",
"output_addr_const",
"(",
"stream",
",",
"x",
")",
";",
"break",
";",
"}",
"break",
";",
"}",
"}",
"</s>"
] | [
"Implement",
"TARGET_PRINT_OPERAND",
".",
"Print",
"operand",
"X",
"(",
"an",
"rtx",
")",
"in",
"assembler",
"syntax",
"to",
"file",
"STREAM",
"according",
"to",
"modifier",
"CODE",
".",
"'N'",
"print",
"the",
"log2",
"(",
"X+1",
")",
",",
"mainly",
"used",
"for",
"bmaski",
"'",
"P'",
"print",
"the",
"log2",
"(",
"X",
")",
"'",
"Q'",
"print",
"the",
"log2",
"(",
"~X",
")",
"'",
"O'",
"print",
"a",
"decimal",
"number",
"'M'",
"print",
"a",
"decimal",
"number",
"as",
"its",
"negative",
"'",
"R'",
"print",
"the",
"next",
"register",
"or",
"memory",
"location",
"along",
",",
"i.e",
".",
"the",
"lsw",
"in",
"a",
"double",
"word",
"value",
"'",
"H'",
"print",
"the",
"high",
"16",
"bits",
"of",
"a",
"constant",
"."
] | [
"csky",
"0xffffffff",
"0xffffffff",
"\"0\"",
"\"%d\"",
"0xffffffff",
"1",
"32",
"\"%d\"",
"0xffffffff",
"\"%d\"",
"0xffffffff",
"\"%d\"",
"\"%d\"",
"1",
"4",
"0",
"\"%ld\"",
"0xFFFF0000",
"16",
"0",
"20",
"0",
"1",
"\"%s\""
] | csky | csky_print_operand | csky | CPU | GCC | 19,893 | 382 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"isSchedulingBoundary",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"MachineBasicBlock",
"*",
"MBB",
",",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"isTerminator",
"(",
")",
"||",
"MI",
".",
"isPosition",
"(",
")",
")",
"return",
"true",
";",
"return",
"MI",
".",
"modifiesRegister",
"(",
"AMDGPU",
"::",
"EXEC",
",",
"&",
"RI",
")",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"AMDGPU",
"::",
"S_SETREG_IMM32_B32",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"AMDGPU",
"::",
"S_SETREG_B32",
"||",
"changesVGPRIndexingMode",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"isSchedulingBoundary",
"-",
"Overrides",
"the",
"isSchedulingBoundary",
"from",
"Codegen/TargetInstrInfo.cpp",
"to",
"make",
"it",
"capable",
"of",
"identifying",
"ENDBR",
"intructions",
"and",
"prevent",
"it",
"from",
"being",
"re-scheduled",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::EXEC",
"AMDGPU::S_SETREG_IMM32_B32",
"AMDGPU::S_SETREG_B32"
] | SIInstrInfo46 | isSchedulingBoundary | AMDGPU | GPU | LLVM | 19,894 | 78 | 1 | [] |
[
"<s>",
"virtual",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"TargetTransformInfo",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"R600"
] | AMDGPUTargetTransformInfo38 | getAnalysisUsage | R600 | GPU | LLVM | 19,895 | 19 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUCallLowering",
"::",
"isEligibleForTailCallOptimization",
"(",
"MachineIRBuilder",
"&",
"B",
",",
"CallLoweringInfo",
"&",
"Info",
",",
"SmallVectorImpl",
"<",
"ArgInfo",
">",
"&",
"InArgs",
",",
"SmallVectorImpl",
"<",
"ArgInfo",
">",
"&",
"OutArgs",
")",
"const",
"{",
"if",
"(",
"!",
"Info",
".",
"IsTailCall",
")",
"return",
"false",
";",
"if",
"(",
"Info",
".",
"Callee",
".",
"isReg",
"(",
")",
")",
"return",
"false",
";",
"MachineFunction",
"&",
"MF",
"=",
"B",
".",
"getMF",
"(",
")",
";",
"const",
"Function",
"&",
"CallerF",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"CallingConv",
"::",
"ID",
"CalleeCC",
"=",
"Info",
".",
"CallConv",
";",
"CallingConv",
"::",
"ID",
"CallerCC",
"=",
"CallerF",
".",
"getCallingConv",
"(",
")",
";",
"const",
"SIRegisterInfo",
"*",
"TRI",
"=",
"MF",
".",
"getSubtarget",
"<",
"GCNSubtarget",
">",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"const",
"uint32_t",
"*",
"CallerPreserved",
"=",
"TRI",
"->",
"getCallPreservedMask",
"(",
"MF",
",",
"CallerCC",
")",
";",
"if",
"(",
"!",
"CallerPreserved",
")",
"return",
"false",
";",
"if",
"(",
"!",
"mayTailCallThisCC",
"(",
"CalleeCC",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"... Calling convention cannot be tail called.\\n\"",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"any_of",
"(",
"CallerF",
".",
"args",
"(",
")",
",",
"[",
"]",
"(",
"const",
"Argument",
"&",
"A",
")",
"{",
"return",
"A",
".",
"hasByValAttr",
"(",
")",
"||",
"A",
".",
"hasSwiftErrorAttr",
"(",
")",
";",
"}",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"... Cannot tail call from callers with byval \"",
"\"or swifterror arguments\\n\"",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"Options",
".",
"GuaranteedTailCallOpt",
")",
"return",
"canGuaranteeTCO",
"(",
"CalleeCC",
")",
"&&",
"CalleeCC",
"==",
"CallerF",
".",
"getCallingConv",
"(",
")",
";",
"if",
"(",
"!",
"doCallerAndCalleePassArgsTheSameWay",
"(",
"Info",
",",
"MF",
",",
"InArgs",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"... Caller and callee have incompatible calling conventions.\\n\"",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"areCalleeOutgoingArgsTailCallable",
"(",
"Info",
",",
"MF",
",",
"OutArgs",
")",
")",
"return",
"false",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"... Call is eligible for tail call optimization.\\n\"",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"call",
"can",
"be",
"lowered",
"as",
"a",
"tail",
"call",
"."
] | [
"AMDGPU",
"AMDGPU",
"SI",
"\"... Calling convention cannot be tail called.\\n\"",
"\"... Cannot tail call from callers with byval \"",
"\"or swifterror arguments\\n\"",
"\"... Caller and callee have incompatible calling conventions.\\n\"",
"\"... Call is eligible for tail call optimization.\\n\""
] | AMDGPUCallLowering10 | isEligibleForTailCallOptimization | AMDGPU | GPU | LLVM | 19,896 | 285 | 1 | [] |
[
"<s>",
"rtx",
"m68k_libcall_value",
"(",
"machine_mode",
"mode",
")",
"{",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_SFmode",
":",
"case",
"E_DFmode",
":",
"case",
"E_XFmode",
":",
"if",
"(",
"TARGET_68881",
")",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"FP0_REG",
")",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"m68k_libcall_value_in_a0_p",
"?",
"A0_REG",
":",
"D0_REG",
")",
";",
"}",
"</s>"
] | [
"Return",
"floating",
"point",
"values",
"in",
"a",
"68881",
"register",
".",
"This",
"makes",
"68881",
"code",
"a",
"little",
"bit",
"faster",
".",
"It",
"also",
"makes",
"-msoft-float",
"code",
"incompatible",
"with",
"hard-float",
"code",
",",
"so",
"people",
"have",
"to",
"be",
"careful",
"not",
"to",
"mix",
"the",
"two",
".",
"For",
"ColdFire",
"it",
"was",
"decided",
"the",
"ABI",
"incompatibility",
"is",
"undesirable",
".",
"If",
"there",
"is",
"need",
"for",
"a",
"hard-float",
"ABI",
"it",
"is",
"probably",
"worth",
"doing",
"it",
"properly",
"and",
"also",
"passing",
"function",
"arguments",
"in",
"FP",
"registers",
"."
] | [
"m68k"
] | m68k | m68k_libcall_value | m68k | MPU | GCC | 19,897 | 53 | 1 | [] |
[
"<s>",
"unsigned",
"RISCVInstrInfo",
"::",
"getInstSizeInBytes",
"(",
"const",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"{",
"if",
"(",
"MI",
".",
"getParent",
"(",
")",
"&&",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
")",
"{",
"const",
"auto",
"MF",
"=",
"MI",
".",
"getMF",
"(",
")",
";",
"const",
"auto",
"&",
"TM",
"=",
"static_cast",
"<",
"const",
"RISCVTargetMachine",
"&",
">",
"(",
"MF",
"->",
"getTarget",
"(",
")",
")",
";",
"const",
"MCRegisterInfo",
"&",
"MRI",
"=",
"*",
"TM",
".",
"getMCRegisterInfo",
"(",
")",
";",
"const",
"MCSubtargetInfo",
"&",
"STI",
"=",
"*",
"TM",
".",
"getMCSubtargetInfo",
"(",
")",
";",
"const",
"RISCVSubtarget",
"&",
"ST",
"=",
"MF",
"->",
"getSubtarget",
"<",
"RISCVSubtarget",
">",
"(",
")",
";",
"if",
"(",
"isCompressibleInst",
"(",
"MI",
",",
"&",
"ST",
",",
"MRI",
",",
"STI",
")",
")",
"return",
"2",
";",
"}",
"return",
"get",
"(",
"Opcode",
")",
".",
"getSize",
"(",
")",
";",
"}",
"case",
"TargetOpcode",
"::",
"EH_LABEL",
":",
"case",
"TargetOpcode",
"::",
"IMPLICIT_DEF",
":",
"case",
"TargetOpcode",
"::",
"KILL",
":",
"case",
"TargetOpcode",
"::",
"DBG_VALUE",
":",
"return",
"0",
";",
"case",
"RISCV",
"::",
"PseudoCALLReg",
":",
"case",
"RISCV",
"::",
"PseudoCALL",
":",
"case",
"RISCV",
"::",
"PseudoJump",
":",
"case",
"RISCV",
"::",
"PseudoTAIL",
":",
"case",
"RISCV",
"::",
"PseudoLLA",
":",
"case",
"RISCV",
"::",
"PseudoLA",
":",
"case",
"RISCV",
"::",
"PseudoLA_TLS_IE",
":",
"case",
"RISCV",
"::",
"PseudoLA_TLS_GD",
":",
"return",
"8",
";",
"case",
"TargetOpcode",
"::",
"INLINEASM",
":",
"case",
"TargetOpcode",
"::",
"INLINEASM_BR",
":",
"{",
"const",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"auto",
"&",
"TM",
"=",
"static_cast",
"<",
"const",
"RISCVTargetMachine",
"&",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
")",
";",
"return",
"getInlineAsmLength",
"(",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getSymbolName",
"(",
")",
",",
"*",
"TM",
".",
"getMCAsmInfo",
"(",
")",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"specified",
"MachineInstr",
",",
"or",
"~0U",
"when",
"this",
"function",
"is",
"not",
"implemented",
"by",
"a",
"target",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"RISCV",
"RISCV",
"2",
"0",
"RISCV::PseudoCALLReg",
"RISCV::PseudoCALL",
"RISCV::PseudoJump",
"RISCV::PseudoTAIL",
"RISCV::PseudoLLA",
"RISCV::PseudoLA",
"RISCV::PseudoLA_TLS_IE",
"RISCV::PseudoLA_TLS_GD",
"8",
"RISCV",
"0"
] | RISCVInstrInfo29 | getInstSizeInBytes | RISCV | CPU | LLVM | 19,898 | 281 | 1 | [] |
[
"<s>",
"rtx",
"prepare_scc_operands",
"(",
"enum",
"rtx_code",
"code",
")",
"{",
"rtx",
"t_reg",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"T_REG",
")",
";",
"enum",
"rtx_code",
"oldcode",
"=",
"code",
";",
"enum",
"machine_mode",
"mode",
";",
"switch",
"(",
"code",
")",
"{",
"case",
"NE",
":",
"gcc_unreachable",
"(",
")",
";",
"case",
"LT",
":",
"code",
"=",
"GT",
";",
"break",
";",
"case",
"LE",
":",
"code",
"=",
"GE",
";",
"break",
";",
"case",
"LTU",
":",
"code",
"=",
"GTU",
";",
"break",
";",
"case",
"LEU",
":",
"code",
"=",
"GEU",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"if",
"(",
"code",
"!=",
"oldcode",
")",
"{",
"rtx",
"tmp",
"=",
"sh_compare_op0",
";",
"sh_compare_op0",
"=",
"sh_compare_op1",
";",
"sh_compare_op1",
"=",
"tmp",
";",
"}",
"mode",
"=",
"GET_MODE",
"(",
"sh_compare_op0",
")",
";",
"if",
"(",
"mode",
"==",
"VOIDmode",
")",
"mode",
"=",
"GET_MODE",
"(",
"sh_compare_op1",
")",
";",
"sh_compare_op0",
"=",
"force_reg",
"(",
"mode",
",",
"sh_compare_op0",
")",
";",
"if",
"(",
"(",
"code",
"!=",
"EQ",
"&&",
"code",
"!=",
"NE",
"&&",
"(",
"sh_compare_op1",
"!=",
"const0_rtx",
"||",
"code",
"==",
"GTU",
"||",
"code",
"==",
"GEU",
"||",
"code",
"==",
"LTU",
"||",
"code",
"==",
"LEU",
")",
")",
"||",
"(",
"mode",
"==",
"DImode",
"&&",
"sh_compare_op1",
"!=",
"const0_rtx",
")",
"||",
"(",
"TARGET_SH2E",
"&&",
"GET_MODE_CLASS",
"(",
"mode",
")",
"==",
"MODE_FLOAT",
")",
")",
"sh_compare_op1",
"=",
"force_reg",
"(",
"mode",
",",
"sh_compare_op1",
")",
";",
"if",
"(",
"(",
"TARGET_SH4",
"||",
"TARGET_SH2A",
")",
"&&",
"GET_MODE_CLASS",
"(",
"mode",
")",
"==",
"MODE_FLOAT",
")",
"(",
"mode",
"==",
"SFmode",
"?",
"emit_sf_insn",
":",
"emit_df_insn",
")",
"(",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"gen_rtvec",
"(",
"2",
",",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"t_reg",
",",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"SImode",
",",
"sh_compare_op0",
",",
"sh_compare_op1",
")",
")",
",",
"gen_rtx_USE",
"(",
"VOIDmode",
",",
"get_fpscr_rtx",
"(",
")",
")",
")",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"t_reg",
",",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"SImode",
",",
"sh_compare_op0",
",",
"sh_compare_op1",
")",
")",
")",
";",
"return",
"t_reg",
";",
"}",
"</s>"
] | [
"Prepare",
"the",
"operands",
"for",
"an",
"scc",
"instruction",
";",
"make",
"sure",
"that",
"the",
"compare",
"has",
"been",
"done",
"."
] | [
"sh",
"2"
] | sh3 | prepare_scc_operands | sh | CPU | GCC | 19,899 | 284 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.