ground_truth
listlengths 8
512
| natrual_language
listlengths 1
243
| TS_V_token
listlengths 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
listlengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"void",
"RISCVAsmPrinter",
"::",
"emitStartOfAsmFile",
"(",
"Module",
"&",
"M",
")",
"{",
"if",
"(",
"TM",
".",
"getTargetTriple",
"(",
")",
".",
"isOSBinFormatELF",
"(",
")",
")",
"emitAttributes",
"(",
")",
";",
"}",
"</s>"
] |
[
"This",
"virtual",
"method",
"can",
"be",
"overridden",
"by",
"targets",
"that",
"want",
"to",
"emit",
"something",
"at",
"the",
"start",
"of",
"their",
"file",
"."
] |
[
"RI5CY",
"RISCV"
] |
RISCVAsmPrinter
|
emitStartOfAsmFile
|
RI5CY
|
CPU
|
LLVM
| 1,000 | 27 | 1 |
[] |
[
"<s>",
"SDValue",
"LanaiSelectionDAGInfo",
"::",
"EmitTargetCodeForMemcpy",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"SDLoc",
"&",
"dl",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Dst",
",",
"SDValue",
"Src",
",",
"SDValue",
"Size",
",",
"unsigned",
"Align",
",",
"bool",
"isVolatile",
",",
"bool",
"AlwaysInline",
",",
"MachinePointerInfo",
"DstPtrInfo",
",",
"MachinePointerInfo",
"SrcPtrInfo",
")",
"const",
"{",
"ConstantSDNode",
"*",
"ConstantSize",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Size",
")",
";",
"if",
"(",
"!",
"ConstantSize",
")",
"return",
"SDValue",
"(",
")",
";",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] |
[
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memcpy",
"."
] |
[
"Lanai",
"Lanai"
] |
LanaiSelectionDAGInfo8
|
EmitTargetCodeForMemcpy
|
Lanai
|
CPU
|
LLVM
| 1,001 | 71 | 1 |
[] |
[
"<s>",
"bool",
"fixupNeedsRelaxation",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"uint64_t",
"Value",
",",
"const",
"MCInstFragment",
"*",
"DF",
",",
"const",
"MCAsmLayout",
"&",
"Layout",
")",
"const",
"{",
"llvm_unreachable",
"(",
"\"RelaxInstruction() is not implemented yet\"",
")",
";",
"}",
"</s>"
] |
[
"Simple",
"predicate",
"for",
"targets",
"where",
"!",
"Resolved",
"implies",
"requiring",
"relaxation",
"."
] |
[
"TOY",
"\"RelaxInstruction() is not implemented yet\""
] |
TOYAsmBackend
|
fixupNeedsRelaxation
|
TOY
|
CPU
|
LLVM
| 1,002 | 29 | 1 |
[] |
[
"<s>",
"void",
"X86FrameLowering",
"::",
"emitStackProbe",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
",",
"const",
"DebugLoc",
"&",
"DL",
",",
"bool",
"InProlog",
")",
"const",
"{",
"const",
"X86Subtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"if",
"(",
"STI",
".",
"isTargetWindowsCoreCLR",
"(",
")",
")",
"{",
"if",
"(",
"InProlog",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"X86",
"::",
"STACKALLOC_W_PROBING",
")",
")",
".",
"addImm",
"(",
"0",
")",
";",
"}",
"else",
"{",
"emitStackProbeInline",
"(",
"MF",
",",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"false",
")",
";",
"}",
"}",
"else",
"{",
"emitStackProbeCall",
"(",
"MF",
",",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"InProlog",
")",
";",
"}",
"}",
"</s>"
] |
[
"Emit",
"target",
"stack",
"probe",
"code",
"."
] |
[
"X86",
"X86",
"X86",
"X86",
"X86::STACKALLOC_W_PROBING",
"0"
] |
X86FrameLowering1
|
emitStackProbe
|
X86
|
CPU
|
LLVM
| 1,003 | 114 | 1 |
[] |
[
"<s>",
"static",
"void",
"*",
"device_malloc",
"(",
"size_t",
"size",
",",
"hsa_region_t",
"region",
")",
"{",
"void",
"*",
"result",
";",
"XHSA",
"(",
"hsa_fns",
".",
"hsa_memory_allocate_fn",
"(",
"region",
",",
"size",
",",
"&",
"result",
")",
",",
"\"Allocate device memory\"",
")",
";",
"return",
"result",
";",
"}",
"</s>"
] |
[
"Allocate",
"some",
"device",
"memory",
"from",
"the",
"kernargs",
"region",
".",
"The",
"returned",
"address",
"will",
"be",
"32-bit",
"(",
"with",
"excess",
"zeroed",
"on",
"64-bit",
"host",
")",
",",
"and",
"accessible",
"via",
"the",
"same",
"address",
"on",
"both",
"host",
"and",
"target",
"(",
"via",
"__flat_scalar",
"GCN",
"address",
"space",
")",
"."
] |
[
"gcn",
"\"Allocate device memory\""
] |
gcn-run
|
device_malloc
|
gcn
|
GPU
|
GCC
| 1,004 | 37 | 1 |
[] |
[
"<s>",
"SDValue",
"PPCTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"assert",
"(",
"0",
"&&",
"\"Wasn't expecting to be able to lower this!\"",
")",
";",
"case",
"ISD",
"::",
"ConstantPool",
":",
"return",
"LowerConstantPool",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"LowerGlobalAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalTLSAddress",
":",
"return",
"LowerGlobalTLSAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"JumpTable",
":",
"return",
"LowerJumpTable",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SETCC",
":",
"return",
"LowerSETCC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"TRAMPOLINE",
":",
"return",
"LowerTRAMPOLINE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VASTART",
":",
"return",
"LowerVASTART",
"(",
"Op",
",",
"DAG",
",",
"VarArgsFrameIndex",
",",
"VarArgsStackOffset",
",",
"VarArgsNumGPR",
",",
"VarArgsNumFPR",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"VAARG",
":",
"return",
"LowerVAARG",
"(",
"Op",
",",
"DAG",
",",
"VarArgsFrameIndex",
",",
"VarArgsStackOffset",
",",
"VarArgsNumGPR",
",",
"VarArgsNumFPR",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"FORMAL_ARGUMENTS",
":",
"return",
"LowerFORMAL_ARGUMENTS",
"(",
"Op",
",",
"DAG",
",",
"VarArgsFrameIndex",
",",
"VarArgsStackOffset",
",",
"VarArgsNumGPR",
",",
"VarArgsNumFPR",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"CALL",
":",
"return",
"LowerCALL",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
",",
"getTargetMachine",
"(",
")",
")",
";",
"case",
"ISD",
"::",
"RET",
":",
"return",
"LowerRET",
"(",
"Op",
",",
"DAG",
",",
"getTargetMachine",
"(",
")",
")",
";",
"case",
"ISD",
"::",
"STACKRESTORE",
":",
"return",
"LowerSTACKRESTORE",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"DYNAMIC_STACKALLOC",
":",
"return",
"LowerDYNAMIC_STACKALLOC",
"(",
"Op",
",",
"DAG",
",",
"PPCSubTarget",
")",
";",
"case",
"ISD",
"::",
"SELECT_CC",
":",
"return",
"LowerSELECT_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FP_TO_SINT",
":",
"return",
"LowerFP_TO_SINT",
"(",
"Op",
",",
"DAG",
",",
"Op",
".",
"getDebugLoc",
"(",
")",
")",
";",
"case",
"ISD",
"::",
"SINT_TO_FP",
":",
"return",
"LowerSINT_TO_FP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FLT_ROUNDS_",
":",
"return",
"LowerFLT_ROUNDS_",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SHL_PARTS",
":",
"return",
"LowerSHL_PARTS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SRL_PARTS",
":",
"return",
"LowerSRL_PARTS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SRA_PARTS",
":",
"return",
"LowerSRA_PARTS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BUILD_VECTOR",
":",
"return",
"LowerBUILD_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VECTOR_SHUFFLE",
":",
"return",
"LowerVECTOR_SHUFFLE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"LowerINTRINSIC_WO_CHAIN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SCALAR_TO_VECTOR",
":",
"return",
"LowerSCALAR_TO_VECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"MUL",
":",
"return",
"LowerMUL",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"RETURNADDR",
":",
"return",
"LowerRETURNADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRAMEADDR",
":",
"return",
"LowerFRAMEADDR",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] |
[
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] |
[
"PowerPC",
"PPC",
"0",
"\"Wasn't expecting to be able to lower this!\"",
"ISD::ConstantPool",
"ISD::GlobalAddress",
"ISD::GlobalTLSAddress",
"ISD::JumpTable",
"ISD::SETCC",
"ISD::TRAMPOLINE",
"ISD::VASTART",
"PPC",
"ISD::VAARG",
"PPC",
"ISD::FORMAL_ARGUMENTS",
"PPC",
"ISD::CALL",
"PPC",
"ISD::RET",
"ISD::STACKRESTORE",
"PPC",
"ISD::DYNAMIC_STACKALLOC",
"PPC",
"ISD::SELECT_CC",
"ISD::FP_TO_SINT",
"ISD::SINT_TO_FP",
"ISD::FLT_ROUNDS_",
"ISD::SHL_PARTS",
"ISD::SRL_PARTS",
"ISD::SRA_PARTS",
"ISD::BUILD_VECTOR",
"ISD::VECTOR_SHUFFLE",
"ISD::INTRINSIC_WO_CHAIN",
"ISD::SCALAR_TO_VECTOR",
"ISD::MUL",
"ISD::RETURNADDR",
"ISD::FRAMEADDR"
] |
PPCISelLowering123
|
LowerOperation
|
PowerPC
|
CPU
|
LLVM
| 1,005 | 439 | 1 |
[] |
[
"<s>",
"std",
"::",
"unique_ptr",
"<",
"SICacheControl",
">",
"SICacheControl",
"::",
"create",
"(",
"const",
"SISubtarget",
"&",
"ST",
")",
"{",
"AMDGPUSubtarget",
"::",
"Generation",
"Generation",
"=",
"ST",
".",
"getGeneration",
"(",
")",
";",
"if",
"(",
"Generation",
"<=",
"AMDGPUSubtarget",
"::",
"SOUTHERN_ISLANDS",
")",
"return",
"make_unique",
"<",
"SIGfx6CacheControl",
">",
"(",
"ST",
")",
";",
"return",
"make_unique",
"<",
"SIGfx7CacheControl",
">",
"(",
"ST",
")",
";",
"}",
"</s>"
] |
[
"This",
"creates",
"an",
"identified",
"struct",
"."
] |
[
"AMDGPU",
"SI",
"SI",
"SI",
"AMDGPU",
"AMDGPU",
"SI",
"SI"
] |
SIMemoryLegalizer21
|
create
|
AMDGPU
|
GPU
|
LLVM
| 1,006 | 54 | 1 |
[] |
[
"<s>",
"void",
"arm_load_pic_register",
"(",
"unsigned",
"long",
"saved_regs",
"ATTRIBUTE_UNUSED",
",",
"rtx",
"pic_reg",
")",
"{",
"rtx",
"l1",
",",
"labelno",
",",
"pic_tmp",
",",
"pic_rtx",
";",
"if",
"(",
"crtl",
"->",
"uses_pic_offset_table",
"==",
"0",
"||",
"TARGET_SINGLE_PIC_BASE",
")",
"return",
";",
"gcc_assert",
"(",
"flag_pic",
")",
";",
"if",
"(",
"pic_reg",
"==",
"NULL_RTX",
")",
"pic_reg",
"=",
"cfun",
"->",
"machine",
"->",
"pic_reg",
";",
"if",
"(",
"TARGET_VXWORKS_RTP",
")",
"{",
"pic_rtx",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"VXWORKS_GOTT_BASE",
")",
";",
"pic_rtx",
"=",
"gen_rtx_CONST",
"(",
"Pmode",
",",
"pic_rtx",
")",
";",
"emit_insn",
"(",
"gen_pic_load_addr_32bit",
"(",
"pic_reg",
",",
"pic_rtx",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"pic_reg",
",",
"gen_rtx_MEM",
"(",
"Pmode",
",",
"pic_reg",
")",
")",
")",
";",
"pic_tmp",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"VXWORKS_GOTT_INDEX",
")",
";",
"emit_insn",
"(",
"gen_pic_offset_arm",
"(",
"pic_reg",
",",
"pic_reg",
",",
"pic_tmp",
")",
")",
";",
"}",
"else",
"{",
"labelno",
"=",
"GEN_INT",
"(",
"pic_labelno",
"++",
")",
";",
"l1",
"=",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"1",
",",
"labelno",
")",
",",
"UNSPEC_PIC_LABEL",
")",
";",
"l1",
"=",
"gen_rtx_CONST",
"(",
"VOIDmode",
",",
"l1",
")",
";",
"pic_rtx",
"=",
"plus_constant",
"(",
"Pmode",
",",
"l1",
",",
"TARGET_ARM",
"?",
"8",
":",
"4",
")",
";",
"pic_rtx",
"=",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"1",
",",
"pic_rtx",
")",
",",
"UNSPEC_GOTSYM_OFF",
")",
";",
"pic_rtx",
"=",
"gen_rtx_CONST",
"(",
"Pmode",
",",
"pic_rtx",
")",
";",
"if",
"(",
"TARGET_32BIT",
")",
"{",
"emit_insn",
"(",
"gen_pic_load_addr_unified",
"(",
"pic_reg",
",",
"pic_rtx",
",",
"labelno",
")",
")",
";",
"}",
"else",
"{",
"if",
"(",
"arm_pic_register",
"!=",
"INVALID_REGNUM",
"&&",
"REGNO",
"(",
"pic_reg",
")",
">",
"LAST_LO_REGNUM",
")",
"{",
"pic_tmp",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"thumb_find_work_register",
"(",
"saved_regs",
")",
")",
";",
"emit_insn",
"(",
"gen_pic_load_addr_thumb1",
"(",
"pic_tmp",
",",
"pic_rtx",
")",
")",
";",
"emit_insn",
"(",
"gen_movsi",
"(",
"pic_offset_table_rtx",
",",
"pic_tmp",
")",
")",
";",
"emit_insn",
"(",
"gen_pic_add_dot_plus_four",
"(",
"pic_reg",
",",
"pic_reg",
",",
"labelno",
")",
")",
";",
"}",
"else",
"if",
"(",
"arm_pic_register",
"!=",
"INVALID_REGNUM",
"&&",
"arm_pic_register",
">",
"LAST_LO_REGNUM",
"&&",
"REGNO",
"(",
"pic_reg",
")",
"<=",
"LAST_LO_REGNUM",
")",
"{",
"emit_insn",
"(",
"gen_pic_load_addr_unified",
"(",
"pic_reg",
",",
"pic_rtx",
",",
"labelno",
")",
")",
";",
"emit_move_insn",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"arm_pic_register",
")",
",",
"pic_reg",
")",
";",
"emit_use",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"arm_pic_register",
")",
")",
";",
"}",
"else",
"emit_insn",
"(",
"gen_pic_load_addr_unified",
"(",
"pic_reg",
",",
"pic_rtx",
",",
"labelno",
")",
")",
";",
"}",
"}",
"emit_use",
"(",
"pic_reg",
")",
";",
"}",
"</s>"
] |
[
"Generate",
"code",
"to",
"load",
"the",
"PIC",
"register",
".",
"In",
"thumb",
"mode",
"SCRATCH",
"is",
"a",
"low",
"register",
"."
] |
[
"arm",
"0",
"1",
"8",
"4",
"1"
] |
arm8
|
arm_load_pic_register
|
arm
|
CPU
|
GCC
| 1,007 | 351 | 1 |
[] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"unsigned",
">",
"MOSInstrInfo",
"::",
"decomposeMachineOperandsTargetFlags",
"(",
"unsigned",
"TF",
")",
"const",
"{",
"return",
"std",
"::",
"make_pair",
"(",
"TF",
",",
"0u",
")",
";",
"}",
"</s>"
] |
[
"Decompose",
"the",
"machine",
"operand",
"'s",
"target",
"flags",
"into",
"two",
"values",
"-",
"the",
"direct",
"target",
"flag",
"value",
"and",
"any",
"of",
"bit",
"flags",
"that",
"are",
"applied",
"."
] |
[
"MOS",
"MOS",
"0u"
] |
MOSInstrInfo
|
decomposeMachineOperandsTargetFlags
|
MOS
|
MPU
|
LLVM
| 1,008 | 28 | 1 |
[] |
[
"<s>",
"bool",
"M68kPassConfig",
"::",
"addGlobalInstructionSelect",
"(",
")",
"{",
"addPass",
"(",
"new",
"InstructionSelect",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] |
[
"This",
"method",
"should",
"install",
"a",
"(",
"global",
")",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"possibly",
"generic",
"instructions",
"to",
"fully",
"target-specific",
"instructions",
",",
"thereby",
"constraining",
"all",
"generic",
"virtual",
"registers",
"to",
"register",
"classes",
"."
] |
[
"M68k",
"M68k"
] |
M68kTargetMachine
|
addGlobalInstructionSelect
|
M68k
|
MPU
|
LLVM
| 1,009 | 19 | 1 |
[] |
[
"<s>",
"static",
"void",
"load_reg",
"(",
"int",
"reg",
",",
"HOST_WIDE_INT",
"disp",
",",
"int",
"base",
")",
"{",
"rtx",
"dest",
"=",
"gen_rtx_REG",
"(",
"word_mode",
",",
"reg",
")",
";",
"rtx",
"basereg",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"base",
")",
";",
"rtx",
"src",
";",
"if",
"(",
"VAL_14_BITS_P",
"(",
"disp",
")",
")",
"src",
"=",
"gen_rtx_MEM",
"(",
"word_mode",
",",
"plus_constant",
"(",
"Pmode",
",",
"basereg",
",",
"disp",
")",
")",
";",
"else",
"if",
"(",
"TARGET_64BIT",
"&&",
"!",
"VAL_32_BITS_P",
"(",
"disp",
")",
")",
"{",
"rtx",
"delta",
"=",
"GEN_INT",
"(",
"disp",
")",
";",
"rtx",
"tmpreg",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"1",
")",
";",
"emit_move_insn",
"(",
"tmpreg",
",",
"delta",
")",
";",
"if",
"(",
"TARGET_DISABLE_INDEXING",
")",
"{",
"emit_move_insn",
"(",
"tmpreg",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"tmpreg",
",",
"basereg",
")",
")",
";",
"src",
"=",
"gen_rtx_MEM",
"(",
"word_mode",
",",
"tmpreg",
")",
";",
"}",
"else",
"src",
"=",
"gen_rtx_MEM",
"(",
"word_mode",
",",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"tmpreg",
",",
"basereg",
")",
")",
";",
"}",
"else",
"{",
"rtx",
"delta",
"=",
"GEN_INT",
"(",
"disp",
")",
";",
"rtx",
"high",
"=",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"basereg",
",",
"gen_rtx_HIGH",
"(",
"Pmode",
",",
"delta",
")",
")",
";",
"rtx",
"tmpreg",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"1",
")",
";",
"emit_move_insn",
"(",
"tmpreg",
",",
"high",
")",
";",
"src",
"=",
"gen_rtx_MEM",
"(",
"word_mode",
",",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"tmpreg",
",",
"delta",
")",
")",
";",
"}",
"emit_move_insn",
"(",
"dest",
",",
"src",
")",
";",
"}",
"</s>"
] |
[
"Emit",
"RTL",
"to",
"load",
"REG",
"from",
"the",
"memory",
"location",
"specified",
"by",
"BASE+DISP",
".",
"Handle",
"case",
"where",
"DISP",
">",
"8k",
"by",
"using",
"the",
"add_high_const",
"patterns",
"."
] |
[
"pa",
"1",
"1"
] |
pa
|
load_reg
|
pa
|
CPU
|
GCC
| 1,010 | 213 | 1 |
[] |
[
"<s>",
"static",
"void",
"frv_registers_update",
"(",
"rtx",
"x",
")",
"{",
"regstate_t",
"flags",
";",
"flags",
"=",
"REGSTATE_MODIFIED",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"COND_EXEC",
")",
"{",
"flags",
"|=",
"frv_cond_flags",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
";",
"x",
"=",
"XEXP",
"(",
"x",
",",
"1",
")",
";",
"}",
"note_stores",
"(",
"x",
",",
"frv_registers_update_1",
",",
"&",
"flags",
")",
";",
"}",
"</s>"
] |
[
"Update",
"the",
"register",
"state",
"information",
"for",
"an",
"instruction",
"whose",
"body",
"is",
"X",
"."
] |
[
"frv",
"0",
"1"
] |
frv2
|
frv_registers_update
|
frv
|
VLIW
|
GCC
| 1,011 | 58 | 1 |
[] |
[
"<s>",
"void",
"i386_pe_encode_section_info",
"(",
"tree",
"decl",
",",
"rtx",
"rtl",
",",
"int",
"first",
")",
"{",
"default_encode_section_info",
"(",
"decl",
",",
"rtl",
",",
"first",
")",
";",
"if",
"(",
"first",
"&&",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
")",
"{",
"tree",
"type_attributes",
"=",
"TYPE_ATTRIBUTES",
"(",
"TREE_TYPE",
"(",
"decl",
")",
")",
";",
"tree",
"newid",
"=",
"NULL_TREE",
";",
"if",
"(",
"lookup_attribute",
"(",
"\"stdcall\"",
",",
"type_attributes",
")",
")",
"newid",
"=",
"gen_stdcall_or_fastcall_suffix",
"(",
"decl",
",",
"false",
")",
";",
"else",
"if",
"(",
"lookup_attribute",
"(",
"\"fastcall\"",
",",
"type_attributes",
")",
")",
"newid",
"=",
"gen_stdcall_or_fastcall_suffix",
"(",
"decl",
",",
"true",
")",
";",
"if",
"(",
"newid",
"!=",
"NULL_TREE",
")",
"{",
"rtx",
"rtlname",
"=",
"XEXP",
"(",
"rtl",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"rtlname",
")",
"==",
"MEM",
")",
"rtlname",
"=",
"XEXP",
"(",
"rtlname",
",",
"0",
")",
";",
"XSTR",
"(",
"rtlname",
",",
"0",
")",
"=",
"IDENTIFIER_POINTER",
"(",
"newid",
")",
";",
"change_decl_assembler_name",
"(",
"decl",
",",
"newid",
")",
";",
"}",
"}",
"if",
"(",
"i386_pe_dllexport_p",
"(",
"decl",
")",
")",
"i386_pe_mark_dllexport",
"(",
"decl",
")",
";",
"else",
"if",
"(",
"i386_pe_dllimport_p",
"(",
"decl",
")",
")",
"i386_pe_mark_dllimport",
"(",
"decl",
")",
";",
"else",
"gcc_assert",
"(",
"!",
"(",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
"||",
"TREE_CODE",
"(",
"decl",
")",
"==",
"VAR_DECL",
")",
"&&",
"rtl",
"!=",
"NULL_RTX",
"&&",
"GET_CODE",
"(",
"rtl",
")",
"==",
"MEM",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"rtl",
",",
"0",
")",
")",
"==",
"MEM",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"rtl",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"SYMBOL_REF",
"&&",
"i386_pe_dllimport_name_p",
"(",
"XSTR",
"(",
"XEXP",
"(",
"XEXP",
"(",
"rtl",
",",
"0",
")",
",",
"0",
")",
",",
"0",
")",
")",
")",
")",
";",
"}",
"</s>"
] |
[
"Cover",
"function",
"to",
"implement",
"ENCODE_SECTION_INFO",
"."
] |
[
"i386",
"\"stdcall\"",
"\"fastcall\"",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0"
] |
winnt3
|
i386_pe_encode_section_info
|
i386
|
CPU
|
GCC
| 1,012 | 252 | 1 |
[] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"preferIncOfAddToSubOfNot",
"(",
"EVT",
"VT",
")",
"const",
"{",
"return",
"VT",
".",
"isScalarInteger",
"(",
")",
";",
"}",
"</s>"
] |
[
"These",
"two",
"forms",
"are",
"equivalent",
":",
"sub",
"y",
",",
"(",
"xor",
"x",
",",
"-1",
")",
"add",
"(",
"add",
"x",
",",
"1",
")",
",",
"y",
"The",
"variant",
"with",
"two",
"add",
"'s",
"is",
"IR-canonical",
"."
] |
[
"AArch64",
"AArch64"
] |
AArch64ISelLowering (2)2
|
preferIncOfAddToSubOfNot
|
AArch64
|
CPU
|
LLVM
| 1,013 | 18 | 1 |
[] |
[
"<s>",
"MachineBasicBlock",
"*",
"M68kTargetLowering",
"::",
"EmitInstrWithCustomInserter",
"(",
"MachineInstr",
"&",
"MI",
",",
"MachineBasicBlock",
"*",
"BB",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unexpected instr type to insert\"",
")",
";",
"case",
"M68k",
"::",
"CMOV8d",
":",
"case",
"M68k",
"::",
"CMOV16d",
":",
"case",
"M68k",
"::",
"CMOV32r",
":",
"return",
"EmitLoweredSelect",
"(",
"MI",
",",
"BB",
")",
";",
"case",
"M68k",
"::",
"SALLOCA",
":",
"return",
"EmitLoweredSegAlloca",
"(",
"MI",
",",
"BB",
")",
";",
"}",
"}",
"</s>"
] |
[
"This",
"method",
"should",
"be",
"implemented",
"by",
"targets",
"that",
"mark",
"instructions",
"with",
"the",
"'usesCustomInserter",
"'",
"flag",
"."
] |
[
"M68k",
"M68k",
"\"Unexpected instr type to insert\"",
"M68k::CMOV8d",
"M68k::CMOV16d",
"M68k::CMOV32r",
"M68k::SALLOCA"
] |
M68kISelLowering
|
EmitInstrWithCustomInserter
|
M68k
|
MPU
|
LLVM
| 1,014 | 70 | 1 |
[] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"SI Type Rewriter\"",
";",
"}",
"</s>"
] |
[
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] |
[
"R600",
"\"SI Type Rewriter\""
] |
SITypeRewriter
|
getPassName
|
R600
|
GPU
|
LLVM
| 1,015 | 13 | 1 |
[] |
[
"<s>",
"static",
"int",
"unspec_sqrdcmlah",
"(",
"int",
"rot",
")",
"{",
"switch",
"(",
"rot",
")",
"{",
"case",
"0",
":",
"return",
"UNSPEC_SQRDCMLAH",
";",
"case",
"90",
":",
"return",
"UNSPEC_SQRDCMLAH90",
";",
"case",
"180",
":",
"return",
"UNSPEC_SQRDCMLAH180",
";",
"case",
"270",
":",
"return",
"UNSPEC_SQRDCMLAH270",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] |
[
"Return",
"the",
"UNSPEC_SQRDCMLAH",
"*",
"unspec",
"for",
"rotation",
"amount",
"ROT",
"."
] |
[
"aarch64",
"0",
"90",
"180",
"270"
] |
aarch64-sve-builtins-sve2
|
unspec_sqrdcmlah
|
aarch64
|
CPU
|
GCC
| 1,016 | 45 | 1 |
[] |
[
"<s>",
"static",
"bool",
"conditions_opposite_p",
"(",
"rtx",
"cond1",
",",
"rtx",
"cond2",
")",
"{",
"return",
"(",
"rtx_equal_p",
"(",
"XEXP",
"(",
"cond1",
",",
"0",
")",
",",
"XEXP",
"(",
"cond2",
",",
"0",
")",
")",
"&&",
"rtx_equal_p",
"(",
"XEXP",
"(",
"cond1",
",",
"1",
")",
",",
"XEXP",
"(",
"cond2",
",",
"1",
")",
")",
"&&",
"GET_CODE",
"(",
"cond1",
")",
"==",
"reverse_condition",
"(",
"GET_CODE",
"(",
"cond2",
")",
")",
")",
";",
"}",
"</s>"
] |
[
"Return",
"true",
"iff",
"COND1",
"and",
"COND2",
"are",
"exactly",
"opposite",
"conditions",
"one",
"of",
"them",
"NE",
"and",
"the",
"other",
"EQ",
"."
] |
[
"c6x",
"0",
"0",
"1",
"1"
] |
c6x
|
conditions_opposite_p
|
c6x
|
VLIW
|
GCC
| 1,017 | 62 | 1 |
[] |
[
"<s>",
"StackOffset",
"AArch64FrameLowering",
"::",
"getFrameIndexReference",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"int",
"FI",
",",
"Register",
"&",
"FrameReg",
")",
"const",
"{",
"return",
"resolveFrameIndexReference",
"(",
"MF",
",",
"FI",
",",
"FrameReg",
",",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"SanitizeHWAddress",
")",
",",
"false",
")",
";",
"}",
"</s>"
] |
[
"getFrameIndexReference",
"-",
"This",
"method",
"should",
"return",
"the",
"base",
"register",
"and",
"offset",
"used",
"to",
"reference",
"a",
"frame",
"index",
"location",
"."
] |
[
"AArch64",
"AArch64"
] |
AArch64FrameLowering (2)1
|
getFrameIndexReference
|
AArch64
|
CPU
|
LLVM
| 1,018 | 45 | 1 |
[] |
[
"<s>",
"bool",
"isReg",
"(",
")",
"const",
"override",
"{",
"return",
"Kind",
"==",
"Register",
"&&",
"Reg",
".",
"Modifiers",
"==",
"-",
"1",
";",
"}",
"</s>"
] |
[
"isReg",
"-",
"Is",
"this",
"a",
"register",
"operand",
"?"
] |
[
"AMDGPU",
"1"
] |
AMDGPUAsmParser (2)
|
isReg
|
AMDGPU
|
GPU
|
LLVM
| 1,019 | 20 | 1 |
[] |
[
"<s>",
"virtual",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"MachineFrameInfo",
"*",
"FFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"RI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"unsigned",
"MaxAlign",
"=",
"calculateMaxStackAlignment",
"(",
"FFI",
")",
";",
"for",
"(",
"unsigned",
"RegNum",
"=",
"TargetRegisterInfo",
"::",
"FirstVirtualRegister",
";",
"RegNum",
"<",
"RI",
".",
"getLastVirtReg",
"(",
")",
";",
"++",
"RegNum",
")",
"MaxAlign",
"=",
"std",
"::",
"max",
"(",
"MaxAlign",
",",
"RI",
".",
"getRegClass",
"(",
"RegNum",
")",
"->",
"getAlignment",
"(",
")",
")",
";",
"if",
"(",
"FFI",
"->",
"getMaxAlignment",
"(",
")",
"==",
"MaxAlign",
")",
"return",
"false",
";",
"FFI",
"->",
"setMaxAlignment",
"(",
"MaxAlign",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] |
[
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] |
[
"X86"
] |
X86RegisterInfo41
|
runOnMachineFunction
|
X86
|
CPU
|
LLVM
| 1,020 | 101 | 1 |
[] |
[
"<s>",
"TargetPassConfig",
"*",
"AZPRTargetMachine",
"::",
"createPassConfig",
"(",
"PassManagerBase",
"&",
"PM",
")",
"{",
"return",
"new",
"AZPRPassConfig",
"(",
"this",
",",
"PM",
")",
";",
"}",
"</s>"
] |
[
"Create",
"a",
"pass",
"configuration",
"object",
"to",
"be",
"used",
"by",
"addPassToEmitX",
"methods",
"for",
"generating",
"a",
"pipeline",
"of",
"CodeGen",
"passes",
"."
] |
[
"AZPR",
"AZPR",
"AZPR"
] |
AZPRTargetMachine
|
createPassConfig
|
AZPR
|
CPU
|
LLVM
| 1,021 | 21 | 1 |
[] |
[
"<s>",
"FunctionPass",
"*",
"TVMPassConfig",
"::",
"createTargetRegisterAllocator",
"(",
"bool",
")",
"{",
"return",
"nullptr",
";",
"}",
"</s>"
] |
[
"createTargetRegisterAllocator",
"-",
"Create",
"the",
"register",
"allocator",
"pass",
"for",
"this",
"target",
"at",
"the",
"current",
"optimization",
"level",
"."
] |
[
"TVM",
"TVM"
] |
TVMTargetMachine
|
createTargetRegisterAllocator
|
TVM
|
Virtual ISA
|
LLVM
| 1,022 | 13 | 1 |
[] |
[
"<s>",
"void",
"NVPTXFrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"if",
"(",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"hasStackObjects",
"(",
")",
")",
"{",
"assert",
"(",
"&",
"MF",
".",
"front",
"(",
")",
"==",
"&",
"MBB",
"&&",
"\"Shrink-wrapping not yet supported\"",
")",
";",
"MachineInstr",
"*",
"MI",
"=",
"&",
"MBB",
".",
"front",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MR",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"DebugLoc",
"(",
")",
";",
"bool",
"Is64Bit",
"=",
"static_cast",
"<",
"const",
"NVPTXTargetMachine",
"&",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
")",
".",
"is64Bit",
"(",
")",
";",
"unsigned",
"CvtaLocalOpcode",
"=",
"(",
"Is64Bit",
"?",
"NVPTX",
"::",
"cvta_local_yes_64",
":",
"NVPTX",
"::",
"cvta_local_yes",
")",
";",
"unsigned",
"MovDepotOpcode",
"=",
"(",
"Is64Bit",
"?",
"NVPTX",
"::",
"MOV_DEPOT_ADDR_64",
":",
"NVPTX",
"::",
"MOV_DEPOT_ADDR",
")",
";",
"if",
"(",
"!",
"MR",
".",
"use_empty",
"(",
"NVPTX",
"::",
"VRFrame",
")",
")",
"{",
"MI",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"dl",
",",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
"->",
"get",
"(",
"CvtaLocalOpcode",
")",
",",
"NVPTX",
"::",
"VRFrame",
")",
".",
"addReg",
"(",
"NVPTX",
"::",
"VRFrameLocal",
")",
";",
"}",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"dl",
",",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
"->",
"get",
"(",
"MovDepotOpcode",
")",
",",
"NVPTX",
"::",
"VRFrameLocal",
")",
".",
"addImm",
"(",
"MF",
".",
"getFunctionNumber",
"(",
")",
")",
";",
"}",
"}",
"</s>"
] |
[
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] |
[
"NVPTX",
"NVPTX",
"\"Shrink-wrapping not yet supported\"",
"NVPTX",
"NVPTX::cvta_local_yes_64",
"NVPTX::cvta_local_yes",
"NVPTX::MOV_DEPOT_ADDR_64",
"NVPTX::MOV_DEPOT_ADDR",
"NVPTX::VRFrame",
"NVPTX::VRFrame",
"NVPTX::VRFrameLocal",
"NVPTX::VRFrameLocal"
] |
NVPTXFrameLowering19
|
emitPrologue
|
NVPTX
|
GPU
|
LLVM
| 1,023 | 212 | 1 |
[] |
[
"<s>",
"machine_mode",
"nvptx_underlying_object_mode",
"(",
"rtx",
"obj",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"obj",
")",
"==",
"SUBREG",
")",
"obj",
"=",
"SUBREG_REG",
"(",
"obj",
")",
";",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"obj",
")",
";",
"if",
"(",
"mode",
"==",
"TImode",
")",
"return",
"DImode",
";",
"if",
"(",
"COMPLEX_MODE_P",
"(",
"mode",
")",
")",
"return",
"GET_MODE_INNER",
"(",
"mode",
")",
";",
"return",
"mode",
";",
"}",
"</s>"
] |
[
"Return",
"the",
"mode",
"to",
"be",
"used",
"when",
"declaring",
"a",
"ptx",
"object",
"for",
"OBJ",
".",
"For",
"objects",
"with",
"subparts",
"such",
"as",
"complex",
"modes",
"this",
"is",
"the",
"mode",
"of",
"the",
"subpart",
"."
] |
[
"nvptx"
] |
nvptx2
|
nvptx_underlying_object_mode
|
nvptx
|
GPU
|
GCC
| 1,024 | 57 | 1 |
[] |
[
"<s>",
"SDValue",
"AMDGPUTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"Op",
"->",
"print",
"(",
"errs",
"(",
")",
",",
"&",
"DAG",
")",
";",
"llvm_unreachable",
"(",
"\"Custom lowering code for this\"",
"\"instruction is not implemented yet!\"",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND_INREG",
":",
"return",
"LowerSIGN_EXTEND_INREG",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"CONCAT_VECTORS",
":",
"return",
"LowerCONCAT_VECTORS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
":",
"return",
"LowerEXTRACT_SUBVECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"UDIVREM",
":",
"return",
"LowerUDIVREM",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SDIVREM",
":",
"return",
"LowerSDIVREM",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FREM",
":",
"return",
"LowerFREM",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FCEIL",
":",
"return",
"LowerFCEIL",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FTRUNC",
":",
"return",
"LowerFTRUNC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRINT",
":",
"return",
"LowerFRINT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FNEARBYINT",
":",
"return",
"LowerFNEARBYINT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FROUND",
":",
"return",
"LowerFROUND",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FFLOOR",
":",
"return",
"LowerFFLOOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FLOG",
":",
"return",
"LowerFLOG",
"(",
"Op",
",",
"DAG",
",",
"numbers",
"::",
"ln2f",
")",
";",
"case",
"ISD",
"::",
"FLOG10",
":",
"return",
"LowerFLOG",
"(",
"Op",
",",
"DAG",
",",
"numbers",
"::",
"ln2f",
"/",
"numbers",
"::",
"ln10f",
")",
";",
"case",
"ISD",
"::",
"FEXP",
":",
"return",
"lowerFEXP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SINT_TO_FP",
":",
"return",
"LowerSINT_TO_FP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"UINT_TO_FP",
":",
"return",
"LowerUINT_TO_FP",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FP_TO_FP16",
":",
"return",
"LowerFP_TO_FP16",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FP_TO_SINT",
":",
"return",
"LowerFP_TO_SINT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FP_TO_UINT",
":",
"return",
"LowerFP_TO_UINT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"CTTZ",
":",
"case",
"ISD",
"::",
"CTTZ_ZERO_UNDEF",
":",
"case",
"ISD",
"::",
"CTLZ",
":",
"case",
"ISD",
"::",
"CTLZ_ZERO_UNDEF",
":",
"return",
"LowerCTLZ_CTTZ",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"DYNAMIC_STACKALLOC",
":",
"return",
"LowerDYNAMIC_STACKALLOC",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"return",
"Op",
";",
"}",
"</s>"
] |
[
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] |
[
"AMDGPU",
"AMDGPU",
"\"Custom lowering code for this\"",
"\"instruction is not implemented yet!\"",
"ISD::SIGN_EXTEND_INREG",
"SI",
"ISD::CONCAT_VECTORS",
"ISD::EXTRACT_SUBVECTOR",
"ISD::UDIVREM",
"ISD::SDIVREM",
"ISD::FREM",
"ISD::FCEIL",
"ISD::FTRUNC",
"ISD::FRINT",
"ISD::FNEARBYINT",
"ISD::FROUND",
"ISD::FFLOOR",
"ISD::FLOG",
"ISD::FLOG10",
"ISD::FEXP",
"ISD::SINT_TO_FP",
"SI",
"ISD::UINT_TO_FP",
"ISD::FP_TO_FP16",
"ISD::FP_TO_SINT",
"SI",
"ISD::FP_TO_UINT",
"ISD::CTTZ",
"ISD::CTTZ_ZERO_UNDEF",
"ISD::CTLZ",
"ISD::CTLZ_ZERO_UNDEF",
"ISD::DYNAMIC_STACKALLOC"
] |
AMDGPUISelLowering31
|
LowerOperation
|
AMDGPU
|
GPU
|
LLVM
| 1,025 | 363 | 1 |
[] |
[
"<s>",
"void",
"dump",
"(",
")",
"{",
"errs",
"(",
")",
"<<",
"\"rriCoreISelAddressMode \"",
"<<",
"this",
"<<",
"'\\n'",
";",
"if",
"(",
"BaseType",
"==",
"RegBase",
"&&",
"Base",
".",
"Reg",
".",
"getNode",
"(",
")",
"!=",
"nullptr",
")",
"{",
"errs",
"(",
")",
"<<",
"\"Base.Reg \"",
";",
"Base",
".",
"Reg",
".",
"getNode",
"(",
")",
"->",
"dump",
"(",
")",
";",
"}",
"else",
"if",
"(",
"BaseType",
"==",
"FrameIndexBase",
")",
"{",
"errs",
"(",
")",
"<<",
"\" Base.FrameIndex \"",
"<<",
"Base",
".",
"FrameIndex",
"<<",
"'\\n'",
";",
"}",
"errs",
"(",
")",
"<<",
"\" Disp \"",
"<<",
"Disp",
"<<",
"'\\n'",
";",
"if",
"(",
"GV",
")",
"{",
"errs",
"(",
")",
"<<",
"\"GV \"",
";",
"GV",
"->",
"dump",
"(",
")",
";",
"}",
"else",
"if",
"(",
"CP",
")",
"{",
"errs",
"(",
")",
"<<",
"\" CP \"",
";",
"CP",
"->",
"dump",
"(",
")",
";",
"errs",
"(",
")",
"<<",
"\" Align\"",
"<<",
"Align",
"<<",
"'\\n'",
";",
"}",
"else",
"if",
"(",
"ES",
")",
"{",
"errs",
"(",
")",
"<<",
"\"ES \"",
";",
"errs",
"(",
")",
"<<",
"ES",
"<<",
"'\\n'",
";",
"}",
"else",
"if",
"(",
"JT",
"!=",
"-",
"1",
")",
"errs",
"(",
")",
"<<",
"\" JT\"",
"<<",
"JT",
"<<",
"\" Align\"",
"<<",
"Align",
"<<",
"'\\n'",
";",
"}",
"</s>"
] |
[
"Dump",
"the",
"plan",
"to",
"stderr",
"(",
"for",
"debugging",
")",
"."
] |
[
"TriCore",
"\"rriCoreISelAddressMode \"",
"\"Base.Reg \"",
"\" Base.FrameIndex \"",
"\" Disp \"",
"\"GV \"",
"\" CP \"",
"\" Align\"",
"\"ES \"",
"1",
"\" JT\"",
"\" Align\""
] |
TriCoreISelDAGToDAG (2)
|
dump
|
TriCore
|
MPU
|
LLVM
| 1,026 | 173 | 1 |
[] |
[
"<s>",
"void",
"alpha_split_atomic_exchange",
"(",
"rtx",
"operands",
"[",
"]",
")",
"{",
"rtx",
"retval",
",",
"mem",
",",
"val",
",",
"scratch",
";",
"enum",
"memmodel",
"model",
";",
"machine_mode",
"mode",
";",
"rtx",
"label",
",",
"x",
",",
"cond",
";",
"retval",
"=",
"operands",
"[",
"0",
"]",
";",
"mem",
"=",
"operands",
"[",
"1",
"]",
";",
"val",
"=",
"operands",
"[",
"2",
"]",
";",
"model",
"=",
"(",
"enum",
"memmodel",
")",
"INTVAL",
"(",
"operands",
"[",
"3",
"]",
")",
";",
"scratch",
"=",
"operands",
"[",
"4",
"]",
";",
"mode",
"=",
"GET_MODE",
"(",
"mem",
")",
";",
"cond",
"=",
"gen_lowpart",
"(",
"DImode",
",",
"scratch",
")",
";",
"alpha_pre_atomic_barrier",
"(",
"model",
")",
";",
"label",
"=",
"gen_rtx_LABEL_REF",
"(",
"DImode",
",",
"gen_label_rtx",
"(",
")",
")",
";",
"emit_label",
"(",
"XEXP",
"(",
"label",
",",
"0",
")",
")",
";",
"emit_insn",
"(",
"gen_load_locked",
"(",
"mode",
",",
"retval",
",",
"mem",
")",
")",
";",
"emit_move_insn",
"(",
"scratch",
",",
"val",
")",
";",
"emit_insn",
"(",
"gen_store_conditional",
"(",
"mode",
",",
"cond",
",",
"mem",
",",
"scratch",
")",
")",
";",
"x",
"=",
"gen_rtx_EQ",
"(",
"DImode",
",",
"cond",
",",
"const0_rtx",
")",
";",
"emit_unlikely_jump",
"(",
"x",
",",
"label",
")",
";",
"alpha_post_atomic_barrier",
"(",
"model",
")",
";",
"}",
"</s>"
] |
[
"Expand",
"an",
"atomic",
"exchange",
"operation",
"."
] |
[
"alpha",
"0",
"1",
"2",
"3",
"4",
"0"
] |
alpha
|
alpha_split_atomic_exchange
|
alpha
|
MPU
|
GCC
| 1,027 | 173 | 1 |
[] |
[
"<s>",
"bool",
"m68k_legitimate_address_p",
"(",
"machine_mode",
"mode",
",",
"rtx",
"x",
",",
"bool",
"strict_p",
")",
"{",
"struct",
"m68k_address",
"address",
";",
"return",
"m68k_decompose_address",
"(",
"mode",
",",
"x",
",",
"strict_p",
",",
"&",
"address",
")",
";",
"}",
"</s>"
] |
[
"Return",
"true",
"if",
"X",
"is",
"a",
"legitimate",
"address",
"for",
"values",
"of",
"mode",
"MODE",
".",
"STRICT_P",
"says",
"whether",
"strict",
"checking",
"is",
"needed",
"."
] |
[
"m68k"
] |
m68k
|
m68k_legitimate_address_p
|
m68k
|
MPU
|
GCC
| 1,028 | 31 | 1 |
[] |
[
"<s>",
"void",
"GCNPassConfig",
"::",
"addOptimizedRegAlloc",
"(",
"FunctionPass",
"*",
"RegAllocPass",
")",
"{",
"insertPass",
"(",
"&",
"MachineSchedulerID",
",",
"&",
"SIFixControlFlowLiveIntervalsID",
")",
";",
"insertPass",
"(",
"&",
"RenameIndependentSubregsID",
",",
"&",
"SILowerControlFlowID",
")",
";",
"TargetPassConfig",
"::",
"addOptimizedRegAlloc",
"(",
"RegAllocPass",
")",
";",
"}",
"</s>"
] |
[
"addOptimizedRegAlloc",
"-",
"Add",
"passes",
"related",
"to",
"register",
"allocation",
"."
] |
[
"AMDGPU",
"SI",
"SI"
] |
AMDGPUTargetMachine84
|
addOptimizedRegAlloc
|
AMDGPU
|
GPU
|
LLVM
| 1,029 | 36 | 1 |
[] |
[
"<s>",
"static",
"ia64_addr_area",
"ia64_get_addr_area",
"(",
"tree",
"decl",
")",
"{",
"tree",
"model_attr",
";",
"model_attr",
"=",
"lookup_attribute",
"(",
"\"model\"",
",",
"DECL_ATTRIBUTES",
"(",
"decl",
")",
")",
";",
"if",
"(",
"model_attr",
")",
"{",
"tree",
"id",
";",
"init_idents",
"(",
")",
";",
"id",
"=",
"TREE_VALUE",
"(",
"TREE_VALUE",
"(",
"model_attr",
")",
")",
";",
"if",
"(",
"id",
"==",
"small_ident1",
"||",
"id",
"==",
"small_ident2",
")",
"return",
"ADDR_AREA_SMALL",
";",
"}",
"return",
"ADDR_AREA_NORMAL",
";",
"}",
"</s>"
] |
[
"Retrieve",
"the",
"address",
"area",
"that",
"has",
"been",
"chosen",
"for",
"the",
"given",
"decl",
"."
] |
[
"ia64",
"\"model\""
] |
ia64
|
ia64_get_addr_area
|
ia64
|
CPU
|
GCC
| 1,030 | 63 | 1 |
[] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isNoopAddrSpaceCast",
"(",
"unsigned",
"SrcAS",
",",
"unsigned",
"DestAS",
")",
"const",
"{",
"assert",
"(",
"SrcAS",
"!=",
"DestAS",
"&&",
"\"Expected different address spaces!\"",
")",
";",
"const",
"TargetMachine",
"&",
"TM",
"=",
"getTargetMachine",
"(",
")",
";",
"if",
"(",
"TM",
".",
"getPointerSize",
"(",
"SrcAS",
")",
"!=",
"TM",
".",
"getPointerSize",
"(",
"DestAS",
")",
")",
"return",
"false",
";",
"return",
"SrcAS",
"<",
"256",
"&&",
"DestAS",
"<",
"256",
";",
"}",
"</s>"
] |
[
"Returns",
"true",
"if",
"a",
"cast",
"between",
"SrcAS",
"and",
"DestAS",
"is",
"a",
"noop",
"."
] |
[
"X86",
"X86",
"\"Expected different address spaces!\"",
"256",
"256"
] |
X86ISelLowering (2)6
|
isNoopAddrSpaceCast
|
X86
|
CPU
|
LLVM
| 1,031 | 60 | 1 |
[] |
[
"<s>",
"unsigned",
"AlphaCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"MachineOperand",
"&",
"MO",
")",
"{",
"unsigned",
"rv",
"=",
"0",
";",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"{",
"rv",
"=",
"getAlphaRegNumber",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"{",
"rv",
"=",
"MO",
".",
"getImm",
"(",
")",
";",
"}",
"else",
"if",
"(",
"MO",
".",
"isGlobal",
"(",
")",
"||",
"MO",
".",
"isSymbol",
"(",
")",
"||",
"MO",
".",
"isCPI",
"(",
")",
")",
"{",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"MO",
"<<",
"\" is a relocated op for \"",
"<<",
"MI",
"<<",
"\"\\n\"",
")",
";",
"unsigned",
"Reloc",
"=",
"0",
";",
"int",
"Offset",
"=",
"0",
";",
"bool",
"useGOT",
"=",
"false",
";",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"Alpha",
"::",
"BSR",
":",
"Reloc",
"=",
"Alpha",
"::",
"reloc_bsr",
";",
"break",
";",
"case",
"Alpha",
"::",
"LDLr",
":",
"case",
"Alpha",
"::",
"LDQr",
":",
"case",
"Alpha",
"::",
"LDBUr",
":",
"case",
"Alpha",
"::",
"LDWUr",
":",
"case",
"Alpha",
"::",
"LDSr",
":",
"case",
"Alpha",
"::",
"LDTr",
":",
"case",
"Alpha",
"::",
"LDAr",
":",
"case",
"Alpha",
"::",
"STQr",
":",
"case",
"Alpha",
"::",
"STLr",
":",
"case",
"Alpha",
"::",
"STWr",
":",
"case",
"Alpha",
"::",
"STBr",
":",
"case",
"Alpha",
"::",
"STSr",
":",
"case",
"Alpha",
"::",
"STTr",
":",
"Reloc",
"=",
"Alpha",
"::",
"reloc_gprellow",
";",
"break",
";",
"case",
"Alpha",
"::",
"LDAHr",
":",
"Reloc",
"=",
"Alpha",
"::",
"reloc_gprelhigh",
";",
"break",
";",
"case",
"Alpha",
"::",
"LDQl",
":",
"Reloc",
"=",
"Alpha",
"::",
"reloc_literal",
";",
"useGOT",
"=",
"true",
";",
"break",
";",
"case",
"Alpha",
"::",
"LDAg",
":",
"case",
"Alpha",
"::",
"LDAHg",
":",
"Reloc",
"=",
"Alpha",
"::",
"reloc_gpdist",
";",
"Offset",
"=",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"getImm",
"(",
")",
";",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"unknown relocatable instruction\"",
")",
";",
"}",
"if",
"(",
"MO",
".",
"isGlobal",
"(",
")",
")",
"MCE",
".",
"addRelocation",
"(",
"MachineRelocation",
"::",
"getGV",
"(",
"MCE",
".",
"getCurrentPCOffset",
"(",
")",
",",
"Reloc",
",",
"const_cast",
"<",
"GlobalValue",
"*",
">",
"(",
"MO",
".",
"getGlobal",
"(",
")",
")",
",",
"Offset",
",",
"isa",
"<",
"Function",
">",
"(",
"MO",
".",
"getGlobal",
"(",
")",
")",
",",
"useGOT",
")",
")",
";",
"else",
"if",
"(",
"MO",
".",
"isSymbol",
"(",
")",
")",
"MCE",
".",
"addRelocation",
"(",
"MachineRelocation",
"::",
"getExtSym",
"(",
"MCE",
".",
"getCurrentPCOffset",
"(",
")",
",",
"Reloc",
",",
"MO",
".",
"getSymbolName",
"(",
")",
",",
"Offset",
",",
"true",
")",
")",
";",
"else",
"MCE",
".",
"addRelocation",
"(",
"MachineRelocation",
"::",
"getConstPool",
"(",
"MCE",
".",
"getCurrentPCOffset",
"(",
")",
",",
"Reloc",
",",
"MO",
".",
"getIndex",
"(",
")",
",",
"Offset",
")",
")",
";",
"}",
"else",
"if",
"(",
"MO",
".",
"isMBB",
"(",
")",
")",
"{",
"MCE",
".",
"addRelocation",
"(",
"MachineRelocation",
"::",
"getBB",
"(",
"MCE",
".",
"getCurrentPCOffset",
"(",
")",
",",
"Alpha",
"::",
"reloc_bsr",
",",
"MO",
".",
"getMBB",
"(",
")",
")",
")",
";",
"}",
"else",
"{",
"errs",
"(",
")",
"<<",
"\"ERROR: Unknown type of MachineOperand: \"",
"<<",
"MO",
"<<",
"\"\\n\"",
";",
"llvm_unreachable",
"(",
"0",
")",
";",
"}",
"return",
"rv",
";",
"}",
"</s>"
] |
[
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] |
[
"Alpha",
"Alpha",
"0",
"Alpha",
"\" is a relocated op for \"",
"\"\\n\"",
"0",
"0",
"Alpha::BSR",
"Alpha::reloc_bsr",
"Alpha::LDLr",
"Alpha::LDQr",
"Alpha::LDBUr",
"Alpha::LDWUr",
"Alpha::LDSr",
"Alpha::LDTr",
"Alpha::LDAr",
"Alpha::STQr",
"Alpha::STLr",
"Alpha::STWr",
"Alpha::STBr",
"Alpha::STSr",
"Alpha::STTr",
"Alpha::reloc_gprellow",
"Alpha::LDAHr",
"Alpha::reloc_gprelhigh",
"Alpha::LDQl",
"Alpha::reloc_literal",
"Alpha::LDAg",
"Alpha::LDAHg",
"Alpha::reloc_gpdist",
"3",
"\"unknown relocatable instruction\"",
"Alpha::reloc_bsr",
"\"ERROR: Unknown type of MachineOperand: \"",
"\"\\n\"",
"0"
] |
AlphaCodeEmitter
|
getMachineOpValue
|
Alpha
|
MPU
|
LLVM
| 1,032 | 456 | 1 |
[] |
[
"<s>",
"void",
"ARMTargetLowering",
"::",
"HandleByVal",
"(",
"CCState",
"*",
"State",
",",
"unsigned",
"&",
"Size",
",",
"unsigned",
"Align",
")",
"const",
"{",
"assert",
"(",
"(",
"State",
"->",
"getCallOrPrologue",
"(",
")",
"==",
"Prologue",
"||",
"State",
"->",
"getCallOrPrologue",
"(",
")",
"==",
"Call",
")",
"&&",
"\"unhandled ParmContext\"",
")",
";",
"Align",
"=",
"std",
"::",
"max",
"(",
"Align",
",",
"4U",
")",
";",
"unsigned",
"Reg",
"=",
"State",
"->",
"AllocateReg",
"(",
"GPRArgRegs",
")",
";",
"if",
"(",
"!",
"Reg",
")",
"return",
";",
"unsigned",
"AlignInRegs",
"=",
"Align",
"/",
"4",
";",
"unsigned",
"Waste",
"=",
"(",
"ARM",
"::",
"R4",
"-",
"Reg",
")",
"%",
"AlignInRegs",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"Waste",
";",
"++",
"i",
")",
"Reg",
"=",
"State",
"->",
"AllocateReg",
"(",
"GPRArgRegs",
")",
";",
"if",
"(",
"!",
"Reg",
")",
"return",
";",
"unsigned",
"Excess",
"=",
"4",
"*",
"(",
"ARM",
"::",
"R4",
"-",
"Reg",
")",
";",
"const",
"unsigned",
"NSAAOffset",
"=",
"State",
"->",
"getNextStackOffset",
"(",
")",
";",
"if",
"(",
"NSAAOffset",
"!=",
"0",
"&&",
"Size",
">",
"Excess",
")",
"{",
"while",
"(",
"State",
"->",
"AllocateReg",
"(",
"GPRArgRegs",
")",
")",
";",
"return",
";",
"}",
"unsigned",
"ByValRegBegin",
"=",
"Reg",
";",
"unsigned",
"ByValRegEnd",
"=",
"std",
"::",
"min",
"<",
"unsigned",
">",
"(",
"Reg",
"+",
"Size",
"/",
"4",
",",
"ARM",
"::",
"R4",
")",
";",
"State",
"->",
"addInRegsParamInfo",
"(",
"ByValRegBegin",
",",
"ByValRegEnd",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"Reg",
"+",
"1",
";",
"i",
"!=",
"ByValRegEnd",
";",
"++",
"i",
")",
"State",
"->",
"AllocateReg",
"(",
"GPRArgRegs",
")",
";",
"Size",
"=",
"std",
"::",
"max",
"<",
"int",
">",
"(",
"Size",
"-",
"Excess",
",",
"0",
")",
";",
"}",
"</s>"
] |
[
"Target-specific",
"cleanup",
"for",
"formal",
"ByVal",
"parameters",
"."
] |
[
"ARM",
"ARM",
"\"unhandled ParmContext\"",
"4U",
"4",
"ARM::R4",
"0",
"4",
"ARM::R4",
"0",
"4",
"ARM::R4",
"1",
"0"
] |
ARMISelLowering (2)2
|
HandleByVal
|
ARM
|
CPU
|
LLVM
| 1,033 | 241 | 1 |
[] |
[
"<s>",
"static",
"bool",
"mips_near_type_p",
"(",
"const_tree",
"type",
")",
"{",
"return",
"(",
"lookup_attribute",
"(",
"\"short_call\"",
",",
"TYPE_ATTRIBUTES",
"(",
"type",
")",
")",
"!=",
"NULL",
"||",
"lookup_attribute",
"(",
"\"near\"",
",",
"TYPE_ATTRIBUTES",
"(",
"type",
")",
")",
"!=",
"NULL",
")",
";",
"}",
"</s>"
] |
[
"Predicates",
"to",
"test",
"for",
"presence",
"of",
"``",
"near",
"''",
"and",
"``",
"far",
"''",
"/",
"''",
"long_call",
"''",
"attributes",
"on",
"the",
"given",
"TYPE",
"."
] |
[
"mips",
"\"short_call\"",
"\"near\""
] |
mips
|
mips_near_type_p
|
mips
|
CPU
|
GCC
| 1,034 | 36 | 1 |
[] |
[
"<s>",
"static",
"void",
"emit_final_str_compare_gpr",
"(",
"rtx",
"str1",
",",
"rtx",
"str2",
",",
"rtx",
"result",
")",
"{",
"machine_mode",
"m",
"=",
"GET_MODE",
"(",
"str1",
")",
";",
"rtx",
"rot_amt",
"=",
"gen_reg_rtx",
"(",
"m",
")",
";",
"rtx",
"rot1_1",
"=",
"gen_reg_rtx",
"(",
"m",
")",
";",
"rtx",
"rot1_2",
"=",
"gen_reg_rtx",
"(",
"m",
")",
";",
"rtx",
"rot2_1",
"=",
"gen_reg_rtx",
"(",
"m",
")",
";",
"rtx",
"rot2_2",
"=",
"gen_reg_rtx",
"(",
"m",
")",
";",
"if",
"(",
"m",
"==",
"SImode",
")",
"{",
"emit_insn",
"(",
"gen_clzsi2",
"(",
"rot_amt",
",",
"result",
")",
")",
";",
"emit_insn",
"(",
"gen_addsi3",
"(",
"rot_amt",
",",
"rot_amt",
",",
"GEN_INT",
"(",
"8",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rotlsi3",
"(",
"rot1_1",
",",
"str1",
",",
"gen_lowpart",
"(",
"SImode",
",",
"rot_amt",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_andsi3_mask",
"(",
"rot1_2",
",",
"rot1_1",
",",
"GEN_INT",
"(",
"0xff",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rotlsi3",
"(",
"rot2_1",
",",
"str2",
",",
"gen_lowpart",
"(",
"SImode",
",",
"rot_amt",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_andsi3_mask",
"(",
"rot2_2",
",",
"rot2_1",
",",
"GEN_INT",
"(",
"0xff",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_subsi3",
"(",
"result",
",",
"rot1_2",
",",
"rot2_2",
")",
")",
";",
"}",
"else",
"if",
"(",
"m",
"==",
"DImode",
")",
"{",
"emit_insn",
"(",
"gen_clzdi2",
"(",
"rot_amt",
",",
"result",
")",
")",
";",
"emit_insn",
"(",
"gen_adddi3",
"(",
"rot_amt",
",",
"rot_amt",
",",
"GEN_INT",
"(",
"8",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rotldi3",
"(",
"rot1_1",
",",
"str1",
",",
"gen_lowpart",
"(",
"SImode",
",",
"rot_amt",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_anddi3_mask",
"(",
"rot1_2",
",",
"rot1_1",
",",
"GEN_INT",
"(",
"0xff",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rotldi3",
"(",
"rot2_1",
",",
"str2",
",",
"gen_lowpart",
"(",
"SImode",
",",
"rot_amt",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_anddi3_mask",
"(",
"rot2_2",
",",
"rot2_1",
",",
"GEN_INT",
"(",
"0xff",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_subdi3",
"(",
"result",
",",
"rot1_2",
",",
"rot2_2",
")",
")",
";",
"}",
"else",
"gcc_unreachable",
"(",
")",
";",
"return",
";",
"}",
"</s>"
] |
[
"Generate",
"the",
"final",
"sequence",
"that",
"identifies",
"the",
"differing",
"byte",
"and",
"generates",
"the",
"final",
"result",
",",
"taking",
"into",
"account",
"zero",
"bytes",
":",
"cntlzd",
"get",
"bit",
"of",
"first",
"zero/diff",
"byte",
"addi",
"convert",
"for",
"rldcl",
"use",
"rldcl",
"rldcl",
"extract",
"diff/zero",
"byte",
"subf",
"subtract",
"for",
"final",
"result",
"STR1",
"is",
"the",
"reg",
"rtx",
"for",
"data",
"from",
"string",
"1",
".",
"STR2",
"is",
"the",
"reg",
"rtx",
"for",
"data",
"from",
"string",
"2",
".",
"RESULT",
"is",
"the",
"reg",
"rtx",
"for",
"the",
"comparison",
"result",
"."
] |
[
"rs6000",
"8",
"0xff",
"0xff",
"8",
"0xff",
"0xff"
] |
rs6000-string
|
emit_final_str_compare_gpr
|
rs6000
|
CPU
|
GCC
| 1,035 | 289 | 1 |
[] |
[
"<s>",
"void",
"AArch64WinCOFFStreamer",
"::",
"finishImpl",
"(",
")",
"{",
"emitFrames",
"(",
"nullptr",
")",
";",
"emitWindowsUnwindTables",
"(",
")",
";",
"MCWinCOFFStreamer",
"::",
"finishImpl",
"(",
")",
";",
"}",
"</s>"
] |
[
"Streamer",
"specific",
"finalization",
"."
] |
[
"AArch64",
"AArch64"
] |
AArch64WinCOFFStreamer5
|
finishImpl
|
AArch64
|
CPU
|
LLVM
| 1,036 | 23 | 1 |
[] |
[
"<s>",
"void",
"R600TTIImpl",
"::",
"getPeelingPreferences",
"(",
"Loop",
"*",
"L",
",",
"ScalarEvolution",
"&",
"SE",
",",
"TTI",
"::",
"PeelingPreferences",
"&",
"PP",
")",
"{",
"CommonTTI",
".",
"getPeelingPreferences",
"(",
"L",
",",
"SE",
",",
"PP",
")",
";",
"}",
"</s>"
] |
[
"Get",
"target-customized",
"preferences",
"for",
"the",
"generic",
"loop",
"peeling",
"transformation",
"."
] |
[
"AMDGPU",
"R600"
] |
AMDGPUTargetTransformInfo2
|
getPeelingPreferences
|
AMDGPU
|
GPU
|
LLVM
| 1,037 | 32 | 1 |
[] |
[
"<s>",
"virtual",
"void",
"*",
"getAdjustedAnalysisPointer",
"(",
"const",
"void",
"*",
"ID",
")",
"{",
"if",
"(",
"ID",
"==",
"&",
"TargetTransformInfo",
"::",
"ID",
")",
"return",
"(",
"TargetTransformInfo",
"*",
")",
"this",
";",
"return",
"this",
";",
"}",
"</s>"
] |
[
"getAdjustedAnalysisPointer",
"-",
"This",
"method",
"is",
"used",
"when",
"a",
"pass",
"implements",
"an",
"analysis",
"interface",
"through",
"multiple",
"inheritance",
"."
] |
[
"X86"
] |
X86TargetTransformInfo113
|
getAdjustedAnalysisPointer
|
X86
|
CPU
|
LLVM
| 1,038 | 31 | 1 |
[] |
[
"<s>",
"void",
"X86AsmPrinter",
"::",
"emitEndOfAsmFile",
"(",
"Module",
"&",
"M",
")",
"{",
"const",
"Triple",
"&",
"TT",
"=",
"TM",
".",
"getTargetTriple",
"(",
")",
";",
"emitAsanMemaccessSymbols",
"(",
"M",
")",
";",
"if",
"(",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
")",
"{",
"emitNonLazyStubs",
"(",
"MMI",
",",
"*",
"OutStreamer",
")",
";",
"emitStackMaps",
"(",
"SM",
")",
";",
"FM",
".",
"serializeToFaultMapSection",
"(",
")",
";",
"OutStreamer",
"->",
"emitAssemblerFlag",
"(",
"MCAF_SubsectionsViaSymbols",
")",
";",
"}",
"else",
"if",
"(",
"TT",
".",
"isOSBinFormatCOFF",
"(",
")",
")",
"{",
"if",
"(",
"MMI",
"->",
"usesMSVCFloatingPoint",
"(",
")",
")",
"{",
"StringRef",
"SymbolName",
"=",
"(",
"TT",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86",
")",
"?",
"\"__fltused\"",
":",
"\"_fltused\"",
";",
"MCSymbol",
"*",
"S",
"=",
"MMI",
"->",
"getContext",
"(",
")",
".",
"getOrCreateSymbol",
"(",
"SymbolName",
")",
";",
"OutStreamer",
"->",
"emitSymbolAttribute",
"(",
"S",
",",
"MCSA_Global",
")",
";",
"return",
";",
"}",
"emitStackMaps",
"(",
"SM",
")",
";",
"}",
"else",
"if",
"(",
"TT",
".",
"isOSBinFormatELF",
"(",
")",
")",
"{",
"emitStackMaps",
"(",
"SM",
")",
";",
"FM",
".",
"serializeToFaultMapSection",
"(",
")",
";",
"}",
"}",
"</s>"
] |
[
"This",
"virtual",
"method",
"can",
"be",
"overridden",
"by",
"targets",
"that",
"want",
"to",
"emit",
"something",
"at",
"the",
"end",
"of",
"their",
"file",
"."
] |
[
"X86",
"X86",
"\"__fltused\"",
"\"_fltused\""
] |
X86AsmPrinter20
|
emitEndOfAsmFile
|
X86
|
CPU
|
LLVM
| 1,039 | 156 | 1 |
[] |
[
"<s>",
"static",
"unsigned",
"long",
"get_csky_isr_type",
"(",
"tree",
"argument",
")",
"{",
"const",
"isr_attribute_entry",
"*",
"ptr",
";",
"const",
"char",
"*",
"arg",
";",
"if",
"(",
"argument",
"==",
"NULL_TREE",
")",
"return",
"CSKY_FT_ISR",
";",
"if",
"(",
"TREE_VALUE",
"(",
"argument",
")",
"==",
"NULL_TREE",
"||",
"TREE_CODE",
"(",
"TREE_VALUE",
"(",
"argument",
")",
")",
"!=",
"STRING_CST",
")",
"return",
"CSKY_FT_UNKNOWN",
";",
"arg",
"=",
"TREE_STRING_POINTER",
"(",
"TREE_VALUE",
"(",
"argument",
")",
")",
";",
"for",
"(",
"ptr",
"=",
"isr_attribute_map",
";",
"ptr",
"->",
"arg",
"!=",
"NULL",
";",
"ptr",
"++",
")",
"if",
"(",
"strcmp",
"(",
"arg",
",",
"ptr",
"->",
"arg",
")",
"==",
"0",
")",
"return",
"ptr",
"->",
"return_value",
";",
"return",
"CSKY_FT_UNKNOWN",
";",
"}",
"</s>"
] |
[
"Return",
"the",
"function",
"type",
"of",
"the",
"current",
"function",
",",
"if",
"it",
"has",
"not",
"been",
"determined",
",",
"return",
"CSKY_FT_UNKNOWN",
"."
] |
[
"csky",
"0"
] |
csky
|
get_csky_isr_type
|
csky
|
CPU
|
GCC
| 1,040 | 97 | 1 |
[] |
[
"<s>",
"static",
"unsigned",
"int",
"ATTRIBUTE_UNUSED",
"x86_64_elf_section_type_flags",
"(",
"tree",
"decl",
",",
"const",
"char",
"*",
"name",
",",
"int",
"reloc",
")",
"{",
"unsigned",
"int",
"flags",
"=",
"default_section_type_flags",
"(",
"decl",
",",
"name",
",",
"reloc",
")",
";",
"if",
"(",
"decl",
"==",
"NULL_TREE",
"&&",
"(",
"strcmp",
"(",
"name",
",",
"\".ldata.rel.ro\"",
")",
"==",
"0",
"||",
"strcmp",
"(",
"name",
",",
"\".ldata.rel.ro.local\"",
")",
"==",
"0",
")",
")",
"flags",
"|=",
"SECTION_RELRO",
";",
"if",
"(",
"strcmp",
"(",
"name",
",",
"\".lbss\"",
")",
"==",
"0",
"||",
"strncmp",
"(",
"name",
",",
"\".lbss.\"",
",",
"5",
")",
"==",
"0",
"||",
"strncmp",
"(",
"name",
",",
"\".gnu.linkonce.lb.\"",
",",
"16",
")",
"==",
"0",
")",
"flags",
"|=",
"SECTION_BSS",
";",
"return",
"flags",
";",
"}",
"</s>"
] |
[
"Select",
"a",
"set",
"of",
"attributes",
"for",
"section",
"NAME",
"based",
"on",
"the",
"properties",
"of",
"DECL",
"and",
"whether",
"or",
"not",
"RELOC",
"indicates",
"that",
"DECL",
"'s",
"initializer",
"might",
"contain",
"runtime",
"relocations",
"."
] |
[
"i386",
"\".ldata.rel.ro\"",
"0",
"\".ldata.rel.ro.local\"",
"0",
"\".lbss\"",
"0",
"\".lbss.\"",
"5",
"0",
"\".gnu.linkonce.lb.\"",
"16",
"0"
] |
i3864
|
x86_64_elf_section_type_flags
|
i386
|
CPU
|
GCC
| 1,041 | 102 | 1 |
[] |
[
"<s>",
"Register",
"NVPTXRegisterInfo",
"::",
"getFrameRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"NVPTX",
"::",
"VRFrame",
";",
"}",
"</s>"
] |
[
"Debug",
"information",
"queries",
"."
] |
[
"NVPTX",
"NVPTX",
"NVPTX::VRFrame"
] |
NVPTXRegisterInfo14
|
getFrameRegister
|
NVPTX
|
GPU
|
LLVM
| 1,042 | 18 | 1 |
[] |
[
"<s>",
"opt_machine_mode",
"aarch64_full_sve_mode",
"(",
"scalar_mode",
"mode",
")",
"{",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_DFmode",
":",
"return",
"VNx2DFmode",
";",
"case",
"E_SFmode",
":",
"return",
"VNx4SFmode",
";",
"case",
"E_HFmode",
":",
"return",
"VNx8HFmode",
";",
"case",
"E_BFmode",
":",
"return",
"VNx8BFmode",
";",
"case",
"E_DImode",
":",
"return",
"VNx2DImode",
";",
"case",
"E_SImode",
":",
"return",
"VNx4SImode",
";",
"case",
"E_HImode",
":",
"return",
"VNx8HImode",
";",
"case",
"E_QImode",
":",
"return",
"VNx16QImode",
";",
"default",
":",
"return",
"opt_machine_mode",
"(",
")",
";",
"}",
"}",
"</s>"
] |
[
"Return",
"the",
"full-width",
"SVE",
"vector",
"mode",
"for",
"element",
"mode",
"MODE",
",",
"if",
"one",
"exists",
"."
] |
[
"aarch64"
] |
aarch64
|
aarch64_full_sve_mode
|
aarch64
|
CPU
|
GCC
| 1,043 | 69 | 1 |
[] |
[
"<s>",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"override",
"{",
"Subtarget",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"SystemZSubtarget",
">",
"(",
")",
";",
"return",
"SelectionDAGISel",
"::",
"runOnMachineFunction",
"(",
"MF",
")",
";",
"}",
"</s>"
] |
[
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] |
[
"SystemZ",
"SystemZ"
] |
SystemZISelDAGToDAG (2)
|
runOnMachineFunction
|
SystemZ
|
CPU
|
LLVM
| 1,044 | 30 | 1 |
[] |
[
"<s>",
"void",
"assignValueToReg",
"(",
"Register",
"ValVReg",
",",
"Register",
"PhysReg",
",",
"CCValAssign",
"&",
"VA",
")",
"override",
"{",
"MIB",
".",
"addUse",
"(",
"PhysReg",
",",
"RegState",
"::",
"Implicit",
")",
";",
"Register",
"ExtReg",
"=",
"extendRegisterMin32",
"(",
"ValVReg",
",",
"VA",
")",
";",
"MIRBuilder",
".",
"buildCopy",
"(",
"PhysReg",
",",
"ExtReg",
")",
";",
"}",
"</s>"
] |
[
"The",
"specified",
"value",
"has",
"been",
"assigned",
"to",
"a",
"physical",
"register",
",",
"handle",
"the",
"appropriate",
"COPY",
"(",
"either",
"to",
"or",
"from",
")",
"and",
"mark",
"any",
"relevant",
"uses/defines",
"as",
"needed",
"."
] |
[
"AMDGPU"
] |
AMDGPUCallLowering21
|
assignValueToReg
|
AMDGPU
|
GPU
|
LLVM
| 1,045 | 46 | 1 |
[] |
[
"<s>",
"unsigned",
"ARMFastISel",
"::",
"constrainOperandRegClass",
"(",
"const",
"MCInstrDesc",
"&",
"II",
",",
"unsigned",
"Op",
",",
"unsigned",
"OpNum",
")",
"{",
"if",
"(",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"Op",
")",
")",
"{",
"const",
"TargetRegisterClass",
"*",
"RegClass",
"=",
"TII",
".",
"getRegClass",
"(",
"II",
",",
"OpNum",
",",
"&",
"TRI",
",",
"*",
"FuncInfo",
".",
"MF",
")",
";",
"if",
"(",
"!",
"MRI",
".",
"constrainRegClass",
"(",
"Op",
",",
"RegClass",
")",
")",
"{",
"unsigned",
"NewOp",
"=",
"createResultReg",
"(",
"RegClass",
")",
";",
"AddOptionalDefs",
"(",
"BuildMI",
"(",
"*",
"FuncInfo",
".",
"MBB",
",",
"FuncInfo",
".",
"InsertPt",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"TargetOpcode",
"::",
"COPY",
")",
",",
"NewOp",
")",
".",
"addReg",
"(",
"Op",
")",
")",
";",
"return",
"NewOp",
";",
"}",
"}",
"return",
"Op",
";",
"}",
"</s>"
] |
[
"Try",
"to",
"constrain",
"Op",
"so",
"that",
"it",
"is",
"usable",
"by",
"argument",
"OpNum",
"of",
"the",
"provided",
"MCInstrDesc",
"."
] |
[
"ARM",
"ARM"
] |
ARMFastISel63
|
constrainOperandRegClass
|
ARM
|
CPU
|
LLVM
| 1,046 | 112 | 1 |
[] |
[
"<s>",
"void",
"VEInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"uint64_t",
"Address",
",",
"StringRef",
"Annot",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"raw_ostream",
"&",
"OS",
")",
"{",
"if",
"(",
"!",
"printAliasInstr",
"(",
"MI",
",",
"STI",
",",
"OS",
")",
")",
"printInstruction",
"(",
"MI",
",",
"Address",
",",
"STI",
",",
"OS",
")",
";",
"printAnnotation",
"(",
"OS",
",",
"Annot",
")",
";",
"}",
"</s>"
] |
[
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] |
[
"VE",
"VE"
] |
VEInstPrinter1
|
printInst
|
VE
|
CPU
|
LLVM
| 1,047 | 57 | 1 |
[] |
[
"<s>",
"void",
"arm_lang_object_attributes_init",
"(",
"void",
")",
"{",
"arm_lang_output_object_attributes_hook",
"=",
"arm_output_c_attributes",
";",
"}",
"</s>"
] |
[
"Setup",
"so",
"that",
"common",
"code",
"calls",
"arm_output_c_attributes",
"."
] |
[
"arm"
] |
arm-c
|
arm_lang_object_attributes_init
|
arm
|
CPU
|
GCC
| 1,048 | 11 | 1 |
[] |
[
"<s>",
"unsigned",
"getGlobalBaseReg",
"(",
")",
"const",
"{",
"return",
"GlobalBaseReg",
";",
"}",
"</s>"
] |
[
"getGlobalBaseReg",
"-",
"Return",
"a",
"virtual",
"register",
"initialized",
"with",
"the",
"the",
"global",
"base",
"register",
"value",
"."
] |
[
"Alpha"
] |
AlphaMachineFunctionInfo
|
getGlobalBaseReg
|
Alpha
|
MPU
|
LLVM
| 1,049 | 10 | 1 |
[] |
[
"<s>",
"const",
"LegalizerInfo",
"*",
"getLegalizerInfo",
"(",
")",
"const",
"override",
"{",
"return",
"Legalizer",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] |
[
"Expose",
"LegalizerInfo",
"so",
"the",
"clients",
"can",
"re-use",
"."
] |
[
"AMDGPU"
] |
AMDGPUSubtarget
|
getLegalizerInfo
|
AMDGPU
|
GPU
|
LLVM
| 1,050 | 17 | 1 |
[] |
[
"<s>",
"static",
"tree",
"ix86_stack_protect_guard",
"(",
"void",
")",
"{",
"if",
"(",
"TARGET_SSP_TLS_GUARD",
")",
"return",
"NULL_TREE",
";",
"return",
"default_stack_protect_guard",
"(",
")",
";",
"}",
"</s>"
] |
[
"If",
"using",
"TLS",
"guards",
",",
"do",
"n't",
"waste",
"time",
"creating",
"and",
"expanding",
"__stack_chk_guard",
"decl",
"and",
"MEM",
"as",
"we",
"are",
"going",
"to",
"ignore",
"it",
"."
] |
[
"i386"
] |
i3866
|
ix86_stack_protect_guard
|
i386
|
CPU
|
GCC
| 1,051 | 20 | 1 |
[] |
[
"<s>",
"int",
"v9_regcmp_p",
"(",
"enum",
"rtx_code",
"code",
")",
"{",
"return",
"(",
"code",
"==",
"EQ",
"||",
"code",
"==",
"NE",
"||",
"code",
"==",
"GE",
"||",
"code",
"==",
"LT",
"||",
"code",
"==",
"LE",
"||",
"code",
"==",
"GT",
")",
";",
"}",
"</s>"
] |
[
"Nonzero",
"if",
"CODE",
",",
"a",
"comparison",
",",
"is",
"suitable",
"for",
"use",
"in",
"v9",
"conditional",
"move",
"or",
"branch",
"on",
"register",
"contents",
"instructions",
"."
] |
[
"sparc"
] |
sparc
|
v9_regcmp_p
|
sparc
|
CPU
|
GCC
| 1,052 | 36 | 1 |
[] |
[
"<s>",
"bool",
"nds32_n10_ex_to_ex_p",
"(",
"rtx_insn",
"*",
"producer",
",",
"rtx_insn",
"*",
"consumer",
")",
"{",
"gcc_assert",
"(",
"get_attr_type",
"(",
"producer",
")",
"==",
"TYPE_FLOAD",
"||",
"get_attr_type",
"(",
"producer",
")",
"==",
"TYPE_FSTORE",
")",
";",
"gcc_assert",
"(",
"get_attr_type",
"(",
"consumer",
")",
"==",
"TYPE_FLOAD",
"||",
"get_attr_type",
"(",
"consumer",
")",
"==",
"TYPE_FSTORE",
")",
";",
"if",
"(",
"!",
"post_update_insn_p",
"(",
"producer",
")",
")",
"return",
"false",
";",
"return",
"reg_overlap_p",
"(",
"extract_base_reg",
"(",
"producer",
")",
",",
"extract_mem_rtx",
"(",
"consumer",
")",
")",
";",
"}",
"</s>"
] |
[
"Check",
"dependencies",
"from",
"EX",
"to",
"EX",
"(",
"ADDR_OUT",
"-",
">",
"ADDR_IN",
")",
"."
] |
[
"nds32"
] |
nds32-pipelines-auxiliary
|
nds32_n10_ex_to_ex_p
|
nds32
|
CPU
|
GCC
| 1,053 | 72 | 1 |
[] |
[
"<s>",
"bool",
"ARMCodeGenPrepare",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"F",
")",
"||",
"DisableCGP",
")",
"return",
"false",
";",
"auto",
"*",
"TPC",
"=",
"&",
"getAnalysis",
"<",
"TargetPassConfig",
">",
"(",
")",
";",
"if",
"(",
"!",
"TPC",
")",
"return",
"false",
";",
"const",
"TargetMachine",
"&",
"TM",
"=",
"TPC",
"->",
"getTM",
"<",
"TargetMachine",
">",
"(",
")",
";",
"ST",
"=",
"&",
"TM",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
"F",
")",
";",
"bool",
"MadeChange",
"=",
"false",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"ARM CGP: Running on \"",
"<<",
"F",
".",
"getName",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"for",
"(",
"BasicBlock",
"&",
"BB",
":",
"F",
")",
"{",
"auto",
"&",
"Insts",
"=",
"BB",
".",
"getInstList",
"(",
")",
";",
"for",
"(",
"auto",
"&",
"I",
":",
"Insts",
")",
"{",
"if",
"(",
"AllVisited",
".",
"count",
"(",
"&",
"I",
")",
")",
"continue",
";",
"if",
"(",
"isa",
"<",
"ICmpInst",
">",
"(",
"I",
")",
")",
"{",
"auto",
"&",
"CI",
"=",
"cast",
"<",
"ICmpInst",
">",
"(",
"I",
")",
";",
"if",
"(",
"CI",
".",
"isSigned",
"(",
")",
"||",
"!",
"isa",
"<",
"IntegerType",
">",
"(",
"CI",
".",
"getOperand",
"(",
"0",
")",
"->",
"getType",
"(",
")",
")",
")",
"continue",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"ARM CGP: Searching from: \"",
"<<",
"CI",
"<<",
"\"\\n\"",
")",
";",
"for",
"(",
"auto",
"&",
"Op",
":",
"CI",
".",
"operands",
"(",
")",
")",
"{",
"if",
"(",
"auto",
"*",
"I",
"=",
"dyn_cast",
"<",
"Instruction",
">",
"(",
"Op",
")",
")",
"{",
"if",
"(",
"isa",
"<",
"ZExtInst",
">",
"(",
"I",
")",
")",
"MadeChange",
"|=",
"TryToPromote",
"(",
"I",
"->",
"getOperand",
"(",
"0",
")",
")",
";",
"else",
"MadeChange",
"|=",
"TryToPromote",
"(",
"I",
")",
";",
"}",
"}",
"}",
"}",
"Promoter",
"->",
"Cleanup",
"(",
")",
";",
"LLVM_DEBUG",
"(",
"if",
"(",
"verifyFunction",
"(",
"F",
",",
"&",
"dbgs",
"(",
")",
")",
")",
"{",
"dbgs",
"(",
")",
";",
"report_fatal_error",
"(",
"\"Broken function after type promotion\"",
")",
";",
"}",
")",
";",
"}",
"if",
"(",
"MadeChange",
")",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"After ARMCodeGenPrepare: \"",
"<<",
"F",
"<<",
"\"\\n\"",
")",
";",
"return",
"MadeChange",
";",
"}",
"</s>"
] |
[
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] |
[
"ARM",
"ARM",
"ARM",
"\"ARM CGP: Running on \"",
"\"\\n\"",
"0",
"\"ARM CGP: Searching from: \"",
"\"\\n\"",
"0",
"\"Broken function after type promotion\"",
"\"After ARMCodeGenPrepare: \"",
"\"\\n\""
] |
ARMCodeGenPrepare1
|
runOnFunction
|
ARM
|
CPU
|
LLVM
| 1,054 | 312 | 1 |
[] |
[
"<s>",
"void",
"AMDGPUAsmPrinter",
"::",
"emitFunctionBodyStart",
"(",
")",
"{",
"const",
"SIMachineFunctionInfo",
"&",
"MFI",
"=",
"*",
"MF",
"->",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"const",
"GCNSubtarget",
"&",
"STM",
"=",
"MF",
"->",
"getSubtarget",
"<",
"GCNSubtarget",
">",
"(",
")",
";",
"const",
"Function",
"&",
"F",
"=",
"MF",
"->",
"getFunction",
"(",
")",
";",
"if",
"(",
"getTargetStreamer",
"(",
")",
"&&",
"!",
"getTargetStreamer",
"(",
")",
"->",
"getTargetID",
"(",
")",
")",
"initializeTargetID",
"(",
"*",
"F",
".",
"getParent",
"(",
")",
")",
";",
"const",
"auto",
"&",
"FunctionTargetID",
"=",
"STM",
".",
"getTargetID",
"(",
")",
";",
"if",
"(",
"FunctionTargetID",
".",
"isXnackSupported",
"(",
")",
"&&",
"FunctionTargetID",
".",
"getXnackSetting",
"(",
")",
"!=",
"IsaInfo",
"::",
"TargetIDSetting",
"::",
"Any",
"&&",
"FunctionTargetID",
".",
"getXnackSetting",
"(",
")",
"!=",
"getTargetStreamer",
"(",
")",
"->",
"getTargetID",
"(",
")",
"->",
"getXnackSetting",
"(",
")",
")",
"{",
"OutContext",
".",
"reportError",
"(",
"{",
"}",
",",
"\"xnack setting of '\"",
"+",
"Twine",
"(",
"MF",
"->",
"getName",
"(",
")",
")",
"+",
"\"' function does not match module xnack setting\"",
")",
";",
"return",
";",
"}",
"if",
"(",
"FunctionTargetID",
".",
"isSramEccSupported",
"(",
")",
"&&",
"FunctionTargetID",
".",
"getSramEccSetting",
"(",
")",
"!=",
"IsaInfo",
"::",
"TargetIDSetting",
"::",
"Any",
"&&",
"FunctionTargetID",
".",
"getSramEccSetting",
"(",
")",
"!=",
"getTargetStreamer",
"(",
")",
"->",
"getTargetID",
"(",
")",
"->",
"getSramEccSetting",
"(",
")",
")",
"{",
"OutContext",
".",
"reportError",
"(",
"{",
"}",
",",
"\"sramecc setting of '\"",
"+",
"Twine",
"(",
"MF",
"->",
"getName",
"(",
")",
")",
"+",
"\"' function does not match module sramecc setting\"",
")",
";",
"return",
";",
"}",
"if",
"(",
"!",
"MFI",
".",
"isEntryFunction",
"(",
")",
")",
"return",
";",
"if",
"(",
"(",
"STM",
".",
"isMesaKernel",
"(",
"F",
")",
"||",
"isHsaAbiVersion2",
"(",
"getGlobalSTI",
"(",
")",
")",
")",
"&&",
"(",
"F",
".",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"AMDGPU_KERNEL",
"||",
"F",
".",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"SPIR_KERNEL",
")",
")",
"{",
"amd_kernel_code_t",
"KernelCode",
";",
"getAmdKernelCode",
"(",
"KernelCode",
",",
"CurrentProgramInfo",
",",
"*",
"MF",
")",
";",
"getTargetStreamer",
"(",
")",
"->",
"EmitAMDKernelCodeT",
"(",
"KernelCode",
")",
";",
"}",
"if",
"(",
"STM",
".",
"isAmdHsaOS",
"(",
")",
")",
"HSAMetadataStream",
"->",
"emitKernel",
"(",
"*",
"MF",
",",
"CurrentProgramInfo",
")",
";",
"}",
"</s>"
] |
[
"Targets",
"can",
"override",
"this",
"to",
"emit",
"stuff",
"before",
"the",
"first",
"basic",
"block",
"in",
"the",
"function",
"."
] |
[
"AMDGPU",
"AMDGPU",
"SI",
"SI",
"\"xnack setting of '\"",
"\"' function does not match module xnack setting\"",
"\"sramecc setting of '\"",
"\"' function does not match module sramecc setting\"",
"AMDGPU"
] |
AMDGPUAsmPrinter
|
emitFunctionBodyStart
|
AMDGPU
|
GPU
|
LLVM
| 1,055 | 303 | 1 |
[] |
[
"<s>",
"bool",
"ix86_avoid_lea_for_addr",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"operands",
"[",
"]",
")",
"{",
"unsigned",
"int",
"regno0",
",",
"regno1",
",",
"regno2",
";",
"int",
"split_cost",
";",
"struct",
"ix86_address",
"parts",
";",
"int",
"ok",
";",
"if",
"(",
"REG_P",
"(",
"operands",
"[",
"1",
"]",
")",
"||",
"(",
"SImode_address_operand",
"(",
"operands",
"[",
"1",
"]",
",",
"VOIDmode",
")",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"operands",
"[",
"1",
"]",
",",
"0",
")",
")",
")",
")",
"return",
"false",
";",
"ok",
"=",
"ix86_decompose_address",
"(",
"operands",
"[",
"1",
"]",
",",
"&",
"parts",
")",
";",
"gcc_assert",
"(",
"ok",
")",
";",
"if",
"(",
"(",
"parts",
".",
"base",
"!=",
"NULL_RTX",
")",
"+",
"(",
"parts",
".",
"index",
"!=",
"NULL_RTX",
")",
"+",
"(",
"parts",
".",
"disp",
"!=",
"NULL_RTX",
")",
"+",
"(",
"parts",
".",
"scale",
">",
"1",
")",
"<",
"2",
")",
"return",
"false",
";",
"if",
"(",
"parts",
".",
"disp",
"&&",
"flag_pic",
"&&",
"!",
"LEGITIMATE_PIC_OPERAND_P",
"(",
"parts",
".",
"disp",
")",
")",
"return",
"false",
";",
"regno0",
"=",
"true_regnum",
"(",
"operands",
"[",
"0",
"]",
")",
";",
"regno1",
"=",
"INVALID_REGNUM",
";",
"regno2",
"=",
"INVALID_REGNUM",
";",
"if",
"(",
"parts",
".",
"base",
")",
"regno1",
"=",
"true_regnum",
"(",
"parts",
".",
"base",
")",
";",
"if",
"(",
"parts",
".",
"index",
")",
"regno2",
"=",
"true_regnum",
"(",
"parts",
".",
"index",
")",
";",
"if",
"(",
"!",
"TARGET_CPU_P",
"(",
"BONNELL",
")",
"&&",
"parts",
".",
"scale",
"==",
"1",
"&&",
"(",
"!",
"parts",
".",
"disp",
"||",
"parts",
".",
"disp",
"==",
"const0_rtx",
")",
"&&",
"(",
"regno0",
"==",
"regno1",
"||",
"regno0",
"==",
"regno2",
")",
")",
"return",
"true",
";",
"if",
"(",
"!",
"TARGET_AVOID_LEA_FOR_ADDR",
"||",
"optimize_function_for_size_p",
"(",
"cfun",
")",
")",
"return",
"false",
";",
"split_cost",
"=",
"0",
";",
"if",
"(",
"parts",
".",
"base",
"||",
"parts",
".",
"index",
")",
"{",
"if",
"(",
"regno1",
"!=",
"regno0",
"&&",
"regno2",
"!=",
"regno0",
")",
"split_cost",
"+=",
"1",
";",
"if",
"(",
"parts",
".",
"base",
"&&",
"parts",
".",
"index",
")",
"split_cost",
"+=",
"1",
";",
"if",
"(",
"parts",
".",
"scale",
">",
"1",
")",
"{",
"if",
"(",
"regno0",
"!=",
"regno1",
")",
"split_cost",
"+=",
"1",
";",
"else",
"if",
"(",
"regno2",
"==",
"regno0",
")",
"split_cost",
"+=",
"4",
";",
"else",
"split_cost",
"+=",
"parts",
".",
"scale",
";",
"}",
"if",
"(",
"parts",
".",
"disp",
"&&",
"parts",
".",
"disp",
"!=",
"const0_rtx",
")",
"split_cost",
"+=",
"1",
";",
"split_cost",
"-=",
"1",
";",
"}",
"return",
"!",
"ix86_lea_outperforms",
"(",
"insn",
",",
"regno0",
",",
"regno1",
",",
"regno2",
",",
"split_cost",
",",
"parts",
".",
"scale",
">",
"1",
")",
";",
"}",
"</s>"
] |
[
"Return",
"true",
"if",
"we",
"need",
"to",
"split",
"lea",
"into",
"a",
"sequence",
"of",
"instructions",
"to",
"avoid",
"AGU",
"stalls",
"during",
"peephole2",
"."
] |
[
"i386",
"1",
"1",
"1",
"0",
"1",
"1",
"2",
"0",
"1",
"0",
"1",
"1",
"1",
"1",
"4",
"1",
"1",
"1"
] |
i386
|
ix86_avoid_lea_for_addr
|
i386
|
CPU
|
GCC
| 1,056 | 370 | 1 |
[] |
[
"<s>",
"SDValue",
"X86TargetLowering",
"::",
"BuildSDIVPow2",
"(",
"SDNode",
"*",
"N",
",",
"const",
"APInt",
"&",
"Divisor",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDNode",
"*",
">",
"&",
"Created",
")",
"const",
"{",
"AttributeList",
"Attr",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getFunction",
"(",
")",
".",
"getAttributes",
"(",
")",
";",
"if",
"(",
"isIntDivCheap",
"(",
"N",
"->",
"getValueType",
"(",
"0",
")",
",",
"Attr",
")",
")",
"return",
"SDValue",
"(",
"N",
",",
"0",
")",
";",
"assert",
"(",
"(",
"Divisor",
".",
"isPowerOf2",
"(",
")",
"||",
"(",
"-",
"Divisor",
")",
".",
"isPowerOf2",
"(",
")",
")",
"&&",
"\"Unexpected divisor!\"",
")",
";",
"if",
"(",
"!",
"Subtarget",
".",
"hasCMov",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"EVT",
"VT",
"=",
"N",
"->",
"getValueType",
"(",
"0",
")",
";",
"if",
"(",
"VT",
"!=",
"MVT",
"::",
"i16",
"&&",
"VT",
"!=",
"MVT",
"::",
"i32",
"&&",
"!",
"(",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"VT",
"==",
"MVT",
"::",
"i64",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"unsigned",
"Lg2",
"=",
"Divisor",
".",
"countTrailingZeros",
"(",
")",
";",
"if",
"(",
"Lg2",
"==",
"1",
")",
"return",
"SDValue",
"(",
")",
";",
"SDLoc",
"DL",
"(",
"N",
")",
";",
"SDValue",
"N0",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"Zero",
"=",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"DL",
",",
"VT",
")",
";",
"APInt",
"Lg2Mask",
"=",
"APInt",
"::",
"getLowBitsSet",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
",",
"Lg2",
")",
";",
"SDValue",
"Pow2MinusOne",
"=",
"DAG",
".",
"getConstant",
"(",
"Lg2Mask",
",",
"DL",
",",
"VT",
")",
";",
"SDValue",
"Cmp",
"=",
"DAG",
".",
"getSetCC",
"(",
"DL",
",",
"MVT",
"::",
"i8",
",",
"N0",
",",
"Zero",
",",
"ISD",
"::",
"SETLT",
")",
";",
"SDValue",
"Add",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"VT",
",",
"N0",
",",
"Pow2MinusOne",
")",
";",
"SDValue",
"CMov",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SELECT",
",",
"DL",
",",
"VT",
",",
"Cmp",
",",
"Add",
",",
"N0",
")",
";",
"Created",
".",
"push_back",
"(",
"Cmp",
".",
"getNode",
"(",
")",
")",
";",
"Created",
".",
"push_back",
"(",
"Add",
".",
"getNode",
"(",
")",
")",
";",
"Created",
".",
"push_back",
"(",
"CMov",
".",
"getNode",
"(",
")",
")",
";",
"SDValue",
"SRA",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SRA",
",",
"DL",
",",
"VT",
",",
"CMov",
",",
"DAG",
".",
"getConstant",
"(",
"Lg2",
",",
"DL",
",",
"MVT",
"::",
"i8",
")",
")",
";",
"if",
"(",
"Divisor",
".",
"isNonNegative",
"(",
")",
")",
"return",
"SRA",
";",
"Created",
".",
"push_back",
"(",
"SRA",
".",
"getNode",
"(",
")",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SUB",
",",
"DL",
",",
"VT",
",",
"Zero",
",",
"SRA",
")",
";",
"}",
"</s>"
] |
[
"Targets",
"may",
"override",
"this",
"function",
"to",
"provide",
"custom",
"SDIV",
"lowering",
"for",
"power-of-2",
"denominators",
"."
] |
[
"X86",
"X86",
"0",
"0",
"\"Unexpected divisor!\"",
"0",
"MVT::i16",
"MVT::i32",
"MVT::i64",
"1",
"0",
"0",
"MVT::i8",
"ISD::SETLT",
"ISD::ADD",
"ISD::SELECT",
"ISD::SRA",
"MVT::i8",
"ISD::SUB"
] |
X86ISelLowering (2)5
|
BuildSDIVPow2
|
X86
|
CPU
|
LLVM
| 1,057 | 396 | 1 |
[] |
[
"<s>",
"unsigned",
"SystemZInstrInfo",
"::",
"isStoreToStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"return",
"isSimpleMove",
"(",
"MI",
",",
"FrameIndex",
",",
"SystemZII",
"::",
"SimpleBDXStore",
")",
";",
"}",
"</s>"
] |
[
"isStoreToStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"store",
"to",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"source",
"reg",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] |
[
"SystemZ",
"SystemZ",
"SystemZII::SimpleBDXStore"
] |
SystemZInstrInfo (2)2
|
isStoreToStackSlot
|
SystemZ
|
CPU
|
LLVM
| 1,058 | 29 | 1 |
[] |
[
"<s>",
"bool",
"SIWholeQuadMode",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getCallingConv",
"(",
")",
"!=",
"CallingConv",
"::",
"AMDGPU_PS",
")",
"return",
"false",
";",
"Instructions",
".",
"clear",
"(",
")",
";",
"Blocks",
".",
"clear",
"(",
")",
";",
"ExecExports",
".",
"clear",
"(",
")",
";",
"LiveMaskQueries",
".",
"clear",
"(",
")",
";",
"const",
"SISubtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"SISubtarget",
">",
"(",
")",
";",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"&",
"TII",
"->",
"getRegisterInfo",
"(",
")",
";",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"char",
"GlobalFlags",
"=",
"analyzeFunction",
"(",
"MF",
")",
";",
"if",
"(",
"!",
"(",
"GlobalFlags",
"&",
"StateWQM",
")",
")",
"{",
"lowerLiveMaskQueries",
"(",
"AMDGPU",
"::",
"EXEC",
")",
";",
"return",
"!",
"LiveMaskQueries",
".",
"empty",
"(",
")",
";",
"}",
"unsigned",
"LiveMaskReg",
"=",
"0",
";",
"{",
"MachineBasicBlock",
"&",
"Entry",
"=",
"MF",
".",
"front",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"EntryMI",
"=",
"Entry",
".",
"getFirstNonPHI",
"(",
")",
";",
"if",
"(",
"GlobalFlags",
"&",
"StateExact",
"||",
"!",
"LiveMaskQueries",
".",
"empty",
"(",
")",
")",
"{",
"LiveMaskReg",
"=",
"MRI",
"->",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"SReg_64RegClass",
")",
";",
"BuildMI",
"(",
"Entry",
",",
"EntryMI",
",",
"DebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"COPY",
")",
",",
"LiveMaskReg",
")",
".",
"addReg",
"(",
"AMDGPU",
"::",
"EXEC",
")",
";",
"}",
"if",
"(",
"GlobalFlags",
"==",
"StateWQM",
")",
"{",
"BuildMI",
"(",
"Entry",
",",
"EntryMI",
",",
"DebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_WQM_B64",
")",
",",
"AMDGPU",
"::",
"EXEC",
")",
".",
"addReg",
"(",
"AMDGPU",
"::",
"EXEC",
")",
";",
"lowerLiveMaskQueries",
"(",
"LiveMaskReg",
")",
";",
"return",
"true",
";",
"}",
"}",
"lowerLiveMaskQueries",
"(",
"LiveMaskReg",
")",
";",
"for",
"(",
"auto",
"BII",
":",
"Blocks",
")",
"processBlock",
"(",
"*",
"BII",
".",
"first",
",",
"LiveMaskReg",
",",
"BII",
".",
"first",
"==",
"&",
"*",
"MF",
".",
"begin",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] |
[
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] |
[
"AMDGPU",
"SI",
"AMDGPU",
"SI",
"SI",
"AMDGPU::EXEC",
"0",
"AMDGPU::SReg_64RegClass",
"AMDGPU::COPY",
"AMDGPU::EXEC",
"AMDGPU::S_WQM_B64",
"AMDGPU::EXEC",
"AMDGPU::EXEC"
] |
SIWholeQuadMode42
|
runOnMachineFunction
|
AMDGPU
|
GPU
|
LLVM
| 1,059 | 296 | 1 |
[] |
[
"<s>",
"bool",
"NVPTXPrologEpilogPass",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"TargetSubtargetInfo",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
";",
"const",
"TargetFrameLowering",
"&",
"TFI",
"=",
"*",
"STI",
".",
"getFrameLowering",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"&",
"TRI",
"=",
"*",
"STI",
".",
"getRegisterInfo",
"(",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"calculateFrameObjectOffsets",
"(",
"MF",
")",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"{",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"MBB",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"MI",
".",
"getNumOperands",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"isFI",
"(",
")",
")",
"continue",
";",
"if",
"(",
"MI",
".",
"isDebugValue",
"(",
")",
")",
"{",
"assert",
"(",
"i",
"==",
"0",
"&&",
"\"Frame indices can only appear as the first \"",
"\"operand of a DBG_VALUE machine instruction\"",
")",
";",
"unsigned",
"Reg",
";",
"int64_t",
"Offset",
"=",
"TFI",
".",
"getFrameIndexReference",
"(",
"MF",
",",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getIndex",
"(",
")",
",",
"Reg",
")",
";",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"ChangeToRegister",
"(",
"Reg",
",",
"false",
")",
";",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"setIsDebug",
"(",
")",
";",
"auto",
"*",
"DIExpr",
"=",
"DIExpression",
"::",
"prepend",
"(",
"MI",
".",
"getDebugExpression",
"(",
")",
",",
"DIExpression",
"::",
"ApplyOffset",
",",
"Offset",
")",
";",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"setMetadata",
"(",
"DIExpr",
")",
";",
"continue",
";",
"}",
"TRI",
".",
"eliminateFrameIndex",
"(",
"MI",
",",
"0",
",",
"i",
",",
"nullptr",
")",
";",
"Modified",
"=",
"true",
";",
"}",
"}",
"}",
"TFI",
".",
"emitPrologue",
"(",
"MF",
",",
"MF",
".",
"front",
"(",
")",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"I",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"I",
"->",
"isReturnBlock",
"(",
")",
")",
"TFI",
".",
"emitEpilogue",
"(",
"MF",
",",
"*",
"I",
")",
";",
"}",
"return",
"Modified",
";",
"}",
"</s>"
] |
[
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] |
[
"NVPTX",
"NVPTX",
"0",
"0",
"\"Frame indices can only appear as the first \"",
"\"operand of a DBG_VALUE machine instruction\"",
"0",
"0",
"0",
"3",
"0"
] |
NVPTXPrologEpilogPass15
|
runOnMachineFunction
|
NVPTX
|
GPU
|
LLVM
| 1,060 | 303 | 1 |
[] |
[
"<s>",
"static",
"void",
"mips_legitimize_const_move",
"(",
"machine_mode",
"mode",
",",
"rtx",
"dest",
",",
"rtx",
"src",
")",
"{",
"rtx",
"base",
",",
"offset",
";",
"if",
"(",
"splittable_const_int_operand",
"(",
"src",
",",
"mode",
")",
")",
"{",
"mips_move_integer",
"(",
"dest",
",",
"dest",
",",
"INTVAL",
"(",
"src",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"mips_split_symbol",
"(",
"dest",
",",
"src",
",",
"MAX_MACHINE_MODE",
",",
"&",
"src",
")",
")",
"{",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"dest",
",",
"src",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"mips_tls_symbol_p",
"(",
"src",
")",
")",
"{",
"mips_emit_move",
"(",
"dest",
",",
"mips_legitimize_tls_address",
"(",
"src",
")",
")",
";",
"return",
";",
"}",
"split_const",
"(",
"src",
",",
"&",
"base",
",",
"&",
"offset",
")",
";",
"if",
"(",
"offset",
"!=",
"const0_rtx",
"&&",
"(",
"targetm",
".",
"cannot_force_const_mem",
"(",
"mode",
",",
"src",
")",
"||",
"(",
"!",
"TARGET_MIPS16",
"&&",
"can_create_pseudo_p",
"(",
")",
")",
")",
")",
"{",
"base",
"=",
"mips_force_temporary",
"(",
"dest",
",",
"base",
")",
";",
"mips_emit_move",
"(",
"dest",
",",
"mips_add_offset",
"(",
"NULL",
",",
"base",
",",
"INTVAL",
"(",
"offset",
")",
")",
")",
";",
"return",
";",
"}",
"src",
"=",
"force_const_mem",
"(",
"mode",
",",
"src",
")",
";",
"mips_split_symbol",
"(",
"dest",
",",
"XEXP",
"(",
"src",
",",
"0",
")",
",",
"mode",
",",
"&",
"XEXP",
"(",
"src",
",",
"0",
")",
")",
";",
"mips_emit_move",
"(",
"dest",
",",
"src",
")",
";",
"}",
"</s>"
] |
[
"Subroutine",
"of",
"mips_legitimize_move",
".",
"Move",
"constant",
"SRC",
"into",
"register",
"DEST",
"given",
"that",
"SRC",
"satisfies",
"immediate_operand",
"but",
"does",
"n't",
"satisfy",
"move_operand",
"."
] |
[
"mips",
"0",
"0"
] |
mips4
|
mips_legitimize_const_move
|
mips
|
CPU
|
GCC
| 1,061 | 201 | 1 |
[] |
[
"<s>",
"bool",
"X86FrameLowering",
"::",
"restoreCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"isFuncletReturnInstr",
"(",
"*",
"MI",
")",
"&&",
"STI",
".",
"isOSWindows",
"(",
")",
")",
"{",
"if",
"(",
"STI",
".",
"is32Bit",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"X86",
"::",
"CATCHRET",
")",
"{",
"const",
"Function",
"*",
"Func",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getFunction",
"(",
")",
";",
"bool",
"IsSEH",
"=",
"isAsynchronousEHPersonality",
"(",
"classifyEHPersonality",
"(",
"Func",
"->",
"getPersonalityFn",
"(",
")",
")",
")",
";",
"if",
"(",
"IsSEH",
")",
"return",
"true",
";",
"}",
"}",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"]",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"X86",
"::",
"GR64RegClass",
".",
"contains",
"(",
"Reg",
")",
"||",
"X86",
"::",
"GR32RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"continue",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TRI",
"->",
"getMinimalPhysRegClass",
"(",
"Reg",
")",
";",
"TII",
".",
"loadRegFromStackSlot",
"(",
"MBB",
",",
"MI",
",",
"Reg",
",",
"CSI",
"[",
"i",
"]",
".",
"getFrameIdx",
"(",
")",
",",
"RC",
",",
"TRI",
")",
";",
"--",
"MI",
";",
"MI",
"->",
"setFlag",
"(",
"MachineInstr",
"::",
"FrameDestroy",
")",
";",
"++",
"MI",
";",
"}",
"unsigned",
"Opc",
"=",
"STI",
".",
"is64Bit",
"(",
")",
"?",
"X86",
"::",
"POP64r",
":",
"X86",
"::",
"POP32r",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"]",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"!",
"X86",
"::",
"GR64RegClass",
".",
"contains",
"(",
"Reg",
")",
"&&",
"!",
"X86",
"::",
"GR32RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"continue",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"Reg",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameDestroy",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] |
[
"restoreCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"restore",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"load",
"instructions",
"via",
"loadRegToStackSlot",
"(",
")",
"."
] |
[
"X86",
"X86",
"X86::CATCHRET",
"0",
"X86::GR64RegClass",
"X86::GR32RegClass",
"X86::POP64r",
"X86::POP32r",
"0",
"X86::GR64RegClass",
"X86::GR32RegClass"
] |
X86FrameLowering8
|
restoreCalleeSavedRegisters
|
X86
|
CPU
|
LLVM
| 1,062 | 345 | 1 |
[] |
[
"<s>",
"bool",
"usesFunctionDescriptors",
"(",
")",
"const",
"{",
"return",
"isAIXABI",
"(",
")",
"||",
"(",
"is64BitELFABI",
"(",
")",
"&&",
"!",
"isELFv2ABI",
"(",
")",
")",
";",
"}",
"</s>"
] |
[
"True",
"if",
"the",
"ABI",
"is",
"descriptor",
"based",
"."
] |
[
"PowerPC"
] |
PPCSubtarget12
|
usesFunctionDescriptors
|
PowerPC
|
CPU
|
LLVM
| 1,063 | 23 | 1 |
[] |
[
"<s>",
"SDValue",
"MSP430TargetLowering",
"::",
"LowerCall",
"(",
"TargetLowering",
"::",
"CallLoweringInfo",
"&",
"CLI",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"SelectionDAG",
"&",
"DAG",
"=",
"CLI",
".",
"DAG",
";",
"SDLoc",
"&",
"dl",
"=",
"CLI",
".",
"DL",
";",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
"=",
"CLI",
".",
"Outs",
";",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
"=",
"CLI",
".",
"OutVals",
";",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
"=",
"CLI",
".",
"Ins",
";",
"SDValue",
"Chain",
"=",
"CLI",
".",
"Chain",
";",
"SDValue",
"Callee",
"=",
"CLI",
".",
"Callee",
";",
"bool",
"&",
"isTailCall",
"=",
"CLI",
".",
"IsTailCall",
";",
"CallingConv",
"::",
"ID",
"CallConv",
"=",
"CLI",
".",
"CallConv",
";",
"bool",
"isVarArg",
"=",
"CLI",
".",
"IsVarArg",
";",
"isTailCall",
"=",
"false",
";",
"switch",
"(",
"CallConv",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unsupported calling convention\"",
")",
";",
"case",
"CallingConv",
"::",
"MSP430_BUILTIN",
":",
"case",
"CallingConv",
"::",
"Fast",
":",
"case",
"CallingConv",
"::",
"C",
":",
"return",
"LowerCCCCallTo",
"(",
"Chain",
",",
"Callee",
",",
"CallConv",
",",
"isVarArg",
",",
"isTailCall",
",",
"Outs",
",",
"OutVals",
",",
"Ins",
",",
"dl",
",",
"DAG",
",",
"InVals",
")",
";",
"case",
"CallingConv",
"::",
"MSP430_INTR",
":",
"report_fatal_error",
"(",
"\"ISRs cannot be called directly\"",
")",
";",
"}",
"}",
"</s>"
] |
[
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"calls",
"into",
"the",
"specified",
"DAG",
"."
] |
[
"MSP430",
"MSP430",
"ISD::OutputArg",
"ISD::InputArg",
"\"Unsupported calling convention\"",
"MSP430",
"MSP430",
"\"ISRs cannot be called directly\""
] |
MSP430ISelLowering41
|
LowerCall
|
MSP430
|
MPU
|
LLVM
| 1,064 | 180 | 1 |
[] |
[
"<s>",
"void",
"MBlazeInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"O",
",",
"StringRef",
"Annot",
")",
"{",
"printInstruction",
"(",
"MI",
",",
"O",
")",
";",
"printAnnotation",
"(",
"O",
",",
"Annot",
")",
";",
"}",
"</s>"
] |
[
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] |
[
"MBlaze",
"MBlaze"
] |
MBlazeInstPrinter
|
printInst
|
MBlaze
|
MPU
|
LLVM
| 1,065 | 33 | 1 |
[] |
[
"<s>",
"void",
"ARMAsmBackend",
"::",
"relaxInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"MCInst",
"&",
"Res",
")",
"const",
"{",
"unsigned",
"RelaxedOp",
"=",
"getRelaxedOpcode",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"RelaxedOp",
"==",
"Inst",
".",
"getOpcode",
"(",
")",
")",
"{",
"SmallString",
"<",
"256",
">",
"Tmp",
";",
"raw_svector_ostream",
"OS",
"(",
"Tmp",
")",
";",
"Inst",
".",
"dump_pretty",
"(",
"OS",
")",
";",
"OS",
"<<",
"\"\\n\"",
";",
"report_fatal_error",
"(",
"\"unexpected instruction to relax: \"",
"+",
"OS",
".",
"str",
"(",
")",
")",
";",
"}",
"if",
"(",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"tCBZ",
"||",
"Inst",
".",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"tCBNZ",
")",
"&&",
"RelaxedOp",
"==",
"ARM",
"::",
"tHINT",
")",
"{",
"Res",
".",
"setOpcode",
"(",
"RelaxedOp",
")",
";",
"Res",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"0",
")",
")",
";",
"Res",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"14",
")",
")",
";",
"Res",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createReg",
"(",
"0",
")",
")",
";",
"return",
";",
"}",
"Res",
"=",
"Inst",
";",
"Res",
".",
"setOpcode",
"(",
"RelaxedOp",
")",
";",
"}",
"</s>"
] |
[
"Relax",
"the",
"instruction",
"in",
"the",
"given",
"fragment",
"to",
"the",
"next",
"wider",
"instruction",
"."
] |
[
"ARM",
"ARM",
"256",
"\"\\n\"",
"\"unexpected instruction to relax: \"",
"ARM::tCBZ",
"ARM::tCBNZ",
"ARM::tHINT",
"0",
"14",
"0"
] |
ARMAsmBackend11
|
relaxInstruction
|
ARM
|
CPU
|
LLVM
| 1,066 | 168 | 1 |
[] |
[
"<s>",
"SDValue",
"SystemZTargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"ZERO_EXTEND",
":",
"return",
"combineZERO_EXTEND",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND",
":",
"return",
"combineSIGN_EXTEND",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND_INREG",
":",
"return",
"combineSIGN_EXTEND_INREG",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"MERGE_HIGH",
":",
"case",
"SystemZISD",
"::",
"MERGE_LOW",
":",
"return",
"combineMERGE",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"combineSTORE",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
":",
"return",
"combineEXTRACT_VECTOR_ELT",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"JOIN_DWORDS",
":",
"return",
"combineJOIN_DWORDS",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"FP_ROUND",
":",
"return",
"combineFP_ROUND",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"BSWAP",
":",
"return",
"combineBSWAP",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"SHL",
":",
"case",
"ISD",
"::",
"SRA",
":",
"case",
"ISD",
"::",
"SRL",
":",
"case",
"ISD",
"::",
"ROTL",
":",
"return",
"combineSHIFTROT",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"BR_CCMASK",
":",
"return",
"combineBR_CCMASK",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"SELECT_CCMASK",
":",
"return",
"combineSELECT_CCMASK",
"(",
"N",
",",
"DCI",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] |
[
"This",
"method",
"will",
"be",
"invoked",
"for",
"all",
"target",
"nodes",
"and",
"for",
"any",
"target-independent",
"nodes",
"that",
"the",
"target",
"has",
"registered",
"with",
"invoke",
"it",
"for",
"."
] |
[
"SystemZ",
"SystemZ",
"ISD::ZERO_EXTEND",
"ISD::SIGN_EXTEND",
"ISD::SIGN_EXTEND_INREG",
"SystemZISD::MERGE_HIGH",
"SystemZISD::MERGE_LOW",
"ISD::STORE",
"ISD::EXTRACT_VECTOR_ELT",
"SystemZISD::JOIN_DWORDS",
"ISD::FP_ROUND",
"ISD::BSWAP",
"ISD::SHL",
"ISD::SRA",
"ISD::SRL",
"ISD::ROTL",
"SystemZISD::BR_CCMASK",
"SystemZISD::SELECT_CCMASK"
] |
SystemZISelLowering121
|
PerformDAGCombine
|
SystemZ
|
CPU
|
LLVM
| 1,067 | 211 | 1 |
[] |
[
"<s>",
"static",
"int",
"rs6000_arg_partial_bytes",
"(",
"cumulative_args_t",
"cum_v",
",",
"machine_mode",
"mode",
",",
"tree",
"type",
",",
"bool",
"named",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"cum",
"=",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"bool",
"passed_in_gprs",
"=",
"true",
";",
"int",
"ret",
"=",
"0",
";",
"int",
"align_words",
";",
"machine_mode",
"elt_mode",
";",
"int",
"n_elts",
";",
"rs6000_discover_homogeneous_aggregate",
"(",
"mode",
",",
"type",
",",
"&",
"elt_mode",
",",
"&",
"n_elts",
")",
";",
"if",
"(",
"DEFAULT_ABI",
"==",
"ABI_V4",
")",
"return",
"0",
";",
"if",
"(",
"USE_ALTIVEC_FOR_ARG_P",
"(",
"cum",
",",
"elt_mode",
",",
"named",
")",
")",
"{",
"if",
"(",
"TARGET_64BIT",
"&&",
"!",
"cum",
"->",
"prototype",
")",
"return",
"0",
";",
"passed_in_gprs",
"=",
"false",
";",
"if",
"(",
"cum",
"->",
"vregno",
"+",
"n_elts",
">",
"ALTIVEC_ARG_MAX_REG",
"+",
"1",
")",
"ret",
"=",
"(",
"ALTIVEC_ARG_MAX_REG",
"+",
"1",
"-",
"cum",
"->",
"vregno",
")",
"*",
"16",
";",
"}",
"if",
"(",
"TARGET_MACHO",
"&&",
"rs6000_darwin64_struct_check_p",
"(",
"mode",
",",
"type",
")",
")",
"return",
"0",
";",
"align_words",
"=",
"rs6000_parm_start",
"(",
"mode",
",",
"type",
",",
"cum",
"->",
"words",
")",
";",
"if",
"(",
"USE_FP_FOR_ARG_P",
"(",
"cum",
",",
"elt_mode",
")",
")",
"{",
"unsigned",
"long",
"n_fpreg",
"=",
"(",
"GET_MODE_SIZE",
"(",
"elt_mode",
")",
"+",
"7",
")",
">>",
"3",
";",
"if",
"(",
"type",
"&&",
"(",
"cum",
"->",
"nargs_prototype",
"<=",
"0",
"||",
"(",
"(",
"DEFAULT_ABI",
"==",
"ABI_AIX",
"||",
"DEFAULT_ABI",
"==",
"ABI_ELFv2",
")",
"&&",
"TARGET_XL_COMPAT",
"&&",
"align_words",
">=",
"GP_ARG_NUM_REG",
")",
")",
")",
"return",
"0",
";",
"passed_in_gprs",
"=",
"false",
";",
"if",
"(",
"cum",
"->",
"fregno",
"+",
"n_elts",
"*",
"n_fpreg",
">",
"FP_ARG_MAX_REG",
"+",
"1",
")",
"{",
"int",
"fpr",
"=",
"(",
"(",
"FP_ARG_MAX_REG",
"+",
"1",
"-",
"cum",
"->",
"fregno",
")",
"*",
"MIN",
"(",
"8",
",",
"GET_MODE_SIZE",
"(",
"elt_mode",
")",
")",
")",
";",
"int",
"fpr_words",
"=",
"fpr",
"/",
"(",
"TARGET_32BIT",
"?",
"4",
":",
"8",
")",
";",
"if",
"(",
"align_words",
"+",
"fpr_words",
"<",
"GP_ARG_NUM_REG",
")",
"passed_in_gprs",
"=",
"true",
";",
"else",
"ret",
"=",
"fpr",
";",
"}",
"}",
"if",
"(",
"passed_in_gprs",
"&&",
"align_words",
"<",
"GP_ARG_NUM_REG",
"&&",
"GP_ARG_NUM_REG",
"<",
"align_words",
"+",
"rs6000_arg_size",
"(",
"mode",
",",
"type",
")",
")",
"ret",
"=",
"(",
"GP_ARG_NUM_REG",
"-",
"align_words",
")",
"*",
"(",
"TARGET_32BIT",
"?",
"4",
":",
"8",
")",
";",
"if",
"(",
"ret",
"!=",
"0",
"&&",
"TARGET_DEBUG_ARG",
")",
"fprintf",
"(",
"stderr",
",",
"\"rs6000_arg_partial_bytes: %d\\n\"",
",",
"ret",
")",
";",
"return",
"ret",
";",
"}",
"</s>"
] |
[
"For",
"an",
"arg",
"passed",
"partly",
"in",
"registers",
"and",
"partly",
"in",
"memory",
",",
"this",
"is",
"the",
"number",
"of",
"bytes",
"passed",
"in",
"registers",
".",
"For",
"args",
"passed",
"entirely",
"in",
"registers",
"or",
"entirely",
"in",
"memory",
",",
"zero",
".",
"When",
"an",
"arg",
"is",
"described",
"by",
"a",
"PARALLEL",
",",
"perhaps",
"using",
"more",
"than",
"one",
"register",
"type",
",",
"this",
"function",
"returns",
"the",
"number",
"of",
"bytes",
"used",
"by",
"the",
"first",
"element",
"of",
"the",
"PARALLEL",
"."
] |
[
"rs6000",
"0",
"0",
"0",
"1",
"1",
"16",
"0",
"7",
"3",
"0",
"0",
"1",
"1",
"8",
"4",
"8",
"4",
"8",
"0",
"\"rs6000_arg_partial_bytes: %d\\n\""
] |
rs60004
|
rs6000_arg_partial_bytes
|
rs6000
|
CPU
|
GCC
| 1,068 | 339 | 1 |
[] |
[
"<s>",
"bool",
"WebAssemblyPrepareForLiveIntervals",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"LLVM_DEBUG",
"(",
"{",
"dbgs",
"(",
")",
"<<",
"\"********** Prepare For LiveIntervals **********\\n\"",
"<<",
"\"********** Function: \"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
";",
"}",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"auto",
"&",
"TII",
"=",
"*",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"MachineBasicBlock",
"&",
"Entry",
"=",
"*",
"MF",
".",
"begin",
"(",
")",
";",
"assert",
"(",
"!",
"mustPreserveAnalysisID",
"(",
"LiveIntervalsID",
")",
"&&",
"\"LiveIntervals shouldn't be active yet!\"",
")",
";",
"MRI",
".",
"leaveSSA",
"(",
")",
";",
"for",
"(",
"unsigned",
"I",
"=",
"0",
",",
"E",
"=",
"MRI",
".",
"getNumVirtRegs",
"(",
")",
";",
"I",
"<",
"E",
";",
"++",
"I",
")",
"{",
"unsigned",
"Reg",
"=",
"TargetRegisterInfo",
"::",
"index2VirtReg",
"(",
"I",
")",
";",
"if",
"(",
"MRI",
".",
"use_nodbg_empty",
"(",
"Reg",
")",
")",
"continue",
";",
"if",
"(",
"hasArgumentDef",
"(",
"Reg",
",",
"MRI",
")",
")",
"continue",
";",
"BuildMI",
"(",
"Entry",
",",
"Entry",
".",
"begin",
"(",
")",
",",
"DebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"WebAssembly",
"::",
"IMPLICIT_DEF",
")",
",",
"Reg",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"for",
"(",
"auto",
"MII",
"=",
"Entry",
".",
"begin",
"(",
")",
",",
"MIE",
"=",
"Entry",
".",
"end",
"(",
")",
";",
"MII",
"!=",
"MIE",
";",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"MII",
"++",
";",
"if",
"(",
"WebAssembly",
"::",
"isArgument",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
")",
"{",
"MI",
".",
"removeFromParent",
"(",
")",
";",
"Entry",
".",
"insert",
"(",
"Entry",
".",
"begin",
"(",
")",
",",
"&",
"MI",
")",
";",
"}",
"}",
"MF",
".",
"getProperties",
"(",
")",
".",
"set",
"(",
"MachineFunctionProperties",
"::",
"Property",
"::",
"TracksLiveness",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] |
[
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] |
[
"WebAssembly",
"WebAssembly",
"\"********** Prepare For LiveIntervals **********\\n\"",
"\"********** Function: \"",
"WebAssembly",
"\"LiveIntervals shouldn't be active yet!\"",
"0",
"WebAssembly::IMPLICIT_DEF",
"WebAssembly::isArgument"
] |
WebAssemblyPrepareForLiveIntervals16
|
runOnMachineFunction
|
WebAssembly
|
Virtual ISA
|
LLVM
| 1,069 | 268 | 1 |
[] |
[
"<s>",
"void",
"MBlazeRegisterInfo",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"MBB",
".",
"erase",
"(",
"I",
")",
";",
"}",
"</s>"
] |
[
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] |
[
"MBlaze",
"MBlaze"
] |
MBlazeRegisterInfo12
|
eliminateCallFramePseudoInstr
|
MBlaze
|
MPU
|
LLVM
| 1,070 | 28 | 1 |
[] |
[
"<s>",
"bool",
"ba_p",
"(",
"rtx",
"op",
",",
"bool",
"strict",
")",
"{",
"return",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"MEM",
"&&",
"inside_ba_p",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
",",
"strict",
")",
")",
"||",
"(",
"reload_in_progress",
"&&",
"GET_CODE",
"(",
"op",
")",
"==",
"REG",
"&&",
"REGNO",
"(",
"op",
")",
">=",
"FIRST_PSEUDO_REGISTER",
")",
"||",
"(",
"reload_in_progress",
"&&",
"GET_CODE",
"(",
"op",
")",
"==",
"MEM",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"REG",
"&&",
"REGNO",
"(",
"op",
")",
">=",
"FIRST_PSEUDO_REGISTER",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
",",
"1",
")",
")",
"==",
"CONST_INT",
"&&",
"(",
"INTVAL",
"(",
"XEXP",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
",",
"1",
")",
")",
"&",
"0x1",
")",
"==",
"0",
")",
";",
"}",
"</s>"
] |
[
"Also",
"accept",
"(",
"MEM",
"(",
"PLUS",
"(",
"pseudo",
")",
"CONST_INT",
")",
")",
",",
"since",
"the",
"pseudo",
"will",
"always",
"be",
"allocated",
"to",
"a",
"PTR",
"reg",
"."
] |
[
"z8k",
"0",
"0",
"0",
"0",
"0",
"1",
"0",
"1",
"0x1",
"0"
] |
z8k
|
ba_p
|
z8k
|
MPU
|
GCC
| 1,071 | 136 | 1 |
[] |
[
"<s>",
"void",
"NVPTXFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"}",
"</s>"
] |
[
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] |
[
"NVPTX",
"NVPTX"
] |
NVPTXFrameLowering22
|
emitEpilogue
|
NVPTX
|
GPU
|
LLVM
| 1,072 | 16 | 1 |
[] |
[
"<s>",
"static",
"bool",
"matchBitfieldExtractFromSExtInReg",
"(",
"MachineInstr",
"&",
"MI",
",",
"MachineRegisterInfo",
"&",
"MRI",
",",
"std",
"::",
"function",
"<",
"void",
"(",
"MachineIRBuilder",
"&",
")",
">",
"&",
"MatchInfo",
")",
"{",
"assert",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"TargetOpcode",
"::",
"G_SEXT_INREG",
")",
";",
"Register",
"Dst",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"Register",
"Src",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"int64_t",
"Width",
"=",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"LLT",
"Ty",
"=",
"MRI",
".",
"getType",
"(",
"Src",
")",
";",
"assert",
"(",
"(",
"Ty",
"==",
"LLT",
"::",
"scalar",
"(",
"32",
")",
"||",
"Ty",
"==",
"LLT",
"::",
"scalar",
"(",
"64",
")",
")",
"&&",
"\"Unexpected type for G_SEXT_INREG?\"",
")",
";",
"Register",
"ShiftSrc",
";",
"int64_t",
"ShiftImm",
";",
"if",
"(",
"!",
"mi_match",
"(",
"Src",
",",
"MRI",
",",
"m_OneNonDBGUse",
"(",
"m_any_of",
"(",
"m_GAShr",
"(",
"m_Reg",
"(",
"ShiftSrc",
")",
",",
"m_ICst",
"(",
"ShiftImm",
")",
")",
",",
"m_GLShr",
"(",
"m_Reg",
"(",
"ShiftSrc",
")",
",",
"m_ICst",
"(",
"ShiftImm",
")",
")",
")",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"ShiftImm",
"<",
"0",
"||",
"ShiftImm",
"+",
"Width",
">",
"Ty",
".",
"getSizeInBits",
"(",
")",
")",
"return",
"false",
";",
"MatchInfo",
"=",
"[",
"=",
"]",
"(",
"MachineIRBuilder",
"&",
"B",
")",
"{",
"auto",
"Cst1",
"=",
"B",
".",
"buildConstant",
"(",
"Ty",
",",
"ShiftImm",
")",
";",
"auto",
"Cst2",
"=",
"B",
".",
"buildConstant",
"(",
"Ty",
",",
"Width",
")",
";",
"B",
".",
"buildInstr",
"(",
"TargetOpcode",
"::",
"G_SBFX",
",",
"{",
"Dst",
"}",
",",
"{",
"ShiftSrc",
",",
"Cst1",
",",
"Cst2",
"}",
")",
";",
"}",
";",
"return",
"true",
";",
"}",
"</s>"
] |
[
"Form",
"a",
"G_SBFX",
"from",
"a",
"G_SEXT_INREG",
"fed",
"by",
"a",
"right",
"shift",
"."
] |
[
"AArch64",
"0",
"1",
"2",
"32",
"64",
"\"Unexpected type for G_SEXT_INREG?\"",
"0"
] |
AArch64PostLegalizerCombiner11
|
matchBitfieldExtractFromSExtInReg
|
AArch64
|
CPU
|
LLVM
| 1,073 | 248 | 1 |
[] |
[
"<s>",
"static",
"bool",
"is_branch",
"(",
"rtx",
"insn",
")",
"{",
"return",
"(",
"CALL_P",
"(",
"insn",
")",
"||",
"JUMP_P",
"(",
"insn",
")",
")",
";",
"}",
"</s>"
] |
[
"Return",
"true",
"if",
"insn",
"is",
"a",
"branch",
"instruction",
"."
] |
[
"i386"
] |
i3864
|
is_branch
|
i386
|
CPU
|
GCC
| 1,074 | 22 | 1 |
[] |
[
"<s>",
"void",
"AArch64AsmBackend",
"::",
"applyFixup",
"(",
"const",
"MCAssembler",
"&",
"Asm",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
"Target",
",",
"MutableArrayRef",
"<",
"char",
">",
"Data",
",",
"uint64_t",
"Value",
",",
"bool",
"IsResolved",
")",
"const",
"{",
"unsigned",
"NumBytes",
"=",
"getFixupKindNumBytes",
"(",
"Fixup",
".",
"getKind",
"(",
")",
")",
";",
"if",
"(",
"!",
"Value",
")",
"return",
";",
"MCFixupKindInfo",
"Info",
"=",
"getFixupKindInfo",
"(",
"Fixup",
".",
"getKind",
"(",
")",
")",
";",
"MCContext",
"&",
"Ctx",
"=",
"Asm",
".",
"getContext",
"(",
")",
";",
"Value",
"=",
"adjustFixupValue",
"(",
"Fixup",
",",
"Value",
",",
"Ctx",
")",
";",
"Value",
"<<=",
"Info",
".",
"TargetOffset",
";",
"unsigned",
"Offset",
"=",
"Fixup",
".",
"getOffset",
"(",
")",
";",
"assert",
"(",
"Offset",
"+",
"NumBytes",
"<=",
"Data",
".",
"size",
"(",
")",
"&&",
"\"Invalid fixup offset!\"",
")",
";",
"unsigned",
"FulleSizeInBytes",
"=",
"getFixupKindContainereSizeInBytes",
"(",
"Fixup",
".",
"getKind",
"(",
")",
")",
";",
"if",
"(",
"FulleSizeInBytes",
"==",
"0",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"NumBytes",
";",
"++",
"i",
")",
"{",
"Data",
"[",
"Offset",
"+",
"i",
"]",
"|=",
"uint8_t",
"(",
"(",
"Value",
">>",
"(",
"i",
"*",
"8",
")",
")",
"&",
"0xff",
")",
";",
"}",
"}",
"else",
"{",
"assert",
"(",
"(",
"Offset",
"+",
"FulleSizeInBytes",
")",
"<=",
"Data",
".",
"size",
"(",
")",
"&&",
"\"Invalid fixup size!\"",
")",
";",
"assert",
"(",
"NumBytes",
"<=",
"FulleSizeInBytes",
"&&",
"\"Invalid fixup size!\"",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"NumBytes",
";",
"++",
"i",
")",
"{",
"unsigned",
"Idx",
"=",
"FulleSizeInBytes",
"-",
"1",
"-",
"i",
";",
"Data",
"[",
"Offset",
"+",
"Idx",
"]",
"|=",
"uint8_t",
"(",
"(",
"Value",
">>",
"(",
"i",
"*",
"8",
")",
")",
"&",
"0xff",
")",
";",
"}",
"}",
"}",
"</s>"
] |
[
"Apply",
"the",
"Value",
"for",
"given",
"Fixup",
"into",
"the",
"provided",
"data",
"fragment",
",",
"at",
"the",
"offset",
"specified",
"by",
"the",
"fixup",
"and",
"following",
"the",
"fixup",
"kind",
"as",
"appropriate",
"."
] |
[
"AArch64",
"AArch64",
"\"Invalid fixup offset!\"",
"0",
"0",
"8",
"0xff",
"\"Invalid fixup size!\"",
"\"Invalid fixup size!\"",
"0",
"1",
"8",
"0xff"
] |
AArch64AsmBackend33
|
applyFixup
|
AArch64
|
CPU
|
LLVM
| 1,075 | 251 | 1 |
[] |
[
"<s>",
"rtx",
"sparc_legitimize_reload_address",
"(",
"rtx",
"x",
",",
"machine_mode",
"mode",
",",
"int",
"opnum",
",",
"int",
"type",
",",
"int",
"ind_levels",
"ATTRIBUTE_UNUSED",
",",
"int",
"*",
"win",
")",
"{",
"if",
"(",
"CONSTANT_P",
"(",
"x",
")",
"&&",
"(",
"mode",
"!=",
"TFmode",
"||",
"TARGET_ARCH64",
")",
"&&",
"GET_MODE",
"(",
"x",
")",
"==",
"SImode",
"&&",
"GET_CODE",
"(",
"x",
")",
"!=",
"LO_SUM",
"&&",
"GET_CODE",
"(",
"x",
")",
"!=",
"HIGH",
"&&",
"sparc_code_model",
"<=",
"CM_MEDLOW",
"&&",
"!",
"(",
"flag_pic",
"&&",
"(",
"symbolic_operand",
"(",
"x",
",",
"Pmode",
")",
"||",
"pic_address_needs_scratch",
"(",
"x",
")",
")",
")",
")",
"{",
"x",
"=",
"gen_rtx_LO_SUM",
"(",
"GET_MODE",
"(",
"x",
")",
",",
"gen_rtx_HIGH",
"(",
"GET_MODE",
"(",
"x",
")",
",",
"x",
")",
",",
"x",
")",
";",
"push_reload",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"NULL_RTX",
",",
"&",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"NULL",
",",
"BASE_REG_CLASS",
",",
"GET_MODE",
"(",
"x",
")",
",",
"VOIDmode",
",",
"0",
",",
"0",
",",
"opnum",
",",
"(",
"enum",
"reload_type",
")",
"type",
")",
";",
"*",
"win",
"=",
"1",
";",
"return",
"x",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"LO_SUM",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"==",
"HIGH",
")",
"{",
"push_reload",
"(",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"NULL_RTX",
",",
"&",
"XEXP",
"(",
"x",
",",
"0",
")",
",",
"NULL",
",",
"BASE_REG_CLASS",
",",
"GET_MODE",
"(",
"x",
")",
",",
"VOIDmode",
",",
"0",
",",
"0",
",",
"opnum",
",",
"(",
"enum",
"reload_type",
")",
"type",
")",
";",
"*",
"win",
"=",
"1",
";",
"return",
"x",
";",
"}",
"*",
"win",
"=",
"0",
";",
"return",
"x",
";",
"}",
"</s>"
] |
[
"SPARC",
"implementation",
"of",
"LEGITIMIZE_RELOAD_ADDRESS",
".",
"Returns",
"a",
"value",
"to",
"replace",
"the",
"input",
"X",
",",
"or",
"the",
"original",
"X",
"if",
"no",
"replacement",
"is",
"called",
"for",
".",
"The",
"output",
"parameter",
"*",
"WIN",
"is",
"1",
"if",
"the",
"calling",
"macro",
"should",
"goto",
"WIN",
",",
"0",
"if",
"it",
"should",
"not",
".",
"For",
"SPARC",
",",
"we",
"wish",
"to",
"handle",
"addresses",
"by",
"splitting",
"them",
"into",
"HIGH+LO_SUM",
"pairs",
",",
"retaining",
"the",
"LO_SUM",
"in",
"the",
"memory",
"reference",
".",
"This",
"cuts",
"the",
"number",
"of",
"extra",
"insns",
"by",
"one",
".",
"Do",
"nothing",
"when",
"generating",
"PIC",
"code",
"and",
"the",
"address",
"is",
"a",
"symbolic",
"operand",
"or",
"requires",
"a",
"scratch",
"register",
"."
] |
[
"sparc",
"0",
"0",
"0",
"0",
"1",
"0",
"0",
"0",
"0",
"0",
"1",
"0"
] |
sparc
|
sparc_legitimize_reload_address
|
sparc
|
CPU
|
GCC
| 1,076 | 241 | 1 |
[] |
[
"<s>",
"bool",
"mep_vliw_jmp_match",
"(",
"rtx",
"tgt",
")",
"{",
"bool",
"src_vliw",
"=",
"mep_vliw_function_p",
"(",
"cfun",
"->",
"decl",
")",
";",
"bool",
"tgt_vliw",
"=",
"INTVAL",
"(",
"tgt",
")",
";",
"if",
"(",
"mep_section_tag",
"(",
"DECL_RTL",
"(",
"cfun",
"->",
"decl",
")",
")",
"==",
"'f'",
")",
"return",
"false",
";",
"return",
"src_vliw",
"==",
"tgt_vliw",
";",
"}",
"</s>"
] |
[
"Like",
"the",
"above",
",",
"but",
"also",
"test",
"for",
"near/far",
"mismatches",
"."
] |
[
"mep"
] |
mep
|
mep_vliw_jmp_match
|
mep
|
CPU
|
GCC
| 1,077 | 48 | 1 |
[] |
[
"<s>",
"bool",
"TOYPassConfig",
"::",
"addInstSelector",
"(",
")",
"{",
"addPass",
"(",
"createTOYISelDag",
"(",
"getTOYTargetMachine",
"(",
")",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] |
[
"addInstSelector",
"-",
"This",
"method",
"should",
"install",
"an",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"from",
"LLVM",
"code",
"to",
"machine",
"instructions",
"."
] |
[
"TOY",
"TOY",
"TOY",
"TOY"
] |
TOYTargetMachine
|
addInstSelector
|
TOY
|
CPU
|
LLVM
| 1,078 | 21 | 1 |
[] |
[
"<s>",
"bool",
"SparcAsmPrinter",
"::",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"if",
"(",
"ExtraCode",
"&&",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"if",
"(",
"ExtraCode",
"[",
"1",
"]",
"!=",
"0",
")",
"return",
"true",
";",
"switch",
"(",
"ExtraCode",
"[",
"0",
"]",
")",
"{",
"default",
":",
"return",
"true",
";",
"case",
"'r'",
":",
"break",
";",
"}",
"}",
"printOperand",
"(",
"MI",
",",
"OpNo",
",",
"O",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] |
[
"PrintAsmOperand",
"-",
"Print",
"out",
"an",
"operand",
"for",
"an",
"inline",
"asm",
"expression",
"."
] |
[
"Sparc",
"Sparc",
"0",
"1",
"0",
"0"
] |
SparcAsmPrinter30
|
PrintAsmOperand
|
Sparc
|
CPU
|
LLVM
| 1,079 | 81 | 1 |
[] |
[
"<s>",
"SDValue",
"NVPTXTargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
"=",
"getTargetMachine",
"(",
")",
".",
"getOptLevel",
"(",
")",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"ADD",
":",
"case",
"ISD",
"::",
"FADD",
":",
"return",
"PerformADDCombine",
"(",
"N",
",",
"DCI",
",",
"STI",
",",
"OptLevel",
")",
";",
"case",
"ISD",
"::",
"MUL",
":",
"return",
"PerformMULCombine",
"(",
"N",
",",
"DCI",
",",
"OptLevel",
")",
";",
"case",
"ISD",
"::",
"SHL",
":",
"return",
"PerformSHLCombine",
"(",
"N",
",",
"DCI",
",",
"OptLevel",
")",
";",
"case",
"ISD",
"::",
"AND",
":",
"return",
"PerformANDCombine",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"SELECT",
":",
"return",
"PerformSELECTCombine",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"UREM",
":",
"case",
"ISD",
"::",
"SREM",
":",
"return",
"PerformREMCombine",
"(",
"N",
",",
"DCI",
",",
"OptLevel",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] |
[
"This",
"method",
"will",
"be",
"invoked",
"for",
"all",
"target",
"nodes",
"and",
"for",
"any",
"target-independent",
"nodes",
"that",
"the",
"target",
"has",
"registered",
"with",
"invoke",
"it",
"for",
"."
] |
[
"NVPTX",
"NVPTX",
"ISD::ADD",
"ISD::FADD",
"ISD::MUL",
"ISD::SHL",
"ISD::AND",
"ISD::SELECT",
"ISD::UREM",
"ISD::SREM"
] |
NVPTXISelLowering21
|
PerformDAGCombine
|
NVPTX
|
GPU
|
LLVM
| 1,080 | 146 | 1 |
[] |
[
"<s>",
"void",
"WebAssemblyFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"uint64_t",
"StackSize",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"getStackSize",
"(",
")",
";",
"if",
"(",
"!",
"StackSize",
")",
"return",
";",
"const",
"auto",
"*",
"TII",
"=",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"auto",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"unsigned",
"OffsetReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"WebAssembly",
"::",
"I32RegClass",
")",
";",
"auto",
"InsertPt",
"=",
"MBB",
".",
"getFirstTerminator",
"(",
")",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"InsertPt",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"{",
"DL",
"=",
"InsertPt",
"->",
"getDebugLoc",
"(",
")",
";",
"}",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"CONST_I32",
")",
",",
"OffsetReg",
")",
".",
"addImm",
"(",
"StackSize",
")",
";",
"auto",
"*",
"SPSymbol",
"=",
"MF",
".",
"createExternalSymbolName",
"(",
"\"__stack_pointer\"",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"ADD_I32",
")",
",",
"WebAssembly",
"::",
"SP32",
")",
".",
"addReg",
"(",
"WebAssembly",
"::",
"SP32",
")",
".",
"addReg",
"(",
"OffsetReg",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"CONST_I32",
")",
",",
"OffsetReg",
")",
".",
"addExternalSymbol",
"(",
"SPSymbol",
")",
";",
"auto",
"*",
"MMO",
"=",
"new",
"MachineMemOperand",
"(",
"MachinePointerInfo",
"(",
")",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"4",
",",
"4",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"InsertPt",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"STORE_I32",
")",
",",
"WebAssembly",
"::",
"SP32",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addReg",
"(",
"OffsetReg",
")",
".",
"addImm",
"(",
"2",
")",
".",
"addReg",
"(",
"WebAssembly",
"::",
"SP32",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"}",
"</s>"
] |
[
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] |
[
"WebAssembly",
"WebAssembly",
"WebAssembly",
"WebAssembly::I32RegClass",
"WebAssembly::CONST_I32",
"\"__stack_pointer\"",
"WebAssembly::ADD_I32",
"WebAssembly::SP32",
"WebAssembly::SP32",
"WebAssembly::CONST_I32",
"4",
"4",
"WebAssembly::STORE_I32",
"WebAssembly::SP32",
"0",
"2",
"WebAssembly::SP32"
] |
WebAssemblyFrameLowering22
|
emitEpilogue
|
WebAssembly
|
Virtual ISA
|
LLVM
| 1,081 | 273 | 1 |
[] |
[
"<s>",
"unsigned",
"getRsaSize",
"(",
"void",
")",
"const",
"{",
"return",
"176",
";",
"}",
"</s>"
] |
[
"Get",
"the",
"size",
"of",
"RSA",
",",
"return",
"address",
",",
"and",
"frame",
"pointer",
"as",
"described",
"in",
"VEFrameLowering.cpp",
"."
] |
[
"VE",
"176"
] |
VESubtarget5
|
getRsaSize
|
VE
|
CPU
|
LLVM
| 1,082 | 11 | 1 |
[] |
[
"<s>",
"void",
"function_builder",
"::",
"append_name",
"(",
"const",
"char",
"*",
"name",
")",
"{",
"obstack_grow",
"(",
"&",
"m_string_obstack",
",",
"name",
",",
"strlen",
"(",
"name",
")",
")",
";",
"}",
"</s>"
] |
[
"Add",
"NAME",
"to",
"the",
"end",
"of",
"the",
"function",
"name",
"being",
"built",
"."
] |
[
"riscv"
] |
riscv-vector-builtins
|
append_name
|
riscv
|
CPU
|
GCC
| 1,083 | 25 | 1 |
[] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"optimizeCompareInstr",
"(",
"MachineInstr",
"&",
"CmpInstr",
",",
"unsigned",
"SrcReg",
",",
"unsigned",
"SrcReg2",
",",
"int",
"CmpMask",
",",
"int",
"CmpValue",
",",
"const",
"MachineRegisterInfo",
"*",
"MRI",
")",
"const",
"{",
"assert",
"(",
"CmpInstr",
".",
"getParent",
"(",
")",
")",
";",
"assert",
"(",
"MRI",
")",
";",
"int",
"DeadNZCVIdx",
"=",
"CmpInstr",
".",
"findRegisterDefOperandIdx",
"(",
"AArch64",
"::",
"NZCV",
",",
"true",
")",
";",
"if",
"(",
"DeadNZCVIdx",
"!=",
"-",
"1",
")",
"{",
"if",
"(",
"CmpInstr",
".",
"definesRegister",
"(",
"AArch64",
"::",
"WZR",
")",
"||",
"CmpInstr",
".",
"definesRegister",
"(",
"AArch64",
"::",
"XZR",
")",
")",
"{",
"CmpInstr",
".",
"eraseFromParent",
"(",
")",
";",
"return",
"true",
";",
"}",
"unsigned",
"Opc",
"=",
"CmpInstr",
".",
"getOpcode",
"(",
")",
";",
"unsigned",
"NewOpc",
"=",
"convertFlagSettingOpcode",
"(",
"CmpInstr",
")",
";",
"if",
"(",
"NewOpc",
"==",
"Opc",
")",
"return",
"false",
";",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"get",
"(",
"NewOpc",
")",
";",
"CmpInstr",
".",
"setDesc",
"(",
"MCID",
")",
";",
"CmpInstr",
".",
"RemoveOperand",
"(",
"DeadNZCVIdx",
")",
";",
"bool",
"succeeded",
"=",
"UpdateOperandRegClass",
"(",
"CmpInstr",
")",
";",
"(",
"void",
")",
"succeeded",
";",
"assert",
"(",
"succeeded",
"&&",
"\"Some operands reg class are incompatible!\"",
")",
";",
"return",
"true",
";",
"}",
"assert",
"(",
"(",
"CmpValue",
"==",
"0",
"||",
"CmpValue",
"==",
"1",
")",
"&&",
"\"CmpValue must be 0 or 1!\"",
")",
";",
"if",
"(",
"CmpValue",
"!=",
"0",
"||",
"SrcReg2",
"!=",
"0",
")",
"return",
"false",
";",
"if",
"(",
"!",
"MRI",
"->",
"use_nodbg_empty",
"(",
"CmpInstr",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
")",
"return",
"false",
";",
"return",
"substituteCmpToZero",
"(",
"CmpInstr",
",",
"SrcReg",
",",
"MRI",
")",
";",
"}",
"</s>"
] |
[
"optimizeCompareInstr",
"-",
"Check",
"if",
"there",
"exists",
"an",
"earlier",
"instruction",
"that",
"operates",
"on",
"the",
"same",
"source",
"operands",
"and",
"sets",
"flags",
"in",
"the",
"same",
"way",
"as",
"Compare",
";",
"remove",
"Compare",
"if",
"possible",
"."
] |
[
"AArch64",
"AArch64",
"AArch64::NZCV",
"1",
"AArch64::WZR",
"AArch64::XZR",
"\"Some operands reg class are incompatible!\"",
"0",
"1",
"\"CmpValue must be 0 or 1!\"",
"0",
"0",
"0"
] |
AArch64InstrInfo109
|
optimizeCompareInstr
|
AArch64
|
CPU
|
LLVM
| 1,084 | 230 | 1 |
[] |
[
"<s>",
"void",
"X86IntelInstPrinter",
"::",
"printPCRelImm",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"const",
"MCOperand",
"&",
"Op",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNo",
")",
";",
"if",
"(",
"Op",
".",
"isImm",
"(",
")",
")",
"O",
"<<",
"formatImm",
"(",
"Op",
".",
"getImm",
"(",
")",
")",
";",
"else",
"{",
"assert",
"(",
"Op",
".",
"isExpr",
"(",
")",
"&&",
"\"unknown pcrel immediate operand\"",
")",
";",
"const",
"MCConstantExpr",
"*",
"BranchTarget",
"=",
"dyn_cast",
"<",
"MCConstantExpr",
">",
"(",
"Op",
".",
"getExpr",
"(",
")",
")",
";",
"int64_t",
"Address",
";",
"if",
"(",
"BranchTarget",
"&&",
"BranchTarget",
"->",
"EvaluateAsAbsolute",
"(",
"Address",
")",
")",
"{",
"O",
"<<",
"formatHex",
"(",
"(",
"uint64_t",
")",
"Address",
")",
";",
"}",
"else",
"{",
"O",
"<<",
"*",
"Op",
".",
"getExpr",
"(",
")",
";",
"}",
"}",
"}",
"</s>"
] |
[
"value",
"(",
"e.g",
"."
] |
[
"X86",
"X86",
"\"unknown pcrel immediate operand\""
] |
X86IntelInstPrinter (2)
|
printPCRelImm
|
X86
|
CPU
|
LLVM
| 1,085 | 119 | 1 |
[] |
[
"<s>",
"static",
"struct",
"machine_function",
"*",
"arc_init_machine_status",
"(",
"void",
")",
"{",
"struct",
"machine_function",
"*",
"machine",
";",
"machine",
"=",
"ggc_cleared_alloc",
"<",
"machine_function",
">",
"(",
")",
";",
"machine",
"->",
"fn_type",
"=",
"ARC_FUNCTION_UNKNOWN",
";",
"return",
"machine",
";",
"}",
"</s>"
] |
[
"The",
"usual",
";",
"we",
"set",
"up",
"our",
"machine_function",
"data",
"."
] |
[
"arc"
] |
arc
|
arc_init_machine_status
|
arc
|
MPU
|
GCC
| 1,086 | 33 | 1 |
[] |
[
"<s>",
"void",
"SIInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FrameIndex",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"unsigned",
"KillFlag",
"=",
"isKill",
"?",
"RegState",
"::",
"Kill",
":",
"0",
";",
"if",
"(",
"TRI",
"->",
"getCommonSubClass",
"(",
"RC",
",",
"&",
"AMDGPU",
"::",
"SGPR_32RegClass",
")",
")",
"{",
"unsigned",
"Lane",
"=",
"MFI",
"->",
"SpillTracker",
".",
"getNextLane",
"(",
"MRI",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"V_WRITELANE_B32",
")",
",",
"MFI",
"->",
"SpillTracker",
".",
"LaneVGPR",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"KillFlag",
")",
".",
"addImm",
"(",
"Lane",
")",
";",
"MFI",
"->",
"SpillTracker",
".",
"addSpilledReg",
"(",
"FrameIndex",
",",
"MFI",
"->",
"SpillTracker",
".",
"LaneVGPR",
",",
"Lane",
")",
";",
"}",
"else",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"RC",
"->",
"getSize",
"(",
")",
"/",
"4",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"SubReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"SReg_32RegClass",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
",",
"get",
"(",
"AMDGPU",
"::",
"COPY",
")",
",",
"SubReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"0",
",",
"RI",
".",
"getSubRegFromChannel",
"(",
"i",
")",
")",
";",
"storeRegToStackSlot",
"(",
"MBB",
",",
"MI",
",",
"SubReg",
",",
"isKill",
",",
"FrameIndex",
"+",
"i",
",",
"&",
"AMDGPU",
"::",
"SReg_32RegClass",
",",
"TRI",
")",
";",
"}",
"}",
"}",
"</s>"
] |
[
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] |
[
"R600",
"SI",
"SI",
"SI",
"0",
"0",
"4",
"0"
] |
SIInstrInfo16
|
storeRegToStackSlot
|
R600
|
GPU
|
LLVM
| 1,087 | 268 | 1 |
[] |
[
"<s>",
"void",
"PatmosAsmPrinter",
"::",
"emitBasicBlockEnd",
"(",
"const",
"MachineBasicBlock",
"&",
"MBB",
")",
"{",
"if",
"(",
"&",
"MBB",
".",
"getParent",
"(",
")",
"->",
"back",
"(",
")",
"==",
"&",
"MBB",
")",
"return",
";",
"const",
"MachineBasicBlock",
"*",
"Next",
"=",
"MBB",
".",
"getNextNode",
"(",
")",
";",
"bool",
"followedByFStart",
"=",
"isFStart",
"(",
"Next",
")",
";",
"if",
"(",
"followedByFStart",
")",
"{",
"OutStreamer",
"->",
"emitLabel",
"(",
"CurrCodeEnd",
")",
";",
"}",
"}",
"</s>"
] |
[
"Targets",
"can",
"override",
"this",
"to",
"emit",
"stuff",
"at",
"the",
"end",
"of",
"a",
"basic",
"block",
"."
] |
[
"Patmos",
"Patmos"
] |
PatmosAsmPrinter1
|
emitBasicBlockEnd
|
Patmos
|
VLIW
|
LLVM
| 1,088 | 62 | 1 |
[] |
[
"<s>",
"int",
"scalar_chain",
"::",
"convert",
"(",
")",
"{",
"bitmap_iterator",
"bi",
";",
"unsigned",
"id",
";",
"int",
"converted_insns",
"=",
"0",
";",
"if",
"(",
"!",
"dbg_cnt",
"(",
"stv_conversion",
")",
")",
"return",
"0",
";",
"if",
"(",
"dump_file",
")",
"fprintf",
"(",
"dump_file",
",",
"\"Converting chain #%d...\\n\"",
",",
"chain_id",
")",
";",
"convert_registers",
"(",
")",
";",
"EXECUTE_IF_SET_IN_BITMAP",
"(",
"insns",
",",
"0",
",",
"id",
",",
"bi",
")",
"{",
"rtx_insn",
"*",
"insn",
"=",
"DF_INSN_UID_GET",
"(",
"id",
")",
"->",
"insn",
";",
"convert_insn_common",
"(",
"insn",
")",
";",
"convert_insn",
"(",
"insn",
")",
";",
"converted_insns",
"++",
";",
"}",
"return",
"converted_insns",
";",
"}",
"</s>"
] |
[
"Convert",
"whole",
"chain",
"creating",
"required",
"register",
"conversions",
"and",
"copies",
"."
] |
[
"i386",
"0",
"0",
"\"Converting chain #%d...\\n\"",
"0"
] |
i386-features1
|
convert
|
i386
|
CPU
|
GCC
| 1,089 | 86 | 1 |
[] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"isLegalFLATOffset",
"(",
"int64_t",
"Offset",
",",
"unsigned",
"AddrSpace",
",",
"bool",
"Signed",
")",
"const",
"{",
"if",
"(",
"!",
"ST",
".",
"hasFlatInstOffsets",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"ST",
".",
"hasFlatSegmentOffsetBug",
"(",
")",
"&&",
"AddrSpace",
"==",
"AMDGPUAS",
"::",
"FLAT_ADDRESS",
")",
"return",
"false",
";",
"if",
"(",
"ST",
".",
"getGeneration",
"(",
")",
">=",
"AMDGPUSubtarget",
"::",
"GFX10",
")",
"return",
"Signed",
"?",
"isInt",
"<",
"12",
">",
"(",
"Offset",
")",
":",
"isUInt",
"<",
"11",
">",
"(",
"Offset",
")",
";",
"return",
"Signed",
"?",
"isInt",
"<",
"13",
">",
"(",
"Offset",
")",
":",
"isUInt",
"<",
"12",
">",
"(",
"Offset",
")",
";",
"}",
"</s>"
] |
[
"Returns",
"if",
"Offset",
"is",
"legal",
"for",
"the",
"subtarget",
"as",
"the",
"offset",
"to",
"a",
"FLAT",
"encoded",
"instruction",
"."
] |
[
"AMDGPU",
"SI",
"AMDGPU",
"AMDGPU",
"12",
"11",
"13",
"12"
] |
SIInstrInfo111
|
isLegalFLATOffset
|
AMDGPU
|
GPU
|
LLVM
| 1,090 | 96 | 1 |
[] |
[
"<s>",
"bool",
"PPCTargetLowering",
"::",
"decomposeMulByConstant",
"(",
"LLVMContext",
"&",
"Context",
",",
"EVT",
"VT",
",",
"SDValue",
"C",
")",
"const",
"{",
"if",
"(",
"!",
"VT",
".",
"isScalarInteger",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"auto",
"*",
"ConstNode",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"C",
".",
"getNode",
"(",
")",
")",
")",
"{",
"if",
"(",
"!",
"ConstNode",
"->",
"getAPIntValue",
"(",
")",
".",
"isSignedIntN",
"(",
"64",
")",
")",
"return",
"false",
";",
"int64_t",
"Imm",
"=",
"ConstNode",
"->",
"getSExtValue",
"(",
")",
";",
"unsigned",
"Shift",
"=",
"countTrailingZeros",
"<",
"uint64_t",
">",
"(",
"Imm",
")",
";",
"Imm",
">>=",
"Shift",
";",
"if",
"(",
"isInt",
"<",
"16",
">",
"(",
"Imm",
")",
")",
"return",
"false",
";",
"uint64_t",
"UImm",
"=",
"static_cast",
"<",
"uint64_t",
">",
"(",
"Imm",
")",
";",
"if",
"(",
"isPowerOf2_64",
"(",
"UImm",
"+",
"1",
")",
"||",
"isPowerOf2_64",
"(",
"UImm",
"-",
"1",
")",
"||",
"isPowerOf2_64",
"(",
"1",
"-",
"UImm",
")",
"||",
"isPowerOf2_64",
"(",
"-",
"1",
"-",
"UImm",
")",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] |
[
"Return",
"true",
"if",
"it",
"is",
"profitable",
"to",
"transform",
"an",
"integer",
"multiplication-by-constant",
"into",
"simpler",
"operations",
"like",
"shifts",
"and",
"adds",
"."
] |
[
"PowerPC",
"PPC",
"64",
"16",
"1",
"1",
"1",
"1"
] |
PPCISelLowering109
|
decomposeMulByConstant
|
PowerPC
|
CPU
|
LLVM
| 1,091 | 152 | 1 |
[] |
[
"<s>",
"static",
"void",
"parse_mrgf_banked_regs_option",
"(",
"const",
"char",
"*",
"arg",
")",
"{",
"long",
"int",
"val",
";",
"char",
"*",
"end_ptr",
";",
"errno",
"=",
"0",
";",
"val",
"=",
"strtol",
"(",
"arg",
",",
"&",
"end_ptr",
",",
"10",
")",
";",
"if",
"(",
"errno",
"!=",
"0",
"||",
"*",
"arg",
"==",
"'\\0'",
"||",
"*",
"end_ptr",
"!=",
"'\\0'",
"||",
"(",
"val",
"!=",
"0",
"&&",
"val",
"!=",
"4",
"&&",
"val",
"!=",
"8",
"&&",
"val",
"!=",
"16",
"&&",
"val",
"!=",
"32",
")",
")",
"{",
"error",
"(",
"\"invalid number in -mrgf-banked-regs=%s \"",
"\"valid values are 0, 4, 8, 16, or 32\"",
",",
"arg",
")",
";",
"return",
";",
"}",
"rgf_banked_register_count",
"=",
"(",
"int",
")",
"val",
";",
"}",
"</s>"
] |
[
"Parse",
"-mrgf-banked-regs=NUM",
"option",
"string",
".",
"Valid",
"values",
"for",
"NUM",
"are",
"4",
",",
"8",
",",
"16",
",",
"or",
"32",
"."
] |
[
"arc",
"0",
"10",
"0",
"0",
"4",
"8",
"16",
"32",
"\"invalid number in -mrgf-banked-regs=%s \"",
"\"valid values are 0, 4, 8, 16, or 32\""
] |
arc7
|
parse_mrgf_banked_regs_option
|
arc
|
MPU
|
GCC
| 1,092 | 92 | 1 |
[] |
[
"<s>",
"bool",
"match",
"(",
"MachineInstr",
"*",
"&",
"Instr",
",",
"unsigned",
"int",
"Opcode",
",",
"ArgsT",
"...",
"Args",
")",
"{",
"Instr",
"=",
"match",
"(",
"Opcode",
",",
"Args",
"...",
")",
";",
"return",
"Instr",
"!=",
"nullptr",
";",
"}",
"</s>"
] |
[
"matches",
"-",
"Match",
"the",
"regex",
"against",
"a",
"given",
"String",
"."
] |
[
"TVM"
] |
TVMMachineInstrMatcher
|
match
|
TVM
|
Virtual ISA
|
LLVM
| 1,093 | 33 | 1 |
[] |
[
"<s>",
"void",
"emitThumbFunc",
"(",
"MCSymbol",
"*",
"Func",
")",
"override",
"{",
"getAssembler",
"(",
")",
".",
"setIsThumbFunc",
"(",
"Func",
")",
";",
"emitSymbolAttribute",
"(",
"Func",
",",
"MCSA_ELF_TypeFunction",
")",
";",
"}",
"</s>"
] |
[
"Note",
"in",
"the",
"output",
"that",
"the",
"specified",
"Func",
"is",
"a",
"Thumb",
"mode",
"function",
"(",
"ARM",
"target",
"only",
")",
"."
] |
[
"ARM"
] |
ARMELFStreamer22
|
emitThumbFunc
|
ARM
|
CPU
|
LLVM
| 1,094 | 26 | 1 |
[] |
[
"<s>",
"CCAssignFn",
"*",
"AArch64TargetLowering",
"::",
"CCAssignFnForCall",
"(",
"CallingConv",
"::",
"ID",
"CC",
",",
"bool",
"IsVarArg",
")",
"const",
"{",
"switch",
"(",
"CC",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unsupported calling convention.\"",
")",
";",
"case",
"CallingConv",
"::",
"WebKit_JS",
":",
"return",
"CC_AArch64_WebKit_JS",
";",
"case",
"CallingConv",
"::",
"GHC",
":",
"return",
"CC_AArch64_GHC",
";",
"case",
"CallingConv",
"::",
"C",
":",
"case",
"CallingConv",
"::",
"Fast",
":",
"case",
"CallingConv",
"::",
"PreserveMost",
":",
"if",
"(",
"!",
"Subtarget",
"->",
"isTargetDarwin",
"(",
")",
")",
"return",
"CC_AArch64_AAPCS",
";",
"return",
"IsVarArg",
"?",
"CC_AArch64_DarwinPCS_VarArg",
":",
"CC_AArch64_DarwinPCS",
";",
"}",
"}",
"</s>"
] |
[
"Selects",
"the",
"correct",
"CCAssignFn",
"for",
"a",
"given",
"CallingConvention",
"value",
"."
] |
[
"AArch64",
"AArch64",
"\"Unsupported calling convention.\"",
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] |
AArch64ISelLowering19
|
CCAssignFnForCall
|
AArch64
|
CPU
|
LLVM
| 1,095 | 80 | 1 |
[] |
[
"<s>",
"void",
"NVPTXRegisterInfo",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"MBB",
".",
"erase",
"(",
"I",
")",
";",
"}",
"</s>"
] |
[
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] |
[
"NVPTX",
"NVPTX"
] |
NVPTXRegisterInfo22
|
eliminateCallFramePseudoInstr
|
NVPTX
|
GPU
|
LLVM
| 1,096 | 28 | 1 |
[] |
[
"<s>",
"const",
"char",
"*",
"output_fix_trunc",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"*",
"operands",
",",
"bool",
"fisttp",
")",
"{",
"bool",
"stack_top_dies",
"=",
"find_regno_note",
"(",
"insn",
",",
"REG_DEAD",
",",
"FIRST_STACK_REG",
")",
";",
"bool",
"dimode_p",
"=",
"GET_MODE",
"(",
"operands",
"[",
"0",
"]",
")",
"==",
"DImode",
";",
"int",
"round_mode",
"=",
"get_attr_i387_cw",
"(",
"insn",
")",
";",
"static",
"char",
"buf",
"[",
"40",
"]",
";",
"const",
"char",
"*",
"p",
";",
"if",
"(",
"(",
"dimode_p",
"||",
"fisttp",
")",
"&&",
"!",
"stack_top_dies",
")",
"output_asm_insn",
"(",
"\"fld\\t%y1\"",
",",
"operands",
")",
";",
"gcc_assert",
"(",
"STACK_TOP_P",
"(",
"operands",
"[",
"1",
"]",
")",
")",
";",
"gcc_assert",
"(",
"MEM_P",
"(",
"operands",
"[",
"0",
"]",
")",
")",
";",
"gcc_assert",
"(",
"GET_MODE",
"(",
"operands",
"[",
"1",
"]",
")",
"!=",
"TFmode",
")",
";",
"if",
"(",
"fisttp",
")",
"return",
"\"fisttp%Z0\\t%0\"",
";",
"strcpy",
"(",
"buf",
",",
"\"fist\"",
")",
";",
"if",
"(",
"round_mode",
"!=",
"I387_CW_ANY",
")",
"output_asm_insn",
"(",
"\"fldcw\\t%3\"",
",",
"operands",
")",
";",
"p",
"=",
"\"p%Z0\\t%0\"",
";",
"strcat",
"(",
"buf",
",",
"p",
"+",
"!",
"(",
"stack_top_dies",
"||",
"dimode_p",
")",
")",
";",
"output_asm_insn",
"(",
"buf",
",",
"operands",
")",
";",
"if",
"(",
"round_mode",
"!=",
"I387_CW_ANY",
")",
"output_asm_insn",
"(",
"\"fldcw\\t%2\"",
",",
"operands",
")",
";",
"return",
"\"\"",
";",
"}",
"</s>"
] |
[
"Output",
"code",
"for",
"INSN",
"to",
"convert",
"a",
"float",
"to",
"a",
"signed",
"int",
".",
"OPERANDS",
"are",
"the",
"insn",
"operands",
".",
"The",
"output",
"may",
"be",
"[",
"HSD",
"]",
"Imode",
"and",
"the",
"input",
"operand",
"may",
"be",
"[",
"SDX",
"]",
"Fmode",
"."
] |
[
"i386",
"0",
"40",
"\"fld\\t%y1\"",
"1",
"0",
"1",
"\"fisttp%Z0\\t%0\"",
"\"fist\"",
"\"fldcw\\t%3\"",
"\"p%Z0\\t%0\"",
"\"fldcw\\t%2\"",
"\"\""
] |
i386
|
output_fix_trunc
|
i386
|
CPU
|
GCC
| 1,097 | 184 | 1 |
[] |
[
"<s>",
"static",
"void",
"mips_move_integer",
"(",
"rtx",
"dest",
",",
"unsigned",
"HOST_WIDE_INT",
"value",
")",
"{",
"struct",
"mips_integer_op",
"codes",
"[",
"MIPS_MAX_INTEGER_OPS",
"]",
";",
"enum",
"machine_mode",
"mode",
";",
"unsigned",
"int",
"i",
",",
"cost",
";",
"rtx",
"x",
";",
"mode",
"=",
"GET_MODE",
"(",
"dest",
")",
";",
"cost",
"=",
"mips_build_integer",
"(",
"codes",
",",
"value",
")",
";",
"x",
"=",
"GEN_INT",
"(",
"codes",
"[",
"0",
"]",
".",
"value",
")",
";",
"for",
"(",
"i",
"=",
"1",
";",
"i",
"<",
"cost",
";",
"i",
"++",
")",
"{",
"if",
"(",
"no_new_pseudos",
")",
"emit_move_insn",
"(",
"dest",
",",
"x",
")",
",",
"x",
"=",
"dest",
";",
"else",
"x",
"=",
"force_reg",
"(",
"mode",
",",
"x",
")",
";",
"x",
"=",
"gen_rtx_fmt_ee",
"(",
"codes",
"[",
"i",
"]",
".",
"code",
",",
"mode",
",",
"x",
",",
"GEN_INT",
"(",
"codes",
"[",
"i",
"]",
".",
"value",
")",
")",
";",
"}",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"dest",
",",
"x",
")",
")",
";",
"}",
"</s>"
] |
[
"Move",
"VALUE",
"into",
"register",
"DEST",
"."
] |
[
"mips",
"0",
"1"
] |
mips3
|
mips_move_integer
|
mips
|
CPU
|
GCC
| 1,098 | 139 | 1 |
[] |
[
"<s>",
"void",
"SIWholeQuadMode",
"::",
"processBlock",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"unsigned",
"LiveMaskReg",
",",
"bool",
"isEntry",
")",
"{",
"auto",
"BII",
"=",
"Blocks",
".",
"find",
"(",
"&",
"MBB",
")",
";",
"if",
"(",
"BII",
"==",
"Blocks",
".",
"end",
"(",
")",
")",
"return",
";",
"const",
"BlockInfo",
"&",
"BI",
"=",
"BII",
"->",
"second",
";",
"if",
"(",
"!",
"(",
"BI",
".",
"InNeeds",
"&",
"StateWQM",
")",
")",
"return",
";",
"if",
"(",
"!",
"isEntry",
"&&",
"!",
"(",
"BI",
".",
"Needs",
"&",
"StateExact",
")",
"&&",
"BI",
".",
"OutNeeds",
"!=",
"StateExact",
")",
"return",
";",
"unsigned",
"SavedWQMReg",
"=",
"0",
";",
"bool",
"WQMFromExec",
"=",
"isEntry",
";",
"char",
"State",
"=",
"isEntry",
"?",
"StateExact",
":",
"StateWQM",
";",
"auto",
"II",
"=",
"MBB",
".",
"getFirstNonPHI",
"(",
")",
",",
"IE",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"while",
"(",
"II",
"!=",
"IE",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"++",
"II",
";",
"if",
"(",
"TII",
"->",
"isScalarUnit",
"(",
"MI",
")",
"&&",
"!",
"MI",
".",
"isTerminator",
"(",
")",
")",
"continue",
";",
"if",
"(",
"TargetInstrInfo",
"::",
"isGenericOpcode",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
")",
"{",
"if",
"(",
"MI",
".",
"getNumExplicitOperands",
"(",
")",
">=",
"1",
")",
"{",
"const",
"MachineOperand",
"&",
"Op",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
";",
"if",
"(",
"Op",
".",
"isReg",
"(",
")",
")",
"{",
"if",
"(",
"TRI",
"->",
"isSGPRReg",
"(",
"*",
"MRI",
",",
"Op",
".",
"getReg",
"(",
")",
")",
")",
"{",
"continue",
";",
"}",
"}",
"}",
"}",
"char",
"Needs",
"=",
"0",
";",
"char",
"OutNeeds",
"=",
"0",
";",
"auto",
"InstrInfoIt",
"=",
"Instructions",
".",
"find",
"(",
"&",
"MI",
")",
";",
"if",
"(",
"InstrInfoIt",
"!=",
"Instructions",
".",
"end",
"(",
")",
")",
"{",
"Needs",
"=",
"InstrInfoIt",
"->",
"second",
".",
"Needs",
";",
"OutNeeds",
"=",
"InstrInfoIt",
"->",
"second",
".",
"OutNeeds",
";",
"if",
"(",
"OutNeeds",
"==",
"StateExact",
"&&",
"MI",
".",
"isTerminator",
"(",
")",
")",
"{",
"assert",
"(",
"Needs",
"==",
"0",
")",
";",
"Needs",
"=",
"StateExact",
";",
"}",
"}",
"if",
"(",
"Needs",
"&&",
"State",
"!=",
"Needs",
")",
"{",
"if",
"(",
"Needs",
"==",
"StateExact",
")",
"{",
"assert",
"(",
"!",
"SavedWQMReg",
")",
";",
"if",
"(",
"!",
"WQMFromExec",
"&&",
"(",
"OutNeeds",
"&",
"StateWQM",
")",
")",
"SavedWQMReg",
"=",
"MRI",
"->",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"SReg_64RegClass",
")",
";",
"toExact",
"(",
"MBB",
",",
"&",
"MI",
",",
"SavedWQMReg",
",",
"LiveMaskReg",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"WQMFromExec",
"==",
"(",
"SavedWQMReg",
"==",
"0",
")",
")",
";",
"toWQM",
"(",
"MBB",
",",
"&",
"MI",
",",
"SavedWQMReg",
")",
";",
"SavedWQMReg",
"=",
"0",
";",
"}",
"State",
"=",
"Needs",
";",
"}",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"AMDGPU",
"::",
"SI_ELSE",
"&&",
"State",
"==",
"StateExact",
")",
"MI",
".",
"getOperand",
"(",
"3",
")",
".",
"setImm",
"(",
"1",
")",
";",
"}",
"if",
"(",
"(",
"BI",
".",
"OutNeeds",
"&",
"StateWQM",
")",
"&&",
"State",
"!=",
"StateWQM",
")",
"{",
"assert",
"(",
"WQMFromExec",
"==",
"(",
"SavedWQMReg",
"==",
"0",
")",
")",
";",
"toWQM",
"(",
"MBB",
",",
"MBB",
".",
"end",
"(",
")",
",",
"SavedWQMReg",
")",
";",
"}",
"else",
"if",
"(",
"BI",
".",
"OutNeeds",
"==",
"StateExact",
"&&",
"State",
"!=",
"StateExact",
")",
"{",
"toExact",
"(",
"MBB",
",",
"MBB",
".",
"end",
"(",
")",
",",
"0",
",",
"LiveMaskReg",
")",
";",
"}",
"}",
"</s>"
] |
[
"processBlock",
"-",
"If",
"there",
"are",
"any",
"predecessors",
"whose",
"control",
"can",
"be",
"threaded",
"through",
"to",
"a",
"successor",
",",
"transform",
"them",
"now",
"."
] |
[
"AMDGPU",
"SI",
"0",
"1",
"0",
"0",
"0",
"0",
"AMDGPU::SReg_64RegClass",
"0",
"0",
"AMDGPU::SI_ELSE",
"3",
"1",
"0",
"0"
] |
SIWholeQuadMode31
|
processBlock
|
AMDGPU
|
GPU
|
LLVM
| 1,099 | 488 | 1 |
[] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.