ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"bool",
"mips_fmadd_bypass",
"(",
"rtx_insn",
"*",
"out_insn",
",",
"rtx_insn",
"*",
"in_insn",
")",
"{",
"int",
"dst_reg",
",",
"src_reg",
";",
"gcc_assert",
"(",
"get_attr_type",
"(",
"in_insn",
")",
"==",
"TYPE_FMADD",
")",
";",
"gcc_assert",
"(",
"get_attr_type",
"(",
"out_insn",
")",
"==",
"TYPE_FMADD",
")",
";",
"extract_insn",
"(",
"in_insn",
")",
";",
"dst_reg",
"=",
"REG_P",
"(",
"recog_data",
".",
"operand",
"[",
"0",
"]",
")",
";",
"extract_insn",
"(",
"out_insn",
")",
";",
"src_reg",
"=",
"REG_P",
"(",
"recog_data",
".",
"operand",
"[",
"1",
"]",
")",
";",
"if",
"(",
"dst_reg",
"==",
"src_reg",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"destination",
"of",
"IN_INSN",
"is",
"used",
"as",
"add",
"source",
"in",
"OUT_INSN",
".",
"Both",
"IN_INSN",
"and",
"OUT_INSN",
"are",
"of",
"type",
"fmadd",
".",
"Example",
":",
"madd.s",
"dst",
",",
"x",
",",
"y",
",",
"z",
"madd.s",
"a",
",",
"dst",
",",
"b",
",",
"c"
] | [
"mips",
"0",
"1"
] | mips | mips_fmadd_bypass | mips | CPU | GCC | 3,100 | 84 | 1 | [] |
[
"<s>",
"static",
"ArrayRef",
"<",
"MCPhysReg",
">",
"getAllSGPR128",
"(",
")",
"{",
"return",
"makeArrayRef",
"(",
"AMDGPU",
"::",
"SGPR_128RegClass",
".",
"begin",
"(",
")",
",",
"AMDGPU",
"::",
"SGPR_128RegClass",
".",
"getNumRegs",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"all",
"SGPR128",
"which",
"satisfy",
"the",
"waves",
"per",
"execution",
"unit",
"requirement",
"of",
"the",
"subtarget",
"."
] | [
"AMDGPU",
"AMDGPU::SGPR_128RegClass",
"AMDGPU::SGPR_128RegClass"
] | SIFrameLowering27 | getAllSGPR128 | AMDGPU | GPU | LLVM | 3,101 | 30 | 1 | [] |
[
"<s>",
"static",
"void",
"loongarch_output_mi_thunk",
"(",
"FILE",
"*",
"file",
",",
"tree",
"thunk_fndecl",
"ATTRIBUTE_UNUSED",
",",
"HOST_WIDE_INT",
"delta",
",",
"HOST_WIDE_INT",
"vcall_offset",
",",
"tree",
"function",
")",
"{",
"const",
"char",
"*",
"fnname",
"=",
"IDENTIFIER_POINTER",
"(",
"DECL_ASSEMBLER_NAME",
"(",
"thunk_fndecl",
")",
")",
";",
"rtx",
"this_rtx",
",",
"temp1",
",",
"temp2",
",",
"fnaddr",
";",
"rtx_insn",
"*",
"insn",
";",
"bool",
"use_sibcall_p",
";",
"reload_completed",
"=",
"1",
";",
"emit_note",
"(",
"NOTE_INSN_PROLOGUE_END",
")",
";",
"fnaddr",
"=",
"XEXP",
"(",
"DECL_RTL",
"(",
"function",
")",
",",
"0",
")",
";",
"use_sibcall_p",
"=",
"const_call_insn_operand",
"(",
"fnaddr",
",",
"Pmode",
")",
";",
"temp1",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"12",
")",
";",
"temp2",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"13",
")",
";",
"if",
"(",
"aggregate_value_p",
"(",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"function",
")",
")",
",",
"function",
")",
")",
"this_rtx",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"GP_ARG_FIRST",
"+",
"1",
")",
";",
"else",
"this_rtx",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"GP_ARG_FIRST",
")",
";",
"if",
"(",
"delta",
"!=",
"0",
")",
"{",
"rtx",
"offset",
"=",
"GEN_INT",
"(",
"delta",
")",
";",
"if",
"(",
"!",
"IMM12_OPERAND",
"(",
"delta",
")",
")",
"{",
"loongarch_emit_move",
"(",
"temp1",
",",
"offset",
")",
";",
"offset",
"=",
"temp1",
";",
"}",
"emit_insn",
"(",
"gen_add3_insn",
"(",
"this_rtx",
",",
"this_rtx",
",",
"offset",
")",
")",
";",
"}",
"if",
"(",
"vcall_offset",
"!=",
"0",
")",
"{",
"rtx",
"addr",
";",
"loongarch_emit_move",
"(",
"temp1",
",",
"gen_rtx_MEM",
"(",
"Pmode",
",",
"this_rtx",
")",
")",
";",
"addr",
"=",
"loongarch_add_offset",
"(",
"temp2",
",",
"temp1",
",",
"vcall_offset",
")",
";",
"loongarch_emit_move",
"(",
"temp1",
",",
"gen_rtx_MEM",
"(",
"Pmode",
",",
"addr",
")",
")",
";",
"emit_insn",
"(",
"gen_add3_insn",
"(",
"this_rtx",
",",
"this_rtx",
",",
"temp1",
")",
")",
";",
"}",
"if",
"(",
"use_sibcall_p",
")",
"{",
"insn",
"=",
"emit_call_insn",
"(",
"gen_sibcall_internal",
"(",
"fnaddr",
",",
"const0_rtx",
")",
")",
";",
"SIBLING_CALL_P",
"(",
"insn",
")",
"=",
"1",
";",
"}",
"else",
"{",
"loongarch_emit_move",
"(",
"temp1",
",",
"fnaddr",
")",
";",
"emit_jump_insn",
"(",
"gen_indirect_jump",
"(",
"temp1",
")",
")",
";",
"}",
"insn",
"=",
"get_insns",
"(",
")",
";",
"split_all_insns_noflow",
"(",
")",
";",
"shorten_branches",
"(",
"insn",
")",
";",
"assemble_start_function",
"(",
"thunk_fndecl",
",",
"fnname",
")",
";",
"final_start_function",
"(",
"insn",
",",
"file",
",",
"1",
")",
";",
"final",
"(",
"insn",
",",
"file",
",",
"1",
")",
";",
"final_end_function",
"(",
")",
";",
"assemble_end_function",
"(",
"thunk_fndecl",
",",
"fnname",
")",
";",
"reload_completed",
"=",
"0",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ASM_OUTPUT_MI_THUNK",
".",
"Generate",
"rtl",
"rather",
"than",
"asm",
"text",
"in",
"order",
"to",
"avoid",
"duplicating",
"too",
"much",
"logic",
"from",
"elsewhere",
"."
] | [
"loongarch",
"1",
"0",
"12",
"13",
"1",
"0",
"0",
"1",
"1",
"1",
"0"
] | loongarch | loongarch_output_mi_thunk | loongarch | CPU | GCC | 3,102 | 341 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"PPCTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"return",
"0",
";",
"case",
"PPCISD",
"::",
"FSEL",
":",
"return",
"\"PPCISD::FSEL\"",
";",
"case",
"PPCISD",
"::",
"FCFID",
":",
"return",
"\"PPCISD::FCFID\"",
";",
"case",
"PPCISD",
"::",
"FCTIDZ",
":",
"return",
"\"PPCISD::FCTIDZ\"",
";",
"case",
"PPCISD",
"::",
"FCTIWZ",
":",
"return",
"\"PPCISD::FCTIWZ\"",
";",
"case",
"PPCISD",
"::",
"STFIWX",
":",
"return",
"\"PPCISD::STFIWX\"",
";",
"case",
"PPCISD",
"::",
"VMADDFP",
":",
"return",
"\"PPCISD::VMADDFP\"",
";",
"case",
"PPCISD",
"::",
"VNMSUBFP",
":",
"return",
"\"PPCISD::VNMSUBFP\"",
";",
"case",
"PPCISD",
"::",
"VPERM",
":",
"return",
"\"PPCISD::VPERM\"",
";",
"case",
"PPCISD",
"::",
"Hi",
":",
"return",
"\"PPCISD::Hi\"",
";",
"case",
"PPCISD",
"::",
"Lo",
":",
"return",
"\"PPCISD::Lo\"",
";",
"case",
"PPCISD",
"::",
"TOC_ENTRY",
":",
"return",
"\"PPCISD::TOC_ENTRY\"",
";",
"case",
"PPCISD",
"::",
"TOC_RESTORE",
":",
"return",
"\"PPCISD::TOC_RESTORE\"",
";",
"case",
"PPCISD",
"::",
"LOAD",
":",
"return",
"\"PPCISD::LOAD\"",
";",
"case",
"PPCISD",
"::",
"LOAD_TOC",
":",
"return",
"\"PPCISD::LOAD_TOC\"",
";",
"case",
"PPCISD",
"::",
"DYNALLOC",
":",
"return",
"\"PPCISD::DYNALLOC\"",
";",
"case",
"PPCISD",
"::",
"GlobalBaseReg",
":",
"return",
"\"PPCISD::GlobalBaseReg\"",
";",
"case",
"PPCISD",
"::",
"SRL",
":",
"return",
"\"PPCISD::SRL\"",
";",
"case",
"PPCISD",
"::",
"SRA",
":",
"return",
"\"PPCISD::SRA\"",
";",
"case",
"PPCISD",
"::",
"SHL",
":",
"return",
"\"PPCISD::SHL\"",
";",
"case",
"PPCISD",
"::",
"EXTSW_32",
":",
"return",
"\"PPCISD::EXTSW_32\"",
";",
"case",
"PPCISD",
"::",
"STD_32",
":",
"return",
"\"PPCISD::STD_32\"",
";",
"case",
"PPCISD",
"::",
"CALL_SVR4",
":",
"return",
"\"PPCISD::CALL_SVR4\"",
";",
"case",
"PPCISD",
"::",
"CALL_NOP_SVR4",
":",
"return",
"\"PPCISD::CALL_NOP_SVR4\"",
";",
"case",
"PPCISD",
"::",
"CALL_Darwin",
":",
"return",
"\"PPCISD::CALL_Darwin\"",
";",
"case",
"PPCISD",
"::",
"NOP",
":",
"return",
"\"PPCISD::NOP\"",
";",
"case",
"PPCISD",
"::",
"MTCTR",
":",
"return",
"\"PPCISD::MTCTR\"",
";",
"case",
"PPCISD",
"::",
"BCTRL_Darwin",
":",
"return",
"\"PPCISD::BCTRL_Darwin\"",
";",
"case",
"PPCISD",
"::",
"BCTRL_SVR4",
":",
"return",
"\"PPCISD::BCTRL_SVR4\"",
";",
"case",
"PPCISD",
"::",
"RET_FLAG",
":",
"return",
"\"PPCISD::RET_FLAG\"",
";",
"case",
"PPCISD",
"::",
"MFCR",
":",
"return",
"\"PPCISD::MFCR\"",
";",
"case",
"PPCISD",
"::",
"VCMP",
":",
"return",
"\"PPCISD::VCMP\"",
";",
"case",
"PPCISD",
"::",
"VCMPo",
":",
"return",
"\"PPCISD::VCMPo\"",
";",
"case",
"PPCISD",
"::",
"LBRX",
":",
"return",
"\"PPCISD::LBRX\"",
";",
"case",
"PPCISD",
"::",
"STBRX",
":",
"return",
"\"PPCISD::STBRX\"",
";",
"case",
"PPCISD",
"::",
"LARX",
":",
"return",
"\"PPCISD::LARX\"",
";",
"case",
"PPCISD",
"::",
"STCX",
":",
"return",
"\"PPCISD::STCX\"",
";",
"case",
"PPCISD",
"::",
"COND_BRANCH",
":",
"return",
"\"PPCISD::COND_BRANCH\"",
";",
"case",
"PPCISD",
"::",
"MFFS",
":",
"return",
"\"PPCISD::MFFS\"",
";",
"case",
"PPCISD",
"::",
"MTFSB0",
":",
"return",
"\"PPCISD::MTFSB0\"",
";",
"case",
"PPCISD",
"::",
"MTFSB1",
":",
"return",
"\"PPCISD::MTFSB1\"",
";",
"case",
"PPCISD",
"::",
"FADDRTZ",
":",
"return",
"\"PPCISD::FADDRTZ\"",
";",
"case",
"PPCISD",
"::",
"MTFSF",
":",
"return",
"\"PPCISD::MTFSF\"",
";",
"case",
"PPCISD",
"::",
"TC_RETURN",
":",
"return",
"\"PPCISD::TC_RETURN\"",
";",
"}",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"PowerPC",
"PPC",
"0",
"PPCISD::FSEL",
"\"PPCISD::FSEL\"",
"PPCISD::FCFID",
"\"PPCISD::FCFID\"",
"PPCISD::FCTIDZ",
"\"PPCISD::FCTIDZ\"",
"PPCISD::FCTIWZ",
"\"PPCISD::FCTIWZ\"",
"PPCISD::STFIWX",
"\"PPCISD::STFIWX\"",
"PPCISD::VMADDFP",
"\"PPCISD::VMADDFP\"",
"PPCISD::VNMSUBFP",
"\"PPCISD::VNMSUBFP\"",
"PPCISD::VPERM",
"\"PPCISD::VPERM\"",
"PPCISD::Hi",
"\"PPCISD::Hi\"",
"PPCISD::Lo",
"\"PPCISD::Lo\"",
"PPCISD::TOC_ENTRY",
"\"PPCISD::TOC_ENTRY\"",
"PPCISD::TOC_RESTORE",
"\"PPCISD::TOC_RESTORE\"",
"PPCISD::LOAD",
"\"PPCISD::LOAD\"",
"PPCISD::LOAD_TOC",
"\"PPCISD::LOAD_TOC\"",
"PPCISD::DYNALLOC",
"\"PPCISD::DYNALLOC\"",
"PPCISD::GlobalBaseReg",
"\"PPCISD::GlobalBaseReg\"",
"PPCISD::SRL",
"\"PPCISD::SRL\"",
"PPCISD::SRA",
"\"PPCISD::SRA\"",
"PPCISD::SHL",
"\"PPCISD::SHL\"",
"PPCISD::EXTSW_32",
"\"PPCISD::EXTSW_32\"",
"PPCISD::STD_32",
"\"PPCISD::STD_32\"",
"PPCISD::CALL_SVR4",
"\"PPCISD::CALL_SVR4\"",
"PPCISD::CALL_NOP_SVR4",
"\"PPCISD::CALL_NOP_SVR4\"",
"PPCISD::CALL_Darwin",
"\"PPCISD::CALL_Darwin\"",
"PPCISD::NOP",
"\"PPCISD::NOP\"",
"PPCISD::MTCTR",
"\"PPCISD::MTCTR\"",
"PPCISD::BCTRL_Darwin",
"\"PPCISD::BCTRL_Darwin\"",
"PPCISD::BCTRL_SVR4",
"\"PPCISD::BCTRL_SVR4\"",
"PPCISD::RET_FLAG",
"\"PPCISD::RET_FLAG\"",
"PPCISD::MFCR",
"\"PPCISD::MFCR\"",
"PPCISD::VCMP",
"\"PPCISD::VCMP\"",
"PPCISD::VCMPo",
"\"PPCISD::VCMPo\"",
"PPCISD::LBRX",
"\"PPCISD::LBRX\"",
"PPCISD::STBRX",
"\"PPCISD::STBRX\"",
"PPCISD::LARX",
"\"PPCISD::LARX\"",
"PPCISD::STCX",
"\"PPCISD::STCX\"",
"PPCISD::COND_BRANCH",
"\"PPCISD::COND_BRANCH\"",
"PPCISD::MFFS",
"\"PPCISD::MFFS\"",
"PPCISD::MTFSB0",
"\"PPCISD::MTFSB0\"",
"PPCISD::MTFSB1",
"\"PPCISD::MTFSB1\"",
"PPCISD::FADDRTZ",
"\"PPCISD::FADDRTZ\"",
"PPCISD::MTFSF",
"\"PPCISD::MTFSF\"",
"PPCISD::TC_RETURN",
"\"PPCISD::TC_RETURN\""
] | PPCISelLowering114 | getTargetNodeName | PowerPC | CPU | LLVM | 3,103 | 368 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUOpenCLEnqueuedBlockLowering",
"::",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"{",
"DenseSet",
"<",
"Function",
"*",
">",
"Callers",
";",
"auto",
"&",
"C",
"=",
"M",
".",
"getContext",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"auto",
"&",
"F",
":",
"M",
".",
"functions",
"(",
")",
")",
"{",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"\"enqueued-block\"",
")",
")",
"{",
"if",
"(",
"!",
"F",
".",
"hasName",
"(",
")",
")",
"{",
"SmallString",
"<",
"64",
">",
"Name",
";",
"Mangler",
"::",
"getNameWithPrefix",
"(",
"Name",
",",
"\"__amdgpu_enqueued_kernel\"",
",",
"M",
".",
"getDataLayout",
"(",
")",
")",
";",
"F",
".",
"setName",
"(",
"Name",
")",
";",
"}",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"found enqueued kernel: \"",
"<<",
"F",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
")",
";",
"auto",
"RuntimeHandle",
"=",
"(",
"F",
".",
"getName",
"(",
")",
"+",
"\".runtime_handle\"",
")",
".",
"str",
"(",
")",
";",
"auto",
"T",
"=",
"Type",
"::",
"getInt8Ty",
"(",
"C",
")",
"->",
"getPointerTo",
"(",
"AMDGPUAS",
"::",
"GLOBAL_ADDRESS",
")",
";",
"auto",
"*",
"GV",
"=",
"new",
"GlobalVariable",
"(",
"M",
",",
"T",
",",
"false",
",",
"GlobalValue",
"::",
"ExternalLinkage",
",",
"Constant",
"::",
"getNullValue",
"(",
"T",
")",
",",
"RuntimeHandle",
",",
"nullptr",
",",
"GlobalValue",
"::",
"NotThreadLocal",
",",
"AMDGPUAS",
"::",
"GLOBAL_ADDRESS",
",",
"false",
")",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"runtime handle created: \"",
"<<",
"*",
"GV",
"<<",
"'\\n'",
")",
";",
"for",
"(",
"auto",
"U",
":",
"F",
".",
"users",
"(",
")",
")",
"{",
"auto",
"*",
"UU",
"=",
"&",
"*",
"U",
";",
"if",
"(",
"!",
"isa",
"<",
"ConstantExpr",
">",
"(",
"UU",
")",
")",
"continue",
";",
"collectFunctionUsers",
"(",
"UU",
",",
"Callers",
")",
";",
"auto",
"*",
"BitCast",
"=",
"cast",
"<",
"ConstantExpr",
">",
"(",
"UU",
")",
";",
"auto",
"*",
"NewPtr",
"=",
"ConstantExpr",
"::",
"getPointerCast",
"(",
"GV",
",",
"BitCast",
"->",
"getType",
"(",
")",
")",
";",
"BitCast",
"->",
"replaceAllUsesWith",
"(",
"NewPtr",
")",
";",
"F",
".",
"addFnAttr",
"(",
"\"runtime-handle\"",
",",
"RuntimeHandle",
")",
";",
"F",
".",
"setLinkage",
"(",
"GlobalValue",
"::",
"ExternalLinkage",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"}",
"}",
"for",
"(",
"auto",
"F",
":",
"Callers",
")",
"{",
"if",
"(",
"F",
"->",
"getCallingConv",
"(",
")",
"!=",
"CallingConv",
"::",
"AMDGPU_KERNEL",
")",
"continue",
";",
"F",
"->",
"addFnAttr",
"(",
"\"calls-enqueue-kernel\"",
")",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"mark enqueue_kernel caller:\"",
"<<",
"F",
"->",
"getName",
"(",
")",
"<<",
"'\\n'",
")",
";",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] | [
"AMDGPU",
"AMDGPU",
"\"enqueued-block\"",
"64",
"\"__amdgpu_enqueued_kernel\"",
"\"found enqueued kernel: \"",
"\".runtime_handle\"",
"AMDGPU",
"AMDGPU",
"\"runtime handle created: \"",
"\"runtime-handle\"",
"AMDGPU",
"\"calls-enqueue-kernel\"",
"\"mark enqueue_kernel caller:\""
] | AMDGPUOpenCLEnqueuedBlockLowering | runOnModule | AMDGPU | GPU | LLVM | 3,104 | 350 | 1 | [] |
[
"<s>",
"SDValue",
"M68kTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Should not custom lower this!\"",
")",
";",
"case",
"ISD",
"::",
"SADDO",
":",
"case",
"ISD",
"::",
"UADDO",
":",
"case",
"ISD",
"::",
"SSUBO",
":",
"case",
"ISD",
"::",
"USUBO",
":",
"case",
"ISD",
"::",
"SMULO",
":",
"case",
"ISD",
"::",
"UMULO",
":",
"return",
"LowerXALUO",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SETCC",
":",
"return",
"LowerSETCC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SETCCCARRY",
":",
"return",
"LowerSETCCCARRY",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SELECT",
":",
"return",
"LowerSELECT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BRCOND",
":",
"return",
"LowerBRCOND",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ADDC",
":",
"case",
"ISD",
"::",
"ADDE",
":",
"case",
"ISD",
"::",
"SUBC",
":",
"case",
"ISD",
"::",
"SUBE",
":",
"return",
"LowerADDC_ADDE_SUBC_SUBE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ConstantPool",
":",
"return",
"LowerConstantPool",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"LowerGlobalAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"ExternalSymbol",
":",
"return",
"LowerExternalSymbol",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BlockAddress",
":",
"return",
"LowerBlockAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"JumpTable",
":",
"return",
"LowerJumpTable",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VASTART",
":",
"return",
"LowerVASTART",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"DYNAMIC_STACKALLOC",
":",
"return",
"LowerDYNAMIC_STACKALLOC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SHL_PARTS",
":",
"return",
"LowerShiftLeftParts",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SRA_PARTS",
":",
"return",
"LowerShiftRightParts",
"(",
"Op",
",",
"DAG",
",",
"true",
")",
";",
"case",
"ISD",
"::",
"SRL_PARTS",
":",
"return",
"LowerShiftRightParts",
"(",
"Op",
",",
"DAG",
",",
"false",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"M68k",
"M68k",
"\"Should not custom lower this!\"",
"ISD::SADDO",
"ISD::UADDO",
"ISD::SSUBO",
"ISD::USUBO",
"ISD::SMULO",
"ISD::UMULO",
"ISD::SETCC",
"ISD::SETCCCARRY",
"ISD::SELECT",
"ISD::BRCOND",
"ISD::ADDC",
"ISD::ADDE",
"ISD::SUBC",
"ISD::SUBE",
"ISD::ConstantPool",
"ISD::GlobalAddress",
"ISD::ExternalSymbol",
"ISD::BlockAddress",
"ISD::JumpTable",
"ISD::VASTART",
"ISD::DYNAMIC_STACKALLOC",
"ISD::SHL_PARTS",
"ISD::SRA_PARTS",
"ISD::SRL_PARTS"
] | M68kISelLowering | LowerOperation | M68k | MPU | LLVM | 3,105 | 284 | 1 | [] |
[
"<s>",
"void",
"Z80oldInstPrinterBase",
"::",
"printRegName",
"(",
"raw_ostream",
"&",
"OS",
",",
"unsigned",
"RegNo",
")",
"const",
"{",
"OS",
"<<",
"markup",
"(",
"\"<reg:\"",
")",
"<<",
"getRegName",
"(",
"RegNo",
")",
"<<",
"markup",
"(",
"\">\"",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"assembler",
"register",
"name",
"."
] | [
"Z80old",
"Z80old",
"\"<reg:\"",
"\">\""
] | Z80oldInstPrinterBase | printRegName | Z80old | MPU | LLVM | 3,106 | 32 | 1 | [] |
[
"<s>",
"unsigned",
"VEInstrInfo",
"::",
"isLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"VE",
"::",
"LDrii",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"VE",
"::",
"LDLSXrii",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"VE",
"::",
"LDUrii",
")",
"{",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isFI",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"==",
"0",
"&&",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"getImm",
"(",
")",
"==",
"0",
")",
"{",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isLoadFromStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"destination",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"VE",
"VE",
"VE::LDrii",
"VE::LDLSXrii",
"VE::LDUrii",
"1",
"2",
"2",
"0",
"3",
"3",
"0",
"1",
"0",
"0"
] | VEInstrInfo1 | isLoadFromStackSlot | VE | CPU | LLVM | 3,107 | 142 | 1 | [] |
[
"<s>",
"unsigned",
"getNumFixupKinds",
"(",
")",
"const",
"override",
"{",
"return",
"AMDGPU",
"::",
"NumTargetFixupKinds",
";",
"}",
"</s>"
] | [
"Get",
"the",
"number",
"of",
"target",
"specific",
"fixup",
"kinds",
"."
] | [
"AMDGPU",
"AMDGPU::NumTargetFixupKinds"
] | AMDGPUAsmBackend (2) | getNumFixupKinds | AMDGPU | GPU | LLVM | 3,108 | 13 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"rs6000_mangle_fundamental_type",
"(",
"tree",
"type",
")",
"{",
"if",
"(",
"type",
"==",
"bool_char_type_node",
")",
"return",
"\"U6__boolc\"",
";",
"if",
"(",
"type",
"==",
"bool_short_type_node",
")",
"return",
"\"U6__bools\"",
";",
"if",
"(",
"type",
"==",
"pixel_type_node",
")",
"return",
"\"u7__pixel\"",
";",
"if",
"(",
"type",
"==",
"bool_int_type_node",
")",
"return",
"\"U6__booli\"",
";",
"if",
"(",
"TYPE_MAIN_VARIANT",
"(",
"type",
")",
"==",
"long_double_type_node",
"&&",
"TARGET_ELF",
"&&",
"TARGET_LONG_DOUBLE_128",
"&&",
"!",
"TARGET_IEEEQUAD",
")",
"return",
"\"g\"",
";",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"AltiVec",
"defines",
"four",
"built-in",
"scalar",
"types",
"that",
"serve",
"as",
"vector",
"elements",
";",
"we",
"must",
"teach",
"the",
"compiler",
"how",
"to",
"mangle",
"them",
"."
] | [
"rs6000",
"\"U6__boolc\"",
"\"U6__bools\"",
"\"u7__pixel\"",
"\"U6__booli\"",
"\"g\""
] | rs60003 | rs6000_mangle_fundamental_type | rs6000 | CPU | GCC | 3,109 | 69 | 1 | [] |
[
"<s>",
"static",
"void",
"or1k_tls_call",
"(",
"rtx",
"dest",
",",
"rtx",
"arg",
")",
"{",
"emit_library_call_value",
"(",
"gen_tls_get_addr",
"(",
")",
",",
"dest",
",",
"LCT_CONST",
",",
"Pmode",
",",
"arg",
",",
"Pmode",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"call",
"to",
"'__tls_get_addr",
"'",
"."
] | [
"or1k"
] | or1k | or1k_tls_call | or1k | CPU | GCC | 3,110 | 29 | 1 | [] |
[
"<s>",
"bool",
"sh_can_use_simple_return_p",
"(",
"void",
")",
"{",
"HARD_REG_SET",
"live_regs_mask",
";",
"int",
"d",
";",
"if",
"(",
"TARGET_SHMEDIA",
"||",
"(",
"TARGET_SHCOMPACT",
"&&",
"(",
"crtl",
"->",
"args",
".",
"info",
".",
"call_cookie",
"&",
"CALL_COOKIE_RET_TRAMP",
"(",
"1",
")",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"reload_completed",
"||",
"frame_pointer_needed",
")",
"return",
"false",
";",
"if",
"(",
"optimize_function_for_size_p",
"(",
"cfun",
")",
")",
"return",
"false",
";",
"d",
"=",
"calc_live_regs",
"(",
"&",
"live_regs_mask",
")",
";",
"if",
"(",
"rounded_frame_size",
"(",
"d",
")",
">",
"4",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"is",
"appropriate",
"to",
"emit",
"`",
"ret",
"'",
"instructions",
"in",
"the",
"body",
"of",
"a",
"function",
"."
] | [
"sh",
"1",
"4"
] | sh4 | sh_can_use_simple_return_p | sh | CPU | GCC | 3,111 | 82 | 1 | [] |
[
"<s>",
"void",
"RISCVFrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"RISCV",
"RISCV"
] | RISCVFrameLowering24 | emitPrologue | RISCV | CPU | LLVM | 3,112 | 16 | 1 | [] |
[
"<s>",
"void",
"MINA32InstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"uint64_t",
"Address",
",",
"StringRef",
"Annot",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"if",
"(",
"!",
"printAliasInstr",
"(",
"MI",
",",
"Address",
",",
"O",
")",
")",
"printInstruction",
"(",
"MI",
",",
"Address",
",",
"O",
")",
";",
"printAnnotation",
"(",
"O",
",",
"Annot",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"MINA32",
"MINA32"
] | MINA32InstPrinter | printInst | MINA32 | CPU | LLVM | 3,113 | 55 | 1 | [] |
[
"<s>",
"bool",
"fp_one_operand",
"(",
"rtx",
"op",
")",
"{",
"REAL_VALUE_TYPE",
"r",
";",
"if",
"(",
"GET_MODE",
"(",
"op",
")",
"!=",
"SFmode",
")",
"return",
"false",
";",
"REAL_VALUE_FROM_CONST_DOUBLE",
"(",
"r",
",",
"op",
")",
";",
"return",
"REAL_VALUES_EQUAL",
"(",
"r",
",",
"dconst1",
")",
";",
"}",
"</s>"
] | [
"Nonzero",
"if",
"OP",
"is",
"a",
"floating",
"point",
"value",
"with",
"value",
"1.0",
"."
] | [
"sh"
] | sh4 | fp_one_operand | sh | CPU | GCC | 3,114 | 38 | 1 | [] |
[
"<s>",
"bool",
"ARMBlockPlacement",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"const",
"ARMSubtarget",
"&",
"ST",
"=",
"static_cast",
"<",
"const",
"ARMSubtarget",
"&",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
")",
";",
"if",
"(",
"!",
"ST",
".",
"hasLOB",
"(",
")",
")",
"return",
"false",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"DEBUG_PREFIX",
"<<",
"\"Running on \"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"MLI",
"=",
"&",
"getAnalysis",
"<",
"MachineLoopInfo",
">",
"(",
")",
";",
"TII",
"=",
"static_cast",
"<",
"const",
"ARMBaseInstrInfo",
"*",
">",
"(",
"ST",
".",
"getInstrInfo",
"(",
")",
")",
";",
"BBUtils",
"=",
"std",
"::",
"unique_ptr",
"<",
"ARMBasicBlockUtils",
">",
"(",
"new",
"ARMBasicBlockUtils",
"(",
"MF",
")",
")",
";",
"MF",
".",
"RenumberBlocks",
"(",
")",
";",
"BBUtils",
"->",
"computeAllBlockSizes",
"(",
")",
";",
"BBUtils",
"->",
"adjustBBOffsetsAfter",
"(",
"&",
"MF",
".",
"front",
"(",
")",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"auto",
"*",
"ML",
":",
"*",
"MLI",
")",
"Changed",
"|=",
"processPostOrderLoops",
"(",
"ML",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"\"Running on \"",
"\"\\n\"",
"ARM",
"ARM",
"ARM"
] | ARMBlockPlacement | runOnMachineFunction | ARM | CPU | LLVM | 3,115 | 165 | 1 | [] |
[
"<s>",
"static",
"const",
"__EIT_entry",
"*",
"search_EIT_table",
"(",
"const",
"__EIT_entry",
"*",
"table",
",",
"int",
"nrec",
",",
"_uw",
"return_address",
")",
"{",
"_uw",
"next_fn",
";",
"_uw",
"this_fn",
";",
"int",
"n",
",",
"left",
",",
"right",
";",
"if",
"(",
"nrec",
"==",
"0",
")",
"return",
"(",
"__EIT_entry",
"*",
")",
"0",
";",
"left",
"=",
"0",
";",
"right",
"=",
"nrec",
"-",
"1",
";",
"while",
"(",
"1",
")",
"{",
"n",
"=",
"(",
"left",
"+",
"right",
")",
"/",
"2",
";",
"this_fn",
"=",
"selfrel_offset31",
"(",
"&",
"table",
"[",
"n",
"]",
".",
"fnoffset",
")",
";",
"if",
"(",
"n",
"!=",
"nrec",
"-",
"1",
")",
"next_fn",
"=",
"selfrel_offset31",
"(",
"&",
"table",
"[",
"n",
"+",
"1",
"]",
".",
"fnoffset",
")",
"-",
"1",
";",
"else",
"next_fn",
"=",
"(",
"_uw",
")",
"0",
"-",
"1",
";",
"if",
"(",
"return_address",
"<",
"this_fn",
")",
"{",
"if",
"(",
"n",
"==",
"left",
")",
"return",
"(",
"__EIT_entry",
"*",
")",
"0",
";",
"right",
"=",
"n",
"-",
"1",
";",
"}",
"else",
"if",
"(",
"return_address",
"<=",
"next_fn",
")",
"return",
"&",
"table",
"[",
"n",
"]",
";",
"else",
"left",
"=",
"n",
"+",
"1",
";",
"}",
"}",
"</s>"
] | [
"Perform",
"a",
"binary",
"search",
"for",
"RETURN_ADDRESS",
"in",
"TABLE",
".",
"The",
"table",
"contains",
"NREC",
"entries",
"."
] | [
"arm",
"0",
"0",
"0",
"1",
"1",
"2",
"1",
"1",
"1",
"0",
"1",
"0",
"1",
"1"
] | unwind-arm | search_EIT_table | arm | CPU | GCC | 3,116 | 167 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"SystemZ DAG->DAG Pattern Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"SystemZ",
"\"SystemZ DAG->DAG Pattern Instruction Selection\""
] | SystemZISelDAGToDAG16 | getPassName | SystemZ | CPU | LLVM | 3,117 | 13 | 1 | [] |
[
"<s>",
"bool",
"PatmosInstrInfo",
"::",
"isPredicated",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"if",
"(",
"MI",
"->",
"isBundle",
"(",
")",
")",
"{",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"II",
"=",
"MI",
";",
"while",
"(",
"II",
"->",
"isBundledWithSucc",
"(",
")",
")",
"{",
"++",
"II",
";",
"if",
"(",
"isPredicated",
"(",
"&",
"*",
"II",
")",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"int",
"i",
"=",
"MI",
"->",
"findFirstPredOperandIdx",
"(",
")",
";",
"if",
"(",
"i",
"!=",
"-",
"1",
")",
"{",
"unsigned",
"preg",
"=",
"MI",
"->",
"getOperand",
"(",
"i",
")",
".",
"getReg",
"(",
")",
";",
"int",
"flag",
"=",
"MI",
"->",
"getOperand",
"(",
"++",
"i",
")",
".",
"getImm",
"(",
")",
";",
"return",
"(",
"preg",
"!=",
"Patmos",
"::",
"NoRegister",
"&&",
"preg",
"!=",
"Patmos",
"::",
"P0",
")",
"||",
"flag",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"instruction",
"is",
"already",
"predicated",
"."
] | [
"Patmos",
"Patmos",
"1",
"Patmos::NoRegister",
"Patmos::P0"
] | PatmosInstrInfo | isPredicated | Patmos | VLIW | LLVM | 3,118 | 125 | 1 | [] |
[
"<s>",
"static",
"rtx",
"c6x_struct_value_rtx",
"(",
"tree",
"type",
"ATTRIBUTE_UNUSED",
",",
"int",
"incoming",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"gen_rtx_REG",
"(",
"Pmode",
",",
"REG_A3",
")",
";",
"}",
"</s>"
] | [
"TARGET_STRUCT_VALUE_RTX",
"implementation",
"."
] | [
"c6x"
] | c6x | c6x_struct_value_rtx | c6x | VLIW | GCC | 3,119 | 22 | 1 | [] |
[
"<s>",
"MVT",
"AArch64TargetLowering",
"::",
"getScalarShiftAmountTy",
"(",
"EVT",
"LHSTy",
")",
"const",
"{",
"return",
"MVT",
"::",
"i64",
";",
"}",
"</s>"
] | [
"Return",
"the",
"type",
"to",
"use",
"for",
"a",
"scalar",
"shift",
"opcode",
",",
"given",
"the",
"shifted",
"amount",
"type",
"."
] | [
"AArch64",
"AArch64",
"MVT::i64"
] | AArch64ISelLowering116 | getScalarShiftAmountTy | AArch64 | CPU | LLVM | 3,120 | 16 | 1 | [] |
[
"<s>",
"MCObjectWriter",
"*",
"WebAssemblyAsmBackend",
"::",
"createObjectWriter",
"(",
"raw_pwrite_stream",
"&",
"OS",
")",
"const",
"{",
"return",
"createWebAssemblyWasmObjectWriter",
"(",
"OS",
",",
"Is64Bit",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"new",
"MCObjectWriter",
"instance",
"for",
"use",
"by",
"the",
"assembler",
"backend",
"to",
"emit",
"the",
"final",
"object",
"file",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly"
] | WebAssemblyAsmBackend13 | createObjectWriter | WebAssembly | Virtual ISA | LLVM | 3,121 | 21 | 1 | [] |
[
"<s>",
"EVT",
"PPCTargetLowering",
"::",
"getSetCCResultType",
"(",
"LLVMContext",
"&",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"!",
"VT",
".",
"isVector",
"(",
")",
")",
"return",
"MVT",
"::",
"i32",
";",
"return",
"VT",
".",
"changeVectorElementTypeToInteger",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"value",
"type",
"to",
"use",
"for",
"ISD",
":",
":SETCC",
"."
] | [
"PowerPC",
"PPC",
"MVT::i32"
] | PPCISelLowering (2)1 | getSetCCResultType | PowerPC | CPU | LLVM | 3,122 | 35 | 1 | [] |
[
"<s>",
"void",
"SITargetLowering",
"::",
"allocateSpecialInputVGPRsFixed",
"(",
"CCState",
"&",
"CCInfo",
",",
"MachineFunction",
"&",
"MF",
",",
"const",
"SIRegisterInfo",
"&",
"TRI",
",",
"SIMachineFunctionInfo",
"&",
"Info",
")",
"const",
"{",
"Register",
"Reg",
"=",
"CCInfo",
".",
"AllocateReg",
"(",
"AMDGPU",
"::",
"VGPR31",
")",
";",
"if",
"(",
"!",
"Reg",
")",
"report_fatal_error",
"(",
"\"failed to allocated VGPR for implicit arguments\"",
")",
";",
"const",
"unsigned",
"Mask",
"=",
"0x3ff",
";",
"Info",
".",
"setWorkItemIDX",
"(",
"ArgDescriptor",
"::",
"createRegister",
"(",
"Reg",
",",
"Mask",
")",
")",
";",
"Info",
".",
"setWorkItemIDY",
"(",
"ArgDescriptor",
"::",
"createRegister",
"(",
"Reg",
",",
"Mask",
"<<",
"10",
")",
")",
";",
"Info",
".",
"setWorkItemIDZ",
"(",
"ArgDescriptor",
"::",
"createRegister",
"(",
"Reg",
",",
"Mask",
"<<",
"20",
")",
")",
";",
"}",
"</s>"
] | [
"Allocate",
"implicit",
"function",
"VGPR",
"arguments",
"in",
"fixed",
"registers",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"AMDGPU::VGPR31",
"\"failed to allocated VGPR for implicit arguments\"",
"0x3ff",
"10",
"20"
] | SIISelLowering10 | allocateSpecialInputVGPRsFixed | AMDGPU | GPU | LLVM | 3,123 | 99 | 1 | [] |
[
"<s>",
"bool",
"rs6000_emit_set_const",
"(",
"rtx",
"dest",
",",
"rtx",
"source",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"dest",
")",
";",
"rtx",
"temp",
",",
"set",
";",
"rtx_insn",
"*",
"insn",
";",
"HOST_WIDE_INT",
"c",
";",
"gcc_checking_assert",
"(",
"CONST_INT_P",
"(",
"source",
")",
")",
";",
"c",
"=",
"INTVAL",
"(",
"source",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_QImode",
":",
"case",
"E_HImode",
":",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"dest",
",",
"source",
")",
")",
";",
"return",
"true",
";",
"case",
"E_SImode",
":",
"temp",
"=",
"!",
"can_create_pseudo_p",
"(",
")",
"?",
"dest",
":",
"gen_reg_rtx",
"(",
"SImode",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"copy_rtx",
"(",
"temp",
")",
",",
"GEN_INT",
"(",
"c",
"&",
"~",
"(",
"HOST_WIDE_INT",
")",
"0xffff",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"dest",
",",
"gen_rtx_IOR",
"(",
"SImode",
",",
"copy_rtx",
"(",
"temp",
")",
",",
"GEN_INT",
"(",
"c",
"&",
"0xffff",
")",
")",
")",
")",
";",
"break",
";",
"case",
"E_DImode",
":",
"if",
"(",
"!",
"TARGET_POWERPC64",
")",
"{",
"rtx",
"hi",
",",
"lo",
";",
"hi",
"=",
"operand_subword_force",
"(",
"copy_rtx",
"(",
"dest",
")",
",",
"WORDS_BIG_ENDIAN",
"==",
"0",
",",
"DImode",
")",
";",
"lo",
"=",
"operand_subword_force",
"(",
"dest",
",",
"WORDS_BIG_ENDIAN",
"!=",
"0",
",",
"DImode",
")",
";",
"emit_move_insn",
"(",
"hi",
",",
"GEN_INT",
"(",
"c",
">>",
"32",
")",
")",
";",
"c",
"=",
"(",
"(",
"c",
"&",
"0xffffffff",
")",
"^",
"0x80000000",
")",
"-",
"0x80000000",
";",
"emit_move_insn",
"(",
"lo",
",",
"GEN_INT",
"(",
"c",
")",
")",
";",
"}",
"else",
"rs6000_emit_set_long_const",
"(",
"dest",
",",
"c",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"insn",
"=",
"get_last_insn",
"(",
")",
";",
"set",
"=",
"single_set",
"(",
"insn",
")",
";",
"if",
"(",
"!",
"CONSTANT_P",
"(",
"SET_SRC",
"(",
"set",
")",
")",
")",
"set_unique_reg_note",
"(",
"insn",
",",
"REG_EQUAL",
",",
"GEN_INT",
"(",
"c",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Try",
"to",
"output",
"insns",
"to",
"set",
"TARGET",
"equal",
"to",
"the",
"constant",
"C",
"if",
"it",
"can",
"be",
"done",
"in",
"less",
"than",
"N",
"insns",
".",
"Do",
"all",
"computations",
"in",
"MODE",
".",
"Returns",
"the",
"place",
"where",
"the",
"output",
"has",
"been",
"placed",
"if",
"it",
"can",
"be",
"done",
"and",
"the",
"insns",
"have",
"been",
"emitted",
".",
"If",
"it",
"would",
"take",
"more",
"than",
"N",
"insns",
",",
"zero",
"is",
"returned",
"and",
"no",
"insns",
"and",
"emitted",
"."
] | [
"rs6000",
"0xffff",
"0xffff",
"0",
"0",
"32",
"0xffffffff",
"0x80000000",
"0x80000000"
] | rs6000 | rs6000_emit_set_const | rs6000 | CPU | GCC | 3,124 | 272 | 1 | [] |
[
"<s>",
"void",
"crx_function_arg_advance",
"(",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"enum",
"machine_mode",
"mode",
",",
"tree",
"type",
",",
"int",
"named",
"ATTRIBUTE_UNUSED",
")",
"{",
"int",
"l",
"=",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
"/",
"BITS_PER_WORD",
";",
"if",
"(",
"!",
"last_parm_in_reg",
")",
"return",
";",
"if",
"(",
"targetm",
".",
"calls",
".",
"must_pass_in_stack",
"(",
"mode",
",",
"type",
")",
"||",
"(",
"cum",
"->",
"ints",
"<",
"0",
")",
")",
"return",
";",
"if",
"(",
"mode",
"==",
"SImode",
"||",
"mode",
"==",
"HImode",
"||",
"mode",
"==",
"QImode",
"||",
"mode",
"==",
"DImode",
")",
"{",
"if",
"(",
"l",
"<=",
"1",
")",
"cum",
"->",
"ints",
"+=",
"1",
";",
"else",
"cum",
"->",
"ints",
"+=",
"l",
";",
"}",
"else",
"if",
"(",
"mode",
"==",
"SFmode",
"||",
"mode",
"==",
"DFmode",
")",
"cum",
"->",
"ints",
"+=",
"l",
";",
"else",
"if",
"(",
"(",
"mode",
")",
"==",
"BLKmode",
")",
"{",
"if",
"(",
"(",
"l",
"=",
"enough_regs_for_param",
"(",
"cum",
",",
"type",
",",
"mode",
")",
")",
"!=",
"0",
")",
"cum",
"->",
"ints",
"+=",
"l",
";",
"}",
"}",
"</s>"
] | [
"Implements",
"the",
"macro",
"FUNCTION_ARG_ADVANCE",
"defined",
"in",
"crx.h",
"."
] | [
"crx",
"0",
"1",
"1",
"0"
] | crx | crx_function_arg_advance | crx | CPU | GCC | 3,125 | 150 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"WebAssembly Lower Emscripten Exceptions\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"WebAssembly",
"\"WebAssembly Lower Emscripten Exceptions\""
] | WebAssemblyLowerEmscriptenEHSjLj29 | getPassName | WebAssembly | Virtual ISA | LLVM | 3,126 | 13 | 1 | [] |
[
"<s>",
"static",
"void",
"union_defs",
"(",
"swap_web_entry",
"*",
"insn_entry",
",",
"rtx",
"insn",
",",
"df_ref",
"use",
")",
"{",
"struct",
"df_link",
"*",
"link",
"=",
"DF_REF_CHAIN",
"(",
"use",
")",
";",
"if",
"(",
"!",
"link",
")",
"insn_entry",
"[",
"INSN_UID",
"(",
"insn",
")",
"]",
".",
"is_live_in",
"=",
"1",
";",
"while",
"(",
"link",
")",
"{",
"if",
"(",
"DF_REF_IS_ARTIFICIAL",
"(",
"link",
"->",
"ref",
")",
")",
"insn_entry",
"[",
"INSN_UID",
"(",
"insn",
")",
"]",
".",
"is_live_in",
"=",
"1",
";",
"if",
"(",
"DF_REF_INSN_INFO",
"(",
"link",
"->",
"ref",
")",
")",
"{",
"rtx",
"def_insn",
"=",
"DF_REF_INSN",
"(",
"link",
"->",
"ref",
")",
";",
"(",
"void",
")",
"unionfind_union",
"(",
"insn_entry",
"+",
"INSN_UID",
"(",
"insn",
")",
",",
"insn_entry",
"+",
"INSN_UID",
"(",
"def_insn",
")",
")",
";",
"}",
"link",
"=",
"link",
"->",
"next",
";",
"}",
"}",
"</s>"
] | [
"Union",
"INSN",
"with",
"all",
"insns",
"containing",
"definitions",
"that",
"reach",
"USE",
".",
"Detect",
"whether",
"USE",
"is",
"live-in",
"to",
"the",
"current",
"function",
"."
] | [
"rs6000",
"1",
"1"
] | rs6000-p8swap | union_defs | rs6000 | CPU | GCC | 3,127 | 117 | 1 | [] |
[
"<s>",
"SDValue",
"RISCVTargetLowering",
"::",
"LowerReturn",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"const",
"SDLoc",
"&",
"DL",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"IsVarArg",
")",
"{",
"report_fatal_error",
"(",
"\"VarArg not supported\"",
")",
";",
"}",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"analyzeOutputArgs",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"CCInfo",
",",
"Outs",
",",
"true",
")",
";",
"SDValue",
"Flag",
";",
"SmallVector",
"<",
"SDValue",
",",
"4",
">",
"RetOps",
"(",
"1",
",",
"Chain",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"RVLocs",
".",
"size",
"(",
")",
";",
"i",
"<",
"e",
";",
"++",
"i",
")",
"{",
"SDValue",
"Val",
"=",
"OutVals",
"[",
"i",
"]",
";",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"\"Can only return in registers!\"",
")",
";",
"assert",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"Full",
"&&",
"\"Unexpected CCValAssign::LocInfo\"",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"DL",
",",
"VA",
".",
"getLocReg",
"(",
")",
",",
"Val",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"VA",
".",
"getLocReg",
"(",
")",
",",
"VA",
".",
"getLocVT",
"(",
")",
")",
")",
";",
"}",
"RetOps",
"[",
"0",
"]",
"=",
"Chain",
";",
"if",
"(",
"Flag",
".",
"getNode",
"(",
")",
")",
"{",
"RetOps",
".",
"push_back",
"(",
"Flag",
")",
";",
"}",
"return",
"DAG",
".",
"getNode",
"(",
"RISCVISD",
"::",
"RET_FLAG",
",",
"DL",
",",
"MVT",
"::",
"Other",
",",
"RetOps",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"outgoing",
"return",
"values",
",",
"described",
"by",
"the",
"Outs",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] | [
"RISCV",
"RISCV",
"ISD::OutputArg",
"\"VarArg not supported\"",
"16",
"4",
"1",
"0",
"\"Can only return in registers!\"",
"\"Unexpected CCValAssign::LocInfo\"",
"1",
"0",
"RISCVISD::RET_FLAG",
"MVT::Other"
] | RISCVISelLowering55 | LowerReturn | RISCV | CPU | LLVM | 3,128 | 280 | 1 | [] |
[
"<s>",
"bool",
"SystemZMCAsmBackend",
"::",
"shouldForceRelocation",
"(",
"const",
"MCAssembler",
"&",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
")",
"{",
"return",
"Fixup",
".",
"getKind",
"(",
")",
">=",
"FirstLiteralRelocationKind",
";",
"}",
"</s>"
] | [
"Hook",
"to",
"check",
"if",
"a",
"relocation",
"is",
"needed",
"for",
"some",
"target",
"specific",
"reason",
"."
] | [
"SystemZ",
"SystemZ"
] | SystemZMCAsmBackend10 | shouldForceRelocation | SystemZ | CPU | LLVM | 3,129 | 29 | 1 | [] |
[
"<s>",
"BTFTypeStruct",
"::",
"BTFTypeStruct",
"(",
"const",
"DICompositeType",
"*",
"STy",
",",
"bool",
"IsStruct",
",",
"bool",
"HasBitField",
",",
"uint32_t",
"Vlen",
")",
":",
"STy",
"(",
"STy",
")",
",",
"HasBitField",
"(",
"HasBitField",
")",
"{",
"Kind",
"=",
"IsStruct",
"?",
"BTF",
"::",
"BTF_KIND_STRUCT",
":",
"BTF",
"::",
"BTF_KIND_UNION",
";",
"BTFType",
".",
"Size",
"=",
"roundupToBytes",
"(",
"STy",
"->",
"getSizeInBits",
"(",
")",
")",
";",
"BTFType",
".",
"Info",
"=",
"(",
"HasBitField",
"<<",
"31",
")",
"|",
"(",
"Kind",
"<<",
"24",
")",
"|",
"Vlen",
";",
"}",
"</s>"
] | [
"Represent",
"either",
"a",
"struct",
"or",
"a",
"union",
"."
] | [
"BPF",
"BTF::BTF_KIND_STRUCT",
"BTF::BTF_KIND_UNION",
"31",
"24"
] | BTFDebug (2) | BTFTypeStruct | BPF | Virtual ISA | LLVM | 3,130 | 73 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"long",
"arm_compute_save_reg0_reg12_mask",
"(",
")",
"{",
"unsigned",
"long",
"func_type",
"=",
"arm_current_func_type",
"(",
")",
";",
"unsigned",
"int",
"save_reg_mask",
"=",
"0",
";",
"unsigned",
"int",
"reg",
";",
"if",
"(",
"IS_INTERRUPT",
"(",
"func_type",
")",
")",
"{",
"unsigned",
"int",
"max_reg",
";",
"if",
"(",
"ARM_FUNC_TYPE",
"(",
"func_type",
")",
"==",
"ARM_FT_FIQ",
")",
"max_reg",
"=",
"7",
";",
"else",
"max_reg",
"=",
"12",
";",
"for",
"(",
"reg",
"=",
"0",
";",
"reg",
"<=",
"max_reg",
";",
"reg",
"++",
")",
"if",
"(",
"regs_ever_live",
"[",
"reg",
"]",
"||",
"(",
"!",
"current_function_is_leaf",
"&&",
"call_used_regs",
"[",
"reg",
"]",
")",
")",
"save_reg_mask",
"|=",
"(",
"1",
"<<",
"reg",
")",
";",
"}",
"else",
"{",
"for",
"(",
"reg",
"=",
"0",
";",
"reg",
"<=",
"10",
";",
"reg",
"++",
")",
"if",
"(",
"regs_ever_live",
"[",
"reg",
"]",
"&&",
"!",
"call_used_regs",
"[",
"reg",
"]",
")",
"save_reg_mask",
"|=",
"(",
"1",
"<<",
"reg",
")",
";",
"if",
"(",
"!",
"TARGET_APCS_FRAME",
"&&",
"!",
"frame_pointer_needed",
"&&",
"regs_ever_live",
"[",
"HARD_FRAME_POINTER_REGNUM",
"]",
"&&",
"!",
"call_used_regs",
"[",
"HARD_FRAME_POINTER_REGNUM",
"]",
")",
"save_reg_mask",
"|=",
"1",
"<<",
"HARD_FRAME_POINTER_REGNUM",
";",
"if",
"(",
"flag_pic",
"&&",
"!",
"TARGET_SINGLE_PIC_BASE",
"&&",
"regs_ever_live",
"[",
"PIC_OFFSET_TABLE_REGNUM",
"]",
")",
"save_reg_mask",
"|=",
"1",
"<<",
"PIC_OFFSET_TABLE_REGNUM",
";",
"}",
"return",
"save_reg_mask",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"register",
"save",
"mask",
"for",
"registers",
"0",
"through",
"12",
"inclusive",
".",
"This",
"code",
"is",
"used",
"by",
"arm_compute_save_reg_mask",
"."
] | [
"arm",
"0",
"7",
"12",
"0",
"1",
"0",
"10",
"1",
"1",
"1"
] | arm2 | arm_compute_save_reg0_reg12_mask | arm | CPU | GCC | 3,131 | 178 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_elf_asm_init_sections",
"(",
"void",
")",
"{",
"toc_section",
"=",
"get_unnamed_section",
"(",
"0",
",",
"rs6000_elf_output_toc_section_asm_op",
",",
"NULL",
")",
";",
"sdata2_section",
"=",
"get_unnamed_section",
"(",
"SECTION_WRITE",
",",
"output_section_asm_op",
",",
"SDATA2_SECTION_ASM_OP",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ASM_INIT_SECTIONS",
"."
] | [
"powerpcspe",
"0"
] | powerpcspe | rs6000_elf_asm_init_sections | powerpcspe | CPU | GCC | 3,132 | 30 | 1 | [] |
[
"<s>",
"static",
"inline",
"void",
"aarch64_sub_sp",
"(",
"int",
"scratchreg",
",",
"HOST_WIDE_INT",
"delta",
",",
"bool",
"frame_related_p",
")",
"{",
"aarch64_add_constant_internal",
"(",
"Pmode",
",",
"SP_REGNUM",
",",
"scratchreg",
",",
"-",
"delta",
",",
"frame_related_p",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"Subtract",
"DELTA",
"from",
"the",
"stack",
"pointer",
",",
"marking",
"the",
"instructions",
"frame-related",
"if",
"FRAME_RELATED_P",
".",
"TEMP1",
"is",
"available",
"as",
"a",
"temporary",
"if",
"nonnull",
"."
] | [
"aarch64"
] | aarch644 | aarch64_sub_sp | aarch64 | CPU | GCC | 3,133 | 32 | 1 | [] |
[
"<s>",
"bool",
"ARM64RegisterInfo",
"::",
"useFPForScavengingIndex",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"return",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
"&&",
"!",
"hasBasePointer",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"wants",
"to",
"use",
"frame",
"pointer",
"based",
"accesses",
"to",
"spill",
"to",
"the",
"scavenger",
"emergency",
"spill",
"slot",
"."
] | [
"ARM64",
"ARM64"
] | ARM64RegisterInfo | useFPForScavengingIndex | ARM64 | CPU | LLVM | 3,134 | 37 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"X86 WinAlloca Expander\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"X86",
"\"X86 WinAlloca Expander\""
] | X86WinAllocaExpander | getPassName | X86 | CPU | LLVM | 3,135 | 11 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"csky_mangle_type",
"(",
"const_tree",
"type",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"REAL_TYPE",
"&&",
"TYPE_PRECISION",
"(",
"type",
")",
"==",
"16",
"&&",
"TYPE_MAIN_VARIANT",
"(",
"type",
")",
"!=",
"float16_type_node",
")",
"return",
"\"Dh\"",
";",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_MANGLE_TYPE",
"."
] | [
"csky",
"16",
"\"Dh\""
] | csky1 | csky_mangle_type | csky | CPU | GCC | 3,136 | 40 | 1 | [] |
[
"<s>",
"void",
"NVPTXAsmPrinter",
"::",
"emitImplicitDef",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"unsigned",
"RegNo",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"TM",
".",
"getRegisterInfo",
"(",
")",
";",
"if",
"(",
"TRI",
"->",
"isVirtualRegister",
"(",
"RegNo",
")",
")",
"{",
"OutStreamer",
".",
"AddComment",
"(",
"Twine",
"(",
"\"implicit-def: \"",
")",
"+",
"getVirtualRegisterName",
"(",
"RegNo",
")",
")",
";",
"}",
"else",
"{",
"OutStreamer",
".",
"AddComment",
"(",
"Twine",
"(",
"\"implicit-def: \"",
")",
"+",
"TM",
".",
"getRegisterInfo",
"(",
")",
"->",
"getName",
"(",
"RegNo",
")",
")",
";",
"}",
"OutStreamer",
".",
"AddBlankLine",
"(",
")",
";",
"}",
"</s>"
] | [
"Targets",
"can",
"override",
"this",
"to",
"customize",
"the",
"output",
"of",
"IMPLICIT_DEF",
"instructions",
"in",
"verbose",
"mode",
"."
] | [
"NVPTX",
"NVPTX",
"0",
"\"implicit-def: \"",
"\"implicit-def: \""
] | NVPTXAsmPrinter1 | emitImplicitDef | NVPTX | GPU | LLVM | 3,137 | 94 | 1 | [] |
[
"<s>",
"void",
"X86AsmPrinter",
"::",
"emitStartOfAsmFile",
"(",
"Module",
"&",
"M",
")",
"{",
"const",
"Triple",
"&",
"TT",
"=",
"TM",
".",
"getTargetTriple",
"(",
")",
";",
"if",
"(",
"TT",
".",
"isOSBinFormatELF",
"(",
")",
")",
"{",
"unsigned",
"FeatureFlagsAnd",
"=",
"0",
";",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cf-protection-branch\"",
")",
")",
"FeatureFlagsAnd",
"|=",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_IBT",
";",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cf-protection-return\"",
")",
")",
"FeatureFlagsAnd",
"|=",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_SHSTK",
";",
"if",
"(",
"FeatureFlagsAnd",
")",
"{",
"if",
"(",
"!",
"TT",
".",
"isArch32Bit",
"(",
")",
"&&",
"!",
"TT",
".",
"isArch64Bit",
"(",
")",
")",
"llvm_unreachable",
"(",
"\"CFProtection used on invalid architecture!\"",
")",
";",
"MCSection",
"*",
"Cur",
"=",
"OutStreamer",
"->",
"getCurrentSectionOnly",
"(",
")",
";",
"MCSection",
"*",
"Nt",
"=",
"MMI",
"->",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"\".note.gnu.property\"",
",",
"ELF",
"::",
"SHT_NOTE",
",",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"OutStreamer",
"->",
"SwitchSection",
"(",
"Nt",
")",
";",
"const",
"int",
"WordSize",
"=",
"TT",
".",
"isArch64Bit",
"(",
")",
"&&",
"!",
"TT",
".",
"isX32",
"(",
")",
"?",
"8",
":",
"4",
";",
"emitAlignment",
"(",
"WordSize",
"==",
"4",
"?",
"Align",
"(",
"4",
")",
":",
"Align",
"(",
"8",
")",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"4",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"8",
"+",
"WordSize",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitIntValue",
"(",
"ELF",
"::",
"NT_GNU_PROPERTY_TYPE_0",
",",
"4",
")",
";",
"OutStreamer",
"->",
"emitBytes",
"(",
"StringRef",
"(",
"\"GNU\"",
",",
"4",
")",
")",
";",
"OutStreamer",
"->",
"emitInt32",
"(",
"ELF",
"::",
"GNU_PROPERTY_X86_FEATURE_1_AND",
")",
";",
"OutStreamer",
"->",
"emitInt32",
"(",
"4",
")",
";",
"OutStreamer",
"->",
"emitInt32",
"(",
"FeatureFlagsAnd",
")",
";",
"emitAlignment",
"(",
"WordSize",
"==",
"4",
"?",
"Align",
"(",
"4",
")",
":",
"Align",
"(",
"8",
")",
")",
";",
"OutStreamer",
"->",
"endSection",
"(",
"Nt",
")",
";",
"OutStreamer",
"->",
"SwitchSection",
"(",
"Cur",
")",
";",
"}",
"}",
"if",
"(",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
")",
"OutStreamer",
"->",
"SwitchSection",
"(",
"getObjFileLowering",
"(",
")",
".",
"getTextSection",
"(",
")",
")",
";",
"if",
"(",
"TT",
".",
"isOSBinFormatCOFF",
"(",
")",
")",
"{",
"MCSymbol",
"*",
"S",
"=",
"MMI",
"->",
"getContext",
"(",
")",
".",
"getOrCreateSymbol",
"(",
"StringRef",
"(",
"\"@feat.00\"",
")",
")",
";",
"OutStreamer",
"->",
"BeginCOFFSymbolDef",
"(",
"S",
")",
";",
"OutStreamer",
"->",
"emitCOFFSymbolStorageClass",
"(",
"COFF",
"::",
"IMAGE_SYM_CLASS_STATIC",
")",
";",
"OutStreamer",
"->",
"emitCOFFSymbolType",
"(",
"COFF",
"::",
"IMAGE_SYM_DTYPE_NULL",
")",
";",
"OutStreamer",
"->",
"EndCOFFSymbolDef",
"(",
")",
";",
"int64_t",
"Feat00Flags",
"=",
"0",
";",
"if",
"(",
"TT",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86",
")",
"{",
"Feat00Flags",
"|=",
"1",
";",
"}",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"cfguard\"",
")",
")",
"{",
"Feat00Flags",
"|=",
"0x800",
";",
"}",
"if",
"(",
"M",
".",
"getModuleFlag",
"(",
"\"ehcontguard\"",
")",
")",
"{",
"Feat00Flags",
"|=",
"0x4000",
";",
"}",
"OutStreamer",
"->",
"emitSymbolAttribute",
"(",
"S",
",",
"MCSA_Global",
")",
";",
"OutStreamer",
"->",
"emitAssignment",
"(",
"S",
",",
"MCConstantExpr",
"::",
"create",
"(",
"Feat00Flags",
",",
"MMI",
"->",
"getContext",
"(",
")",
")",
")",
";",
"}",
"OutStreamer",
"->",
"emitSyntaxDirective",
"(",
")",
";",
"bool",
"is16",
"=",
"TT",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"CODE16",
";",
"if",
"(",
"M",
".",
"getModuleInlineAsm",
"(",
")",
".",
"empty",
"(",
")",
"&&",
"is16",
")",
"OutStreamer",
"->",
"emitAssemblerFlag",
"(",
"MCAF_Code16",
")",
";",
"}",
"</s>"
] | [
"This",
"virtual",
"method",
"can",
"be",
"overridden",
"by",
"targets",
"that",
"want",
"to",
"emit",
"something",
"at",
"the",
"start",
"of",
"their",
"file",
"."
] | [
"X86",
"X86",
"0",
"\"cf-protection-branch\"",
"X86",
"\"cf-protection-return\"",
"X86",
"\"CFProtection used on invalid architecture!\"",
"\".note.gnu.property\"",
"8",
"4",
"4",
"4",
"8",
"4",
"4",
"8",
"4",
"4",
"\"GNU\"",
"4",
"X86",
"4",
"4",
"4",
"8",
"\"@feat.00\"",
"0",
"1",
"\"cfguard\"",
"0x800",
"\"ehcontguard\"",
"0x4000"
] | X86AsmPrinter50 | emitStartOfAsmFile | X86 | CPU | LLVM | 3,138 | 471 | 1 | [] |
[
"<s>",
"unsigned",
"TeeRISCInstrInfo",
"::",
"getGlobalBaseReg",
"(",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"TeeRISCMachineFunctionInfo",
"*",
"TeeRISCFI",
"=",
"MF",
"->",
"getInfo",
"<",
"TeeRISCMachineFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"GlobalBaseReg",
"=",
"TeeRISCFI",
"->",
"getGlobalBaseReg",
"(",
")",
";",
"if",
"(",
"GlobalBaseReg",
"!=",
"0",
")",
"return",
"GlobalBaseReg",
";",
"MachineBasicBlock",
"&",
"FirstMBB",
"=",
"MF",
"->",
"front",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"FirstMBB",
".",
"begin",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"RegInfo",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"GlobalBaseReg",
"=",
"RegInfo",
".",
"createVirtualRegister",
"(",
"&",
"TeeRISC",
"::",
"IntRegsRegClass",
")",
";",
"DebugLoc",
"dl",
";",
"BuildMI",
"(",
"FirstMBB",
",",
"MBBI",
",",
"dl",
",",
"get",
"(",
"TeeRISC",
"::",
"ADD",
")",
",",
"GlobalBaseReg",
")",
".",
"addReg",
"(",
"TeeRISC",
"::",
"R10",
")",
";",
"RegInfo",
".",
"addLiveIn",
"(",
"TeeRISC",
"::",
"R10",
")",
";",
"TeeRISCFI",
"->",
"setGlobalBaseReg",
"(",
"GlobalBaseReg",
")",
";",
"return",
"GlobalBaseReg",
";",
"}",
"</s>"
] | [
"getGlobalBaseReg",
"-",
"Return",
"a",
"virtual",
"register",
"initialized",
"with",
"the",
"the",
"global",
"base",
"register",
"value",
"."
] | [
"TeeRISC",
"TeeRISC",
"TeeRISC",
"TeeRISC",
"TeeRISC",
"TeeRISC",
"0",
"TeeRISC::IntRegsRegClass",
"TeeRISC::ADD",
"TeeRISC::R10",
"TeeRISC::R10",
"TeeRISC"
] | TeeRISCInstrInfo | getGlobalBaseReg | TeeRISC | CPU | LLVM | 3,139 | 133 | 1 | [] |
[
"<s>",
"void",
"HexagonFrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"auto",
"&",
"HST",
"=",
"MF",
".",
"getSubtarget",
"<",
"HexagonSubtarget",
">",
"(",
")",
";",
"auto",
"&",
"HRI",
"=",
"*",
"HST",
".",
"getRegisterInfo",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
"=",
"MFI",
".",
"getCalleeSavedInfo",
"(",
")",
";",
"MachineBasicBlock",
"*",
"PrologB",
"=",
"&",
"MF",
".",
"front",
"(",
")",
",",
"*",
"EpilogB",
"=",
"nullptr",
";",
"if",
"(",
"EnableShrinkWrapping",
")",
"findShrunkPrologEpilog",
"(",
"MF",
",",
"PrologB",
",",
"EpilogB",
")",
";",
"bool",
"PrologueStubs",
"=",
"false",
";",
"insertCSRSpillsInBlock",
"(",
"*",
"PrologB",
",",
"CSI",
",",
"HRI",
",",
"PrologueStubs",
")",
";",
"insertPrologueInBlock",
"(",
"*",
"PrologB",
",",
"PrologueStubs",
")",
";",
"updateEntryPaths",
"(",
"MF",
",",
"*",
"PrologB",
")",
";",
"if",
"(",
"EpilogB",
")",
"{",
"insertCSRRestoresInBlock",
"(",
"*",
"EpilogB",
",",
"CSI",
",",
"HRI",
")",
";",
"insertEpilogueInBlock",
"(",
"*",
"EpilogB",
")",
";",
"}",
"else",
"{",
"for",
"(",
"auto",
"&",
"B",
":",
"MF",
")",
"if",
"(",
"B",
".",
"isReturnBlock",
"(",
")",
")",
"insertCSRRestoresInBlock",
"(",
"B",
",",
"CSI",
",",
"HRI",
")",
";",
"for",
"(",
"auto",
"&",
"B",
":",
"MF",
")",
"if",
"(",
"B",
".",
"isReturnBlock",
"(",
")",
")",
"insertEpilogueInBlock",
"(",
"B",
")",
";",
"for",
"(",
"auto",
"&",
"B",
":",
"MF",
")",
"{",
"if",
"(",
"B",
".",
"empty",
"(",
")",
")",
"continue",
";",
"MachineInstr",
"*",
"RetI",
"=",
"getReturn",
"(",
"B",
")",
";",
"if",
"(",
"!",
"RetI",
"||",
"isRestoreCall",
"(",
"RetI",
"->",
"getOpcode",
"(",
")",
")",
")",
"continue",
";",
"for",
"(",
"auto",
"&",
"R",
":",
"CSI",
")",
"RetI",
"->",
"addOperand",
"(",
"MachineOperand",
"::",
"CreateReg",
"(",
"R",
".",
"getReg",
"(",
")",
",",
"false",
",",
"true",
")",
")",
";",
"}",
"}",
"if",
"(",
"EpilogB",
")",
"{",
"unsigned",
"MaxBN",
"=",
"MF",
".",
"getNumBlockIDs",
"(",
")",
";",
"BitVector",
"DoneT",
"(",
"MaxBN",
"+",
"1",
")",
",",
"DoneF",
"(",
"MaxBN",
"+",
"1",
")",
",",
"Path",
"(",
"MaxBN",
"+",
"1",
")",
";",
"updateExitPaths",
"(",
"*",
"EpilogB",
",",
"*",
"EpilogB",
",",
"DoneT",
",",
"DoneF",
",",
"Path",
")",
";",
"}",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"1",
"1",
"1"
] | HexagonFrameLowering11 | emitPrologue | Hexagon | DSP | LLVM | 3,140 | 324 | 1 | [] |
[
"<s>",
"void",
"MSP430InstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"printInstruction",
"(",
"MI",
",",
"O",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"MSP430",
"MSP430"
] | MSP430InstPrinter16 | printInst | MSP430 | MPU | LLVM | 3,141 | 23 | 1 | [] |
[
"<s>",
"rtx",
"nds32_legitimize_ict_address",
"(",
"rtx",
"x",
")",
"{",
"rtx",
"symbol",
"=",
"x",
";",
"rtx",
"addr",
"=",
"x",
";",
"rtx",
"reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SYMBOL_REF",
"&&",
"nds32_indirect_call_referenced_p",
"(",
"x",
")",
")",
";",
"addr",
"=",
"gen_rtx_UNSPEC",
"(",
"SImode",
",",
"gen_rtvec",
"(",
"1",
",",
"symbol",
")",
",",
"UNSPEC_ICT",
")",
";",
"addr",
"=",
"gen_rtx_CONST",
"(",
"SImode",
",",
"addr",
")",
";",
"emit_insn",
"(",
"gen_sethi",
"(",
"reg",
",",
"addr",
")",
")",
";",
"x",
"=",
"gen_const_mem",
"(",
"SImode",
",",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"reg",
",",
"addr",
")",
")",
";",
"return",
"x",
";",
"}",
"</s>"
] | [
"Expand",
"ICT",
"symbol",
".",
"Example",
"for",
"@",
"ICT",
"and",
"ICT",
"model=large",
":",
"la",
"$",
"r0",
",",
"symbol",
"@",
"ICT",
"-",
">",
"sethi",
"$",
"rt",
",",
"hi20",
"(",
"symbol",
"@",
"ICT",
")",
"lwi",
"$",
"r0",
",",
"[",
"$",
"rt",
"+",
"lo12",
"(",
"symbol",
"@",
"ICT",
")",
"]"
] | [
"nds32",
"1"
] | nds32-md-auxiliary | nds32_legitimize_ict_address | nds32 | CPU | GCC | 3,142 | 95 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"areMemAccessesTriviallyDisjoint",
"(",
"MachineInstr",
"&",
"MIa",
",",
"MachineInstr",
"&",
"MIb",
",",
"AliasAnalysis",
"*",
"AA",
")",
"const",
"{",
"assert",
"(",
"(",
"MIa",
".",
"mayLoad",
"(",
")",
"||",
"MIa",
".",
"mayStore",
"(",
")",
")",
"&&",
"\"MIa must load from or modify a memory location\"",
")",
";",
"assert",
"(",
"(",
"MIb",
".",
"mayLoad",
"(",
")",
"||",
"MIb",
".",
"mayStore",
"(",
")",
")",
"&&",
"\"MIb must load from or modify a memory location\"",
")",
";",
"if",
"(",
"MIa",
".",
"hasUnmodeledSideEffects",
"(",
")",
"||",
"MIb",
".",
"hasUnmodeledSideEffects",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"MIa",
".",
"hasOrderedMemoryRef",
"(",
")",
"||",
"MIb",
".",
"hasOrderedMemoryRef",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"AA",
"&&",
"MIa",
".",
"hasOneMemOperand",
"(",
")",
"&&",
"MIb",
".",
"hasOneMemOperand",
"(",
")",
")",
"{",
"const",
"MachineMemOperand",
"*",
"MMOa",
"=",
"*",
"MIa",
".",
"memoperands_begin",
"(",
")",
";",
"const",
"MachineMemOperand",
"*",
"MMOb",
"=",
"*",
"MIb",
".",
"memoperands_begin",
"(",
")",
";",
"if",
"(",
"MMOa",
"->",
"getValue",
"(",
")",
"&&",
"MMOb",
"->",
"getValue",
"(",
")",
")",
"{",
"MemoryLocation",
"LocA",
"(",
"MMOa",
"->",
"getValue",
"(",
")",
",",
"MMOa",
"->",
"getSize",
"(",
")",
",",
"MMOa",
"->",
"getAAInfo",
"(",
")",
")",
";",
"MemoryLocation",
"LocB",
"(",
"MMOb",
"->",
"getValue",
"(",
")",
",",
"MMOb",
"->",
"getSize",
"(",
")",
",",
"MMOb",
"->",
"getAAInfo",
"(",
")",
")",
";",
"if",
"(",
"!",
"AA",
"->",
"alias",
"(",
"LocA",
",",
"LocB",
")",
")",
"return",
"true",
";",
"}",
"}",
"if",
"(",
"isDS",
"(",
"MIa",
")",
")",
"{",
"if",
"(",
"isDS",
"(",
"MIb",
")",
")",
"return",
"checkInstOffsetsDoNotOverlap",
"(",
"MIa",
",",
"MIb",
")",
";",
"return",
"!",
"isFLAT",
"(",
"MIb",
")",
"||",
"isSegmentSpecificFLAT",
"(",
"MIb",
")",
";",
"}",
"if",
"(",
"isMUBUF",
"(",
"MIa",
")",
"||",
"isMTBUF",
"(",
"MIa",
")",
")",
"{",
"if",
"(",
"isMUBUF",
"(",
"MIb",
")",
"||",
"isMTBUF",
"(",
"MIb",
")",
")",
"return",
"checkInstOffsetsDoNotOverlap",
"(",
"MIa",
",",
"MIb",
")",
";",
"return",
"!",
"isFLAT",
"(",
"MIb",
")",
"&&",
"!",
"isSMRD",
"(",
"MIb",
")",
";",
"}",
"if",
"(",
"isSMRD",
"(",
"MIa",
")",
")",
"{",
"if",
"(",
"isSMRD",
"(",
"MIb",
")",
")",
"return",
"checkInstOffsetsDoNotOverlap",
"(",
"MIa",
",",
"MIb",
")",
";",
"return",
"!",
"isFLAT",
"(",
"MIb",
")",
"&&",
"!",
"isMUBUF",
"(",
"MIa",
")",
"&&",
"!",
"isMTBUF",
"(",
"MIa",
")",
";",
"}",
"if",
"(",
"isFLAT",
"(",
"MIa",
")",
")",
"{",
"if",
"(",
"isFLAT",
"(",
"MIb",
")",
")",
"return",
"checkInstOffsetsDoNotOverlap",
"(",
"MIa",
",",
"MIb",
")",
";",
"return",
"false",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Sometimes",
",",
"it",
"is",
"possible",
"for",
"the",
"target",
"to",
"tell",
",",
"even",
"without",
"aliasing",
"information",
",",
"that",
"two",
"MIs",
"access",
"different",
"memory",
"addresses",
"."
] | [
"AMDGPU",
"SI",
"\"MIa must load from or modify a memory location\"",
"\"MIb must load from or modify a memory location\""
] | SIInstrInfo (2) | areMemAccessesTriviallyDisjoint | AMDGPU | GPU | LLVM | 3,143 | 365 | 1 | [] |
[
"<s>",
"bool",
"fixupNeedsRelaxation",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"uint64_t",
"Value",
",",
"const",
"MCRelaxableFragment",
"*",
"DF",
",",
"const",
"MCAsmLayout",
"&",
"Layout",
")",
"const",
"override",
"{",
"assert",
"(",
"0",
"&&",
"\"RelaxInstruction() unimplemented\"",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Simple",
"predicate",
"for",
"targets",
"where",
"!",
"Resolved",
"implies",
"requiring",
"relaxation",
"."
] | [
"Mips",
"0",
"\"RelaxInstruction() unimplemented\""
] | MipsAsmBackend24 | fixupNeedsRelaxation | Mips | CPU | LLVM | 3,144 | 35 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_function_value_regno_p",
"(",
"const",
"unsigned",
"int",
"regno",
")",
"{",
"switch",
"(",
"regno",
")",
"{",
"case",
"AX_REG",
":",
"return",
"true",
";",
"case",
"DX_REG",
":",
"return",
"(",
"!",
"TARGET_64BIT",
"||",
"ix86_abi",
"!=",
"MS_ABI",
")",
";",
"case",
"DI_REG",
":",
"case",
"SI_REG",
":",
"return",
"TARGET_64BIT",
"&&",
"ix86_abi",
"!=",
"MS_ABI",
";",
"case",
"FIRST_BND_REG",
":",
"return",
"chkp_function_instrumented_p",
"(",
"current_function_decl",
")",
";",
"case",
"ST0_REG",
":",
"case",
"ST1_REG",
":",
"if",
"(",
"TARGET_64BIT",
"&&",
"ix86_abi",
"==",
"MS_ABI",
")",
"return",
"false",
";",
"return",
"TARGET_FLOAT_RETURNS_IN_80387",
";",
"case",
"XMM0_REG",
":",
"case",
"XMM1_REG",
":",
"return",
"TARGET_SSE",
";",
"case",
"MM0_REG",
":",
"if",
"(",
"TARGET_MACHO",
"||",
"TARGET_64BIT",
")",
"return",
"false",
";",
"return",
"TARGET_MMX",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"N",
"is",
"a",
"possible",
"register",
"number",
"of",
"function",
"value",
"."
] | [
"i386"
] | i3864 | ix86_function_value_regno_p | i386 | CPU | GCC | 3,145 | 105 | 1 | [] |
[
"<s>",
"Register",
"getExceptionPointerRegister",
"(",
"const",
"Constant",
"*",
"PersonalityFn",
")",
"const",
"override",
"{",
"return",
"AArch64",
"::",
"X0",
";",
"}",
"</s>"
] | [
"If",
"a",
"physical",
"register",
",",
"this",
"returns",
"the",
"register",
"that",
"receives",
"the",
"exception",
"address",
"on",
"entry",
"to",
"an",
"EH",
"pad",
"."
] | [
"AArch64",
"AArch64::X0"
] | AArch64ISelLowering (2)1 | getExceptionPointerRegister | AArch64 | CPU | LLVM | 3,146 | 17 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"h8300_asm_insn_count",
"(",
"const",
"char",
"*",
"templ",
")",
"{",
"unsigned",
"int",
"count",
"=",
"1",
";",
"for",
"(",
";",
"*",
"templ",
";",
"templ",
"++",
")",
"if",
"(",
"*",
"templ",
"==",
"'\\n'",
")",
"count",
"++",
";",
"return",
"count",
";",
"}",
"</s>"
] | [
"Count",
"the",
"number",
"of",
"assembly",
"instructions",
"in",
"a",
"string",
"TEMPLATE",
"."
] | [
"h8300",
"1"
] | h8300 | h8300_asm_insn_count | h8300 | MPU | GCC | 3,147 | 40 | 1 | [] |
[
"<s>",
"bool",
"X86AvoidTrailingCallPass",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"X86Subtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"const",
"X86InstrInfo",
"&",
"TII",
"=",
"*",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"assert",
"(",
"STI",
".",
"isTargetWin64",
"(",
")",
"&&",
"\"pass only runs on Win64\"",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"{",
"MachineBasicBlock",
"*",
"NextMBB",
"=",
"MBB",
".",
"getNextNode",
"(",
")",
";",
"if",
"(",
"NextMBB",
"&&",
"!",
"NextMBB",
"->",
"isEHFuncletEntry",
"(",
")",
")",
"continue",
";",
"MachineBasicBlock",
"::",
"reverse_iterator",
"LastRealInstr",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"RMBB",
":",
"make_range",
"(",
"MBB",
".",
"getReverseIterator",
"(",
")",
",",
"MF",
".",
"rend",
"(",
")",
")",
")",
"{",
"LastRealInstr",
"=",
"llvm",
"::",
"find_if",
"(",
"reverse",
"(",
"RMBB",
")",
",",
"isRealInstruction",
")",
";",
"if",
"(",
"LastRealInstr",
"!=",
"RMBB",
".",
"rend",
"(",
")",
")",
"break",
";",
"}",
"if",
"(",
"LastRealInstr",
"==",
"MF",
".",
"begin",
"(",
")",
"->",
"rend",
"(",
")",
")",
"continue",
";",
"if",
"(",
"isCallInstruction",
"(",
"*",
"LastRealInstr",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"{",
"dbgs",
"(",
")",
"<<",
"\"inserting int3 after trailing call instruction:\\n\"",
";",
"LastRealInstr",
"->",
"dump",
"(",
")",
";",
"dbgs",
"(",
")",
"<<",
"'\\n'",
";",
"}",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"std",
"::",
"next",
"(",
"LastRealInstr",
".",
"getReverse",
"(",
")",
")",
";",
"BuildMI",
"(",
"*",
"LastRealInstr",
"->",
"getParent",
"(",
")",
",",
"MBBI",
",",
"LastRealInstr",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"X86",
"::",
"INT3",
")",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"\"pass only runs on Win64\"",
"\"inserting int3 after trailing call instruction:\\n\"",
"X86::INT3"
] | X86AvoidTrailingCall3 | runOnMachineFunction | X86 | CPU | LLVM | 3,148 | 236 | 1 | [] |
[
"<s>",
"static",
"void",
"nds32_conditional_register_usage",
"(",
"void",
")",
"{",
"int",
"regno",
";",
"if",
"(",
"TARGET_HARD_FLOAT",
")",
"{",
"for",
"(",
"regno",
"=",
"NDS32_FIRST_FPR_REGNUM",
";",
"regno",
"<=",
"NDS32_LAST_FPR_REGNUM",
";",
"regno",
"++",
")",
"{",
"fixed_regs",
"[",
"regno",
"]",
"=",
"0",
";",
"if",
"(",
"regno",
"<",
"NDS32_FIRST_FPR_REGNUM",
"+",
"NDS32_MAX_FPR_REGS_FOR_ARGS",
")",
"call_used_regs",
"[",
"regno",
"]",
"=",
"1",
";",
"else",
"if",
"(",
"regno",
">=",
"NDS32_FIRST_FPR_REGNUM",
"+",
"22",
"&&",
"regno",
"<",
"NDS32_FIRST_FPR_REGNUM",
"+",
"48",
")",
"call_used_regs",
"[",
"regno",
"]",
"=",
"1",
";",
"else",
"call_used_regs",
"[",
"regno",
"]",
"=",
"0",
";",
"}",
"}",
"else",
"if",
"(",
"TARGET_FPU_SINGLE",
"||",
"TARGET_FPU_DOUBLE",
")",
"{",
"for",
"(",
"regno",
"=",
"NDS32_FIRST_FPR_REGNUM",
";",
"regno",
"<=",
"NDS32_LAST_FPR_REGNUM",
";",
"regno",
"++",
")",
"fixed_regs",
"[",
"regno",
"]",
"=",
"0",
";",
"}",
"}",
"</s>"
] | [
"Register",
"Usage",
"."
] | [
"nds32",
"0",
"1",
"22",
"48",
"1",
"0",
"0"
] | nds325 | nds32_conditional_register_usage | nds32 | CPU | GCC | 3,149 | 113 | 1 | [] |
[
"<s>",
"TargetIRAnalysis",
"X86TargetMachine",
"::",
"getTargetIRAnalysis",
"(",
")",
"{",
"return",
"TargetIRAnalysis",
"(",
"[",
"this",
"]",
"(",
"Function",
"&",
"F",
")",
"{",
"return",
"TargetTransformInfo",
"(",
"X86TTIImpl",
"(",
"this",
",",
"F",
")",
")",
";",
"}",
")",
";",
"}",
"</s>"
] | [
"Get",
"a",
"TargetIRAnalysis",
"appropriate",
"for",
"the",
"target",
"."
] | [
"X86",
"X86",
"X86"
] | X86TargetMachine110 | getTargetIRAnalysis | X86 | CPU | LLVM | 3,150 | 34 | 1 | [] |
[
"<s>",
"bool",
"builtin_hasher",
"::",
"equal",
"(",
"builtin_hash_struct",
"*",
"p1",
",",
"builtin_hash_struct",
"*",
"p2",
")",
"{",
"return",
"(",
"(",
"p1",
"->",
"mode",
"[",
"0",
"]",
"==",
"p2",
"->",
"mode",
"[",
"0",
"]",
")",
"&&",
"(",
"p1",
"->",
"mode",
"[",
"1",
"]",
"==",
"p2",
"->",
"mode",
"[",
"1",
"]",
")",
"&&",
"(",
"p1",
"->",
"mode",
"[",
"2",
"]",
"==",
"p2",
"->",
"mode",
"[",
"2",
"]",
")",
"&&",
"(",
"p1",
"->",
"mode",
"[",
"3",
"]",
"==",
"p2",
"->",
"mode",
"[",
"3",
"]",
")",
"&&",
"(",
"p1",
"->",
"uns_p",
"[",
"0",
"]",
"==",
"p2",
"->",
"uns_p",
"[",
"0",
"]",
")",
"&&",
"(",
"p1",
"->",
"uns_p",
"[",
"1",
"]",
"==",
"p2",
"->",
"uns_p",
"[",
"1",
"]",
")",
"&&",
"(",
"p1",
"->",
"uns_p",
"[",
"2",
"]",
"==",
"p2",
"->",
"uns_p",
"[",
"2",
"]",
")",
"&&",
"(",
"p1",
"->",
"uns_p",
"[",
"3",
"]",
"==",
"p2",
"->",
"uns_p",
"[",
"3",
"]",
")",
")",
";",
"}",
"</s>"
] | [
"Compare",
"H1",
"and",
"H2",
"for",
"equivalence",
"."
] | [
"rs6000",
"0",
"0",
"1",
"1",
"2",
"2",
"3",
"3",
"0",
"0",
"1",
"1",
"2",
"2",
"3",
"3"
] | rs6000-call | equal | rs6000 | CPU | GCC | 3,151 | 146 | 1 | [] |
[
"<s>",
"static",
"bool",
"is_fmul_op",
"(",
"enum",
"attr_type",
"t",
")",
"{",
"return",
"(",
"t",
"==",
"TYPE_FMULS",
")",
"||",
"(",
"t",
"==",
"TYPE_FMULD",
")",
"||",
"(",
"t",
"==",
"TYPE_NEON_FP_MUL_S",
")",
";",
"}",
"</s>"
] | [
"Return",
"whether",
"T",
"is",
"the",
"attribute",
"of",
"a",
"FMUL",
"instruction",
"."
] | [
"aarch64"
] | cortex-a57-fma-steering | is_fmul_op | aarch64 | CPU | GCC | 3,152 | 29 | 1 | [] |
[
"<s>",
"void",
"M68kTargetLowering",
"::",
"LowerAsmOperandForConstraint",
"(",
"SDValue",
"Op",
",",
"std",
"::",
"string",
"&",
"Constraint",
",",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"&",
"Ops",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SDValue",
"Result",
";",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'I'",
":",
"case",
"'J'",
":",
"case",
"'K'",
":",
"case",
"'L'",
":",
"case",
"'M'",
":",
"case",
"'N'",
":",
"case",
"'O'",
":",
"case",
"'P'",
":",
"{",
"auto",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
")",
";",
"if",
"(",
"!",
"C",
")",
"return",
";",
"int64_t",
"Val",
"=",
"C",
"->",
"getSExtValue",
"(",
")",
";",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'I'",
":",
"if",
"(",
"Val",
">",
"0",
"&&",
"Val",
"<=",
"8",
")",
"break",
";",
"return",
";",
"case",
"'J'",
":",
"if",
"(",
"isInt",
"<",
"16",
">",
"(",
"Val",
")",
")",
"break",
";",
"return",
";",
"case",
"'K'",
":",
"if",
"(",
"Val",
"<",
"-",
"0x80",
"||",
"Val",
">=",
"0x80",
")",
"break",
";",
"return",
";",
"case",
"'L'",
":",
"if",
"(",
"Val",
"<",
"0",
"&&",
"Val",
">=",
"-",
"8",
")",
"break",
";",
"return",
";",
"case",
"'M'",
":",
"if",
"(",
"Val",
"<",
"-",
"0x100",
"||",
"Val",
">=",
"0x100",
")",
"break",
";",
"return",
";",
"case",
"'N'",
":",
"if",
"(",
"Val",
">=",
"24",
"&&",
"Val",
"<=",
"31",
")",
"break",
";",
"return",
";",
"case",
"'O'",
":",
"if",
"(",
"Val",
"==",
"16",
")",
"break",
";",
"return",
";",
"case",
"'P'",
":",
"if",
"(",
"Val",
">=",
"8",
"&&",
"Val",
"<=",
"15",
")",
"break",
";",
"return",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"Unhandled constant constraint\"",
")",
";",
"}",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Val",
",",
"SDLoc",
"(",
"Op",
")",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"}",
"default",
":",
"break",
";",
"}",
"}",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"2",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'C'",
":",
"switch",
"(",
"Constraint",
"[",
"1",
"]",
")",
"{",
"case",
"'0'",
":",
"case",
"'i'",
":",
"case",
"'j'",
":",
"{",
"auto",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
")",
";",
"if",
"(",
"!",
"C",
")",
"break",
";",
"int64_t",
"Val",
"=",
"C",
"->",
"getSExtValue",
"(",
")",
";",
"switch",
"(",
"Constraint",
"[",
"1",
"]",
")",
"{",
"case",
"'0'",
":",
"if",
"(",
"!",
"Val",
")",
"break",
";",
"return",
";",
"case",
"'i'",
":",
"break",
";",
"case",
"'j'",
":",
"if",
"(",
"!",
"isInt",
"<",
"16",
">",
"(",
"C",
"->",
"getSExtValue",
"(",
")",
")",
")",
"break",
";",
"return",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"Unhandled constant constraint\"",
")",
";",
"}",
"Result",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"Val",
",",
"SDLoc",
"(",
"Op",
")",
",",
"Op",
".",
"getValueType",
"(",
")",
")",
";",
"break",
";",
"}",
"default",
":",
"break",
";",
"}",
"break",
";",
"default",
":",
"break",
";",
"}",
"}",
"if",
"(",
"Result",
".",
"getNode",
"(",
")",
")",
"{",
"Ops",
".",
"push_back",
"(",
"Result",
")",
";",
"return",
";",
"}",
"TargetLowering",
"::",
"LowerAsmOperandForConstraint",
"(",
"Op",
",",
"Constraint",
",",
"Ops",
",",
"DAG",
")",
";",
"}",
"</s>"
] | [
"Lower",
"the",
"specified",
"operand",
"into",
"the",
"Ops",
"vector",
"."
] | [
"M68k",
"M68k",
"1",
"0",
"0",
"0",
"8",
"16",
"0x80",
"0x80",
"0",
"8",
"0x100",
"0x100",
"24",
"31",
"16",
"8",
"15",
"\"Unhandled constant constraint\"",
"2",
"0",
"1",
"1",
"16",
"\"Unhandled constant constraint\""
] | M68kISelLowering | LowerAsmOperandForConstraint | M68k | MPU | LLVM | 3,153 | 476 | 1 | [] |
[
"<s>",
"AArch64TargetMachine",
"::",
"AArch64TargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"StringRef",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Reloc",
"::",
"Model",
"RM",
",",
"CodeModel",
"::",
"Model",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
",",
"bool",
"LittleEndian",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"RM",
",",
"CM",
",",
"OL",
")",
",",
"TLOF",
"(",
"createTLOF",
"(",
"Triple",
"(",
"getTargetTriple",
"(",
")",
")",
")",
")",
",",
"Subtarget",
"(",
"TT",
",",
"CPU",
",",
"FS",
",",
"*",
"this",
",",
"LittleEndian",
")",
",",
"isLittle",
"(",
"LittleEndian",
")",
"{",
"initAsmInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"Create",
"an",
"AArch64",
"architecture",
"model",
"."
] | [
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine65 | AArch64TargetMachine | AArch64 | CPU | LLVM | 3,154 | 98 | 1 | [] |
[
"<s>",
"rtx_code",
"m68k_output_compare_fp",
"(",
"rtx",
"op0",
",",
"rtx",
"op1",
",",
"rtx_code",
"code",
")",
"{",
"rtx_code",
"tmp",
"=",
"m68k_find_flags_value",
"(",
"op0",
",",
"op1",
",",
"code",
")",
";",
"if",
"(",
"tmp",
"!=",
"UNKNOWN",
")",
"return",
"tmp",
";",
"rtx",
"ops",
"[",
"2",
"]",
";",
"ops",
"[",
"0",
"]",
"=",
"op0",
";",
"ops",
"[",
"1",
"]",
"=",
"op1",
";",
"remember_compare_flags",
"(",
"op0",
",",
"op1",
")",
";",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"op0",
")",
";",
"std",
"::",
"string",
"prec",
"=",
"mode",
"==",
"SFmode",
"?",
"\"s\"",
":",
"mode",
"==",
"DFmode",
"?",
"\"d\"",
":",
"\"x\"",
";",
"if",
"(",
"op1",
"==",
"CONST0_RTX",
"(",
"GET_MODE",
"(",
"op0",
")",
")",
")",
"{",
"if",
"(",
"FP_REG_P",
"(",
"op0",
")",
")",
"{",
"if",
"(",
"TARGET_COLDFIRE_FPU",
")",
"output_asm_insn",
"(",
"\"ftst%.d %0\"",
",",
"ops",
")",
";",
"else",
"output_asm_insn",
"(",
"\"ftst%.x %0\"",
",",
"ops",
")",
";",
"}",
"else",
"output_asm_insn",
"(",
"(",
"\"ftst%.\"",
"+",
"prec",
"+",
"\" %0\"",
")",
".",
"c_str",
"(",
")",
",",
"ops",
")",
";",
"return",
"code",
";",
"}",
"switch",
"(",
"which_alternative",
")",
"{",
"case",
"0",
":",
"if",
"(",
"TARGET_COLDFIRE_FPU",
")",
"output_asm_insn",
"(",
"\"fcmp%.d %1,%0\"",
",",
"ops",
")",
";",
"else",
"output_asm_insn",
"(",
"\"fcmp%.x %1,%0\"",
",",
"ops",
")",
";",
"break",
";",
"case",
"1",
":",
"output_asm_insn",
"(",
"(",
"\"fcmp%.\"",
"+",
"prec",
"+",
"\" %f1,%0\"",
")",
".",
"c_str",
"(",
")",
",",
"ops",
")",
";",
"break",
";",
"case",
"2",
":",
"output_asm_insn",
"(",
"(",
"\"fcmp%.\"",
"+",
"prec",
"+",
"\" %0,%f1\"",
")",
".",
"c_str",
"(",
")",
",",
"ops",
")",
";",
"std",
"::",
"swap",
"(",
"flags_compare_op0",
",",
"flags_compare_op1",
")",
";",
"return",
"swap_condition",
"(",
"code",
")",
";",
"case",
"3",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"code",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"comparison",
"between",
"OP0",
"and",
"OP1",
".",
"CODE",
"is",
"the",
"code",
"of",
"the",
"comparison",
".",
"It",
"is",
"returned",
",",
"potentially",
"modified",
"if",
"necessary",
"."
] | [
"m68k",
"2",
"0",
"1",
"\"s\"",
"\"d\"",
"\"x\"",
"\"ftst%.d %0\"",
"\"ftst%.x %0\"",
"\"ftst%.\"",
"\" %0\"",
"0",
"\"fcmp%.d %1,%0\"",
"\"fcmp%.x %1,%0\"",
"1",
"\"fcmp%.\"",
"\" %f1,%0\"",
"2",
"\"fcmp%.\"",
"\" %0,%f1\"",
"3"
] | m68k | m68k_output_compare_fp | m68k | MPU | GCC | 3,155 | 249 | 1 | [] |
[
"<s>",
"void",
"add",
"(",
"const",
"SPIRV",
"::",
"SpecialTypeDescriptor",
"&",
"TD",
",",
"const",
"MachineFunction",
"*",
"MF",
",",
"Register",
"R",
")",
"{",
"ST",
".",
"add",
"(",
"TD",
",",
"MF",
",",
"R",
")",
";",
"}",
"</s>"
] | [
"Add",
"a",
"string",
"to",
"the",
"builder",
"."
] | [
"SPIRV",
"SPIRV::SpecialTypeDescriptor"
] | SPIRVDuplicatesTracker | add | SPIRV | Virtual ISA | LLVM | 3,156 | 31 | 1 | [] |
[
"<s>",
"void",
"AMDGPUPassConfig",
"::",
"addCodeGenPrepare",
"(",
")",
"{",
"const",
"AMDGPUSubtarget",
"&",
"ST",
"=",
"*",
"getAMDGPUTargetMachine",
"(",
")",
".",
"getSubtargetImpl",
"(",
")",
";",
"if",
"(",
"ST",
".",
"isPromoteAllocaEnabled",
"(",
")",
")",
"{",
"addPass",
"(",
"createAMDGPUPromoteAlloca",
"(",
"ST",
")",
")",
";",
"addPass",
"(",
"createSROAPass",
"(",
")",
")",
";",
"}",
"TargetPassConfig",
"::",
"addCodeGenPrepare",
"(",
")",
";",
"}",
"</s>"
] | [
"Add",
"pass",
"to",
"prepare",
"the",
"LLVM",
"IR",
"for",
"code",
"generation",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | AMDGPUTargetMachine (2) | addCodeGenPrepare | AMDGPU | GPU | LLVM | 3,157 | 53 | 1 | [] |
[
"<s>",
"bool",
"cris_biap_index_p",
"(",
"const_rtx",
"x",
",",
"bool",
"strict",
")",
"{",
"return",
"(",
"cris_index_p",
"(",
"x",
",",
"strict",
")",
"||",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"MULT",
"&&",
"cris_index_p",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"strict",
")",
"&&",
"cris_scale_int_operand",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
",",
"VOIDmode",
")",
")",
")",
";",
"}",
"</s>"
] | [
"True",
"if",
"X",
"is",
"a",
"valid",
"(",
"register",
")",
"index",
"for",
"BIAP",
",",
"i.e",
".",
"Rd.m",
"."
] | [
"cris",
"0",
"1"
] | cris | cris_biap_index_p | cris | MPU | GCC | 3,158 | 54 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isFsqrtCheap",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"EVT",
"VT",
"=",
"Op",
".",
"getValueType",
"(",
")",
";",
"if",
"(",
"VT",
".",
"getScalarType",
"(",
")",
"==",
"MVT",
"::",
"f16",
")",
"return",
"true",
";",
"if",
"(",
"DAG",
".",
"getNodeIfExists",
"(",
"X86ISD",
"::",
"FRSQRT",
",",
"DAG",
".",
"getVTList",
"(",
"VT",
")",
",",
"Op",
")",
")",
"return",
"false",
";",
"if",
"(",
"VT",
".",
"isVector",
"(",
")",
")",
"return",
"Subtarget",
".",
"hasFastVectorFSQRT",
"(",
")",
";",
"return",
"Subtarget",
".",
"hasFastScalarFSQRT",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"SQRT",
"(",
"X",
")",
"should",
"n't",
"be",
"replaced",
"with",
"X",
"*",
"RSQRT",
"(",
"X",
")",
"."
] | [
"X86",
"X86",
"MVT::f16",
"X86ISD::FRSQRT"
] | X86ISelLowering100 | isFsqrtCheap | X86 | CPU | LLVM | 3,159 | 84 | 1 | [] |
[
"<s>",
"static",
"bool",
"mips_find_gp_ref",
"(",
"bool",
"*",
"cache",
",",
"bool",
"(",
"*",
"pred",
")",
"(",
"rtx_insn",
"*",
")",
")",
"{",
"rtx_insn",
"*",
"insn",
";",
"if",
"(",
"!",
"*",
"cache",
")",
"{",
"push_topmost_sequence",
"(",
")",
";",
"for",
"(",
"insn",
"=",
"get_insns",
"(",
")",
";",
"insn",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"if",
"(",
"USEFUL_INSN_P",
"(",
"insn",
")",
"&&",
"pred",
"(",
"insn",
")",
")",
"{",
"*",
"cache",
"=",
"true",
";",
"break",
";",
"}",
"pop_topmost_sequence",
"(",
")",
";",
"}",
"return",
"*",
"cache",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"predicate",
"PRED",
"is",
"true",
"for",
"at",
"least",
"one",
"instruction",
".",
"Cache",
"the",
"result",
"in",
"*",
"CACHE",
",",
"and",
"assume",
"that",
"the",
"result",
"is",
"true",
"if",
"*",
"CACHE",
"is",
"already",
"true",
"."
] | [
"mips"
] | mips4 | mips_find_gp_ref | mips | CPU | GCC | 3,160 | 82 | 1 | [] |
[
"<s>",
"bool",
"doInitialization",
"(",
"Module",
"&",
"M",
")",
"override",
"{",
"CallGraphResourceInfo",
".",
"clear",
"(",
")",
";",
"return",
"ModulePass",
"::",
"doInitialization",
"(",
"M",
")",
";",
"}",
"</s>"
] | [
"Set",
"up",
"the",
"AsmPrinter",
"when",
"we",
"are",
"working",
"on",
"a",
"new",
"module",
"."
] | [
"AMDGPU"
] | AMDGPUResourceUsageAnalysis | doInitialization | AMDGPU | GPU | LLVM | 3,161 | 24 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"Cpu0TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"StringRef",
"Constraint",
",",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'r'",
":",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"i32",
"||",
"VT",
"==",
"MVT",
"::",
"i16",
"||",
"VT",
"==",
"MVT",
"::",
"i8",
")",
"{",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"Cpu0",
"::",
"CPURegsRegClass",
")",
";",
"}",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"i64",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"Cpu0",
"::",
"CPURegsRegClass",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"0u",
",",
"static_cast",
"<",
"const",
"TargetRegisterClass",
"*",
">",
"(",
"0",
")",
")",
";",
"case",
"'c'",
":",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"i32",
")",
"return",
"std",
"::",
"make_pair",
"(",
"(",
"unsigned",
")",
"Cpu0",
"::",
"T9",
",",
"&",
"Cpu0",
"::",
"CPURegsRegClass",
")",
";",
"assert",
"(",
"\"Unexpected type.\"",
")",
";",
"}",
"}",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"R",
";",
"R",
"=",
"parseRegForInlineAsmConstraint",
"(",
"Constraint",
",",
"VT",
")",
";",
"if",
"(",
"R",
".",
"second",
")",
"return",
"R",
";",
"return",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"TRI",
",",
"Constraint",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"Cpu0",
"Cpu0",
"1",
"0",
"MVT::i32",
"MVT::i16",
"MVT::i8",
"0U",
"Cpu0::CPURegsRegClass",
"MVT::i64",
"0U",
"Cpu0::CPURegsRegClass",
"0u",
"0",
"MVT::i32",
"Cpu0::T9",
"Cpu0::CPURegsRegClass",
"\"Unexpected type.\""
] | Cpu0ISelLowering | getRegForInlineAsmConstraint | Cpu0 | CPU | LLVM | 3,162 | 202 | 1 | [] |
[
"<s>",
"bool",
"PPCAIXAsmPrinter",
"::",
"doInitialization",
"(",
"Module",
"&",
"M",
")",
"{",
"if",
"(",
"M",
".",
"alias_size",
"(",
")",
">",
"0u",
")",
"report_fatal_error",
"(",
"\"module has aliases, which LLVM does not yet support for AIX\"",
")",
";",
"const",
"bool",
"Result",
"=",
"PPCAsmPrinter",
"::",
"doInitialization",
"(",
"M",
")",
";",
"auto",
"setCsectAlignment",
"=",
"[",
"this",
"]",
"(",
"const",
"GlobalObject",
"*",
"GO",
")",
"{",
"if",
"(",
"GO",
"->",
"isDeclaration",
"(",
")",
")",
"return",
";",
"SectionKind",
"GOKind",
"=",
"getObjFileLowering",
"(",
")",
".",
"getKindForGlobal",
"(",
"GO",
",",
"TM",
")",
";",
"MCSectionXCOFF",
"*",
"Csect",
"=",
"cast",
"<",
"MCSectionXCOFF",
">",
"(",
"getObjFileLowering",
"(",
")",
".",
"SectionForGlobal",
"(",
"GO",
",",
"GOKind",
",",
"TM",
")",
")",
";",
"Align",
"GOAlign",
"=",
"getGVAlignment",
"(",
"GO",
",",
"GO",
"->",
"getParent",
"(",
")",
"->",
"getDataLayout",
"(",
")",
")",
";",
"if",
"(",
"GOAlign",
">",
"Csect",
"->",
"getAlignment",
"(",
")",
")",
"Csect",
"->",
"setAlignment",
"(",
"GOAlign",
")",
";",
"}",
";",
"for",
"(",
"const",
"auto",
"&",
"G",
":",
"M",
".",
"globals",
"(",
")",
")",
"setCsectAlignment",
"(",
"&",
"G",
")",
";",
"for",
"(",
"const",
"auto",
"&",
"F",
":",
"M",
")",
"setCsectAlignment",
"(",
"&",
"F",
")",
";",
"return",
"Result",
";",
"}",
"</s>"
] | [
"Set",
"up",
"the",
"AsmPrinter",
"when",
"we",
"are",
"working",
"on",
"a",
"new",
"module",
"."
] | [
"PowerPC",
"PPC",
"0u",
"\"module has aliases, which LLVM does not yet support for AIX\"",
"PPC"
] | PPCAsmPrinter112 | doInitialization | PowerPC | CPU | LLVM | 3,163 | 171 | 1 | [] |
[
"<s>",
"virtual",
"const",
"InstrItineraryData",
"*",
"getInstrItineraryData",
"(",
")",
"const",
"{",
"return",
"InstrItins",
";",
"}",
"</s>"
] | [
"getInstrItineraryData",
"-",
"Returns",
"instruction",
"itinerary",
"data",
"for",
"the",
"target",
"or",
"specific",
"subtarget",
"."
] | [
"rvex"
] | rvexTargetMachine | getInstrItineraryData | rvex | VLIW | LLVM | 3,164 | 13 | 1 | [] |
[
"<s>",
"bool",
"ARM64RegisterInfo",
"::",
"requiresVirtualBaseRegisters",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"wants",
"the",
"LocalStackAllocation",
"pass",
"to",
"be",
"run",
"and",
"virtual",
"base",
"registers",
"used",
"for",
"more",
"efficient",
"stack",
"access",
"."
] | [
"ARM64",
"ARM64"
] | ARM64RegisterInfo | requiresVirtualBaseRegisters | ARM64 | CPU | LLVM | 3,165 | 16 | 1 | [] |
[
"<s>",
"void",
"SystemZInstrInfo",
"::",
"copyPhysReg",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
",",
"DebugLoc",
"DL",
",",
"unsigned",
"DestReg",
",",
"unsigned",
"SrcReg",
",",
"bool",
"KillSrc",
")",
"const",
"{",
"if",
"(",
"SystemZ",
"::",
"GR128BitRegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"{",
"copyPhysReg",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"RI",
".",
"getSubReg",
"(",
"DestReg",
",",
"SystemZ",
"::",
"subreg_h64",
")",
",",
"RI",
".",
"getSubReg",
"(",
"SrcReg",
",",
"SystemZ",
"::",
"subreg_h64",
")",
",",
"KillSrc",
")",
";",
"copyPhysReg",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"RI",
".",
"getSubReg",
"(",
"DestReg",
",",
"SystemZ",
"::",
"subreg_l64",
")",
",",
"RI",
".",
"getSubReg",
"(",
"SrcReg",
",",
"SystemZ",
"::",
"subreg_l64",
")",
",",
"KillSrc",
")",
";",
"return",
";",
"}",
"if",
"(",
"SystemZ",
"::",
"GRX32BitRegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"{",
"emitGRX32Move",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"DestReg",
",",
"SrcReg",
",",
"SystemZ",
"::",
"LR",
",",
"32",
",",
"KillSrc",
")",
";",
"return",
";",
"}",
"unsigned",
"Opcode",
";",
"if",
"(",
"SystemZ",
"::",
"GR64BitRegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opcode",
"=",
"SystemZ",
"::",
"LGR",
";",
"else",
"if",
"(",
"SystemZ",
"::",
"FP32BitRegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opcode",
"=",
"SystemZ",
"::",
"LER",
";",
"else",
"if",
"(",
"SystemZ",
"::",
"FP64BitRegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opcode",
"=",
"SystemZ",
"::",
"LDR",
";",
"else",
"if",
"(",
"SystemZ",
"::",
"FP128BitRegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opcode",
"=",
"SystemZ",
"::",
"LXR",
";",
"else",
"llvm_unreachable",
"(",
"\"Impossible reg-to-reg copy\"",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"}",
"</s>"
] | [
"}",
"Branch",
"Analysis",
"&",
"Modification"
] | [
"SystemZ",
"SystemZ",
"SystemZ::GR128BitRegClass",
"SystemZ::subreg_h64",
"SystemZ::subreg_h64",
"SystemZ::subreg_l64",
"SystemZ::subreg_l64",
"SystemZ::GRX32BitRegClass",
"SystemZ::LR",
"32",
"SystemZ::GR64BitRegClass",
"SystemZ::LGR",
"SystemZ::FP32BitRegClass",
"SystemZ::LER",
"SystemZ::FP64BitRegClass",
"SystemZ::LDR",
"SystemZ::FP128BitRegClass",
"SystemZ::LXR",
"\"Impossible reg-to-reg copy\""
] | SystemZInstrInfo14 | copyPhysReg | SystemZ | CPU | LLVM | 3,166 | 264 | 1 | [] |
[
"<s>",
"void",
"X86TileConfig",
"::",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"{",
"AU",
".",
"addRequired",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"LiveIntervals",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"SlotIndexes",
">",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"VirtRegMap",
">",
"(",
")",
";",
"AU",
".",
"setPreservesAll",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"X86",
"X86"
] | X86TileConfig1 | getAnalysisUsage | X86 | CPU | LLVM | 3,167 | 61 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"shouldSignExtendTypeInLibCall",
"(",
"EVT",
"Type",
",",
"bool",
"IsSigned",
")",
"const",
"{",
"if",
"(",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"Type",
"==",
"MVT",
"::",
"i32",
")",
"return",
"true",
";",
"return",
"IsSigned",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"arguments",
"should",
"be",
"sign-extended",
"in",
"lib",
"calls",
"."
] | [
"RISCV",
"RISCV",
"MVT::i32"
] | RISCVISelLowering1 | shouldSignExtendTypeInLibCall | RISCV | CPU | LLVM | 3,168 | 34 | 1 | [] |
[
"<s>",
"HOST_WIDE_INT",
"thumb_compute_initial_elimination_offset",
"(",
"unsigned",
"int",
"from",
",",
"unsigned",
"int",
"to",
")",
"{",
"arm_stack_offsets",
"*",
"offsets",
";",
"offsets",
"=",
"arm_get_frame_offsets",
"(",
")",
";",
"switch",
"(",
"from",
")",
"{",
"case",
"ARG_POINTER_REGNUM",
":",
"switch",
"(",
"to",
")",
"{",
"case",
"STACK_POINTER_REGNUM",
":",
"return",
"offsets",
"->",
"outgoing_args",
"-",
"offsets",
"->",
"saved_args",
";",
"case",
"FRAME_POINTER_REGNUM",
":",
"return",
"offsets",
"->",
"soft_frame",
"-",
"offsets",
"->",
"saved_args",
";",
"case",
"ARM_HARD_FRAME_POINTER_REGNUM",
":",
"return",
"offsets",
"->",
"saved_regs",
"-",
"offsets",
"->",
"saved_args",
";",
"case",
"THUMB_HARD_FRAME_POINTER_REGNUM",
":",
"return",
"offsets",
"->",
"locals_base",
"-",
"offsets",
"->",
"saved_args",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"break",
";",
"case",
"FRAME_POINTER_REGNUM",
":",
"switch",
"(",
"to",
")",
"{",
"case",
"STACK_POINTER_REGNUM",
":",
"return",
"offsets",
"->",
"outgoing_args",
"-",
"offsets",
"->",
"soft_frame",
";",
"case",
"ARM_HARD_FRAME_POINTER_REGNUM",
":",
"return",
"offsets",
"->",
"saved_regs",
"-",
"offsets",
"->",
"soft_frame",
";",
"case",
"THUMB_HARD_FRAME_POINTER_REGNUM",
":",
"return",
"offsets",
"->",
"locals_base",
"-",
"offsets",
"->",
"soft_frame",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Like",
"arm_compute_initial_elimination",
"offset",
".",
"Simpler",
"because",
"there",
"is",
"n't",
"an",
"ABI",
"specified",
"frame",
"pointer",
"for",
"Thumb",
".",
"Instead",
",",
"we",
"set",
"it",
"to",
"point",
"at",
"the",
"base",
"of",
"the",
"local",
"variables",
"after",
"static",
"stack",
"space",
"for",
"a",
"function",
"has",
"been",
"allocated",
"."
] | [
"arm"
] | arm | thumb_compute_initial_elimination_offset | arm | CPU | GCC | 3,169 | 153 | 1 | [] |
[
"<s>",
"void",
"Thumb2InstrInfo",
"::",
"copyPhysReg",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"unsigned",
"DestReg",
",",
"unsigned",
"SrcReg",
",",
"bool",
"KillSrc",
")",
"const",
"{",
"if",
"(",
"!",
"ARM",
"::",
"GPRRegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"return",
"ARMBaseInstrInfo",
"::",
"copyPhysReg",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"DestReg",
",",
"SrcReg",
",",
"KillSrc",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ARM",
"::",
"tMOVr",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
".",
"add",
"(",
"predOps",
"(",
"ARMCC",
"::",
"AL",
")",
")",
";",
"}",
"</s>"
] | [
"}",
"Branch",
"Analysis",
"&",
"Modification"
] | [
"ARM",
"ARM::GPRRegClass",
"ARM",
"ARM::tMOVr",
"ARMCC::AL"
] | Thumb2InstrInfo (2)1 | copyPhysReg | ARM | CPU | LLVM | 3,170 | 101 | 1 | [] |
[
"<s>",
"MVT",
"::",
"SimpleValueType",
"PIC16TargetLowering",
"::",
"getCmpLibcallReturnType",
"(",
")",
"const",
"{",
"return",
"MVT",
"::",
"i8",
";",
"}",
"</s>"
] | [
"Return",
"the",
"ValueType",
"for",
"comparison",
"libcalls",
"."
] | [
"PIC16",
"MVT::SimpleValueType",
"PIC16",
"MVT::i8"
] | PIC16ISelLowering | getCmpLibcallReturnType | PIC16 | MPU | LLVM | 3,171 | 16 | 1 | [] |
[
"<s>",
"rtx",
"rs6000_libcall_value",
"(",
"machine_mode",
"mode",
")",
"{",
"unsigned",
"int",
"regno",
";",
"if",
"(",
"TARGET_32BIT",
"&&",
"TARGET_POWERPC64",
"&&",
"mode",
"==",
"DImode",
")",
"return",
"rs6000_parallel_return",
"(",
"mode",
",",
"2",
",",
"SImode",
",",
"GP_ARG_RETURN",
",",
"1",
")",
";",
"if",
"(",
"DECIMAL_FLOAT_MODE_P",
"(",
"mode",
")",
"&&",
"TARGET_HARD_FLOAT",
")",
"regno",
"=",
"(",
"mode",
"==",
"TDmode",
")",
"?",
"FP_ARG_RETURN",
"+",
"1",
":",
"FP_ARG_RETURN",
";",
"else",
"if",
"(",
"SCALAR_FLOAT_MODE_NOT_VECTOR_P",
"(",
"mode",
")",
"&&",
"TARGET_HARD_FLOAT",
"&&",
"(",
"(",
"TARGET_SINGLE_FLOAT",
"&&",
"mode",
"==",
"SFmode",
")",
"||",
"TARGET_DOUBLE_FLOAT",
")",
")",
"regno",
"=",
"FP_ARG_RETURN",
";",
"else",
"if",
"(",
"ALTIVEC_OR_VSX_VECTOR_MODE",
"(",
"mode",
")",
"&&",
"TARGET_ALTIVEC",
"&&",
"TARGET_ALTIVEC_ABI",
")",
"regno",
"=",
"ALTIVEC_ARG_RETURN",
";",
"else",
"if",
"(",
"COMPLEX_MODE_P",
"(",
"mode",
")",
"&&",
"targetm",
".",
"calls",
".",
"split_complex_arg",
")",
"return",
"rs6000_complex_function_value",
"(",
"mode",
")",
";",
"else",
"regno",
"=",
"GP_ARG_RETURN",
";",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"regno",
")",
";",
"}",
"</s>"
] | [
"Define",
"how",
"to",
"find",
"the",
"value",
"returned",
"by",
"a",
"library",
"function",
"assuming",
"the",
"value",
"has",
"mode",
"MODE",
"."
] | [
"rs6000",
"2",
"1",
"1"
] | rs60007 | rs6000_libcall_value | rs6000 | CPU | GCC | 3,172 | 134 | 1 | [] |
[
"<s>",
"void",
"VEFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MachineFunction",
"&",
"MF",
",",
"BitVector",
"&",
"SavedRegs",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"TargetFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MF",
",",
"SavedRegs",
",",
"RS",
")",
";",
"if",
"(",
"isLeafProc",
"(",
"MF",
")",
")",
"{",
"VEMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"VEMachineFunctionInfo",
">",
"(",
")",
";",
"MFI",
"->",
"setLeafProc",
"(",
"true",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"determines",
"which",
"of",
"the",
"registers",
"reported",
"by",
"TargetRegisterInfo",
":",
":getCalleeSavedRegs",
"(",
")",
"should",
"actually",
"get",
"saved",
"."
] | [
"VE",
"VE",
"VE",
"VE"
] | VEFrameLowering | determineCalleeSaves | VE | CPU | LLVM | 3,173 | 60 | 1 | [] |
[
"<s>",
"void",
"HexagonPassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"bool",
"NoOpt",
"=",
"(",
"getOptLevel",
"(",
")",
"==",
"CodeGenOpt",
"::",
"None",
")",
";",
"if",
"(",
"!",
"NoOpt",
")",
"{",
"if",
"(",
"EnableInstSimplify",
")",
"addPass",
"(",
"createInstSimplifyLegacyPass",
"(",
")",
")",
";",
"addPass",
"(",
"createDeadCodeEliminationPass",
"(",
")",
")",
";",
"}",
"addPass",
"(",
"createAtomicExpandPass",
"(",
")",
")",
";",
"if",
"(",
"!",
"NoOpt",
")",
"{",
"if",
"(",
"EnableInitialCFGCleanup",
")",
"addPass",
"(",
"createCFGSimplificationPass",
"(",
"SimplifyCFGOptions",
"(",
")",
".",
"forwardSwitchCondToPhi",
"(",
"true",
")",
".",
"convertSwitchToLookupTable",
"(",
"true",
")",
".",
"needCanonicalLoops",
"(",
"false",
")",
".",
"hoistCommonInsts",
"(",
"true",
")",
".",
"sinkCommonInsts",
"(",
"true",
")",
")",
")",
";",
"if",
"(",
"EnableLoopPrefetch",
")",
"addPass",
"(",
"createLoopDataPrefetchPass",
"(",
")",
")",
";",
"if",
"(",
"EnableVectorCombine",
")",
"addPass",
"(",
"createHexagonVectorCombineLegacyPass",
"(",
")",
")",
";",
"if",
"(",
"EnableCommGEP",
")",
"addPass",
"(",
"createHexagonCommonGEP",
"(",
")",
")",
";",
"if",
"(",
"EnableGenExtract",
")",
"addPass",
"(",
"createHexagonGenExtract",
"(",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon"
] | HexagonTargetMachine12 | addIRPasses | Hexagon | DSP | LLVM | 3,174 | 149 | 1 | [] |
[
"<s>",
"MCObjectWriter",
"*",
"createObjectWriter",
"(",
"raw_pwrite_stream",
"&",
"OS",
")",
"const",
"override",
"{",
"return",
"createTriCoreELFObjectWriter",
"(",
"OS",
",",
"OSABI",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"new",
"MCObjectWriter",
"instance",
"for",
"use",
"by",
"the",
"assembler",
"backend",
"to",
"emit",
"the",
"final",
"object",
"file",
"."
] | [
"TriCore",
"TriCore"
] | TriCoreAsmBackend (2) | createObjectWriter | TriCore | MPU | LLVM | 3,175 | 20 | 1 | [] |
[
"<s>",
"static",
"tree",
"s390_expand_overloaded_builtin",
"(",
"location_t",
"loc",
",",
"unsigned",
"fcode",
",",
"vec",
"<",
"tree",
",",
"va_gc",
">",
"*",
"arglist",
",",
"tree",
"return_type",
")",
"{",
"switch",
"(",
"fcode",
")",
"{",
"case",
"S390_OVERLOADED_BUILTIN_s390_vec_step",
":",
"if",
"(",
"TREE_CODE",
"(",
"TREE_TYPE",
"(",
"(",
"*",
"arglist",
")",
"[",
"0",
"]",
")",
")",
"!=",
"VECTOR_TYPE",
")",
"{",
"error_at",
"(",
"loc",
",",
"\"builtin %qs can only be used on vector types\"",
",",
"\"vec_step\"",
")",
";",
"return",
"error_mark_node",
";",
"}",
"return",
"build_int_cst",
"(",
"NULL_TREE",
",",
"TYPE_VECTOR_SUBPARTS",
"(",
"TREE_TYPE",
"(",
"(",
"*",
"arglist",
")",
"[",
"0",
"]",
")",
")",
")",
";",
"case",
"S390_OVERLOADED_BUILTIN_s390_vec_xl",
":",
"case",
"S390_OVERLOADED_BUILTIN_s390_vec_xld2",
":",
"case",
"S390_OVERLOADED_BUILTIN_s390_vec_xlw4",
":",
"{",
"tree",
"mem_type",
"=",
"build_aligned_type",
"(",
"return_type",
",",
"TYPE_ALIGN",
"(",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"(",
"*",
"arglist",
")",
"[",
"1",
"]",
")",
")",
")",
")",
";",
"return",
"build2",
"(",
"MEM_REF",
",",
"mem_type",
",",
"fold_build_pointer_plus",
"(",
"(",
"*",
"arglist",
")",
"[",
"1",
"]",
",",
"(",
"*",
"arglist",
")",
"[",
"0",
"]",
")",
",",
"build_int_cst",
"(",
"TREE_TYPE",
"(",
"(",
"*",
"arglist",
")",
"[",
"1",
"]",
")",
",",
"0",
")",
")",
";",
"}",
"case",
"S390_OVERLOADED_BUILTIN_s390_vec_xst",
":",
"case",
"S390_OVERLOADED_BUILTIN_s390_vec_xstd2",
":",
"case",
"S390_OVERLOADED_BUILTIN_s390_vec_xstw4",
":",
"{",
"tree",
"mem_type",
"=",
"build_aligned_type",
"(",
"TREE_TYPE",
"(",
"(",
"*",
"arglist",
")",
"[",
"0",
"]",
")",
",",
"TYPE_ALIGN",
"(",
"TREE_TYPE",
"(",
"TREE_TYPE",
"(",
"(",
"*",
"arglist",
")",
"[",
"2",
"]",
")",
")",
")",
")",
";",
"return",
"build2",
"(",
"MODIFY_EXPR",
",",
"mem_type",
",",
"build1",
"(",
"INDIRECT_REF",
",",
"mem_type",
",",
"fold_build_pointer_plus",
"(",
"(",
"*",
"arglist",
")",
"[",
"2",
"]",
",",
"(",
"*",
"arglist",
")",
"[",
"1",
"]",
")",
")",
",",
"(",
"*",
"arglist",
")",
"[",
"0",
"]",
")",
";",
"}",
"case",
"S390_OVERLOADED_BUILTIN_s390_vec_load_pair",
":",
"return",
"build_constructor_va",
"(",
"return_type",
",",
"2",
",",
"NULL_TREE",
",",
"(",
"*",
"arglist",
")",
"[",
"0",
"]",
",",
"NULL_TREE",
",",
"(",
"*",
"arglist",
")",
"[",
"1",
"]",
")",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Expand",
"builtins",
"which",
"can",
"directly",
"be",
"mapped",
"to",
"tree",
"expressions",
".",
"LOC",
"-",
"location",
"information",
"FCODE",
"-",
"function",
"code",
"of",
"the",
"builtin",
"ARGLIST",
"-",
"value",
"supposed",
"to",
"be",
"passed",
"as",
"arguments",
"RETURN-TYPE",
"-",
"expected",
"return",
"type",
"of",
"the",
"builtin"
] | [
"s390",
"0",
"\"builtin %qs can only be used on vector types\"",
"\"vec_step\"",
"0",
"1",
"1",
"0",
"1",
"0",
"0",
"2",
"2",
"1",
"0",
"2",
"0",
"1"
] | s390-c | s390_expand_overloaded_builtin | s390 | MPU | GCC | 3,176 | 288 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"s390_invalid_binary_op",
"(",
"int",
"op",
"ATTRIBUTE_UNUSED",
",",
"const_tree",
"type1",
",",
"const_tree",
"type2",
")",
"{",
"bool",
"bool1_p",
",",
"bool2_p",
";",
"bool",
"plusminus_p",
";",
"bool",
"muldiv_p",
";",
"bool",
"compare_p",
";",
"machine_mode",
"mode1",
",",
"mode2",
";",
"if",
"(",
"!",
"TARGET_ZVECTOR",
")",
"return",
"NULL",
";",
"if",
"(",
"!",
"VECTOR_TYPE_P",
"(",
"type1",
")",
"||",
"!",
"VECTOR_TYPE_P",
"(",
"type2",
")",
")",
"return",
"NULL",
";",
"bool1_p",
"=",
"s390_vector_bool_type_p",
"(",
"type1",
")",
";",
"bool2_p",
"=",
"s390_vector_bool_type_p",
"(",
"type2",
")",
";",
"if",
"(",
"!",
"bool1_p",
"&&",
"!",
"bool2_p",
"&&",
"TYPE_UNSIGNED",
"(",
"type1",
")",
"!=",
"TYPE_UNSIGNED",
"(",
"type2",
")",
")",
"return",
"N_",
"(",
"\"types differ in signess\"",
")",
";",
"plusminus_p",
"=",
"(",
"op",
"==",
"PLUS_EXPR",
"||",
"op",
"==",
"MINUS_EXPR",
")",
";",
"muldiv_p",
"=",
"(",
"op",
"==",
"MULT_EXPR",
"||",
"op",
"==",
"RDIV_EXPR",
"||",
"op",
"==",
"TRUNC_DIV_EXPR",
"||",
"op",
"==",
"CEIL_DIV_EXPR",
"||",
"op",
"==",
"FLOOR_DIV_EXPR",
"||",
"op",
"==",
"ROUND_DIV_EXPR",
")",
";",
"compare_p",
"=",
"(",
"op",
"==",
"LT_EXPR",
"||",
"op",
"==",
"LE_EXPR",
"||",
"op",
"==",
"GT_EXPR",
"||",
"op",
"==",
"GE_EXPR",
"||",
"op",
"==",
"EQ_EXPR",
"||",
"op",
"==",
"NE_EXPR",
")",
";",
"if",
"(",
"bool1_p",
"&&",
"bool2_p",
"&&",
"(",
"plusminus_p",
"||",
"muldiv_p",
")",
")",
"return",
"N_",
"(",
"\"binary operator does not support two vector bool operands\"",
")",
";",
"if",
"(",
"bool1_p",
"!=",
"bool2_p",
"&&",
"(",
"muldiv_p",
"||",
"compare_p",
")",
")",
"return",
"N_",
"(",
"\"binary operator does not support vector bool operand\"",
")",
";",
"mode1",
"=",
"TYPE_MODE",
"(",
"type1",
")",
";",
"mode2",
"=",
"TYPE_MODE",
"(",
"type2",
")",
";",
"if",
"(",
"bool1_p",
"!=",
"bool2_p",
"&&",
"plusminus_p",
"&&",
"(",
"GET_MODE_CLASS",
"(",
"mode1",
")",
"==",
"MODE_VECTOR_FLOAT",
"||",
"GET_MODE_CLASS",
"(",
"mode2",
")",
"==",
"MODE_VECTOR_FLOAT",
")",
")",
"return",
"N_",
"(",
"\"binary operator does not support mixing vector \"",
"\"bool with floating point vector operands\"",
")",
";",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"Return",
"the",
"diagnostic",
"message",
"string",
"if",
"the",
"binary",
"operation",
"OP",
"is",
"not",
"permitted",
"on",
"TYPE1",
"and",
"TYPE2",
",",
"NULL",
"otherwise",
"."
] | [
"s390",
"\"types differ in signess\"",
"\"binary operator does not support two vector bool operands\"",
"\"binary operator does not support vector bool operand\"",
"\"binary operator does not support mixing vector \"",
"\"bool with floating point vector operands\""
] | s3905 | s390_invalid_binary_op | s390 | MPU | GCC | 3,177 | 252 | 1 | [] |
[
"<s>",
"static",
"void",
"m68k_trampoline_init",
"(",
"rtx",
"m_tramp",
",",
"tree",
"fndecl",
",",
"rtx",
"chain_value",
")",
"{",
"rtx",
"fnaddr",
"=",
"XEXP",
"(",
"DECL_RTL",
"(",
"fndecl",
")",
",",
"0",
")",
";",
"rtx",
"mem",
";",
"gcc_assert",
"(",
"ADDRESS_REGNO_P",
"(",
"STATIC_CHAIN_REGNUM",
")",
")",
";",
"mem",
"=",
"adjust_address",
"(",
"m_tramp",
",",
"HImode",
",",
"0",
")",
";",
"emit_move_insn",
"(",
"mem",
",",
"GEN_INT",
"(",
"0x207C",
"+",
"(",
"(",
"STATIC_CHAIN_REGNUM",
"-",
"8",
")",
"<<",
"9",
")",
")",
")",
";",
"mem",
"=",
"adjust_address",
"(",
"m_tramp",
",",
"SImode",
",",
"2",
")",
";",
"emit_move_insn",
"(",
"mem",
",",
"chain_value",
")",
";",
"mem",
"=",
"adjust_address",
"(",
"m_tramp",
",",
"HImode",
",",
"6",
")",
";",
"emit_move_insn",
"(",
"mem",
",",
"GEN_INT",
"(",
"0x4EF9",
")",
")",
";",
"mem",
"=",
"adjust_address",
"(",
"m_tramp",
",",
"SImode",
",",
"8",
")",
";",
"emit_move_insn",
"(",
"mem",
",",
"fnaddr",
")",
";",
"FINALIZE_TRAMPOLINE",
"(",
"XEXP",
"(",
"m_tramp",
",",
"0",
")",
")",
";",
"}",
"</s>"
] | [
"We",
"generate",
"a",
"two-instructions",
"program",
"at",
"M_TRAMP",
":",
"movea.l",
"&",
"CHAIN_VALUE",
",",
"%",
"a0",
"jmp",
"FNADDR",
"where",
"%",
"a0",
"can",
"be",
"modified",
"by",
"changing",
"STATIC_CHAIN_REGNUM",
"."
] | [
"m68k",
"0",
"0",
"0x207C",
"8",
"9",
"2",
"6",
"0x4EF9",
"8",
"0"
] | m68k | m68k_trampoline_init | m68k | MPU | GCC | 3,178 | 137 | 1 | [] |
[
"<s>",
"bool",
"HCE",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"LLVM_DEBUG",
"(",
"MF",
".",
"print",
"(",
"dbgs",
"(",
")",
"<<",
"\"Before \"",
"<<",
"getPassName",
"(",
")",
"<<",
"'\\n'",
",",
"nullptr",
")",
")",
";",
"HII",
"=",
"MF",
".",
"getSubtarget",
"<",
"HexagonSubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"HRI",
"=",
"MF",
".",
"getSubtarget",
"<",
"HexagonSubtarget",
">",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"MDT",
"=",
"&",
"getAnalysis",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"AssignmentMap",
"IMap",
";",
"collect",
"(",
"MF",
")",
";",
"llvm",
"::",
"sort",
"(",
"Extenders",
".",
"begin",
"(",
")",
",",
"Extenders",
".",
"end",
"(",
")",
",",
"[",
"]",
"(",
"const",
"ExtDesc",
"&",
"A",
",",
"const",
"ExtDesc",
"&",
"B",
")",
"{",
"return",
"ExtValue",
"(",
"A",
")",
"<",
"ExtValue",
"(",
"B",
")",
";",
"}",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Collected \"",
"<<",
"Extenders",
".",
"size",
"(",
")",
"<<",
"\" extenders\\n\"",
")",
";",
"for",
"(",
"unsigned",
"I",
"=",
"0",
",",
"E",
"=",
"Extenders",
".",
"size",
"(",
")",
";",
"I",
"!=",
"E",
";",
")",
"{",
"unsigned",
"B",
"=",
"I",
";",
"const",
"ExtRoot",
"&",
"T",
"=",
"Extenders",
"[",
"B",
"]",
".",
"getOp",
"(",
")",
";",
"while",
"(",
"I",
"!=",
"E",
"&&",
"ExtRoot",
"(",
"Extenders",
"[",
"I",
"]",
".",
"getOp",
"(",
")",
")",
"==",
"T",
")",
"++",
"I",
";",
"IMap",
".",
"clear",
"(",
")",
";",
"assignInits",
"(",
"T",
",",
"B",
",",
"I",
",",
"IMap",
")",
";",
"Changed",
"|=",
"replaceExtenders",
"(",
"IMap",
")",
";",
"}",
"LLVM_DEBUG",
"(",
"{",
"if",
"(",
"Changed",
")",
"MF",
".",
"print",
"(",
"dbgs",
"(",
")",
"<<",
"\"After \"",
"<<",
"getPassName",
"(",
")",
"<<",
"'\\n'",
",",
"nullptr",
")",
";",
"else",
"dbgs",
"(",
")",
"<<",
"\"No changes\\n\"",
";",
"}",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Hexagon",
"\"Before \"",
"Hexagon",
"Hexagon",
"\"Collected \"",
"\" extenders\\n\"",
"0",
"\"After \"",
"\"No changes\\n\""
] | HexagonConstExtenders | runOnMachineFunction | Hexagon | DSP | LLVM | 3,179 | 297 | 1 | [] |
[
"<s>",
"unsigned",
"ARMAsmParser",
"::",
"checkTargetMatchPredicate",
"(",
"MCInst",
"&",
"Inst",
")",
"{",
"unsigned",
"Opc",
"=",
"Inst",
".",
"getOpcode",
"(",
")",
";",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"MII",
".",
"get",
"(",
"Opc",
")",
";",
"if",
"(",
"MCID",
".",
"TSFlags",
"&",
"ARMII",
"::",
"ThumbArithFlagSetting",
")",
"{",
"assert",
"(",
"MCID",
".",
"hasOptionalDef",
"(",
")",
"&&",
"\"optionally flag setting instruction missing optional def operand\"",
")",
";",
"assert",
"(",
"MCID",
".",
"NumOperands",
"==",
"Inst",
".",
"getNumOperands",
"(",
")",
"&&",
"\"operand count mismatch!\"",
")",
";",
"unsigned",
"OpNo",
";",
"for",
"(",
"OpNo",
"=",
"0",
";",
"!",
"MCID",
".",
"OpInfo",
"[",
"OpNo",
"]",
".",
"isOptionalDef",
"(",
")",
"&&",
"OpNo",
"<",
"MCID",
".",
"NumOperands",
";",
"++",
"OpNo",
")",
";",
"if",
"(",
"isThumbOne",
"(",
")",
"&&",
"Inst",
".",
"getOperand",
"(",
"OpNo",
")",
".",
"getReg",
"(",
")",
"!=",
"ARM",
"::",
"CPSR",
")",
"return",
"Match_MnemonicFail",
";",
"if",
"(",
"isThumbTwo",
"(",
")",
"&&",
"Inst",
".",
"getOperand",
"(",
"OpNo",
")",
".",
"getReg",
"(",
")",
"!=",
"ARM",
"::",
"CPSR",
"&&",
"!",
"inITBlock",
"(",
")",
")",
"return",
"Match_RequiresITBlock",
";",
"if",
"(",
"isThumbTwo",
"(",
")",
"&&",
"Inst",
".",
"getOperand",
"(",
"OpNo",
")",
".",
"getReg",
"(",
")",
"==",
"ARM",
"::",
"CPSR",
"&&",
"inITBlock",
"(",
")",
")",
"return",
"Match_RequiresNotITBlock",
";",
"}",
"else",
"if",
"(",
"isThumbOne",
"(",
")",
")",
"{",
"if",
"(",
"Opc",
"==",
"ARM",
"::",
"tADDhirr",
"&&",
"!",
"hasV6MOps",
"(",
")",
"&&",
"isARMLowRegister",
"(",
"Inst",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
")",
"&&",
"isARMLowRegister",
"(",
"Inst",
".",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
")",
")",
"return",
"Match_RequiresThumb2",
";",
"else",
"if",
"(",
"Opc",
"==",
"ARM",
"::",
"tMOVr",
"&&",
"!",
"hasV6Ops",
"(",
")",
"&&",
"isARMLowRegister",
"(",
"Inst",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
"&&",
"isARMLowRegister",
"(",
"Inst",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
")",
")",
"return",
"Match_RequiresV6",
";",
"}",
"for",
"(",
"unsigned",
"I",
"=",
"0",
";",
"I",
"<",
"MCID",
".",
"NumOperands",
";",
"++",
"I",
")",
"if",
"(",
"MCID",
".",
"OpInfo",
"[",
"I",
"]",
".",
"RegClass",
"==",
"ARM",
"::",
"rGPRRegClassID",
")",
"{",
"if",
"(",
"(",
"Inst",
".",
"getOperand",
"(",
"I",
")",
".",
"getReg",
"(",
")",
"==",
"ARM",
"::",
"SP",
")",
"&&",
"!",
"hasV8Ops",
"(",
")",
")",
"return",
"Match_RequiresV8",
";",
"else",
"if",
"(",
"Inst",
".",
"getOperand",
"(",
"I",
")",
".",
"getReg",
"(",
")",
"==",
"ARM",
"::",
"PC",
")",
"return",
"Match_InvalidOperand",
";",
"}",
"return",
"Match_Success",
";",
"}",
"</s>"
] | [
"checkTargetMatchPredicate",
"-",
"Validate",
"the",
"instruction",
"match",
"against",
"any",
"complex",
"target",
"predicates",
"not",
"expressible",
"via",
"match",
"classes",
"."
] | [
"ARM",
"ARM",
"ARMII::ThumbArithFlagSetting",
"\"optionally flag setting instruction missing optional def operand\"",
"\"operand count mismatch!\"",
"0",
"ARM::CPSR",
"ARM::CPSR",
"ARM::CPSR",
"ARM::tADDhirr",
"ARM",
"1",
"ARM",
"2",
"ARM::tMOVr",
"ARM",
"0",
"ARM",
"1",
"0",
"ARM::rGPRRegClassID",
"ARM::SP",
"ARM::PC"
] | ARMAsmParser (2)5 | checkTargetMatchPredicate | ARM | CPU | LLVM | 3,180 | 364 | 1 | [] |
[
"<s>",
"static",
"rtx",
"ix86_expand_sse_compare_mask",
"(",
"enum",
"rtx_code",
"code",
",",
"rtx",
"op0",
",",
"rtx",
"op1",
",",
"bool",
"swap_operands",
")",
"{",
"rtx",
"(",
"*",
"insn",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
",",
"rtx",
")",
";",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"op0",
")",
";",
"rtx",
"mask",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"if",
"(",
"swap_operands",
")",
"std",
"::",
"swap",
"(",
"op0",
",",
"op1",
")",
";",
"insn",
"=",
"mode",
"==",
"DFmode",
"?",
"gen_setcc_df_sse",
":",
"gen_setcc_sf_sse",
";",
"emit_insn",
"(",
"insn",
"(",
"mask",
",",
"op0",
",",
"op1",
",",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"mode",
",",
"op0",
",",
"op1",
")",
")",
")",
";",
"return",
"mask",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"mask",
"generating",
"SSE",
"comparison",
"instruction",
"comparing",
"OP0",
"with",
"OP1",
"using",
"comparison",
"code",
"CODE",
".",
"Operands",
"are",
"swapped",
"for",
"the",
"comparison",
"if",
"SWAP_OPERANDS",
"is",
"true",
".",
"Returns",
"a",
"rtx",
"for",
"the",
"generated",
"mask",
"."
] | [
"i386"
] | i386-expand | ix86_expand_sse_compare_mask | i386 | CPU | GCC | 3,181 | 99 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"PTXDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"Node",
")",
"{",
"switch",
"(",
"Node",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"ISD",
"::",
"BRCOND",
":",
"return",
"SelectBRCOND",
"(",
"Node",
")",
";",
"case",
"PTXISD",
"::",
"READ_PARAM",
":",
"return",
"SelectREADPARAM",
"(",
"Node",
")",
";",
"case",
"PTXISD",
"::",
"WRITE_PARAM",
":",
"return",
"SelectWRITEPARAM",
"(",
"Node",
")",
";",
"case",
"ISD",
"::",
"FrameIndex",
":",
"return",
"SelectFrameIndex",
"(",
"Node",
")",
";",
"default",
":",
"return",
"SelectCode",
"(",
"Node",
")",
";",
"}",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"PTX",
"PTX",
"ISD::BRCOND",
"PTXISD::READ_PARAM",
"PTXISD::WRITE_PARAM",
"ISD::FrameIndex"
] | PTXISelDAGToDAG3 | Select | PTX | GPU | LLVM | 3,182 | 74 | 1 | [] |
[
"<s>",
"MCSymbol",
"*",
"AAPMCInstLower",
"::",
"GetExternalSymbolSymbol",
"(",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
"{",
"switch",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unknown target flag on GV operand\"",
")",
";",
"case",
"0",
":",
"break",
";",
"}",
"return",
"Printer",
".",
"GetExternalSymbolSymbol",
"(",
"MO",
".",
"getSymbolName",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"MCSymbol",
"for",
"the",
"specified",
"ExternalSymbol",
"."
] | [
"AAP",
"AAP",
"\"Unknown target flag on GV operand\"",
"0"
] | AAPMCInstLower | GetExternalSymbolSymbol | AAP | MPU | LLVM | 3,183 | 48 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"SDValue",
",",
"SDValue",
">",
"SystemZSelectionDAGInfo",
"::",
"EmitTargetCodeForMemcmp",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"SDLoc",
"&",
"DL",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Src1",
",",
"SDValue",
"Src2",
",",
"SDValue",
"Size",
",",
"MachinePointerInfo",
"Op1PtrInfo",
",",
"MachinePointerInfo",
"Op2PtrInfo",
")",
"const",
"{",
"if",
"(",
"auto",
"*",
"CSize",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Size",
")",
")",
"{",
"uint64_t",
"Bytes",
"=",
"CSize",
"->",
"getZExtValue",
"(",
")",
";",
"assert",
"(",
"Bytes",
">",
"0",
"&&",
"\"Caller should have handled 0-size case\"",
")",
";",
"Chain",
"=",
"emitCLC",
"(",
"DAG",
",",
"DL",
",",
"Chain",
",",
"Src1",
",",
"Src2",
",",
"Bytes",
")",
";",
"SDValue",
"Glue",
"=",
"Chain",
".",
"getValue",
"(",
"1",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"addIPMSequence",
"(",
"DL",
",",
"Glue",
",",
"DAG",
")",
",",
"Chain",
")",
";",
"}",
"return",
"std",
"::",
"make_pair",
"(",
"SDValue",
"(",
")",
",",
"SDValue",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memcmp/bcmp",
",",
"in",
"cases",
"where",
"that",
"is",
"faster",
"than",
"a",
"libcall",
"."
] | [
"SystemZ",
"SystemZ",
"0",
"\"Caller should have handled 0-size case\"",
"1"
] | SystemZSelectionDAGInfo20 | EmitTargetCodeForMemcmp | SystemZ | CPU | LLVM | 3,184 | 134 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"getName",
"(",
")",
"{",
"return",
"DEBUG_TYPE",
";",
"}",
"</s>"
] | [
"Return",
"a",
"string",
"with",
"the",
"name",
"of",
"the",
"plan",
"and",
"the",
"applicable",
"VFs",
"and",
"UFs",
"."
] | [
"PowerPC"
] | PPCInstructionSelector | getName | PowerPC | CPU | LLVM | 3,185 | 12 | 1 | [] |
[
"<s>",
"void",
"nios2_adjust_reg_alloc_order",
"(",
"void",
")",
"{",
"const",
"int",
"cdx_reg_alloc_order",
"[",
"]",
"=",
"{",
"2",
",",
"3",
",",
"4",
",",
"5",
",",
"6",
",",
"7",
",",
"16",
",",
"17",
",",
"8",
",",
"9",
",",
"10",
",",
"11",
",",
"12",
",",
"13",
",",
"14",
",",
"15",
",",
"31",
",",
"18",
",",
"19",
",",
"20",
",",
"21",
",",
"22",
",",
"23",
",",
"28",
",",
"0",
",",
"1",
",",
"24",
",",
"25",
",",
"26",
",",
"27",
",",
"29",
",",
"30",
",",
"32",
",",
"33",
",",
"34",
",",
"35",
",",
"36",
",",
"37",
",",
"38",
",",
"39",
"}",
";",
"if",
"(",
"TARGET_HAS_CDX",
")",
"memcpy",
"(",
"reg_alloc_order",
",",
"cdx_reg_alloc_order",
",",
"sizeof",
"(",
"int",
")",
"*",
"FIRST_PSEUDO_REGISTER",
")",
";",
"}",
"</s>"
] | [
"Implement",
"ADJUST_REG_ALLOC_ORDER",
".",
"We",
"use",
"the",
"default",
"ordering",
"for",
"R1",
"and",
"non-CDX",
"R2",
"code",
";",
"for",
"CDX",
"we",
"tweak",
"thing",
"to",
"prefer",
"the",
"registers",
"that",
"can",
"be",
"used",
"as",
"operands",
"to",
"instructions",
"that",
"have",
"3-bit",
"register",
"fields",
"."
] | [
"nios2",
"2",
"3",
"4",
"5",
"6",
"7",
"16",
"17",
"8",
"9",
"10",
"11",
"12",
"13",
"14",
"15",
"31",
"18",
"19",
"20",
"21",
"22",
"23",
"28",
"0",
"1",
"24",
"25",
"26",
"27",
"29",
"30",
"32",
"33",
"34",
"35",
"36",
"37",
"38",
"39"
] | nios2 | nios2_adjust_reg_alloc_order | nios2 | MPU | GCC | 3,186 | 113 | 1 | [] |
[
"<s>",
"bool",
"GCNPassConfig",
"::",
"addPreRewrite",
"(",
")",
"{",
"if",
"(",
"EnableRegReassign",
")",
"addPass",
"(",
"&",
"GCNNSAReassignID",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"addPreRewrite",
"-",
"Add",
"passes",
"to",
"the",
"optimized",
"register",
"allocation",
"pipeline",
"after",
"register",
"allocation",
"is",
"complete",
",",
"but",
"before",
"virtual",
"registers",
"are",
"rewritten",
"to",
"physical",
"registers",
"."
] | [
"AMDGPU"
] | AMDGPUTargetMachine (2)1 | addPreRewrite | AMDGPU | GPU | LLVM | 3,187 | 21 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"PASS_NAME",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"GBZ80"
] | GBZ80PostISel | getPassName | GBZ80 | MPU | LLVM | 3,188 | 11 | 1 | [] |
[
"<s>",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"override",
"{",
"ForCodeSize",
"=",
"MF",
".",
"getFunction",
"(",
")",
".",
"optForSize",
"(",
")",
";",
"Subtarget",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
";",
"return",
"SelectionDAGISel",
"::",
"runOnMachineFunction",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AArch64",
"AArch64"
] | AArch64ISelDAGToDAG18 | runOnMachineFunction | AArch64 | CPU | LLVM | 3,189 | 42 | 1 | [] |
[
"<s>",
"unsigned",
"GBZ80InstrInfo",
"::",
"isLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"GB",
"::",
"LD8_FI",
":",
"{",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"isFI",
"(",
")",
")",
"{",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"break",
";",
"}",
"default",
":",
"break",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isLoadFromStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"destination",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"GBZ80",
"GB",
"GB::LD8_FI",
"1",
"1",
"0",
"0"
] | GBZ80InstrInfo | isLoadFromStackSlot | GBZ80 | MPU | LLVM | 3,190 | 83 | 1 | [] |
[
"<s>",
"bool",
"ARMConstantIslands",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"MachineConstantPool",
"&",
"MCP",
"=",
"*",
"Fn",
".",
"getConstantPool",
"(",
")",
";",
"TII",
"=",
"Fn",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"AFI",
"=",
"Fn",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"isThumb",
"=",
"AFI",
"->",
"isThumbFunction",
"(",
")",
";",
"HasFarJump",
"=",
"false",
";",
"Fn",
".",
"RenumberBlocks",
"(",
")",
";",
"AFI",
"->",
"setAlign",
"(",
"isThumb",
"?",
"1U",
":",
"2U",
")",
";",
"std",
"::",
"vector",
"<",
"MachineInstr",
"*",
">",
"CPEMIs",
";",
"if",
"(",
"!",
"MCP",
".",
"isEmpty",
"(",
")",
")",
"{",
"DoInitialPlacement",
"(",
"Fn",
",",
"CPEMIs",
")",
";",
"if",
"(",
"isThumb",
")",
"AFI",
"->",
"setAlign",
"(",
"2U",
")",
";",
"}",
"AFI",
"->",
"initConstPoolEntryUId",
"(",
"CPEMIs",
".",
"size",
"(",
")",
")",
";",
"InitialFunctionScan",
"(",
"Fn",
",",
"CPEMIs",
")",
";",
"CPEMIs",
".",
"clear",
"(",
")",
";",
"RemoveUnusedCPEntries",
"(",
")",
";",
"bool",
"MadeChange",
"=",
"false",
";",
"while",
"(",
"true",
")",
"{",
"bool",
"Change",
"=",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"CPUsers",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"Change",
"|=",
"HandleConstantPoolUser",
"(",
"Fn",
",",
"i",
")",
";",
"DEBUG",
"(",
"dumpBBs",
"(",
")",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"ImmBranches",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"Change",
"|=",
"FixUpImmediateBr",
"(",
"Fn",
",",
"ImmBranches",
"[",
"i",
"]",
")",
";",
"DEBUG",
"(",
"dumpBBs",
"(",
")",
")",
";",
"if",
"(",
"!",
"Change",
")",
"break",
";",
"MadeChange",
"=",
"true",
";",
"}",
"verify",
"(",
"Fn",
")",
";",
"if",
"(",
"!",
"HasFarJump",
"&&",
"AFI",
"->",
"isLRSpilledForFarJump",
"(",
")",
"&&",
"isThumb",
")",
"MadeChange",
"|=",
"UndoLRSpillRestore",
"(",
")",
";",
"BBSizes",
".",
"clear",
"(",
")",
";",
"BBOffsets",
".",
"clear",
"(",
")",
";",
"WaterList",
".",
"clear",
"(",
")",
";",
"CPUsers",
".",
"clear",
"(",
")",
";",
"CPEntries",
".",
"clear",
"(",
")",
";",
"ImmBranches",
".",
"clear",
"(",
")",
";",
"PushPopMIs",
".",
"clear",
"(",
")",
";",
"return",
"MadeChange",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"1U",
"2U",
"2U",
"0",
"0"
] | ARMConstantIslandPass18 | runOnMachineFunction | ARM | CPU | LLVM | 3,191 | 315 | 1 | [] |
[
"<s>",
"void",
"AArch64InstPrinter",
"::",
"printRegName",
"(",
"raw_ostream",
"&",
"OS",
",",
"unsigned",
"RegNo",
")",
"const",
"{",
"OS",
"<<",
"getRegisterName",
"(",
"RegNo",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"assembler",
"register",
"name",
"."
] | [
"AArch64",
"AArch64"
] | AArch64InstPrinter (2) | printRegName | AArch64 | CPU | LLVM | 3,192 | 22 | 1 | [] |
[
"<s>",
"static",
"rtx",
"nios2_legitimize_constant_address",
"(",
"rtx",
"addr",
")",
"{",
"rtx",
"base",
",",
"offset",
";",
"split_const",
"(",
"addr",
",",
"&",
"base",
",",
"&",
"offset",
")",
";",
"if",
"(",
"nios2_tls_symbol_p",
"(",
"base",
")",
")",
"base",
"=",
"nios2_legitimize_tls_address",
"(",
"base",
")",
";",
"else",
"if",
"(",
"flag_pic",
")",
"base",
"=",
"nios2_load_pic_address",
"(",
"base",
",",
"UNSPEC_PIC_SYM",
",",
"NULL_RTX",
")",
";",
"else",
"if",
"(",
"!",
"nios2_large_constant_allowed",
"(",
")",
"&&",
"nios2_symbolic_constant_p",
"(",
"addr",
")",
")",
"return",
"nios2_split_large_constant",
"(",
"addr",
",",
"gen_reg_rtx",
"(",
"Pmode",
")",
")",
";",
"else",
"if",
"(",
"CONST_INT_P",
"(",
"addr",
")",
")",
"{",
"HOST_WIDE_INT",
"val",
"=",
"INTVAL",
"(",
"addr",
")",
";",
"if",
"(",
"SMALL_INT",
"(",
"val",
")",
")",
"return",
"addr",
";",
"else",
"if",
"(",
"!",
"nios2_large_constant_allowed",
"(",
")",
")",
"return",
"nios2_split_large_constant",
"(",
"addr",
",",
"gen_reg_rtx",
"(",
"Pmode",
")",
")",
";",
"}",
"else",
"return",
"addr",
";",
"if",
"(",
"offset",
"!=",
"const0_rtx",
")",
"{",
"gcc_assert",
"(",
"can_create_pseudo_p",
"(",
")",
")",
";",
"return",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"force_reg",
"(",
"Pmode",
",",
"base",
")",
",",
"(",
"CONST_INT_P",
"(",
"offset",
")",
"?",
"(",
"SMALL_INT",
"(",
"INTVAL",
"(",
"offset",
")",
")",
"?",
"offset",
":",
"force_reg",
"(",
"Pmode",
",",
"offset",
")",
")",
":",
"offset",
")",
")",
";",
"}",
"return",
"base",
";",
"}",
"</s>"
] | [
"Legitimize",
"addresses",
"that",
"are",
"CONSTANT_P",
"expressions",
"."
] | [
"nios2"
] | nios2 | nios2_legitimize_constant_address | nios2 | MPU | GCC | 3,193 | 189 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"getReg",
"(",
"const",
"void",
"*",
"D",
",",
"unsigned",
"RC",
",",
"unsigned",
"RegNo",
")",
"{",
"const",
"NyuziDisassembler",
"*",
"Dis",
"=",
"static_cast",
"<",
"const",
"NyuziDisassembler",
"*",
">",
"(",
"D",
")",
";",
"return",
"*",
"(",
"Dis",
"->",
"getRegInfo",
"(",
")",
"->",
"getRegClass",
"(",
"RC",
")",
".",
"begin",
"(",
")",
"+",
"RegNo",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"Nyuzi",
"Nyuzi",
"Nyuzi"
] | NyuziDisassembler | getReg | Nyuzi | GPU | LLVM | 3,194 | 53 | 1 | [] |
[
"<s>",
"void",
"MipsSETargetLowering",
"::",
"getOpndList",
"(",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"Ops",
",",
"std",
"::",
"deque",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"SDValue",
">>",
"&",
"RegsToPass",
",",
"bool",
"IsPICCall",
",",
"bool",
"GlobalOrExternal",
",",
"bool",
"InternalLinkage",
",",
"bool",
"IsCallReloc",
",",
"CallLoweringInfo",
"&",
"CLI",
",",
"SDValue",
"Callee",
",",
"SDValue",
"Chain",
")",
"const",
"{",
"Ops",
".",
"push_back",
"(",
"Callee",
")",
";",
"MipsTargetLowering",
"::",
"getOpndList",
"(",
"Ops",
",",
"RegsToPass",
",",
"IsPICCall",
",",
"GlobalOrExternal",
",",
"InternalLinkage",
",",
"IsCallReloc",
",",
"CLI",
",",
"Callee",
",",
"Chain",
")",
";",
"}",
"</s>"
] | [
"This",
"function",
"fills",
"Ops",
",",
"which",
"is",
"the",
"list",
"of",
"operands",
"that",
"will",
"later",
"be",
"used",
"when",
"a",
"function",
"call",
"node",
"is",
"created",
"."
] | [
"Mips",
"Mips",
"Mips"
] | MipsSEISelLowering15 | getOpndList | Mips | CPU | LLVM | 3,195 | 82 | 1 | [] |
[
"<s>",
"void",
"BitcodeWriter",
"::",
"writeSymtab",
"(",
")",
"{",
"assert",
"(",
"!",
"WroteStrtab",
"&&",
"!",
"WroteSymtab",
")",
";",
"for",
"(",
"Module",
"*",
"M",
":",
"Mods",
")",
"{",
"if",
"(",
"M",
"->",
"getModuleInlineAsm",
"(",
")",
".",
"empty",
"(",
")",
")",
"continue",
";",
"}",
"WroteSymtab",
"=",
"true",
";",
"SmallVector",
"<",
"char",
",",
"0",
">",
"Symtab",
";",
"if",
"(",
"Error",
"E",
"=",
"irsymtab",
"::",
"build",
"(",
"Mods",
",",
"Symtab",
",",
"StrtabBuilder",
",",
"Alloc",
")",
")",
"{",
"consumeError",
"(",
"std",
"::",
"move",
"(",
"E",
")",
")",
";",
"return",
";",
"}",
"writeBlob",
"(",
"bitc",
"::",
"SYMTAB_BLOCK_ID",
",",
"bitc",
"::",
"SYMTAB_BLOB",
",",
"{",
"Symtab",
".",
"data",
"(",
")",
",",
"Symtab",
".",
"size",
"(",
")",
"}",
")",
";",
"}",
"</s>"
] | [
"Attempt",
"to",
"write",
"a",
"symbol",
"table",
"to",
"the",
"bitcode",
"file",
"."
] | [
"DirectX",
"0"
] | DXILBitcodeWriter | writeSymtab | DirectX | Virtual ISA | LLVM | 3,196 | 110 | 1 | [] |
[
"<s>",
"bool",
"MipsAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"StringRef",
"IDVal",
"=",
"DirectiveID",
".",
"getString",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".ent\"",
")",
"{",
"Parser",
".",
"Lex",
"(",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"\".end\"",
")",
"{",
"Parser",
".",
"Lex",
"(",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"\".frame\"",
")",
"{",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"\".set\"",
")",
"{",
"return",
"parseDirectiveSet",
"(",
")",
";",
"}",
"if",
"(",
"IDVal",
"==",
"\".fmask\"",
")",
"{",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"\".mask\"",
")",
"{",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"\".gpword\"",
")",
"{",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"\".word\"",
")",
"{",
"parseDirectiveWord",
"(",
"4",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"\".mips_hack_stocg\"",
")",
"return",
"parseDirectiveMipsHackStocg",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".mips_hack_elf_flags\"",
")",
"return",
"parseDirectiveMipsHackELFFlags",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"Mips",
"Mips",
"\".ent\"",
"\".end\"",
"\".frame\"",
"\".set\"",
"\".fmask\"",
"\".mask\"",
"\".gpword\"",
"\".word\"",
"4",
"\".mips_hack_stocg\"",
"Mips",
"\".mips_hack_elf_flags\"",
"Mips"
] | MipsAsmParser79 | ParseDirective | Mips | CPU | LLVM | 3,197 | 181 | 1 | [] |
[
"<s>",
"const",
"MCExpr",
"*",
"getSubExpr",
"(",
")",
"const",
"{",
"return",
"Expr",
";",
"}",
"</s>"
] | [
"getSubExpr",
"-",
"Get",
"the",
"child",
"of",
"this",
"expression",
"."
] | [
"VE"
] | VEMCExpr | getSubExpr | VE | CPU | LLVM | 3,198 | 12 | 1 | [] |
[
"<s>",
"SDValue",
"PPCTargetLowering",
"::",
"LowerCall",
"(",
"SDValue",
"Chain",
",",
"SDValue",
"Callee",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"bool",
"&",
"isTailCall",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"if",
"(",
"isTailCall",
")",
"isTailCall",
"=",
"IsEligibleForTailCallOptimization",
"(",
"Callee",
",",
"CallConv",
",",
"isVarArg",
",",
"Ins",
",",
"DAG",
")",
";",
"if",
"(",
"PPCSubTarget",
".",
"isSVR4ABI",
"(",
")",
"&&",
"!",
"PPCSubTarget",
".",
"isPPC64",
"(",
")",
")",
"{",
"return",
"LowerCall_SVR4",
"(",
"Chain",
",",
"Callee",
",",
"CallConv",
",",
"isVarArg",
",",
"isTailCall",
",",
"Outs",
",",
"OutVals",
",",
"Ins",
",",
"dl",
",",
"DAG",
",",
"InVals",
")",
";",
"}",
"else",
"{",
"return",
"LowerCall_Darwin",
"(",
"Chain",
",",
"Callee",
",",
"CallConv",
",",
"isVarArg",
",",
"isTailCall",
",",
"Outs",
",",
"OutVals",
",",
"Ins",
",",
"dl",
",",
"DAG",
",",
"InVals",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"calls",
"into",
"the",
"specified",
"DAG",
"."
] | [
"PowerPC",
"PPC",
"ISD::OutputArg",
"ISD::InputArg",
"PPC",
"PPC",
"PPC"
] | PPCISelLowering54 | LowerCall | PowerPC | CPU | LLVM | 3,199 | 159 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.