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>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"Patmos Single-Path Prepare\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Patmos",
"\"Patmos Single-Path Prepare\""
] | PatmosSPPrepare | getPassName | Patmos | VLIW | LLVM | 6,700 | 13 | 1 | [] |
[
"<s>",
"static",
"bool",
"s390_cannot_copy_insn_p",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"rtx",
"label",
"=",
"s390_execute_label",
"(",
"insn",
")",
";",
"return",
"label",
"&&",
"label",
"!=",
"const0_rtx",
";",
"}",
"</s>"
] | [
"Indicate",
"that",
"INSN",
"can",
"not",
"be",
"duplicated",
".",
"This",
"is",
"the",
"case",
"for",
"execute",
"insns",
"that",
"carry",
"a",
"unique",
"label",
"."
] | [
"s390"
] | s390 | s390_cannot_copy_insn_p | s390 | MPU | GCC | 6,701 | 25 | 1 | [] |
[
"<s>",
"void",
"AMDGPUAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"const",
"AMDGPUSubtarget",
"&",
"STI",
"=",
"MF",
"->",
"getSubtarget",
"<",
"AMDGPUSubtarget",
">",
"(",
")",
";",
"AMDGPUMCInstLower",
"MCInstLoweri... | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"\"Warning: Illegal instruction detected: \"",
"\"\\n\"",
"1",
"AMDGPU",
"4",
"16",
"1",
"0",
"4",
"\"%s%08X\"",
"0",
"\" \"",
"\"\""
] | AMDGPUMCInstLower (2) | EmitInstruction | AMDGPU | GPU | LLVM | 6,702 | 427 | 1 | [] |
[
"<s>",
"void",
"MipsAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"MipsTargetStreamer",
"&",
"TS",
"=",
"getTargetStreamer",
"(",
")",
";",
"TS",
".",
"forbidModuleDirective",
"(",
")",
";",
"if",
"(",
"MI",
"->",
... | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"Mips",
"Mips",
"Mips",
"128",
"Mips::CONSTPOOL_ENTRY",
"Mips::CONSTPOOL_ENTRY",
"0",
"1",
"Mips::PseudoReturn",
"Mips::PseudoReturn64",
"Mips::PseudoIndirectBranch",
"Mips::PseudoIndirectBranch64",
"Mips",
"\"Pseudo opcode found in EmitInstruction()\""
] | MipsAsmPrinter69 | EmitInstruction | Mips | CPU | LLVM | 6,703 | 364 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"Hexagon DAG->DAG Pattern Instruction Selection\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Hexagon",
"\"Hexagon DAG->DAG Pattern Instruction Selection\""
] | HexagonISelDAGToDAG | getPassName | Hexagon | DSP | LLVM | 6,704 | 11 | 1 | [] |
[
"<s>",
"static",
"inline",
"unsigned",
"ptr_regno_for_savres",
"(",
"int",
"sel",
")",
"{",
"if",
"(",
"DEFAULT_ABI",
"==",
"ABI_AIX",
"||",
"DEFAULT_ABI",
"==",
"ABI_ELFv2",
")",
"return",
"(",
"sel",
"&",
"SAVRES_REG",
")",
"==",
"SAVRES_FPR",
"||",
"(",
... | [
"Return",
"the",
"register",
"number",
"used",
"as",
"a",
"pointer",
"by",
"out-of-line",
"save/restore",
"functions",
"."
] | [
"powerpcspe",
"1",
"12",
"1",
"11"
] | powerpcspe | ptr_regno_for_savres | powerpcspe | CPU | GCC | 6,705 | 56 | 1 | [] |
[
"<s>",
"unsigned",
"getReg",
"(",
")",
"const",
"override",
"{",
"assert",
"(",
"Kind",
"==",
"k_Reg",
"&&",
"\"Invalid access!\"",
")",
";",
"return",
"Reg",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"MSP430",
"\"Invalid access!\""
] | MSP430AsmParser11 | getReg | MSP430 | MPU | LLVM | 6,706 | 20 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"getPreIndexedAddressParts",
"(",
"SDNode",
"*",
"N",
",",
"SDValue",
"&",
"Base",
",",
"SDValue",
"&",
"Offset",
",",
"ISD",
"::",
"MemIndexedMode",
"&",
"AM",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"... | [
"Returns",
"true",
"by",
"value",
",",
"base",
"pointer",
"and",
"offset",
"pointer",
"and",
"addressing",
"mode",
"by",
"reference",
"if",
"the",
"node",
"'s",
"address",
"can",
"be",
"legally",
"represented",
"as",
"pre-indexed",
"load",
"/",
"store",
"add... | [
"ARM",
"ARM",
"ISD::MemIndexedMode",
"ISD::SEXTLOAD",
"ARM",
"ISD::PRE_INC",
"ISD::PRE_DEC"
] | ARMISelLowering36 | getPreIndexedAddressParts | ARM | CPU | LLVM | 6,707 | 246 | 1 | [] |
[
"<s>",
"static",
"void",
"iq2000_setup_incoming_varargs",
"(",
"cumulative_args_t",
"cum_v",
",",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"tree",
"type",
"ATTRIBUTE_UNUSED",
",",
"int",
"*",
"pretend_size",
",",
"int",
"no_rtl",
")",
"{",
"CUMULATIVE_ARGS",
... | [
"Worker",
"function",
"for",
"TARGET_SETUP_INCOMING_VARARGS",
"."
] | [
"iq2000",
"0",
"0",
"0",
"0"
] | iq20003 | iq2000_setup_incoming_varargs | iq2000 | CPU | GCC | 6,708 | 191 | 1 | [] |
[
"<s>",
"bool",
"rvexInstrInfo",
"::",
"isSchedulingBoundary",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"const",
"MachineBasicBlock",
"*",
"MBB",
",",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"if",
"(",
"MI",
"->",
"isDebugValue",
"(",
"... | [
"isSchedulingBoundary",
"-",
"Overrides",
"the",
"isSchedulingBoundary",
"from",
"Codegen/TargetInstrInfo.cpp",
"to",
"make",
"it",
"capable",
"of",
"identifying",
"ENDBR",
"intructions",
"and",
"prevent",
"it",
"from",
"being",
"re-scheduled",
"."
] | [
"rvex",
"rvex"
] | rvexInstrInfo | isSchedulingBoundary | rvex | VLIW | LLVM | 6,709 | 66 | 1 | [] |
[
"<s>",
"bool",
"xtensa_b4constu",
"(",
"HOST_WIDE_INT",
"v",
")",
"{",
"switch",
"(",
"v",
")",
"{",
"case",
"32768",
":",
"case",
"65536",
":",
"case",
"2",
":",
"case",
"3",
":",
"case",
"4",
":",
"case",
"5",
":",
"case",
"6",
":",
"case",
"7"... | [
"Functions",
"to",
"test",
"Xtensa",
"immediate",
"operand",
"validity",
"."
] | [
"xtensa",
"32768",
"65536",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"10",
"12",
"16",
"32",
"64",
"128",
"256"
] | xtensa | xtensa_b4constu | xtensa | MPU | GCC | 6,710 | 68 | 1 | [] |
[
"<s>",
"static",
"bool",
"riscv_in_small_data_p",
"(",
"const_tree",
"x",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"x",
")",
"==",
"STRING_CST",
"||",
"TREE_CODE",
"(",
"x",
")",
"==",
"FUNCTION_DECL",
")",
"return",
"false",
";",
"if",
"(",
"TREE_CODE",
"... | [
"Return",
"true",
"if",
"EXP",
"should",
"be",
"placed",
"in",
"the",
"small",
"data",
"section",
"."
] | [
"riscv",
"\".sdata\"",
"0",
"\".sbss\"",
"0"
] | riscv | riscv_in_small_data_p | riscv | CPU | GCC | 6,711 | 85 | 1 | [] |
[
"<s>",
"const",
"AArch64MCExpr",
"*",
"AArch64MCExpr",
"::",
"Create",
"(",
"const",
"MCExpr",
"*",
"Expr",
",",
"VariantKind",
"Kind",
",",
"MCContext",
"&",
"Ctx",
")",
"{",
"return",
"new",
"(",
"Ctx",
")",
"AArch64MCExpr",
"(",
"Expr",
",",
"Kind",
"... | [
"Construct",
"a",
"unary",
"instruction",
",",
"given",
"the",
"opcode",
"and",
"an",
"operand",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64MCExpr | Create | AArch64 | CPU | LLVM | 6,712 | 33 | 1 | [] |
[
"<s>",
"bool",
"X86DAGToDAGISel",
"::",
"SelectInlineAsmMemoryOperand",
"(",
"const",
"SDValue",
"&",
"Op",
",",
"char",
"ConstraintCode",
",",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"&",
"OutOps",
")",
"{",
"SDValue",
"Op0",
",",
"Op1",
",",
"Op2",
"... | [
"SelectInlineAsmMemoryOperand",
"-",
"Select",
"the",
"specified",
"address",
"as",
"a",
"target",
"addressing",
"mode",
",",
"according",
"to",
"the",
"specified",
"constraint",
"."
] | [
"X86",
"X86"
] | X86ISelDAGToDAG45 | SelectInlineAsmMemoryOperand | X86 | CPU | LLVM | 6,713 | 118 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"isSafeToMoveRegClassDefs",
"(",
"const",
"TargetRegisterClass",
"*",
"RC",
")",
"const",
"{",
"return",
"RC",
"!=",
"&",
"AMDGPU",
"::",
"EXECRegRegClass",
";",
"}",
"</s>"
] | [
"isSafeToMoveRegClassDefs",
"-",
"Return",
"true",
"if",
"it",
"'s",
"safe",
"to",
"move",
"a",
"machine",
"instruction",
"that",
"defines",
"the",
"specified",
"register",
"class",
"."
] | [
"R600",
"SI"
] | SIInstrInfo101 | isSafeToMoveRegClassDefs | R600 | GPU | LLVM | 6,714 | 21 | 1 | [] |
[
"<s>",
"bool",
"XtensaRegisterInfo",
"::",
"trackLivenessAfterRegAlloc",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"live-ins",
"should",
"be",
"tracked",
"after",
"register",
"allocation",
"."
] | [
"Xtensa",
"Xtensa"
] | XtensaRegisterInfo1 | trackLivenessAfterRegAlloc | Xtensa | MPU | LLVM | 6,715 | 16 | 1 | [] |
[
"<s>",
"bool",
"RISCVELFTargetObjectFile",
"::",
"isConstantInSmallSection",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"const",
"Constant",
"*",
"CN",
")",
"const",
"{",
"return",
"isInSmallSection",
"(",
"DL",
".",
"getTypeAllocSize",
"(",
"CN",
"->",
"getTyp... | [
"Return",
"true",
"if",
"this",
"constant",
"should",
"be",
"placed",
"into",
"small",
"data",
"section",
"."
] | [
"RI5CY",
"RISCV"
] | RISCVTargetObjectFile | isConstantInSmallSection | RI5CY | CPU | LLVM | 6,716 | 33 | 1 | [] |
[
"<s>",
"void",
"AArch64CallLowering",
"::",
"splitToValueTypes",
"(",
"const",
"ArgInfo",
"&",
"OrigArg",
",",
"SmallVectorImpl",
"<",
"ArgInfo",
">",
"&",
"SplitArgs",
",",
"const",
"DataLayout",
"&",
"DL",
",",
"MachineRegisterInfo",
"&",
"MRI",
",",
"CallingC... | [
"Break",
"OrigArgInfo",
"into",
"one",
"or",
"more",
"pieces",
"the",
"calling",
"convention",
"can",
"process",
",",
"returned",
"in",
"SplitArgs",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"4",
"4",
"0",
"1",
"0",
"0",
"\"Regs / types mismatch\"",
"0"
] | AArch64CallLowering14 | splitToValueTypes | AArch64 | CPU | LLVM | 6,717 | 272 | 1 | [] |
[
"<s>",
"bool",
"HexagonEarlyIfConversion",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"auto",
"&",
"ST",
"=",
"MF",
".",
... | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon"
] | HexagonEarlyIfConv10 | runOnMachineFunction | Hexagon | DSP | LLVM | 6,718 | 139 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"Kudeyar Assembly Printer\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Kudeyar",
"\"Kudeyar Assembly Printer\""
] | KudeyarAsmPrinter | getPassName | Kudeyar | CPU | LLVM | 6,719 | 13 | 1 | [] |
[
"<s>",
"void",
"RISCVInstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"SrcReg",
",",
"bool",
"IsKill",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC... | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"RISCV",
"RISCV",
"RISCV::GPRRegClass",
"RISCV::SW",
"RISCV::FPR32RegClass",
"RISCV::FSW",
"RISCV::FPR64RegClass",
"RISCV::FSD",
"\"Can't store this register to stack slot\"",
"0"
] | RISCVInstrInfo15 | storeRegToStackSlot | RISCV | CPU | LLVM | 6,720 | 153 | 1 | [] |
[
"<s>",
"BitVector",
"KudeyarRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"const",
"TargetFrameLowering",
"*",
"TFI",
"=",
"MF",
".",
"getT... | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"... | [
"Kudeyar",
"Kudeyar",
"Kudeyar::SP",
"Kudeyar::FP"
] | KudeyarRegisterInfo | getReservedRegs | Kudeyar | CPU | LLVM | 6,721 | 66 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUCallLowering",
"::",
"lowerReturn",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Value",
"*",
"Val",
",",
"unsigned",
"VReg",
")",
"const",
"{",
"MIRBuilder",
".",
"buildInstr",
"(",
"AMDGPU",
"::",
"S_ENDPGM",
")",
";",
"... | [
"This",
"hook",
"behaves",
"as",
"the",
"extended",
"lowerReturn",
"function",
",",
"but",
"for",
"targets",
"that",
"do",
"not",
"support",
"swifterror",
"value",
"promotion",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU::S_ENDPGM"
] | AMDGPUCallLowering12 | lowerReturn | AMDGPU | GPU | LLVM | 6,722 | 32 | 1 | [] |
[
"<s>",
"static",
"void",
"aarch64_override_options",
"(",
"void",
")",
"{",
"uint64_t",
"cpu_isa",
"=",
"0",
";",
"uint64_t",
"arch_isa",
"=",
"0",
";",
"aarch64_isa_flags",
"=",
"0",
";",
"bool",
"valid_cpu",
"=",
"true",
";",
"bool",
"valid_tune",
"=",
"... | [
"Implement",
"TARGET_OPTION_OVERRIDE",
"."
] | [
"aarch64",
"0",
"0",
"0",
"6",
"0",
"\"switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch\"",
"2",
"1",
"0",
"\"assembler does not support %<-mabi=ilp32%>\"",
"\"return address signing is only supported for %<-mabi=lp64%>\"",
"0"
] | aarch64 | aarch64_override_options | aarch64 | CPU | GCC | 6,723 | 420 | 1 | [] |
[
"<s>",
"unsigned",
"X86InstrInfo",
"::",
"isLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"if",
"(",
"isFrameLoadOpcode",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
"if",
"(",
"MI",
... | [
"isLoadFromStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"destination",
"along",
"with",
"th... | [
"X86",
"X86",
"0",
"0",
"1",
"0",
"0"
] | X86InstrInfo (2) | isLoadFromStackSlot | X86 | CPU | LLVM | 6,724 | 67 | 1 | [] |
[
"<s>",
"int",
"rs6000_emit_vector_cond_expr",
"(",
"rtx",
"dest",
",",
"rtx",
"op_true",
",",
"rtx",
"op_false",
",",
"rtx",
"cond",
",",
"rtx",
"cc_op0",
",",
"rtx",
"cc_op1",
")",
"{",
"machine_mode",
"dest_mode",
"=",
"GET_MODE",
"(",
"dest",
")",
";",
... | [
"Emit",
"vector",
"conditional",
"expression",
".",
"DEST",
"is",
"destination",
".",
"OP1",
"and",
"OP2",
"are",
"two",
"VEC_COND_EXPR",
"operands",
".",
"CC_OP0",
"and",
"CC_OP1",
"are",
"the",
"two",
"operands",
"for",
"the",
"relation",
"operation",
"COND"... | [
"rs6000",
"0",
"0",
"0",
"1"
] | rs60004 | rs6000_emit_vector_cond_expr | rs6000 | CPU | GCC | 6,725 | 249 | 1 | [] |
[
"<s>",
"bool",
"fixupNeedsRelaxationAdvanced",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"bool",
"Resolved",
",",
"uint64_t",
"Value",
",",
"const",
"MCRelaxableFragment",
"*",
"DF",
",",
"const",
"MCAsmLayout",
"&",
"Layout",
")",
"const",
"override",
"{",
... | [
"Target",
"specific",
"predicate",
"for",
"whether",
"a",
"given",
"fixup",
"requires",
"the",
"associated",
"instruction",
"to",
"be",
"relaxed",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"Hexagon",
"1",
"8",
"Hexagon",
"1",
"10",
"Hexagon",
"1",
"16",
"Hexagon",
"1",
"23",
"1",
"Hexagon"
] | HexagonAsmBackend1 | fixupNeedsRelaxationAdvanced | Hexagon | DSP | LLVM | 6,726 | 326 | 1 | [] |
[
"<s>",
"void",
"GCNPassConfig",
"::",
"addMachineSSAOptimization",
"(",
")",
"{",
"TargetPassConfig",
"::",
"addMachineSSAOptimization",
"(",
")",
";",
"addPass",
"(",
"&",
"SIFoldOperandsID",
")",
";",
"addPass",
"(",
"&",
"DeadMachineInstructionElimID",
")",
";",
... | [
"Methods",
"with",
"trivial",
"inline",
"returns",
"are",
"convenient",
"points",
"in",
"the",
"common",
"codegen",
"pass",
"pipeline",
"where",
"targets",
"may",
"insert",
"passes",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SI",
"SI"
] | AMDGPUTargetMachine18 | addMachineSSAOptimization | AMDGPU | GPU | LLVM | 6,727 | 75 | 1 | [] |
[
"<s>",
"ScheduleHazardRecognizer",
"::",
"HazardType",
"ARMHazardRecognizer",
"::",
"getHazardType",
"(",
"SUnit",
"*",
"SU",
",",
"int",
"Stalls",
")",
"{",
"assert",
"(",
"Stalls",
"==",
"0",
"&&",
"\"ARM hazards don't support scoreboard lookahead\"",
")",
";",
"M... | [
"getHazardType",
"-",
"Return",
"the",
"hazard",
"type",
"of",
"emitting",
"this",
"node",
"."
] | [
"ARM",
"ARM",
"0",
"\"ARM hazards don't support scoreboard lookahead\"",
"ARMII::DomainMask",
"ARMII::DomainGeneral",
"ARM",
"ARM",
"ARMII::DomainMask",
"ARMII::DomainGeneral",
"0",
"4"
] | ARMHazardRecognizer17 | getHazardType | ARM | CPU | LLVM | 6,728 | 279 | 1 | [] |
[
"<s>",
"void",
"AVRFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"const",
"AVRMachineFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"AVRMachineFunctionInfo",
">",
"("... | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"AVR",
"AVR",
"AVR",
"AVR",
"\"Can only insert epilog into returning blocks\"",
"AVR",
"AVR",
"AVR",
"AVR::POPRd",
"AVR::POPWRd",
"6",
"AVR::ADIWRdK",
"AVR::SUBIWRdK",
"AVR::R29R28",
"AVR::R29R28",
"3",
"AVR::SPWRITE",
"AVR::SP",
"AVR::R29R28"
] | AVRFrameLowering16 | emitEpilogue | AVR | MPU | LLVM | 6,729 | 339 | 1 | [] |
[
"<s>",
"bool",
"MSP430PassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"PM",
"->",
"add",
"(",
"createMSP430BranchSelectionPass",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"MSP430",
"MSP430",
"MSP430"
] | MSP430TargetMachine30 | addPreEmitPass | MSP430 | MPU | LLVM | 6,730 | 20 | 1 | [] |
[
"<s>",
"bool",
"SIMemoryLegalizer",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"bool",
"Changed",
"=",
"false",
";",
"SIMemOpAccess",
"MOA",
"(",
"MF",
")",
";",
"CC",
"=",
"SICacheControl",
"::",
"create",
"(",
"MF",
".",
"... | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AMDGPU",
"SI",
"SI",
"SI",
"SIInstrFlags::maybeAtomic"
] | SIMemoryLegalizer1 | runOnMachineFunction | AMDGPU | GPU | LLVM | 6,731 | 211 | 1 | [] |
[
"<s>",
"NVPTXSubtarget",
"&",
"NVPTXSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
")",
"{",
"TargetName",
"=",
"std",
"::",
"string",
"(",
"CPU",
".",
"empty",
"(",
")",
"?",
"\"sm_20\"",
":",
"CPU",
")... | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"NVPTX",
"NVPTX",
"NVPTX",
"\"sm_20\"",
"0",
"32"
] | NVPTXSubtarget17 | initializeSubtargetDependencies | NVPTX | GPU | LLVM | 6,732 | 54 | 1 | [] |
[
"<s>",
"bool",
"ARCFrameLowering",
"::",
"spillCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegiste... | [
"spillCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"spill",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series"... | [
"ARC",
"ARC",
"\"Spill callee saved registers: \"",
"\"\\n\"",
"ARC::R14"
] | ARCFrameLowering1 | spillCalleeSavedRegisters | ARC | MPU | LLVM | 6,733 | 83 | 1 | [] |
[
"<s>",
"enum",
"calling_abi",
"ix86_function_type_abi",
"(",
"const_tree",
"fntype",
")",
"{",
"enum",
"calling_abi",
"abi",
"=",
"ix86_abi",
";",
"if",
"(",
"fntype",
"==",
"NULL_TREE",
"||",
"TYPE_ATTRIBUTES",
"(",
"fntype",
")",
"==",
"NULL_TREE",
")",
"ret... | [
"Returns",
"value",
"SYSV_ABI",
",",
"MS_ABI",
"dependent",
"on",
"fntype",
",",
"specifying",
"the",
"call",
"abi",
"used",
"."
] | [
"i386",
"\"ms_abi\"",
"\"X32 does not support ms_abi attribute\"",
"1",
"\"sysv_abi\""
] | i3867 | ix86_function_type_abi | i386 | CPU | GCC | 6,734 | 99 | 1 | [] |
[
"<s>",
"DecodeStatus",
"TL45Disassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"MI",
",",
"uint64_t",
"&",
"Size",
",",
"ArrayRef",
"<",
"uint8_t",
">",
"Bytes",
",",
"uint64_t",
"Address",
",",
"raw_ostream",
"&",
"OS",
",",
"raw_ostream",
"&",
"CS"... | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"TL45",
"TL45",
"4",
"0",
"support::endian",
"4"
] | TL45Disassembler | getInstruction | TL45 | MPU | LLVM | 6,735 | 99 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"arc_autovectorize_vector_sizes",
"(",
"void",
")",
"{",
"return",
"TARGET_PLUS_QMACW",
"?",
"(",
"8",
"|",
"4",
")",
":",
"0",
";",
"}",
"</s>"
] | [
"Implements",
"target",
"hook",
"TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES",
"."
] | [
"arc",
"8",
"4",
"0"
] | arc6 | arc_autovectorize_vector_sizes | arc | MPU | GCC | 6,736 | 20 | 1 | [] |
[
"<s>",
"bool",
"SIInstrInfo",
"::",
"isInlineConstant",
"(",
"const",
"MachineOperand",
"&",
"MO",
",",
"uint8_t",
"OperandType",
")",
"const",
"{",
"if",
"(",
"!",
"MO",
".",
"isImm",
"(",
")",
"||",
"OperandType",
"<",
"AMDGPU",
"::",
"OPERAND_SRC_FIRST",
... | [
"returns",
"true",
"if",
"the",
"operand",
"OpIdx",
"in",
"MI",
"is",
"a",
"valid",
"inline",
"immediate",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::OPERAND_SRC_FIRST",
"AMDGPU::OPERAND_SRC_LAST",
"AMDGPU::OPERAND_REG_IMM_INT32",
"AMDGPU::OPERAND_REG_IMM_FP32",
"AMDGPU::OPERAND_REG_INLINE_C_INT32",
"AMDGPU::OPERAND_REG_INLINE_C_FP32",
"AMDGPU::isInlinableLiteral32",
"AMDGPU::OPERAND_REG_IMM_INT64",
"AMDGPU::OPERAND_R... | SIInstrInfo18 | isInlineConstant | AMDGPU | GPU | LLVM | 6,737 | 340 | 1 | [] |
[
"<s>",
"tree",
"mips_build_va_list",
"(",
")",
"{",
"if",
"(",
"mips_abi",
"==",
"ABI_EABI",
"&&",
"!",
"TARGET_SOFT_FLOAT",
"&&",
"!",
"TARGET_SINGLE_FLOAT",
")",
"{",
"tree",
"f_ovfl",
",",
"f_gtop",
",",
"f_ftop",
",",
"f_goff",
",",
"f_foff",
",",
"rec... | [
"Create",
"the",
"va_list",
"data",
"type",
".",
"We",
"keep",
"3",
"pointers",
",",
"and",
"two",
"offsets",
".",
"Two",
"pointers",
"are",
"to",
"the",
"overflow",
"area",
",",
"which",
"starts",
"at",
"the",
"CFA",
".",
"One",
"of",
"these",
"is",
... | [
"mips",
"\"__overflow_argptr\"",
"\"__gpr_top\"",
"\"__fpr_top\"",
"\"__gpr_offset\"",
"\"__fpr_offset\""
] | mips2 | mips_build_va_list | mips | CPU | GCC | 6,738 | 192 | 1 | [] |
[
"<s>",
"static",
"rtx",
"rs6000_internal_arg_pointer",
"(",
"void",
")",
"{",
"if",
"(",
"flag_split_stack",
"&&",
"(",
"lookup_attribute",
"(",
"\"no_split_stack\"",
",",
"DECL_ATTRIBUTES",
"(",
"cfun",
"->",
"decl",
")",
")",
"==",
"NULL",
")",
")",
"{",
"... | [
"Return",
"the",
"internal",
"arg",
"pointer",
"used",
"for",
"function",
"incoming",
"arguments",
".",
"When",
"-fsplit-stack",
",",
"the",
"arg",
"pointer",
"is",
"r12",
"so",
"we",
"need",
"to",
"copy",
"it",
"to",
"a",
"pseudo",
"in",
"order",
"for",
... | [
"rs6000",
"\"no_split_stack\"",
"1",
"12"
] | rs60005 | rs6000_internal_arg_pointer | rs6000 | CPU | GCC | 6,739 | 122 | 1 | [] |
[
"<s>",
"void",
"BTFDebug",
"::",
"emitCommonHeader",
"(",
")",
"{",
"OS",
".",
"AddComment",
"(",
"\"0x\"",
"+",
"Twine",
"::",
"utohexstr",
"(",
"BTF",
"::",
"MAGIC",
")",
")",
";",
"OS",
".",
"emitIntValue",
"(",
"BTF",
"::",
"MAGIC",
",",
"2",
")"... | [
"Emit",
"the",
"common",
"part",
"of",
"the",
"header",
"for",
"this",
"unit",
"."
] | [
"BPF",
"\"0x\"",
"BTF::MAGIC",
"BTF::MAGIC",
"2",
"BTF::VERSION",
"0"
] | BTFDebug1 | emitCommonHeader | BPF | Virtual ISA | LLVM | 6,740 | 51 | 1 | [] |
[
"<s>",
"bool",
"AArch64PassConfig",
"::",
"addPreISel",
"(",
")",
"{",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
"&&",
"EnablePromoteConstant",
")",
"addPass",
"(",
"createAArch64PromoteConstantPass",
"(",
")",
")",
";",... | [
"{",
"{",
"@",
"For",
"GlobalISel"
] | [
"AArch64",
"AArch64",
"AArch64",
"4095"
] | AArch64TargetMachine (2)3 | addPreISel | AArch64 | CPU | LLVM | 6,741 | 95 | 1 | [] |
[
"<s>",
"void",
"print",
"(",
"raw_ostream",
"&",
"OS",
")",
"const",
"override",
"{",
"auto",
"RegName",
"=",
"[",
"]",
"(",
"unsigned",
"Reg",
")",
"{",
"if",
"(",
"Reg",
")",
"return",
"RISCVInstPrinter",
"::",
"getRegisterName",
"(",
"Reg",
")",
";"... | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"RISCV",
"RISCV",
"\"noreg\"",
"\"<register \"",
"\">\"",
"\"'\"",
"\"'\"",
"\"<sysreg: \"",
"\"<vtype: \"",
"RISCV"
] | RISCVAsmParser (2) | print | RISCV | CPU | LLVM | 6,742 | 139 | 1 | [] |
[
"<s>",
"bool",
"XtensaAsmPrinter",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"AsmPrinter",
"::",
"runOnMachineFunction",
"(",
"MF",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Xtensa",
"Xtensa"
] | XtensaAsmPrinter1 | runOnMachineFunction | Xtensa | MPU | LLVM | 6,743 | 21 | 1 | [] |
[
"<s>",
"unsigned",
"M68kOperand",
"::",
"getReg",
"(",
")",
"const",
"{",
"assert",
"(",
"isReg",
"(",
")",
")",
";",
"return",
"MemOp",
".",
"OuterReg",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"register",
"associated",
"with",
"this",
"edge",
"."
] | [
"M68k",
"M68k"
] | M68kAsmParser | getReg | M68k | MPU | LLVM | 6,744 | 21 | 1 | [] |
[
"<s>",
"int",
"PPCInstrInfo",
"::",
"getOperandLatency",
"(",
"const",
"InstrItineraryData",
"*",
"ItinData",
",",
"const",
"MachineInstr",
"&",
"DefMI",
",",
"unsigned",
"DefIdx",
",",
"const",
"MachineInstr",
"&",
"UseMI",
",",
"unsigned",
"UseIdx",
")",
"cons... | [
"Compute",
"and",
"return",
"the",
"use",
"operand",
"latency",
"of",
"a",
"given",
"pair",
"of",
"def",
"and",
"use",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC::CRRCRegClass",
"PPC::CRBITRCRegClass",
"PPC::CRRCRegClass",
"PPC::CRBITRCRegClass",
"0",
"PPC::DIR_7400",
"PPC::DIR_750",
"PPC::DIR_970",
"PPC::DIR_E5500",
"PPC::DIR_PWR4",
"PPC::DIR_PWR5",
"PPC::DIR_PWR5X",
"PPC::DIR_PWR6",
"PPC::DIR_PWR6X",
"PPC::DI... | PPCInstrInfo | getOperandLatency | PowerPC | CPU | LLVM | 6,745 | 279 | 1 | [] |
[
"<s>",
"TargetPassConfig",
"*",
"HSAILTargetMachine",
"::",
"createPassConfig",
"(",
"PassManagerBase",
"&",
"PM",
")",
"{",
"return",
"new",
"HSAILPassConfig",
"(",
"this",
",",
"PM",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"pass",
"configuration",
"object",
"to",
"be",
"used",
"by",
"addPassToEmitX",
"methods",
"for",
"generating",
"a",
"pipeline",
"of",
"CodeGen",
"passes",
"."
] | [
"HSAIL",
"HSAIL",
"HSAIL"
] | HSAILTargetMachine | createPassConfig | HSAIL | Virtual ISA | LLVM | 6,746 | 21 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isSafeMemOpType",
"(",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
")",
"return",
"Subtarget",
".",
"hasSSE1",
"(",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
")",
... | [
"Returns",
"true",
"if",
"it",
"'s",
"safe",
"to",
"use",
"load",
"/",
"store",
"of",
"the",
"specified",
"type",
"to",
"expand",
"memcpy",
"/",
"memset",
"inline",
"."
] | [
"X86",
"X86",
"MVT::f32",
"MVT::f64"
] | X86ISelLowering100 | isSafeMemOpType | X86 | CPU | LLVM | 6,747 | 44 | 1 | [] |
[
"<s>",
"void",
"function_builder",
"::",
"append_base_name",
"(",
"const",
"char",
"*",
"name",
")",
"{",
"append_name",
"(",
"\"__riscv_\"",
")",
";",
"append_name",
"(",
"name",
")",
";",
"}",
"</s>"
] | [
"Add",
"``",
"__riscv_",
"''",
"and",
"``",
"name",
"''",
"."
] | [
"riscv",
"\"__riscv_\""
] | riscv-vector-builtins | append_base_name | riscv | CPU | GCC | 6,748 | 22 | 1 | [] |
[
"<s>",
"static",
"rtx",
"m32c_legitimize_address",
"(",
"rtx",
"x",
",",
"rtx",
"oldx",
"ATTRIBUTE_UNUSED",
",",
"machine_mode",
"mode",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"m32c_legitimize_address for mode %s\\n\"",
",",
"mode_name",
"[",
"mode",
"]",
")",... | [
"Implements",
"LEGITIMIZE_ADDRESS",
".",
"The",
"only",
"address",
"we",
"really",
"have",
"to",
"worry",
"about",
"is",
"frame",
"base",
"offsets",
",",
"as",
"$",
"fb",
"has",
"a",
"limited",
"displacement",
"range",
".",
"We",
"deal",
"with",
"this",
"b... | [
"m32c",
"\"m32c_legitimize_address for mode %s\\n\"",
"\"\\n\"",
"0",
"0",
"1",
"1",
"128",
"1",
"128",
"0",
"0"
] | m32c | m32c_legitimize_address | m32c | MPU | GCC | 6,749 | 163 | 1 | [] |
[
"<s>",
"inline",
"static",
"const",
"char",
"*",
"getTagName",
"(",
"TAGS",
"tag",
")",
"{",
"switch",
"(",
"tag",
")",
"{",
"default",
":",
"return",
"\"\"",
";",
"case",
"PREFIX_SYMBOL",
":",
"return",
"\"@\"",
";",
"case",
"AUTOS_LABEL",
":",
"return"... | [
"Return",
"the",
"tag",
"of",
"this",
"operand",
"bundle",
"as",
"a",
"string",
"."
] | [
"PIC16",
"\"\"",
"\"@\"",
"\".auto.\"",
"\".frame.\"",
"\".temp.\"",
"\".args.\"",
"\".ret.\"",
"\".lib.\"",
"\".frame_section.\"",
"\".autos_section.\"",
"\".code_section.\""
] | PIC161 | getTagName | PIC16 | MPU | LLVM | 6,750 | 83 | 1 | [] |
[
"<s>",
"unsigned",
"MSP430RegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"int",
"*",
"Value",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"assert",
"(",
"SPAdj",
"==",
"0",
"&&",... | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"MSP430",
"MSP430",
"0",
"\"Unexpected\"",
"0",
"\"Instr doesn't have FrameIndex operand!\"",
"MSP430::FPW",
"MSP430::SPW",
"2",
"2",
"1",
"MSP430::ADD16ri",
"MSP430::MOV16rr",
"0",
"0",
"0",
"0",
"MSP430::SUB16ri",
"MSP430::ADD16ri",
"0",
"1",
"0"
] | MSP430RegisterInfo25 | eliminateFrameIndex | MSP430 | MPU | LLVM | 6,751 | 375 | 1 | [] |
[
"<s>",
"rtx",
"expand_builtin",
"(",
"unsigned",
"int",
"code",
",",
"tree",
"exp",
",",
"rtx",
"target",
")",
"{",
"registered_function",
"&",
"rfn",
"=",
"*",
"(",
"*",
"registered_functions",
")",
"[",
"code",
"]",
";",
"return",
"function_expander",
"(... | [
"Expand",
"a",
"call",
"to",
"the",
"RVV",
"function",
"with",
"subcode",
"CODE",
".",
"EXP",
"is",
"the",
"call",
"expression",
"and",
"TARGET",
"is",
"the",
"preferred",
"location",
"for",
"the",
"result",
".",
"Return",
"the",
"value",
"of",
"the",
"l... | [
"riscv"
] | riscv-vector-builtins | expand_builtin | riscv | CPU | GCC | 6,752 | 48 | 1 | [] |
[
"<s>",
"void",
"rs6000_expand_atomic_exchange",
"(",
"rtx",
"operands",
"[",
"]",
")",
"{",
"rtx",
"retval",
",",
"mem",
",",
"val",
",",
"cond",
";",
"machine_mode",
"mode",
";",
"enum",
"memmodel",
"model",
";",
"rtx",
"label",
",",
"x",
",",
"mask",
... | [
"Expand",
"an",
"atomic",
"exchange",
"operation",
"."
] | [
"rs6000",
"0",
"1",
"2",
"3",
"1",
"1",
"0",
"0"
] | rs60004 | rs6000_expand_atomic_exchange | rs6000 | CPU | GCC | 6,753 | 271 | 1 | [] |
[
"<s>",
"static",
"bool",
"arc_can_eliminate",
"(",
"const",
"int",
"from",
"ATTRIBUTE_UNUSED",
",",
"const",
"int",
"to",
")",
"{",
"return",
"(",
"(",
"to",
"==",
"HARD_FRAME_POINTER_REGNUM",
")",
"||",
"(",
"to",
"==",
"STACK_POINTER_REGNUM",
")",
")",
";"... | [
"Given",
"FROM",
"and",
"TO",
"register",
"numbers",
",",
"say",
"whether",
"this",
"elimination",
"is",
"allowed",
".",
"Frame",
"pointer",
"elimination",
"is",
"automatically",
"handled",
".",
"All",
"eliminations",
"are",
"permissible",
".",
"If",
"we",
"ne... | [
"arc"
] | arc | arc_can_eliminate | arc | MPU | GCC | 6,754 | 30 | 1 | [] |
[
"<s>",
"static",
"rtx",
"riscv_unspec_address_offset",
"(",
"rtx",
"base",
",",
"rtx",
"offset",
",",
"enum",
"riscv_symbol_type",
"symbol_type",
")",
"{",
"base",
"=",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"1",
",",
"base",
")",
",",
"UNSPE... | [
"Wrap",
"symbol",
"or",
"label",
"BASE",
"in",
"an",
"UNSPEC",
"address",
"of",
"type",
"SYMBOL_TYPE",
",",
"then",
"add",
"CONST_INT",
"OFFSET",
"to",
"the",
"result",
"."
] | [
"riscv",
"1"
] | riscv | riscv_unspec_address_offset | riscv | CPU | GCC | 6,755 | 59 | 1 | [] |
[
"<s>",
"void",
"AMDGPUAsmBackend",
"::",
"applyFixup",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"MutableArrayRef",
"<",
"char",
">",
"Data",
",",
"uint64_t",
"Value",
",",
"bool",
"IsPCRel",
",",
"MCContext",
"&",
"Ctx",
")",
"const",
"{",
"if",
"(",
... | [
"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",
"."
] | [
"AMDGPU",
"AMDGPU",
"\"Invalid fixup offset!\"",
"0",
"8",
"0xff"
] | AMDGPUAsmBackend2 | applyFixup | AMDGPU | GPU | LLVM | 6,756 | 129 | 1 | [] |
[
"<s>",
"static",
"parse_codes",
"parse_bif_stanza",
"(",
"void",
")",
"{",
"pos",
"=",
"0",
";",
"consume_whitespace",
"(",
")",
";",
"if",
"(",
"linebuf",
"[",
"pos",
"]",
"!=",
"'['",
")",
"{",
"diag",
"(",
"pos",
",",
"\"ill-formed stanza header.\\n\"",... | [
"Parse",
"one",
"stanza",
"of",
"the",
"input",
"BIF",
"file",
".",
"linebuf",
"already",
"contains",
"the",
"first",
"line",
"to",
"parse",
"."
] | [
"rs6000",
"0",
"\"ill-formed stanza header.\\n\"",
"\"no expression found in stanza header.\\n\"",
"\"ill-formed stanza header.\\n\"",
"1",
"\"garbage after stanza header.\\n\""
] | rs6000-gen-builtins | parse_bif_stanza | rs6000 | CPU | GCC | 6,757 | 172 | 1 | [] |
[
"<s>",
"void",
"assignValueToReg",
"(",
"Register",
"ValVReg",
",",
"Register",
"PhysReg",
",",
"CCValAssign",
"&",
"VA",
")",
"override",
"{",
"MIB",
".",
"addUse",
"(",
"PhysReg",
",",
"RegState",
"::",
"Implicit",
")",
";",
"Register",
"ExtReg",
"=",
"e... | [
"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"
] | AMDGPUCallLowering22 | assignValueToReg | AMDGPU | GPU | LLVM | 6,758 | 49 | 1 | [] |
[
"<s>",
"MachinePointerInfo",
"Cpu0MachineFunctionInfo",
"::",
"callPtrInfo",
"(",
"const",
"GlobalValue",
"*",
"GV",
")",
"{",
"return",
"MachinePointerInfo",
"(",
"MF",
".",
"getPSVManager",
"(",
")",
".",
"getGlobalValueCallEntry",
"(",
"GV",
")",
")",
";",
"}... | [
"Create",
"a",
"MachinePointerInfo",
"that",
"has",
"a",
"GlobalValuePseudoSourceValue",
"object",
"representing",
"a",
"GOT",
"entry",
"for",
"a",
"global",
"function",
"."
] | [
"Cpu0",
"Cpu0"
] | Cpu0MachineFunction | callPtrInfo | Cpu0 | CPU | LLVM | 6,759 | 27 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUInstrInfo",
"::",
"isCoalescableExtInstr",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"&",
"SrcReg",
",",
"unsigned",
"&",
"DstReg",
",",
"unsigned",
"&",
"SubIdx",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"isCoalescableExtInstr",
"-",
"Return",
"true",
"if",
"the",
"instruction",
"is",
"a",
"``",
"coalescable",
"''",
"extension",
"instruction",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPUInstrInfo | isCoalescableExtInstr | AMDGPU | GPU | LLVM | 6,760 | 28 | 1 | [] |
[
"<s>",
"SDValue",
"AArch64SelectionDAGInfo",
"::",
"EmitTargetCodeForMemmove",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"SDLoc",
"&",
"dl",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Dst",
",",
"SDValue",
"Src",
",",
"SDValue",
"Size",
",",
"Align",
"Alig... | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memmove",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"AArch64ISD::MOPS_MEMMOVE"
] | AArch64SelectionDAGInfo25 | EmitTargetCodeForMemmove | AArch64 | CPU | LLVM | 6,761 | 102 | 1 | [] |
[
"<s>",
"void",
"sparc_expand_vcond",
"(",
"machine_mode",
"mode",
",",
"rtx",
"*",
"operands",
",",
"int",
"ccode",
",",
"int",
"fcode",
")",
"{",
"rtx",
"mask",
",",
"cop0",
",",
"cop1",
",",
"fcmp",
",",
"cmask",
",",
"bshuf",
",",
"gsr",
";",
"enu... | [
"Emit",
"code",
"to",
"conditionally",
"move",
"a",
"combination",
"of",
"OPERANDS",
"[",
"1",
"]",
"and",
"OPERANDS",
"[",
"2",
"]",
"into",
"OPERANDS",
"[",
"0",
"]",
"in",
"MODE",
",",
"depending",
"on",
"the",
"outcome",
"of",
"the",
"comparison",
... | [
"sparc",
"3",
"4",
"5",
"1",
"2",
"3",
"1",
"2",
"0"
] | sparc | sparc_expand_vcond | sparc | CPU | GCC | 6,762 | 211 | 1 | [] |
[
"<s>",
"inline",
"void",
"function_expander",
"::",
"add_input_operand",
"(",
"machine_mode",
"mode",
",",
"rtx",
"op",
")",
"{",
"create_input_operand",
"(",
"&",
"m_ops",
"[",
"opno",
"++",
"]",
",",
"op",
",",
"mode",
")",
";",
"}",
"</s>"
] | [
"Create",
"op",
"and",
"add",
"it",
"into",
"M_OPS",
"and",
"increase",
"OPNO",
"."
] | [
"riscv"
] | riscv-vector-builtins | add_input_operand | riscv | CPU | GCC | 6,763 | 28 | 1 | [] |
[
"<s>",
"virtual",
"const",
"ARMRegisterInfo",
"&",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"RI",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"ARM",
"ARM"
] | ARMInstrInfo19 | getRegisterInfo | ARM | CPU | LLVM | 6,764 | 13 | 1 | [] |
[
"<s>",
"bool",
"csky_minipool_load_p",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"rtx",
"op1",
",",
"addr",
";",
"extract_insn_cached",
"(",
"insn",
")",
";",
"op1",
"=",
"recog_data",
".",
"operand",
"[",
"1",
"]",
";",
"if",
"(",
"CONSTANT_P",
"(",
"op... | [
"Return",
"true",
"if",
"INSN",
"is",
"a",
"minipool",
"load",
"or",
"instruction",
"that",
"will",
"be",
"converted",
"to",
"one",
".",
"It",
"is",
"assumed",
"that",
"INSN",
"has",
"type",
"attribute",
"``",
"load",
"''",
"."
] | [
"csky",
"1",
"0",
"0",
"1",
"0"
] | csky | csky_minipool_load_p | csky | CPU | GCC | 6,765 | 120 | 1 | [] |
[
"<s>",
"unsigned",
"ARMCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
"{",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"return",
"II",
"->",
"getRegisterInfo",
"(... | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"ARM",
"ARM",
"32",
"ARM::reloc_arm_branch",
"ARM::reloc_arm_branch",
"ARMII::FormMask",
"ARMII::VFPLdStFrm",
"ARM::reloc_arm_vfp_cp_entry",
"ARM::reloc_arm_cp_entry",
"ARM::reloc_arm_relative",
"ARM::reloc_arm_branch",
"\"Unable to encode MachineOperand!\"",
"0"
] | ARMCodeEmitter | getMachineOpValue | ARM | CPU | LLVM | 6,766 | 264 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"isOffsetFoldingLegal",
"(",
"const",
"GlobalAddressSDNode",
"*",
"GA",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"folding",
"a",
"constant",
"offset",
"with",
"the",
"given",
"GlobalAddress",
"is",
"legal",
"."
] | [
"AArch64",
"AArch64"
] | AArch64ISelLowering (2) | isOffsetFoldingLegal | AArch64 | CPU | LLVM | 6,767 | 16 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"VERegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"return",
"CSR_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"VE",
"VE"
] | VERegisterInfo1 | getCalleeSavedRegs | VE | CPU | LLVM | 6,768 | 18 | 1 | [] |
[
"<s>",
"bool",
"RISCVAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"StringRef",
"IDVal",
"=",
"DirectiveID",
".",
"getString",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".option\"",
")",
"return",
"parseDirectiveOption",
"(",
"... | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"RISCV",
"RISCV",
"\".option\"",
"\".attribute\""
] | RISCVAsmParser10 | ParseDirective | RISCV | CPU | LLVM | 6,769 | 45 | 1 | [] |
[
"<s>",
"bool",
"NEONPreAllocPass",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"TII",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"for",
"(",
"MachineFunct... | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM"
] | NEONPreAllocPass | runOnMachineFunction | ARM | CPU | LLVM | 6,770 | 75 | 1 | [] |
[
"<s>",
"static",
"HOST_WIDE_INT",
"aarch64_constant_alignment",
"(",
"const_tree",
"exp",
",",
"HOST_WIDE_INT",
"align",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"exp",
")",
"==",
"STRING_CST",
"&&",
"!",
"optimize_size",
")",
"return",
"MAX",
"(",
"align",
",",... | [
"Implement",
"TARGET_CONSTANT_ALIGNMENT",
".",
"Make",
"strings",
"word-aligned",
"so",
"that",
"strcpy",
"from",
"constants",
"will",
"be",
"faster",
"."
] | [
"aarch64"
] | aarch64 | aarch64_constant_alignment | aarch64 | CPU | GCC | 6,771 | 35 | 1 | [] |
[
"<s>",
"bool",
"AArch64ConditionalCompares",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"********** AArch64 Conditional Compares **********\\n\"",
"<<",
"\"********** Function: \"",
"<<",
"MF",
".",
... | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AArch64",
"AArch64",
"\"********** AArch64 Conditional Compares **********\\n\"",
"\"********** Function: \""
] | AArch64ConditionalCompares10 | runOnMachineFunction | AArch64 | CPU | LLVM | 6,772 | 172 | 1 | [] |
[
"<s>",
"bool",
"X86TTIImpl",
"::",
"isLegalMaskedLoad",
"(",
"Type",
"*",
"DataTy",
")",
"{",
"Type",
"*",
"ScalarTy",
"=",
"DataTy",
"->",
"getScalarType",
"(",
")",
";",
"int",
"DataWidth",
"=",
"isa",
"<",
"PointerType",
">",
"(",
"ScalarTy",
")",
"?"... | [
"Return",
"true",
"if",
"the",
"target",
"supports",
"masked",
"load",
"."
] | [
"X86",
"X86",
"32",
"64",
"8",
"16"
] | X86TargetTransformInfo11 | isLegalMaskedLoad | X86 | CPU | LLVM | 6,773 | 81 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAsmParser",
"::",
"ParseInstruction",
"(",
"ParseInstructionInfo",
"&",
"Info",
",",
"StringRef",
"Name",
",",
"SMLoc",
"NameLoc",
",",
"OperandVector",
"&",
"Operands",
")",
"{",
"Operands",
".",
"push_back",
"(",
"AMDGPUOperand",
"::",
"C... | [
"ParseInstruction",
"-",
"Parse",
"one",
"assembly",
"instruction",
"."
] | [
"R600",
"\"Failed parsing operand\"",
"\"Not a valid operand\""
] | AMDGPUAsmParser43 | ParseInstruction | R600 | GPU | LLVM | 6,774 | 100 | 1 | [] |
[
"<s>",
"unsigned",
"ARMMCCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"const",
"MCOperand",
"&",
"MO",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
... | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"ARM",
"ARM",
"ARM::HasMVEIntegerOps",
"ARM::Q0",
"ARM::Q1",
"ARM::Q2",
"ARM::Q3",
"ARM::Q4",
"ARM::Q5",
"ARM::Q6",
"ARM::Q7",
"ARM::Q8",
"ARM::Q9",
"ARM::Q10",
"ARM::Q11",
"ARM::Q12",
"ARM::Q13",
"ARM::Q14",
"ARM::Q15",
"2",
"32",
"\"Unable to encode MCOperand!\""
] | ARMMCCodeEmitter15 | getMachineOpValue | ARM | CPU | LLVM | 6,775 | 250 | 1 | [] |
[
"<s>",
"static",
"bool",
"tryAddingSymbolicOperand",
"(",
"int64_t",
"Value",
",",
"bool",
"IsBranch",
",",
"uint64_t",
"Address",
",",
"uint64_t",
"Offset",
",",
"uint64_t",
"Width",
",",
"MCInst",
"&",
"MI",
",",
"const",
"void",
"*",
"Decoder",
")",
"{",
... | [
"Try",
"to",
"add",
"a",
"symbolic",
"operand",
"instead",
"of",
"Value",
"to",
"the",
"MCInst",
"."
] | [
"DLX"
] | DLXDisassembler | tryAddingSymbolicOperand | DLX | CPU | LLVM | 6,776 | 63 | 1 | [] |
[
"<s>",
"bool",
"RISCVTargetLowering",
"::",
"isLegalAddressingMode",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"const",
"AddrMode",
"&",
"AM",
",",
"Type",
"*",
"Ty",
",",
"unsigned",
"AS",
",",
"Instruction",
"*",
"I",
")",
"const",
"{",
"if",
"(",
"A... | [
"isLegalAddressingMode",
"-",
"Return",
"true",
"if",
"the",
"addressing",
"mode",
"represented",
"by",
"AM",
"is",
"legal",
"for",
"this",
"target",
",",
"for",
"a",
"load/store",
"of",
"the",
"specified",
"type",
"."
] | [
"RI5CY",
"RISCV",
"12",
"0",
"1"
] | RISCVISelLowering | isLegalAddressingMode | RI5CY | CPU | LLVM | 6,777 | 90 | 1 | [] |
[
"<s>",
"bool",
"GBZ80PassConfig",
"::",
"addInstSelector",
"(",
")",
"{",
"addPass",
"(",
"createGBZ80ISelDAG",
"(",
"getGBZ80TargetMachine",
"(",
")",
",",
"getOptLevel",
"(",
")",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"addInstSelector",
"-",
"This",
"method",
"should",
"install",
"an",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"from",
"LLVM",
"code",
"to",
"machine",
"instructions",
"."
] | [
"GBZ80",
"GB",
"GB",
"GB"
] | GBZ80TargetMachine (2) | addInstSelector | GBZ80 | MPU | LLVM | 6,778 | 25 | 1 | [] |
[
"<s>",
"int",
"X86FrameLowering",
"::",
"mergeSPUpdates",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"MBBI",
",",
"bool",
"doMergeWithPrevious",
")",
"const",
"{",
"if",
"(",
"(",
"doMergeWithPrevious",
"&&",
"MBBI",
"... | [
"Check",
"the",
"instruction",
"before/after",
"the",
"passed",
"instruction",
"."
] | [
"X86",
"X86",
"0",
"0",
"X86::ADD64ri32",
"X86::ADD64ri8",
"X86::ADD32ri",
"X86::ADD32ri8",
"0",
"1",
"2",
"X86::LEA32r",
"X86::LEA64_32r",
"0",
"1",
"2",
"1",
"3",
"X86::NoRegister",
"5",
"X86::NoRegister",
"4",
"X86::SUB64ri32",
"X86::SUB64ri8",
"X86::SUB32ri",
"X... | X86FrameLowering10 | mergeSPUpdates | X86 | CPU | LLVM | 6,779 | 427 | 1 | [] |
[
"<s>",
"bool",
"PPCInstrInfo",
"::",
"analyzeLoop",
"(",
"MachineLoop",
"&",
"L",
",",
"MachineInstr",
"*",
"&",
"IndVarInst",
",",
"MachineInstr",
"*",
"&",
"CmpInst",
")",
"const",
"{",
"MachineBasicBlock",
"*",
"LoopEnd",
"=",
"L",
".",
"getBottomBlock",
... | [
"Analyze",
"the",
"loop",
"code",
",",
"return",
"true",
"if",
"it",
"can",
"not",
"be",
"understood",
"."
] | [
"PowerPC",
"PPC"
] | PPCInstrInfo115 | analyzeLoop | PowerPC | CPU | LLVM | 6,780 | 80 | 1 | [] |
[
"<s>",
"bool",
"ARM64TargetLowering",
"::",
"isFPImmLegal",
"(",
"const",
"APFloat",
"&",
"Imm",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Imm",
".",
"isPosZero",
"(",
")",
"&&",
"(",
"VT",
"==",
"MVT",
"::",
"f64",
"||",
"VT",
"==",
"MVT",
... | [
"Returns",
"true",
"if",
"the",
"target",
"can",
"instruction",
"select",
"the",
"specified",
"FP",
"immediate",
"natively",
"."
] | [
"ARM64",
"ARM64",
"MVT::f64",
"MVT::f32",
"MVT::f64",
"ARM64_AM::getFP64Imm",
"1",
"MVT::f32",
"ARM64_AM::getFP32Imm",
"1"
] | ARM64ISelLowering | isFPImmLegal | ARM64 | CPU | LLVM | 6,781 | 83 | 1 | [] |
[
"<s>",
"void",
"EmitInstruction",
"(",
"uint64_t",
"Val",
",",
"unsigned",
"Size",
",",
"raw_ostream",
"&",
"OS",
")",
"const",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"Size",
";",
"++",
"i",
")",
"{",
"unsigned",
"Shift",
"=",
"... | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"TOY",
"0",
"8",
"0xff"
] | TOYMCCodeEmitter | EmitInstruction | TOY | CPU | LLVM | 6,782 | 52 | 1 | [] |
[
"<s>",
"static",
"int",
"mem_is_padded_component_ref",
"(",
"rtx",
"x",
")",
"{",
"tree",
"t",
"=",
"MEM_EXPR",
"(",
"x",
")",
";",
"tree",
"r",
";",
"if",
"(",
"!",
"t",
"||",
"TREE_CODE",
"(",
"t",
")",
"!=",
"COMPONENT_REF",
")",
"return",
"0",
... | [
"Return",
"TRUE",
"if",
"X",
"is",
"MEM",
"which",
"is",
"a",
"struct",
"member",
"reference",
"and",
"the",
"member",
"can",
"safely",
"be",
"loaded",
"and",
"stored",
"with",
"a",
"single",
"instruction",
"because",
"it",
"is",
"padded",
"."
] | [
"spu",
"0",
"1",
"128",
"0",
"0",
"0",
"0",
"1",
"128",
"1",
"0"
] | spu | mem_is_padded_component_ref | spu | MPU | GCC | 6,783 | 155 | 1 | [] |
[
"<s>",
"void",
"order_regs_for_local_alloc",
"(",
"void",
")",
"{",
"static",
"int",
"last_order_nonleaf",
"=",
"1",
";",
"if",
"(",
"df_regs_ever_live_p",
"(",
"15",
")",
"!=",
"last_order_nonleaf",
")",
"{",
"last_order_nonleaf",
"=",
"!",
"last_order_nonleaf",
... | [
"Choose",
"the",
"order",
"in",
"which",
"to",
"allocate",
"hard",
"registers",
"for",
"pseudo-registers",
"local",
"to",
"a",
"basic",
"block",
".",
"Store",
"the",
"desired",
"register",
"order",
"in",
"the",
"array",
"`",
"reg_alloc_order",
"'",
".",
"Ele... | [
"sparc",
"1",
"15"
] | sparc | order_regs_for_local_alloc | sparc | CPU | GCC | 6,784 | 55 | 1 | [] |
[
"<s>",
"static",
"int",
"ix86_mode_after",
"(",
"int",
"entity",
",",
"int",
"mode",
",",
"rtx_insn",
"*",
"insn",
")",
"{",
"switch",
"(",
"entity",
")",
"{",
"case",
"X86_DIRFLAG",
":",
"return",
"mode",
";",
"case",
"AVX_U128",
":",
"return",
"ix86_av... | [
"Return",
"the",
"mode",
"that",
"an",
"insn",
"results",
"in",
"."
] | [
"i386"
] | i3866 | ix86_mode_after | i386 | CPU | GCC | 6,785 | 60 | 1 | [] |
[
"<s>",
"VariantKind",
"getKind",
"(",
")",
"const",
"{",
"return",
"Kind",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"Kind",
"of",
"lane",
"offset",
"."
] | [
"VE"
] | VEMCExpr | getKind | VE | CPU | LLVM | 6,786 | 10 | 1 | [] |
[
"<s>",
"unsigned",
"getMaxInlineSizeThreshold",
"(",
")",
"const",
"{",
"return",
"64",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"maximum",
"memset",
"/",
"memcpy",
"size",
"that",
"still",
"makes",
"it",
"profitable",
"to",
"inline",
"the",
"call",
"."
] | [
"AArch64",
"64"
] | AArch64Subtarget (2) | getMaxInlineSizeThreshold | AArch64 | CPU | LLVM | 6,787 | 10 | 1 | [] |
[
"<s>",
"bool",
"OR1KInstrInfo",
"::",
"analyzeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"&",
"TBB",
",",
"MachineBasicBlock",
"*",
"&",
"FBB",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
",",
"bool",
"Al... | [
"analyzeBranch",
"-",
"Analyze",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"MBB",
",",
"returning",
"true",
"if",
"it",
"can",
"not",
"be",
"understood",
"(",
"e.g",
"."
] | [
"OR1K",
"OR1K",
"OR1K::JR",
"OR1K::J",
"0",
"0",
"0",
"0",
"0"
] | OR1KInstrInfo1 | analyzeBranch | OR1K | CPU | LLVM | 6,788 | 239 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"{",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"R600"
] | R600TextureIntrinsicsReplacer2 | getAnalysisUsage | R600 | GPU | LLVM | 6,789 | 10 | 1 | [] |
[
"<s>",
"bool",
"FPGATTIImpl",
"::",
"isLegalMaskedLoad",
"(",
"Type",
"*",
"DataType",
")",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"supports",
"masked",
"load",
"."
] | [
"FPGA",
"FPGA"
] | FPGATargetTransformInfo | isLegalMaskedLoad | FPGA | CPU | LLVM | 6,790 | 14 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"shouldNormalizeToSelectSequence",
"(",
"LLVMContext",
"&",
",",
"EVT",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"we",
"should",
"normalize",
"select",
"(",
"N0",
"&",
"N1",
",",
"X",
",",
"Y",
")",
"=",
">",
"select",
"(",
"N0",
",",
"select",
"(",
"N1",
",",
"X",
",",
"Y",
")",
",",
"Y",
")",
"and",
"select",
"(",
"N0|N1",
","... | [
"AArch64",
"AArch64"
] | AArch64ISelLowering (2) | shouldNormalizeToSelectSequence | AArch64 | CPU | LLVM | 6,791 | 16 | 1 | [] |
[
"<s>",
"bool",
"invalid_e500_subreg",
"(",
"rtx",
"op",
",",
"enum",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"==",
"SUBREG",
"&&",
"mode",
"==",
"SImode",
"&&",
"REG_P",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"&&",
"... | [
"Return",
"TRUE",
"if",
"OP",
"is",
"an",
"invalid",
"SUBREG",
"operation",
"on",
"the",
"e500",
"."
] | [
"rs6000"
] | rs60003 | invalid_e500_subreg | rs6000 | CPU | GCC | 6,792 | 83 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"Hexagon Vector Combine\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"Hexagon",
"\"Hexagon Vector Combine\""
] | HexagonVectorCombine | getPassName | Hexagon | DSP | LLVM | 6,793 | 11 | 1 | [] |
[
"<s>",
"static",
"void",
"mips16_build_function_stub",
"(",
"void",
")",
"{",
"const",
"char",
"*",
"fnname",
",",
"*",
"alias_name",
",",
"*",
"separator",
";",
"char",
"*",
"secname",
",",
"*",
"stubname",
";",
"tree",
"stubdecl",
";",
"unsigned",
"int",... | [
"Write",
"a",
"MIPS16",
"stub",
"for",
"the",
"current",
"function",
".",
"This",
"stub",
"is",
"used",
"for",
"functions",
"which",
"take",
"arguments",
"in",
"the",
"floating-point",
"registers",
".",
"It",
"is",
"normal-mode",
"code",
"that",
"moves",
"th... | [
"mips",
"0",
"0",
"0",
"\".mips16.fn.\"",
"\"__fn_stub_\"",
"\"\\t# Stub function for %s (\"",
"\"\"",
"0",
"2",
"\"%s%s\"",
"3",
"1",
"\"float\"",
"\"double\"",
"\", \"",
"\")\\n\"",
"\"\\t.option\\tpic0\\n\"",
"\"%(.cpload\\t%^%)\"",
"\".reloc\\t0,R_MIPS_NONE,%0\"",
"\"la\\... | mips | mips16_build_function_stub | mips | CPU | GCC | 6,794 | 344 | 1 | [] |
[
"<s>",
"bool",
"X86CallFrameOptimization",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"STI",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"TII",
"=",
"STI",
"->",
"getInstrInfo",
"(",
")",
";... | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"X86"
] | X86CallFrameOptimization2 | runOnMachineFunction | X86 | CPU | LLVM | 6,795 | 200 | 1 | [] |
[
"<s>",
"bool",
"hasFusion",
"(",
")",
"const",
"{",
"return",
"hasArithmeticBccFusion",
"(",
")",
"||",
"hasArithmeticCbzFusion",
"(",
")",
"||",
"hasFuseAES",
"(",
")",
"||",
"hasFuseLiterals",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"CPU",
"supports",
"any",
"kind",
"of",
"instruction",
"fusion",
"."
] | [
"AArch64"
] | AArch64Subtarget103 | hasFusion | AArch64 | CPU | LLVM | 6,796 | 24 | 1 | [] |
[
"<s>",
"int",
"legitimate_const_double_p",
"(",
"rtx",
"address",
")",
"{",
"REAL_VALUE_TYPE",
"r",
";",
"long",
"sval",
"[",
"2",
"]",
";",
"REAL_VALUE_FROM_CONST_DOUBLE",
"(",
"r",
",",
"address",
")",
";",
"REAL_VALUE_TO_TARGET_DOUBLE",
"(",
"r",
",",
"sval... | [
"This",
"function",
"checks",
"whether",
"a",
"real",
"value",
"can",
"be",
"encoded",
"as",
"a",
"literal",
",",
"i.e.",
",",
"addressing",
"mode",
"27",
".",
"In",
"that",
"mode",
",",
"real",
"values",
"are",
"one",
"word",
"values",
",",
"so",
"the... | [
"pdp11",
"2",
"0",
"0xffff",
"0",
"1",
"0",
"1",
"0"
] | pdp113 | legitimate_const_double_p | pdp11 | MPU | GCC | 6,797 | 57 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"mcore_output_cmov",
"(",
"rtx",
"operands",
"[",
"]",
",",
"int",
"cmp_t",
",",
"const",
"char",
"*",
"test",
")",
"{",
"HOST_WIDE_INT",
"load_value",
";",
"HOST_WIDE_INT",
"adjust_value",
";",
"rtx",
"out_operands",
"[",
"4",
... | [
"Output",
"a",
"conditional",
"move",
"of",
"two",
"constants",
"that",
"are",
"+/-",
"1",
"within",
"each",
"other",
".",
"See",
"the",
"``",
"movtK",
"''",
"patterns",
"in",
"mcore.md",
".",
"I",
"'m",
"not",
"sure",
"this",
"is",
"really",
"worth",
... | [
"mcore",
"4",
"0",
"0",
"1",
"1",
"1",
"2",
"2",
"2",
"1",
"2",
"2",
"1",
"0",
"1",
"2",
"0",
"127",
"\"movi\\t%0,%1\"",
"\"bgeni\\t%0,%P1\"",
"\"bmaski\\t%0,%N1\"",
"\"decf\\t%0\"",
"\"dect\\t%0\"",
"\"incf\\t%0\"",
"\"inct\\t%0\"",
"\"\""
] | mcore | mcore_output_cmov | mcore | MPU | GCC | 6,798 | 251 | 1 | [] |
[
"<s>",
"static",
"int",
"xtensa_register_move_cost",
"(",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"reg_class_t",
"from",
",",
"reg_class_t",
"to",
")",
"{",
"if",
"(",
"from",
"==",
"to",
"&&",
"from",
"!=",
"BR_REGS",
"&&",
"to",
"!=",
"BR_REGS",
"... | [
"Worker",
"function",
"for",
"TARGET_REGISTER_MOVE_COST",
"."
] | [
"xtensa",
"2",
"2",
"3",
"3",
"10"
] | xtensa | xtensa_register_move_cost | xtensa | MPU | GCC | 6,799 | 91 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.