ground_truth
sequencelengths 8
512
| natrual_language
sequencelengths 1
243
| TS_V_token
sequencelengths 1
182
| File
stringlengths 2
45
| Func
stringlengths 1
56
| Target
stringclasses 175
values | Target_Clf
stringclasses 6
values | Compiler_Type
stringclasses 2
values | Idx
int64 0
36.2k
| Length
int64 6
510
| Cover_Rate
float64 1
1
| Template_token
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|
[
"<s>",
"unsigned",
"ARMMCCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"const",
"MCOperand",
"&",
"MO",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"{",
"unsigned",
"Reg",
"=",
"MO",
".",
"getReg",
"(",
")",
";",
"unsigned",
"RegNo",
"=",
"CTX",
".",
"getRegisterInfo",
"(",
")",
"->",
"getEncodingValue",
"(",
"Reg",
")",
";",
"switch",
"(",
"Reg",
")",
"{",
"default",
":",
"return",
"RegNo",
";",
"case",
"ARM",
"::",
"Q0",
":",
"case",
"ARM",
"::",
"Q1",
":",
"case",
"ARM",
"::",
"Q2",
":",
"case",
"ARM",
"::",
"Q3",
":",
"case",
"ARM",
"::",
"Q4",
":",
"case",
"ARM",
"::",
"Q5",
":",
"case",
"ARM",
"::",
"Q6",
":",
"case",
"ARM",
"::",
"Q7",
":",
"case",
"ARM",
"::",
"Q8",
":",
"case",
"ARM",
"::",
"Q9",
":",
"case",
"ARM",
"::",
"Q10",
":",
"case",
"ARM",
"::",
"Q11",
":",
"case",
"ARM",
"::",
"Q12",
":",
"case",
"ARM",
"::",
"Q13",
":",
"case",
"ARM",
"::",
"Q14",
":",
"case",
"ARM",
"::",
"Q15",
":",
"return",
"2",
"*",
"RegNo",
";",
"}",
"}",
"else",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"{",
"return",
"static_cast",
"<",
"unsigned",
">",
"(",
"MO",
".",
"getImm",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"MO",
".",
"isFPImm",
"(",
")",
")",
"{",
"return",
"static_cast",
"<",
"unsigned",
">",
"(",
"APFloat",
"(",
"MO",
".",
"getFPImm",
"(",
")",
")",
".",
"bitcastToAPInt",
"(",
")",
".",
"getHiBits",
"(",
"32",
")",
".",
"getLimitedValue",
"(",
")",
")",
";",
"}",
"llvm_unreachable",
"(",
"\"Unable to encode MCOperand!\"",
")",
";",
"}",
"</s>"
] | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"ARM",
"ARM",
"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!\""
] | ARMMCCodeEmitter1 | getMachineOpValue | ARM | CPU | LLVM | 16,600 | 228 | 1 | [] |
[
"<s>",
"ArrayRef",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"char",
"*",
">>",
"RISCVInstrInfo",
"::",
"getSerializableDirectMachineOperandTargetFlags",
"(",
")",
"const",
"{",
"using",
"namespace",
"RISCVII",
";",
"static",
"const",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"char",
"*",
">",
"TargetFlags",
"[",
"]",
"=",
"{",
"{",
"MO_CALL",
",",
"\"riscv-call\"",
"}",
",",
"{",
"MO_PLT",
",",
"\"riscv-plt\"",
"}",
",",
"{",
"MO_LO",
",",
"\"riscv-lo\"",
"}",
",",
"{",
"MO_HI",
",",
"\"riscv-hi\"",
"}",
",",
"{",
"MO_PCREL_LO",
",",
"\"riscv-pcrel-lo\"",
"}",
",",
"{",
"MO_PCREL_HI",
",",
"\"riscv-pcrel-hi\"",
"}",
",",
"{",
"MO_GOT_HI",
",",
"\"riscv-got-hi\"",
"}",
",",
"{",
"MO_TPREL_LO",
",",
"\"riscv-tprel-lo\"",
"}",
",",
"{",
"MO_TPREL_HI",
",",
"\"riscv-tprel-hi\"",
"}",
",",
"{",
"MO_TPREL_ADD",
",",
"\"riscv-tprel-add\"",
"}",
",",
"{",
"MO_TLS_GOT_HI",
",",
"\"riscv-tls-got-hi\"",
"}",
",",
"{",
"MO_TLS_GD_HI",
",",
"\"riscv-tls-gd-hi\"",
"}",
"}",
";",
"return",
"makeArrayRef",
"(",
"TargetFlags",
")",
";",
"}",
"</s>"
] | [
"Return",
"an",
"array",
"that",
"contains",
"the",
"direct",
"target",
"flag",
"values",
"and",
"their",
"names",
"."
] | [
"RI5CY",
"RISCV",
"RISCV",
"\"riscv-call\"",
"\"riscv-plt\"",
"\"riscv-lo\"",
"\"riscv-hi\"",
"\"riscv-pcrel-lo\"",
"\"riscv-pcrel-hi\"",
"\"riscv-got-hi\"",
"\"riscv-tprel-lo\"",
"\"riscv-tprel-hi\"",
"\"riscv-tprel-add\"",
"\"riscv-tls-got-hi\"",
"\"riscv-tls-gd-hi\""
] | RISCVInstrInfo | getSerializableDirectMachineOperandTargetFlags | RI5CY | CPU | LLVM | 16,601 | 120 | 1 | [] |
[
"<s>",
"int",
"arm_regno_class",
"(",
"int",
"regno",
")",
"{",
"if",
"(",
"TARGET_THUMB",
")",
"{",
"if",
"(",
"regno",
"==",
"STACK_POINTER_REGNUM",
")",
"return",
"STACK_REG",
";",
"if",
"(",
"regno",
"==",
"CC_REGNUM",
")",
"return",
"CC_REG",
";",
"if",
"(",
"regno",
"<",
"8",
")",
"return",
"LO_REGS",
";",
"return",
"HI_REGS",
";",
"}",
"if",
"(",
"regno",
"<=",
"LAST_ARM_REGNUM",
"||",
"regno",
"==",
"FRAME_POINTER_REGNUM",
"||",
"regno",
"==",
"ARG_POINTER_REGNUM",
")",
"return",
"GENERAL_REGS",
";",
"if",
"(",
"regno",
"==",
"CC_REGNUM",
"||",
"regno",
"==",
"VFPCC_REGNUM",
")",
"return",
"NO_REGS",
";",
"if",
"(",
"IS_CIRRUS_REGNUM",
"(",
"regno",
")",
")",
"return",
"CIRRUS_REGS",
";",
"if",
"(",
"IS_VFP_REGNUM",
"(",
"regno",
")",
")",
"return",
"VFP_REGS",
";",
"if",
"(",
"IS_IWMMXT_REGNUM",
"(",
"regno",
")",
")",
"return",
"IWMMXT_REGS",
";",
"if",
"(",
"IS_IWMMXT_GR_REGNUM",
"(",
"regno",
")",
")",
"return",
"IWMMXT_GR_REGS",
";",
"return",
"FPA_REGS",
";",
"}",
"</s>"
] | [
"For",
"efficiency",
"and",
"historical",
"reasons",
"LO_REGS",
",",
"HI_REGS",
"and",
"CC_REGS",
"are",
"not",
"used",
"in",
"arm",
"mode",
"."
] | [
"arm",
"8"
] | arm3 | arm_regno_class | arm | CPU | GCC | 16,602 | 117 | 1 | [] |
[
"<s>",
"const",
"ARMInstrInfo",
"*",
"getInstrInfo",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"InstrInfo",
";",
"}",
"</s>"
] | [
"TargetInstrInfo",
"getter",
"."
] | [
"ARM",
"ARM"
] | ARMTargetMachine15 | getInstrInfo | ARM | CPU | LLVM | 16,603 | 14 | 1 | [] |
[
"<s>",
"std",
"::",
"string",
"BlackfinIntrinsicInfo",
"::",
"getName",
"(",
"unsigned",
"IntrID",
",",
"Type",
"*",
"*",
"Tys",
",",
"unsigned",
"numTys",
")",
"const",
"{",
"static",
"const",
"char",
"*",
"const",
"names",
"[",
"]",
"=",
"{",
"}",
";",
"assert",
"(",
"!",
"isOverloaded",
"(",
"IntrID",
")",
"&&",
"\"Blackfin intrinsics are not overloaded\"",
")",
";",
"if",
"(",
"IntrID",
"<",
"Intrinsic",
"::",
"num_intrinsics",
")",
"return",
"0",
";",
"assert",
"(",
"IntrID",
"<",
"bfinIntrinsic",
"::",
"num_bfin_intrinsics",
"&&",
"\"Invalid intrinsic ID\"",
")",
";",
"std",
"::",
"string",
"Result",
"(",
"names",
"[",
"IntrID",
"-",
"Intrinsic",
"::",
"num_intrinsics",
"]",
")",
";",
"return",
"Result",
";",
"}",
"</s>"
] | [
"Return",
"a",
"string",
"with",
"the",
"name",
"of",
"the",
"plan",
"and",
"the",
"applicable",
"VFs",
"and",
"UFs",
"."
] | [
"Blackfin",
"\"Blackfin intrinsics are not overloaded\"",
"Intrinsic::num_intrinsics",
"0",
"bfinIntrinsic::num_bfin_intrinsics",
"\"Invalid intrinsic ID\"",
"Intrinsic::num_intrinsics"
] | BlackfinIntrinsicInfo2 | getName | Blackfin | DSP | LLVM | 16,604 | 84 | 1 | [] |
[
"<s>",
"MCSection",
"*",
"getExplicitSectionGlobal",
"(",
"const",
"GlobalObject",
"*",
"GO",
",",
"SectionKind",
"Kind",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"const",
"override",
"{",
"return",
"TextSection",
";",
"}",
"</s>"
] | [
"Targets",
"should",
"implement",
"this",
"method",
"to",
"assign",
"a",
"section",
"to",
"globals",
"with",
"an",
"explicit",
"section",
"specfied",
"."
] | [
"SPIRV"
] | SPIRVTargetObjectFile | getExplicitSectionGlobal | SPIRV | Virtual ISA | LLVM | 16,605 | 24 | 1 | [] |
[
"<s>",
"static",
"bool",
"sh_function_ok_for_sibcall",
"(",
"tree",
"decl",
",",
"tree",
"exp",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"(",
"1",
"&&",
"(",
"!",
"TARGET_SHCOMPACT",
"||",
"current_function_args_info",
".",
"stack_regs",
"==",
"0",
")",
"&&",
"!",
"sh_cfun_interrupt_handler_p",
"(",
")",
"&&",
"(",
"!",
"flag_pic",
"||",
"(",
"decl",
"&&",
"!",
"TREE_PUBLIC",
"(",
"decl",
")",
")",
"||",
"(",
"decl",
"&&",
"DECL_VISIBILITY",
"(",
"decl",
")",
"!=",
"VISIBILITY_DEFAULT",
")",
")",
")",
";",
"}",
"</s>"
] | [
"If",
"PIC",
",",
"we",
"can",
"not",
"make",
"sibling",
"calls",
"to",
"global",
"functions",
"because",
"the",
"PLT",
"requires",
"r12",
"to",
"be",
"live",
"."
] | [
"sh",
"1",
"0"
] | sh3 | sh_function_ok_for_sibcall | sh | CPU | GCC | 16,606 | 60 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyDebugValueManager",
"::",
"clone",
"(",
"MachineInstr",
"*",
"Insert",
",",
"unsigned",
"NewReg",
")",
"{",
"MachineBasicBlock",
"*",
"MBB",
"=",
"Insert",
"->",
"getParent",
"(",
")",
";",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
"->",
"getParent",
"(",
")",
";",
"for",
"(",
"MachineInstr",
"*",
"DBI",
":",
"reverse",
"(",
"DbgValues",
")",
")",
"{",
"MachineInstr",
"*",
"Clone",
"=",
"MF",
"->",
"CloneMachineInstr",
"(",
"DBI",
")",
";",
"Clone",
"->",
"getDebugOperand",
"(",
"0",
")",
".",
"setReg",
"(",
"NewReg",
")",
";",
"MBB",
"->",
"insert",
"(",
"Insert",
",",
"Clone",
")",
";",
"}",
"}",
"</s>"
] | [
"Make",
"a",
"functionally",
"equivalent",
"copy",
"of",
"this",
"MachineFunctionInfo",
"in",
"MF",
"."
] | [
"WebAssembly",
"WebAssembly",
"0"
] | WebAssemblyDebugValueManager10 | clone | WebAssembly | Virtual ISA | LLVM | 16,607 | 79 | 1 | [] |
[
"<s>",
"static",
"void",
"c6x_print_unit_specifier_field",
"(",
"FILE",
"*",
"file",
",",
"rtx_insn",
"*",
"insn",
")",
"{",
"enum",
"attr_units",
"units",
"=",
"get_attr_units",
"(",
"insn",
")",
";",
"enum",
"attr_cross",
"cross",
"=",
"get_attr_cross",
"(",
"insn",
")",
";",
"enum",
"attr_dest_regfile",
"rf",
"=",
"get_attr_dest_regfile",
"(",
"insn",
")",
";",
"int",
"half",
";",
"char",
"unitspec",
";",
"if",
"(",
"units",
"==",
"UNITS_D_ADDR",
")",
"{",
"enum",
"attr_addr_regfile",
"arf",
"=",
"get_attr_addr_regfile",
"(",
"insn",
")",
";",
"int",
"t_half",
";",
"gcc_assert",
"(",
"arf",
"!=",
"ADDR_REGFILE_UNKNOWN",
")",
";",
"half",
"=",
"arf",
"==",
"ADDR_REGFILE_A",
"?",
"1",
":",
"2",
";",
"t_half",
"=",
"rf",
"==",
"DEST_REGFILE_A",
"?",
"1",
":",
"2",
";",
"fprintf",
"(",
"file",
",",
"\".d%dt%d\"",
",",
"half",
",",
"t_half",
")",
";",
"return",
";",
"}",
"if",
"(",
"insn_info",
".",
"exists",
"(",
")",
")",
"{",
"int",
"unit",
"=",
"INSN_INFO_ENTRY",
"(",
"INSN_UID",
"(",
"insn",
")",
")",
".",
"reservation",
";",
"fputs",
"(",
"\".\"",
",",
"file",
")",
";",
"fputs",
"(",
"c6x_unit_names",
"[",
"unit",
"]",
",",
"file",
")",
";",
"if",
"(",
"cross",
"==",
"CROSS_Y",
")",
"fputs",
"(",
"\"x\"",
",",
"file",
")",
";",
"return",
";",
"}",
"gcc_assert",
"(",
"rf",
"!=",
"DEST_REGFILE_UNKNOWN",
")",
";",
"unitspec",
"=",
"c6x_get_unit_specifier",
"(",
"insn",
")",
";",
"half",
"=",
"rf",
"==",
"DEST_REGFILE_A",
"?",
"1",
":",
"2",
";",
"fprintf",
"(",
"file",
",",
"\".%c%d%s\"",
",",
"unitspec",
",",
"half",
",",
"cross",
"==",
"CROSS_Y",
"?",
"\"x\"",
":",
"\"\"",
")",
";",
"}",
"</s>"
] | [
"Prints",
"the",
"unit",
"specifier",
"field",
"."
] | [
"c6x",
"1",
"2",
"1",
"2",
"\".d%dt%d\"",
"\".\"",
"\"x\"",
"1",
"2",
"\".%c%d%s\"",
"\"x\"",
"\"\""
] | c6x | c6x_print_unit_specifier_field | c6x | VLIW | GCC | 16,608 | 205 | 1 | [] |
[
"<s>",
"bool",
"csky_symbol_mentioned_p",
"(",
"rtx",
"x",
")",
"{",
"const",
"char",
"*",
"fmt",
";",
"int",
"i",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SYMBOL_REF",
")",
"return",
"true",
";",
"fmt",
"=",
"GET_RTX_FORMAT",
"(",
"GET_CODE",
"(",
"x",
")",
")",
";",
"for",
"(",
"i",
"=",
"GET_RTX_LENGTH",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
")",
"{",
"if",
"(",
"fmt",
"[",
"i",
"]",
"==",
"'E'",
")",
"{",
"int",
"j",
";",
"for",
"(",
"j",
"=",
"XVECLEN",
"(",
"x",
",",
"i",
")",
"-",
"1",
";",
"j",
">=",
"0",
";",
"j",
"--",
")",
"if",
"(",
"csky_symbol_mentioned_p",
"(",
"XVECEXP",
"(",
"x",
",",
"i",
",",
"j",
")",
")",
")",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"fmt",
"[",
"i",
"]",
"==",
"'e'",
"&&",
"csky_symbol_mentioned_p",
"(",
"XEXP",
"(",
"x",
",",
"i",
")",
")",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"TRUE",
"if",
"X",
"references",
"a",
"SYMBOL_REF",
"."
] | [
"csky",
"1",
"0",
"1",
"0"
] | csky | csky_symbol_mentioned_p | csky | CPU | GCC | 16,609 | 138 | 1 | [] |
[
"<s>",
"InstructionCost",
"X86TTIImpl",
"::",
"getGatherScatterOpCost",
"(",
"unsigned",
"Opcode",
",",
"Type",
"*",
"SrcVTy",
",",
"const",
"Value",
"*",
"Ptr",
",",
"bool",
"VariableMask",
",",
"Align",
"Alignment",
",",
"TTI",
"::",
"TargetCostKind",
"CostKind",
",",
"const",
"Instruction",
"*",
"I",
"=",
"nullptr",
")",
"{",
"if",
"(",
"CostKind",
"!=",
"TTI",
"::",
"TCK_RecipThroughput",
")",
"{",
"if",
"(",
"(",
"Opcode",
"==",
"Instruction",
"::",
"Load",
"&&",
"isLegalMaskedGather",
"(",
"SrcVTy",
",",
"Align",
"(",
"Alignment",
")",
")",
")",
"||",
"(",
"Opcode",
"==",
"Instruction",
"::",
"Store",
"&&",
"isLegalMaskedScatter",
"(",
"SrcVTy",
",",
"Align",
"(",
"Alignment",
")",
")",
")",
")",
"return",
"1",
";",
"return",
"BaseT",
"::",
"getGatherScatterOpCost",
"(",
"Opcode",
",",
"SrcVTy",
",",
"Ptr",
",",
"VariableMask",
",",
"Alignment",
",",
"CostKind",
",",
"I",
")",
";",
"}",
"assert",
"(",
"SrcVTy",
"->",
"isVectorTy",
"(",
")",
"&&",
"\"Unexpected data type for Gather/Scatter\"",
")",
";",
"PointerType",
"*",
"PtrTy",
"=",
"dyn_cast",
"<",
"PointerType",
">",
"(",
"Ptr",
"->",
"getType",
"(",
")",
")",
";",
"if",
"(",
"!",
"PtrTy",
"&&",
"Ptr",
"->",
"getType",
"(",
")",
"->",
"isVectorTy",
"(",
")",
")",
"PtrTy",
"=",
"dyn_cast",
"<",
"PointerType",
">",
"(",
"cast",
"<",
"VectorType",
">",
"(",
"Ptr",
"->",
"getType",
"(",
")",
")",
"->",
"getElementType",
"(",
")",
")",
";",
"assert",
"(",
"PtrTy",
"&&",
"\"Unexpected type for Ptr argument\"",
")",
";",
"unsigned",
"AddressSpace",
"=",
"PtrTy",
"->",
"getAddressSpace",
"(",
")",
";",
"if",
"(",
"(",
"Opcode",
"==",
"Instruction",
"::",
"Load",
"&&",
"!",
"isLegalMaskedGather",
"(",
"SrcVTy",
",",
"Align",
"(",
"Alignment",
")",
")",
")",
"||",
"(",
"Opcode",
"==",
"Instruction",
"::",
"Store",
"&&",
"!",
"isLegalMaskedScatter",
"(",
"SrcVTy",
",",
"Align",
"(",
"Alignment",
")",
")",
")",
")",
"return",
"getGSScalarCost",
"(",
"Opcode",
",",
"SrcVTy",
",",
"VariableMask",
",",
"Alignment",
",",
"AddressSpace",
")",
";",
"return",
"getGSVectorCost",
"(",
"Opcode",
",",
"SrcVTy",
",",
"Ptr",
",",
"Alignment",
",",
"AddressSpace",
")",
";",
"}",
"</s>"
] | [
"Calculate",
"the",
"cost",
"of",
"Gather",
"/",
"Scatter",
"operation",
"."
] | [
"X86",
"X86",
"1",
"\"Unexpected data type for Gather/Scatter\"",
"\"Unexpected type for Ptr argument\""
] | X86TargetTransformInfo (2)1 | getGatherScatterOpCost | X86 | CPU | LLVM | 16,610 | 258 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"MSP430TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"const",
"std",
"::",
"string",
"&",
"Constraint",
",",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"default",
":",
"break",
";",
"case",
"'r'",
":",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"i8",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"MSP430",
"::",
"GR8RegClass",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"MSP430",
"::",
"GR16RegClass",
")",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"TRI",
",",
"Constraint",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"MSP430",
"MSP430",
"1",
"0",
"MVT::i8",
"0U",
"MSP430::GR8RegClass",
"0U",
"MSP430::GR16RegClass"
] | MSP430ISelLowering15 | getRegForInlineAsmConstraint | MSP430 | MPU | LLVM | 16,611 | 106 | 1 | [] |
[
"<s>",
"void",
"ix86_emit_swdivsf",
"(",
"rtx",
"res",
",",
"rtx",
"a",
",",
"rtx",
"b",
",",
"machine_mode",
"mode",
")",
"{",
"rtx",
"x0",
",",
"x1",
",",
"e0",
",",
"e1",
";",
"x0",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"e0",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"e1",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"x1",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"b",
"=",
"force_reg",
"(",
"mode",
",",
"b",
")",
";",
"if",
"(",
"mode",
"==",
"V16SFmode",
"||",
"mode",
"==",
"V8DFmode",
")",
"{",
"if",
"(",
"TARGET_AVX512ER",
")",
"{",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"x0",
",",
"gen_rtx_UNSPEC",
"(",
"mode",
",",
"gen_rtvec",
"(",
"1",
",",
"b",
")",
",",
"UNSPEC_RCP28",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"res",
",",
"gen_rtx_MULT",
"(",
"mode",
",",
"a",
",",
"x0",
")",
")",
")",
";",
"return",
";",
"}",
"else",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"x0",
",",
"gen_rtx_UNSPEC",
"(",
"mode",
",",
"gen_rtvec",
"(",
"1",
",",
"b",
")",
",",
"UNSPEC_RCP14",
")",
")",
")",
";",
"}",
"else",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"x0",
",",
"gen_rtx_UNSPEC",
"(",
"mode",
",",
"gen_rtvec",
"(",
"1",
",",
"b",
")",
",",
"UNSPEC_RCP",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"e0",
",",
"gen_rtx_MULT",
"(",
"mode",
",",
"x0",
",",
"b",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"e0",
",",
"gen_rtx_MULT",
"(",
"mode",
",",
"x0",
",",
"e0",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"e1",
",",
"gen_rtx_PLUS",
"(",
"mode",
",",
"x0",
",",
"x0",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"x1",
",",
"gen_rtx_MINUS",
"(",
"mode",
",",
"e1",
",",
"e0",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"res",
",",
"gen_rtx_MULT",
"(",
"mode",
",",
"a",
",",
"x1",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Output",
"code",
"to",
"perform",
"a",
"Newton-Rhapson",
"approximation",
"of",
"a",
"single",
"precision",
"floating",
"point",
"divide",
"[",
"http",
":",
"//en.wikipedia.org/wiki/N-th_root_algorithm",
"]",
"."
] | [
"i386",
"1",
"1",
"1"
] | i386-expand | ix86_emit_swdivsf | i386 | CPU | GCC | 16,612 | 253 | 1 | [] |
[
"<s>",
"bool",
"isReg",
"(",
")",
"const",
"override",
"{",
"return",
"Kind",
"==",
"REGISTER",
";",
"}",
"</s>"
] | [
"isReg",
"-",
"Is",
"this",
"a",
"register",
"operand",
"?"
] | [
"DLX"
] | DLXAsmParser | isReg | DLX | CPU | LLVM | 16,613 | 13 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"SICRegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
")",
"const",
"{",
"return",
"CSR_O32_RegMask",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"SIC",
"SIC"
] | SICRegisterInfo | getCallPreservedMask | SIC | CPU | LLVM | 16,614 | 22 | 1 | [] |
[
"<s>",
"bool",
"SparcAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"StringRef",
"IDVal",
"=",
"DirectiveID",
".",
"getString",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".byte\"",
")",
"return",
"parseDirectiveWord",
"(",
"1",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".half\"",
")",
"return",
"parseDirectiveWord",
"(",
"2",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".word\"",
")",
"return",
"parseDirectiveWord",
"(",
"4",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".nword\"",
")",
"return",
"parseDirectiveWord",
"(",
"is64Bit",
"(",
")",
"?",
"8",
":",
"4",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"if",
"(",
"is64Bit",
"(",
")",
"&&",
"IDVal",
"==",
"\".xword\"",
")",
"return",
"parseDirectiveWord",
"(",
"8",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".register\"",
")",
"{",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"\".proc\"",
")",
"{",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"Sparc",
"Sparc",
"\".byte\"",
"1",
"\".half\"",
"2",
"\".word\"",
"4",
"\".nword\"",
"8",
"4",
"\".xword\"",
"8",
"\".register\"",
"\".proc\""
] | SparcAsmParser12 | ParseDirective | Sparc | CPU | LLVM | 16,615 | 156 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"setPreservesAll",
"(",
")",
";",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"AU",
".",
"addRequired",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"ARM64"
] | ARM64CollectLOH1 | getAnalysisUsage | ARM64 | CPU | LLVM | 16,616 | 33 | 1 | [] |
[
"<s>",
"bool",
"Z80RegisterInfo",
"::",
"isFrameOffsetLegal",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"BaseReg",
",",
"int64_t",
"Offset",
")",
"const",
"{",
"return",
"isInt",
"<",
"8",
">",
"(",
"Offset",
")",
";",
"}",
"</s>"
] | [
"Determine",
"whether",
"a",
"given",
"base",
"register",
"plus",
"offset",
"immediate",
"is",
"encodable",
"to",
"resolve",
"a",
"frame",
"index",
"."
] | [
"Z80",
"Z80",
"8"
] | Z80RegisterInfo2 | isFrameOffsetLegal | Z80 | MPU | LLVM | 16,617 | 28 | 1 | [] |
[
"<s>",
"const",
"TVMSubtarget",
"*",
"getSubtargetImpl",
"(",
"const",
"Function",
"&",
"F",
")",
"const",
"override",
"{",
"return",
"&",
"Subtarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"TVM",
"TVM"
] | TVMTargetMachine | getSubtargetImpl | TVM | Virtual ISA | LLVM | 16,618 | 18 | 1 | [] |
[
"<s>",
"SDValue",
"AArch64TargetLowering",
"::",
"getTargetNode",
"(",
"GlobalAddressSDNode",
"*",
"N",
",",
"EVT",
"Ty",
",",
"SelectionDAG",
"&",
"DAG",
",",
"unsigned",
"Flag",
")",
"const",
"{",
"return",
"DAG",
".",
"getTargetGlobalAddress",
"(",
"N",
"->",
"getGlobal",
"(",
")",
",",
"SDLoc",
"(",
"N",
")",
",",
"Ty",
",",
"0",
",",
"Flag",
")",
";",
"}",
"</s>"
] | [
"Retrieve",
"the",
"target",
"node",
"this",
"edge",
"connects",
"to",
"."
] | [
"AArch64",
"AArch64",
"0"
] | AArch64ISelLowering105 | getTargetNode | AArch64 | CPU | LLVM | 16,619 | 45 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"getMachineCombinerPatterns",
"(",
"MachineInstr",
"&",
"Root",
",",
"SmallVectorImpl",
"<",
"MachineCombinerPattern",
">",
"&",
"Patterns",
",",
"bool",
"DoRegPressureReduce",
")",
"const",
"{",
"if",
"(",
"getMaddPatterns",
"(",
"Root",
",",
"Patterns",
")",
")",
"return",
"true",
";",
"if",
"(",
"getFMAPatterns",
"(",
"Root",
",",
"Patterns",
")",
")",
"return",
"true",
";",
"return",
"TargetInstrInfo",
"::",
"getMachineCombinerPatterns",
"(",
"Root",
",",
"Patterns",
",",
"DoRegPressureReduce",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"when",
"there",
"is",
"potentially",
"a",
"faster",
"code",
"sequence",
"for",
"an",
"instruction",
"chain",
"ending",
"in",
"Root",
"."
] | [
"AArch64",
"AArch64"
] | AArch64InstrInfo105 | getMachineCombinerPatterns | AArch64 | CPU | LLVM | 16,620 | 58 | 1 | [] |
[
"<s>",
"SDValue",
"RISCVTargetLowering",
"::",
"getAddr",
"(",
"NodeTy",
"*",
"N",
",",
"EVT",
"Ty",
",",
"SelectionDAG",
"&",
"DAG",
",",
"bool",
"IsLocal",
",",
"bool",
"CanDeriveFromPcc",
")",
"const",
"{",
"SDLoc",
"DL",
"(",
"N",
")",
";",
"if",
"(",
"RISCVABI",
"::",
"isCheriPureCapABI",
"(",
"Subtarget",
".",
"getTargetABI",
"(",
")",
")",
")",
"{",
"SDValue",
"Addr",
"=",
"getTargetNode",
"(",
"N",
",",
"DL",
",",
"Ty",
",",
"DAG",
",",
"0",
")",
";",
"if",
"(",
"IsLocal",
"&&",
"CanDeriveFromPcc",
")",
"{",
"return",
"SDValue",
"(",
"DAG",
".",
"getMachineNode",
"(",
"RISCV",
"::",
"PseudoCLLC",
",",
"DL",
",",
"Ty",
",",
"Addr",
")",
",",
"0",
")",
";",
"}",
"SDValue",
"Load",
"=",
"SDValue",
"(",
"DAG",
".",
"getMachineNode",
"(",
"RISCV",
"::",
"PseudoCLGC",
",",
"DL",
",",
"Ty",
",",
"Addr",
")",
",",
"0",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"MachineMemOperand",
"*",
"MemOp",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getGOT",
"(",
"MF",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
"|",
"MachineMemOperand",
"::",
"MODereferenceable",
"|",
"MachineMemOperand",
"::",
"MOInvariant",
",",
"LLT",
"(",
"Ty",
".",
"getSimpleVT",
"(",
")",
")",
",",
"Align",
"(",
"Ty",
".",
"getFixedSizeInBits",
"(",
")",
"/",
"8",
")",
")",
";",
"DAG",
".",
"setNodeMemRefs",
"(",
"cast",
"<",
"MachineSDNode",
">",
"(",
"Load",
".",
"getNode",
"(",
")",
")",
",",
"{",
"MemOp",
"}",
")",
";",
"return",
"Load",
";",
"}",
"if",
"(",
"isPositionIndependent",
"(",
")",
")",
"{",
"SDValue",
"Addr",
"=",
"getTargetNode",
"(",
"N",
",",
"DL",
",",
"Ty",
",",
"DAG",
",",
"0",
")",
";",
"if",
"(",
"IsLocal",
")",
"return",
"SDValue",
"(",
"DAG",
".",
"getMachineNode",
"(",
"RISCV",
"::",
"PseudoLLA",
",",
"DL",
",",
"Ty",
",",
"Addr",
")",
",",
"0",
")",
";",
"SDValue",
"Load",
"=",
"SDValue",
"(",
"DAG",
".",
"getMachineNode",
"(",
"RISCV",
"::",
"PseudoLA",
",",
"DL",
",",
"Ty",
",",
"Addr",
")",
",",
"0",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"MachineMemOperand",
"*",
"MemOp",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getGOT",
"(",
"MF",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
"|",
"MachineMemOperand",
"::",
"MODereferenceable",
"|",
"MachineMemOperand",
"::",
"MOInvariant",
",",
"LLT",
"(",
"Ty",
".",
"getSimpleVT",
"(",
")",
")",
",",
"Align",
"(",
"Ty",
".",
"getFixedSizeInBits",
"(",
")",
"/",
"8",
")",
")",
";",
"DAG",
".",
"setNodeMemRefs",
"(",
"cast",
"<",
"MachineSDNode",
">",
"(",
"Load",
".",
"getNode",
"(",
")",
")",
",",
"{",
"MemOp",
"}",
")",
";",
"return",
"Load",
";",
"}",
"switch",
"(",
"getTargetMachine",
"(",
")",
".",
"getCodeModel",
"(",
")",
")",
"{",
"default",
":",
"report_fatal_error",
"(",
"\"Unsupported code model for lowering\"",
")",
";",
"case",
"CodeModel",
"::",
"Small",
":",
"{",
"SDValue",
"AddrHi",
"=",
"getTargetNode",
"(",
"N",
",",
"DL",
",",
"Ty",
",",
"DAG",
",",
"RISCVII",
"::",
"MO_HI",
")",
";",
"SDValue",
"AddrLo",
"=",
"getTargetNode",
"(",
"N",
",",
"DL",
",",
"Ty",
",",
"DAG",
",",
"RISCVII",
"::",
"MO_LO",
")",
";",
"SDValue",
"MNHi",
"=",
"SDValue",
"(",
"DAG",
".",
"getMachineNode",
"(",
"RISCV",
"::",
"LUI",
",",
"DL",
",",
"Ty",
",",
"AddrHi",
")",
",",
"0",
")",
";",
"return",
"SDValue",
"(",
"DAG",
".",
"getMachineNode",
"(",
"RISCV",
"::",
"ADDI",
",",
"DL",
",",
"Ty",
",",
"MNHi",
",",
"AddrLo",
")",
",",
"0",
")",
";",
"}",
"case",
"CodeModel",
"::",
"Medium",
":",
"{",
"SDValue",
"Addr",
"=",
"getTargetNode",
"(",
"N",
",",
"DL",
",",
"Ty",
",",
"DAG",
",",
"0",
")",
";",
"return",
"SDValue",
"(",
"DAG",
".",
"getMachineNode",
"(",
"RISCV",
"::",
"PseudoLLA",
",",
"DL",
",",
"Ty",
",",
"Addr",
")",
",",
"0",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"address",
"accessed",
"by",
"this",
"recipe",
"."
] | [
"RISCV",
"RISCV",
"RISCVABI::isCheriPureCapABI",
"0",
"RISCV::PseudoCLLC",
"0",
"RISCV::PseudoCLGC",
"0",
"8",
"0",
"RISCV::PseudoLLA",
"0",
"RISCV::PseudoLA",
"0",
"8",
"\"Unsupported code model for lowering\"",
"RISCVII::MO_HI",
"RISCVII::MO_LO",
"RISCV::LUI",
"0",
"RISCV::ADDI",
"0",
"0",
"RISCV::PseudoLLA",
"0"
] | RISCVISelLowering42 | getAddr | RISCV | CPU | LLVM | 16,621 | 502 | 1 | [] |
[
"<s>",
"static",
"void",
"s390_reorg",
"(",
"void",
")",
"{",
"bool",
"pool_overflow",
"=",
"false",
";",
"int",
"hw_before",
",",
"hw_after",
";",
"split_all_insns_noflow",
"(",
")",
";",
"for",
"(",
";",
";",
")",
"{",
"struct",
"constant_pool",
"*",
"pool",
"=",
"NULL",
";",
"if",
"(",
"!",
"pool_overflow",
")",
"{",
"pool",
"=",
"s390_mainpool_start",
"(",
")",
";",
"if",
"(",
"!",
"pool",
")",
"pool_overflow",
"=",
"true",
";",
"}",
"if",
"(",
"pool_overflow",
")",
"pool",
"=",
"s390_chunkify_start",
"(",
")",
";",
"if",
"(",
"!",
"TARGET_CPU_ZARCH",
"&&",
"s390_split_branches",
"(",
")",
")",
"{",
"if",
"(",
"pool_overflow",
")",
"s390_chunkify_cancel",
"(",
"pool",
")",
";",
"else",
"s390_mainpool_cancel",
"(",
"pool",
")",
";",
"continue",
";",
"}",
"if",
"(",
"pool_overflow",
")",
"s390_chunkify_finish",
"(",
"pool",
")",
";",
"else",
"s390_mainpool_finish",
"(",
"pool",
")",
";",
"cfun",
"->",
"machine",
"->",
"split_branches_pending_p",
"=",
"false",
";",
"break",
";",
"}",
"if",
"(",
"TARGET_CPU_ZARCH",
")",
"{",
"rtx_insn",
"*",
"insn",
",",
"*",
"target",
";",
"rtx",
"label",
";",
"for",
"(",
"insn",
"=",
"get_insns",
"(",
")",
";",
"insn",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"{",
"label",
"=",
"s390_execute_label",
"(",
"insn",
")",
";",
"if",
"(",
"!",
"label",
")",
"continue",
";",
"gcc_assert",
"(",
"label",
"!=",
"const0_rtx",
")",
";",
"target",
"=",
"emit_label",
"(",
"XEXP",
"(",
"label",
",",
"0",
")",
")",
";",
"INSN_ADDRESSES_NEW",
"(",
"target",
",",
"-",
"1",
")",
";",
"target",
"=",
"emit_insn",
"(",
"s390_execute_target",
"(",
"insn",
")",
")",
";",
"INSN_ADDRESSES_NEW",
"(",
"target",
",",
"-",
"1",
")",
";",
"}",
"}",
"s390_optimize_prologue",
"(",
")",
";",
"if",
"(",
"s390_tune",
"==",
"PROCESSOR_2097_Z10",
"||",
"s390_tune",
"==",
"PROCESSOR_2817_Z196",
"||",
"s390_tune",
"==",
"PROCESSOR_2827_ZEC12",
")",
"{",
"rtx_insn",
"*",
"insn",
";",
"bool",
"insn_added_p",
"=",
"false",
";",
"shorten_branches",
"(",
"get_insns",
"(",
")",
")",
";",
"for",
"(",
"insn",
"=",
"get_insns",
"(",
")",
";",
"insn",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"!",
"INSN_P",
"(",
"insn",
")",
"||",
"INSN_CODE",
"(",
"insn",
")",
"<=",
"0",
")",
"continue",
";",
"if",
"(",
"JUMP_P",
"(",
"insn",
")",
")",
"insn_added_p",
"|=",
"s390_fix_long_loop_prediction",
"(",
"insn",
")",
";",
"if",
"(",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"PARALLEL",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"SET",
")",
"&&",
"s390_tune",
"==",
"PROCESSOR_2097_Z10",
")",
"insn_added_p",
"|=",
"s390_z10_optimize_cmp",
"(",
"insn",
")",
";",
"}",
"if",
"(",
"insn_added_p",
")",
"shorten_branches",
"(",
"get_insns",
"(",
")",
")",
";",
"}",
"s390_function_num_hotpatch_hw",
"(",
"current_function_decl",
",",
"&",
"hw_before",
",",
"&",
"hw_after",
")",
";",
"if",
"(",
"hw_after",
">",
"0",
")",
"{",
"rtx_insn",
"*",
"insn",
";",
"for",
"(",
"insn",
"=",
"get_insns",
"(",
")",
";",
"insn",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"NOTE_P",
"(",
"insn",
")",
"&&",
"NOTE_KIND",
"(",
"insn",
")",
"==",
"NOTE_INSN_FUNCTION_BEG",
")",
"break",
";",
"}",
"gcc_assert",
"(",
"insn",
")",
";",
"while",
"(",
"hw_after",
">",
"0",
")",
"{",
"if",
"(",
"hw_after",
">=",
"3",
"&&",
"TARGET_CPU_ZARCH",
")",
"{",
"insn",
"=",
"emit_insn_after",
"(",
"gen_nop_6_byte",
"(",
")",
",",
"insn",
")",
";",
"hw_after",
"-=",
"3",
";",
"}",
"else",
"if",
"(",
"hw_after",
">=",
"2",
")",
"{",
"insn",
"=",
"emit_insn_after",
"(",
"gen_nop_4_byte",
"(",
")",
",",
"insn",
")",
";",
"hw_after",
"-=",
"2",
";",
"}",
"else",
"{",
"insn",
"=",
"emit_insn_after",
"(",
"gen_nop_2_byte",
"(",
")",
",",
"insn",
")",
";",
"hw_after",
"-=",
"1",
";",
"}",
"}",
"gcc_assert",
"(",
"hw_after",
"==",
"0",
")",
";",
"}",
"}",
"</s>"
] | [
"Perform",
"machine-dependent",
"processing",
"."
] | [
"s390",
"0",
"1",
"1",
"0",
"0",
"0",
"3",
"3",
"2",
"2",
"1",
"0"
] | s3904 | s390_reorg | s390 | MPU | GCC | 16,622 | 492 | 1 | [] |
[
"<s>",
"bool",
"AArch64FrameLowering",
"::",
"canUseRedZone",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"if",
"(",
"!",
"EnableRedZone",
")",
"return",
"false",
";",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"NoRedZone",
")",
")",
"return",
"false",
";",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"AArch64FunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"AArch64FunctionInfo",
">",
"(",
")",
";",
"uint64_t",
"NumBytes",
"=",
"AFI",
"->",
"getLocalStackSize",
"(",
")",
";",
"return",
"!",
"(",
"MFI",
".",
"hasCalls",
"(",
")",
"||",
"hasFP",
"(",
"MF",
")",
"||",
"NumBytes",
">",
"128",
"||",
"getSVEStackSize",
"(",
"MF",
")",
")",
";",
"}",
"</s>"
] | [
"Can",
"this",
"function",
"use",
"the",
"red",
"zone",
"for",
"local",
"allocations",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"128"
] | AArch64FrameLowering100 | canUseRedZone | AArch64 | CPU | LLVM | 16,623 | 97 | 1 | [] |
[
"<s>",
"bool",
"isImm",
"(",
")",
"const",
"{",
"return",
"!",
"OpToFold",
";",
"}",
"</s>"
] | [
"isImm",
"-",
"Is",
"this",
"an",
"immediate",
"operand",
"?"
] | [
"R600"
] | SIFoldOperands18 | isImm | R600 | GPU | LLVM | 16,624 | 11 | 1 | [] |
[
"<s>",
"unsigned",
"WDC65816InstrInfo",
"::",
"getGlobalBaseReg",
"(",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"WDC65816MachineFunctionInfo",
"*",
"WDC65816FI",
"=",
"MF",
"->",
"getInfo",
"<",
"WDC65816MachineFunctionInfo",
">",
"(",
")",
";",
"return",
"WDC65816FI",
"->",
"getGlobalBaseReg",
"(",
")",
";",
"unsigned",
"GlobalBaseReg",
"=",
"WDC65816FI",
"->",
"getGlobalBaseReg",
"(",
")",
";",
"if",
"(",
"GlobalBaseReg",
"!=",
"0",
")",
"return",
"GlobalBaseReg",
";",
"MachineBasicBlock",
"&",
"FirstMBB",
"=",
"MF",
"->",
"front",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"FirstMBB",
".",
"begin",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"RegInfo",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"GlobalBaseReg",
"=",
"RegInfo",
".",
"createVirtualRegister",
"(",
"&",
"SP",
"::",
"IntRegsRegClass",
")",
";",
"DebugLoc",
"dl",
";",
"BuildMI",
"(",
"FirstMBB",
",",
"MBBI",
",",
"dl",
",",
"get",
"(",
"SP",
"::",
"GETPCX",
")",
",",
"GlobalBaseReg",
")",
";",
"SparcFI",
"->",
"setGlobalBaseReg",
"(",
"GlobalBaseReg",
")",
";",
"return",
"GlobalBaseReg",
";",
"}",
"</s>"
] | [
"getGlobalBaseReg",
"-",
"Return",
"a",
"virtual",
"register",
"initialized",
"with",
"the",
"the",
"global",
"base",
"register",
"value",
"."
] | [
"WDC65816",
"WDC",
"WDC",
"WDC",
"WDC",
"WDC",
"WDC",
"0",
"SP::IntRegsRegClass",
"SP::GETPCX"
] | WDC65816InstrInfo | getGlobalBaseReg | WDC65816 | MPU | LLVM | 16,625 | 124 | 1 | [] |
[
"<s>",
"static",
"int",
"pad_groups",
"(",
"FILE",
"*",
"dump",
",",
"int",
"sched_verbose",
",",
"rtx_insn",
"*",
"prev_head_insn",
",",
"rtx_insn",
"*",
"tail",
")",
"{",
"rtx_insn",
"*",
"insn",
",",
"*",
"next_insn",
";",
"rtx",
"nop",
";",
"int",
"issue_rate",
";",
"int",
"can_issue_more",
";",
"int",
"group_end",
";",
"int",
"group_count",
"=",
"0",
";",
"issue_rate",
"=",
"rs6000_issue_rate",
"(",
")",
";",
"can_issue_more",
"=",
"issue_rate",
";",
"insn",
"=",
"get_next_active_insn",
"(",
"prev_head_insn",
",",
"tail",
")",
";",
"next_insn",
"=",
"get_next_active_insn",
"(",
"insn",
",",
"tail",
")",
";",
"while",
"(",
"insn",
"!=",
"NULL_RTX",
")",
"{",
"can_issue_more",
"=",
"rs6000_variable_issue",
"(",
"dump",
",",
"sched_verbose",
",",
"insn",
",",
"can_issue_more",
")",
";",
"group_end",
"=",
"(",
"next_insn",
"==",
"NULL_RTX",
"||",
"GET_MODE",
"(",
"next_insn",
")",
"==",
"TImode",
")",
";",
"if",
"(",
"next_insn",
"==",
"NULL_RTX",
")",
"break",
";",
"if",
"(",
"group_end",
")",
"{",
"if",
"(",
"can_issue_more",
"&&",
"(",
"rs6000_sched_insert_nops",
"==",
"sched_finish_pad_groups",
")",
"&&",
"!",
"insn_terminates_group_p",
"(",
"insn",
",",
"current_group",
")",
"&&",
"!",
"insn_terminates_group_p",
"(",
"next_insn",
",",
"previous_group",
")",
")",
"{",
"if",
"(",
"!",
"is_branch_slot_insn",
"(",
"next_insn",
")",
")",
"can_issue_more",
"--",
";",
"while",
"(",
"can_issue_more",
")",
"{",
"nop",
"=",
"gen_nop",
"(",
")",
";",
"emit_insn_before",
"(",
"nop",
",",
"next_insn",
")",
";",
"can_issue_more",
"--",
";",
"}",
"}",
"can_issue_more",
"=",
"issue_rate",
";",
"group_count",
"++",
";",
"}",
"insn",
"=",
"next_insn",
";",
"next_insn",
"=",
"get_next_active_insn",
"(",
"insn",
",",
"tail",
")",
";",
"}",
"return",
"group_count",
";",
"}",
"</s>"
] | [
"Scan",
"the",
"insn",
"sequence",
"between",
"PREV_HEAD_INSN",
"and",
"TAIL",
"and",
"examine",
"the",
"dispatch",
"group",
"boundaries",
"that",
"the",
"scheduler",
"had",
"marked",
".",
"Pad",
"with",
"nops",
"any",
"dispatch",
"groups",
"which",
"have",
"vacant",
"issue",
"slots",
",",
"in",
"order",
"to",
"force",
"the",
"scheduler",
"'s",
"grouping",
"on",
"the",
"processor",
"dispatcher",
".",
"The",
"function",
"returns",
"the",
"number",
"of",
"dispatch",
"groups",
"found",
"."
] | [
"powerpcspe",
"0"
] | powerpcspe | pad_groups | powerpcspe | CPU | GCC | 16,626 | 207 | 1 | [] |
[
"<s>",
"void",
"rs6000_emit_swsqrt",
"(",
"rtx",
"dst",
",",
"rtx",
"src",
",",
"bool",
"recip",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"src",
")",
";",
"rtx",
"e",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"rtx",
"g",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"rtx",
"h",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"int",
"passes",
"=",
"(",
"TARGET_RECIP_PRECISION",
")",
"?",
"1",
":",
"3",
";",
"if",
"(",
"mode",
"==",
"DFmode",
"||",
"mode",
"==",
"V2DFmode",
")",
"passes",
"++",
";",
"int",
"i",
";",
"rtx",
"mhalf",
";",
"enum",
"insn_code",
"code",
"=",
"optab_handler",
"(",
"smul_optab",
",",
"mode",
")",
";",
"insn_gen_fn",
"gen_mul",
"=",
"GEN_FCN",
"(",
"code",
")",
";",
"gcc_assert",
"(",
"code",
"!=",
"CODE_FOR_nothing",
")",
";",
"mhalf",
"=",
"rs6000_load_constant_and_splat",
"(",
"mode",
",",
"dconsthalf",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"e",
",",
"gen_rtx_UNSPEC",
"(",
"mode",
",",
"gen_rtvec",
"(",
"1",
",",
"src",
")",
",",
"UNSPEC_RSQRT",
")",
")",
")",
";",
"if",
"(",
"!",
"recip",
")",
"{",
"rtx",
"zero",
"=",
"force_reg",
"(",
"mode",
",",
"CONST0_RTX",
"(",
"mode",
")",
")",
";",
"if",
"(",
"mode",
"==",
"SFmode",
")",
"{",
"rtx",
"target",
"=",
"emit_conditional_move",
"(",
"e",
",",
"GT",
",",
"src",
",",
"zero",
",",
"mode",
",",
"e",
",",
"zero",
",",
"mode",
",",
"0",
")",
";",
"if",
"(",
"target",
"!=",
"e",
")",
"emit_move_insn",
"(",
"e",
",",
"target",
")",
";",
"}",
"else",
"{",
"rtx",
"cond",
"=",
"gen_rtx_GT",
"(",
"VOIDmode",
",",
"e",
",",
"zero",
")",
";",
"rs6000_emit_vector_cond_expr",
"(",
"e",
",",
"e",
",",
"zero",
",",
"cond",
",",
"src",
",",
"zero",
")",
";",
"}",
"}",
"emit_insn",
"(",
"gen_mul",
"(",
"g",
",",
"e",
",",
"src",
")",
")",
";",
"emit_insn",
"(",
"gen_mul",
"(",
"h",
",",
"e",
",",
"mhalf",
")",
")",
";",
"if",
"(",
"recip",
")",
"{",
"if",
"(",
"passes",
"==",
"1",
")",
"{",
"rtx",
"t",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"rs6000_emit_nmsub",
"(",
"t",
",",
"g",
",",
"h",
",",
"mhalf",
")",
";",
"rs6000_emit_madd",
"(",
"dst",
",",
"e",
",",
"t",
",",
"e",
")",
";",
"}",
"else",
"{",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"passes",
";",
"i",
"++",
")",
"{",
"rtx",
"t1",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"rtx",
"g1",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"rtx",
"h1",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"rs6000_emit_nmsub",
"(",
"t1",
",",
"g",
",",
"h",
",",
"mhalf",
")",
";",
"rs6000_emit_madd",
"(",
"g1",
",",
"g",
",",
"t1",
",",
"g",
")",
";",
"rs6000_emit_madd",
"(",
"h1",
",",
"h",
",",
"t1",
",",
"h",
")",
";",
"g",
"=",
"g1",
";",
"h",
"=",
"h1",
";",
"}",
"emit_insn",
"(",
"gen_add3_insn",
"(",
"dst",
",",
"h",
",",
"h",
")",
")",
";",
"}",
"}",
"else",
"{",
"rtx",
"t",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"rs6000_emit_nmsub",
"(",
"t",
",",
"g",
",",
"h",
",",
"mhalf",
")",
";",
"rs6000_emit_madd",
"(",
"dst",
",",
"g",
",",
"t",
",",
"g",
")",
";",
"}",
"return",
";",
"}",
"</s>"
] | [
"Goldschmidt",
"'s",
"Algorithm",
"for",
"single/double-precision",
"floating",
"point",
"sqrt",
"and",
"rsqrt",
".",
"Assumes",
"no",
"trapping",
"math",
"and",
"finite",
"arguments",
"."
] | [
"powerpcspe",
"1",
"3",
"1",
"0",
"1",
"0"
] | powerpcspe | rs6000_emit_swsqrt | powerpcspe | CPU | GCC | 16,627 | 426 | 1 | [] |
[
"<s>",
"static",
"tree",
"arm_handle_cmse_nonsecure_call",
"(",
"tree",
"*",
"node",
",",
"tree",
"name",
",",
"tree",
",",
"int",
",",
"bool",
"*",
"no_add_attrs",
")",
"{",
"tree",
"decl",
"=",
"NULL_TREE",
",",
"fntype",
"=",
"NULL_TREE",
";",
"tree",
"type",
";",
"if",
"(",
"!",
"use_cmse",
")",
"{",
"*",
"no_add_attrs",
"=",
"true",
";",
"warning",
"(",
"OPT_Wattributes",
",",
"\"%qE attribute ignored without %<-mcmse%> \"",
"\"option\"",
",",
"name",
")",
";",
"return",
"NULL_TREE",
";",
"}",
"if",
"(",
"TREE_CODE",
"(",
"*",
"node",
")",
"==",
"VAR_DECL",
"||",
"TREE_CODE",
"(",
"*",
"node",
")",
"==",
"TYPE_DECL",
")",
"{",
"decl",
"=",
"*",
"node",
";",
"fntype",
"=",
"TREE_TYPE",
"(",
"decl",
")",
";",
"}",
"while",
"(",
"fntype",
"!=",
"NULL_TREE",
"&&",
"TREE_CODE",
"(",
"fntype",
")",
"==",
"POINTER_TYPE",
")",
"fntype",
"=",
"TREE_TYPE",
"(",
"fntype",
")",
";",
"if",
"(",
"!",
"decl",
"||",
"TREE_CODE",
"(",
"fntype",
")",
"!=",
"FUNCTION_TYPE",
")",
"{",
"warning",
"(",
"OPT_Wattributes",
",",
"\"%qE attribute only applies to base type of a \"",
"\"function pointer\"",
",",
"name",
")",
";",
"*",
"no_add_attrs",
"=",
"true",
";",
"return",
"NULL_TREE",
";",
"}",
"*",
"no_add_attrs",
"|=",
"cmse_func_args_or_return_in_stack",
"(",
"NULL",
",",
"name",
",",
"fntype",
")",
";",
"if",
"(",
"*",
"no_add_attrs",
")",
"return",
"NULL_TREE",
";",
"type",
"=",
"TREE_TYPE",
"(",
"decl",
")",
";",
"type",
"=",
"build_distinct_type_copy",
"(",
"type",
")",
";",
"TREE_TYPE",
"(",
"decl",
")",
"=",
"type",
";",
"fntype",
"=",
"type",
";",
"while",
"(",
"TREE_CODE",
"(",
"fntype",
")",
"!=",
"FUNCTION_TYPE",
")",
"{",
"type",
"=",
"fntype",
";",
"fntype",
"=",
"TREE_TYPE",
"(",
"fntype",
")",
";",
"fntype",
"=",
"build_distinct_type_copy",
"(",
"fntype",
")",
";",
"TREE_TYPE",
"(",
"type",
")",
"=",
"fntype",
";",
"}",
"tree",
"attrs",
"=",
"tree_cons",
"(",
"get_identifier",
"(",
"\"cmse_nonsecure_call\"",
")",
",",
"NULL_TREE",
",",
"TYPE_ATTRIBUTES",
"(",
"fntype",
")",
")",
";",
"TYPE_ATTRIBUTES",
"(",
"fntype",
")",
"=",
"attrs",
";",
"return",
"NULL_TREE",
";",
"}",
"</s>"
] | [
"Called",
"upon",
"detection",
"of",
"the",
"use",
"of",
"the",
"cmse_nonsecure_call",
"attribute",
",",
"this",
"function",
"will",
"check",
"whether",
"the",
"attribute",
"is",
"allowed",
"here",
"and",
"will",
"add",
"the",
"attribute",
"to",
"the",
"function",
"type",
"tree",
"or",
"otherwise",
"issue",
"a",
"diagnostic",
".",
"The",
"reason",
"we",
"check",
"this",
"at",
"declaration",
"time",
"is",
"to",
"only",
"allow",
"the",
"use",
"of",
"the",
"attribute",
"with",
"declarations",
"of",
"function",
"pointers",
"and",
"not",
"function",
"declarations",
".",
"This",
"function",
"checks",
"NODE",
"is",
"of",
"the",
"expected",
"type",
"and",
"issues",
"diagnostics",
"otherwise",
"using",
"NAME",
".",
"If",
"it",
"is",
"not",
"of",
"the",
"expected",
"type",
"*",
"NO_ADD_ATTRS",
"will",
"be",
"set",
"to",
"true",
"."
] | [
"arm",
"\"%qE attribute ignored without %<-mcmse%> \"",
"\"option\"",
"\"%qE attribute only applies to base type of a \"",
"\"function pointer\"",
"\"cmse_nonsecure_call\""
] | arm | arm_handle_cmse_nonsecure_call | arm | CPU | GCC | 16,628 | 251 | 1 | [] |
[
"<s>",
"static",
"rtx",
"moxie_function_arg",
"(",
"cumulative_args_t",
"cum_v",
",",
"const",
"function_arg_info",
"&",
"arg",
")",
"{",
"CUMULATIVE_ARGS",
"*",
"cum",
"=",
"get_cumulative_args",
"(",
"cum_v",
")",
";",
"if",
"(",
"*",
"cum",
"<",
"8",
")",
"return",
"gen_rtx_REG",
"(",
"arg",
".",
"mode",
",",
"*",
"cum",
")",
";",
"else",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Return",
"the",
"next",
"register",
"to",
"be",
"used",
"to",
"hold",
"a",
"function",
"argument",
"or",
"NULL_RTX",
"if",
"there",
"'s",
"no",
"more",
"space",
"."
] | [
"moxie",
"8"
] | moxie | moxie_function_arg | moxie | CPU | GCC | 16,629 | 45 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"ARMBaseRegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
"CC",
")",
"const",
"{",
"const",
"ARMSubtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"GHC",
")",
"return",
"CSR_NoRegs_RegMask",
";",
"return",
"STI",
".",
"isTargetDarwin",
"(",
")",
"?",
"CSR_iOS_RegMask",
":",
"CSR_AAPCS_RegMask",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM"
] | ARMBaseRegisterInfo5 | getCallPreservedMask | ARM | CPU | LLVM | 16,630 | 56 | 1 | [] |
[
"<s>",
"unsigned",
"SIInstrInfo",
"::",
"removeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"int",
"*",
"BytesRemoved",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"getFirstTerminator",
"(",
")",
";",
"unsigned",
"Count",
"=",
"0",
";",
"unsigned",
"RemovedSize",
"=",
"0",
";",
"while",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"Next",
"=",
"std",
"::",
"next",
"(",
"I",
")",
";",
"RemovedSize",
"+=",
"getInstSizeInBytes",
"(",
"*",
"I",
")",
";",
"I",
"->",
"eraseFromParent",
"(",
")",
";",
"++",
"Count",
";",
"I",
"=",
"Next",
";",
"}",
"if",
"(",
"BytesRemoved",
")",
"*",
"BytesRemoved",
"=",
"RemovedSize",
";",
"return",
"Count",
";",
"}",
"</s>"
] | [
"Remove",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"the",
"specific",
"MBB",
"."
] | [
"AMDGPU",
"SI",
"0",
"0"
] | SIInstrInfo120 | removeBranch | AMDGPU | GPU | LLVM | 16,631 | 94 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"gen_prefix",
"(",
"tree",
"decl",
")",
"{",
"if",
"(",
"DECL_ONE_ONLY",
"(",
"decl",
")",
")",
"return",
"NULL",
";",
"if",
"(",
"has_attr",
"(",
"\"section\"",
",",
"decl",
")",
")",
"return",
"NULL",
";",
"if",
"(",
"has_attr",
"(",
"ATTR_LOWER",
",",
"decl",
")",
")",
"return",
"lower_prefix",
";",
"if",
"(",
"!",
"msp430x",
")",
"return",
"NULL",
";",
"if",
"(",
"has_attr",
"(",
"ATTR_UPPER",
",",
"decl",
")",
")",
"return",
"upper_prefix",
";",
"if",
"(",
"has_attr",
"(",
"ATTR_EITHER",
",",
"decl",
")",
")",
"return",
"either_prefix",
";",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"==",
"FUNCTION_DECL",
")",
"{",
"if",
"(",
"msp430_code_region",
"==",
"LOWER",
")",
"return",
"lower_prefix",
";",
"if",
"(",
"msp430_code_region",
"==",
"UPPER",
")",
"return",
"upper_prefix",
";",
"if",
"(",
"msp430_code_region",
"==",
"EITHER",
")",
"return",
"either_prefix",
";",
"}",
"else",
"{",
"if",
"(",
"msp430_data_region",
"==",
"LOWER",
")",
"return",
"lower_prefix",
";",
"if",
"(",
"msp430_data_region",
"==",
"UPPER",
")",
"return",
"upper_prefix",
";",
"if",
"(",
"msp430_data_region",
"==",
"EITHER",
")",
"return",
"either_prefix",
";",
"}",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"Generate",
"a",
"prefix",
"for",
"a",
"section",
"name",
",",
"based",
"upon",
"the",
"region",
"into",
"which",
"the",
"object",
"should",
"be",
"placed",
"."
] | [
"msp430",
"\"section\""
] | msp4303 | gen_prefix | msp430 | MPU | GCC | 16,632 | 148 | 1 | [] |
[
"<s>",
"void",
"X86RegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"unsigned",
"FIOperandNum",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"X86FrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"int",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"getIndex",
"(",
")",
";",
"unsigned",
"BasePtr",
";",
"unsigned",
"Opc",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"bool",
"AfterFPPop",
"=",
"Opc",
"==",
"X86",
"::",
"TAILJMPm64",
"||",
"Opc",
"==",
"X86",
"::",
"TAILJMPm",
"||",
"Opc",
"==",
"X86",
"::",
"TCRETURNmi",
"||",
"Opc",
"==",
"X86",
"::",
"TCRETURNmi64",
";",
"if",
"(",
"hasBasePointer",
"(",
"MF",
")",
")",
"BasePtr",
"=",
"(",
"FrameIndex",
"<",
"0",
"?",
"FramePtr",
":",
"getBaseRegister",
"(",
")",
")",
";",
"else",
"if",
"(",
"needsStackRealignment",
"(",
"MF",
")",
")",
"BasePtr",
"=",
"(",
"FrameIndex",
"<",
"0",
"?",
"FramePtr",
":",
"StackPtr",
")",
";",
"else",
"if",
"(",
"AfterFPPop",
")",
"BasePtr",
"=",
"StackPtr",
";",
"else",
"BasePtr",
"=",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"?",
"FramePtr",
":",
"StackPtr",
")",
";",
"unsigned",
"IgnoredFrameReg",
";",
"if",
"(",
"Opc",
"==",
"TargetOpcode",
"::",
"LOCAL_ESCAPE",
")",
"{",
"MachineOperand",
"&",
"FI",
"=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
";",
"int",
"Offset",
";",
"Offset",
"=",
"TFI",
"->",
"getFrameIndexReference",
"(",
"MF",
",",
"FrameIndex",
",",
"IgnoredFrameReg",
")",
";",
"FI",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"return",
";",
"}",
"if",
"(",
"Opc",
"==",
"X86",
"::",
"LEA64_32r",
"&&",
"X86",
"::",
"GR32RegClass",
".",
"contains",
"(",
"BasePtr",
")",
")",
"BasePtr",
"=",
"getX86SubSuperRegister",
"(",
"BasePtr",
",",
"64",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"ChangeToRegister",
"(",
"BasePtr",
",",
"false",
")",
";",
"int",
"FIOffset",
";",
"if",
"(",
"AfterFPPop",
")",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"FIOffset",
"=",
"MFI",
"->",
"getObjectOffset",
"(",
"FrameIndex",
")",
"-",
"TFI",
"->",
"getOffsetOfLocalArea",
"(",
")",
";",
"}",
"else",
"FIOffset",
"=",
"TFI",
"->",
"getFrameIndexReference",
"(",
"MF",
",",
"FrameIndex",
",",
"IgnoredFrameReg",
")",
";",
"if",
"(",
"BasePtr",
"==",
"StackPtr",
")",
"FIOffset",
"+=",
"SPAdj",
";",
"if",
"(",
"Opc",
"==",
"TargetOpcode",
"::",
"STACKMAP",
"||",
"Opc",
"==",
"TargetOpcode",
"::",
"PATCHPOINT",
")",
"{",
"assert",
"(",
"BasePtr",
"==",
"FramePtr",
"&&",
"\"Expected the FP as base register\"",
")",
";",
"int64_t",
"Offset",
"=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"getImm",
"(",
")",
"+",
"FIOffset",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"return",
";",
"}",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"3",
")",
".",
"isImm",
"(",
")",
")",
"{",
"int",
"Imm",
"=",
"(",
"int",
")",
"(",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"3",
")",
".",
"getImm",
"(",
")",
")",
";",
"int",
"Offset",
"=",
"FIOffset",
"+",
"Imm",
";",
"assert",
"(",
"(",
"!",
"Is64Bit",
"||",
"isInt",
"<",
"32",
">",
"(",
"(",
"long",
"long",
")",
"FIOffset",
"+",
"Imm",
")",
")",
"&&",
"\"Requesting 64-bit offset in 32-bit immediate!\"",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"3",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"}",
"else",
"{",
"uint64_t",
"Offset",
"=",
"FIOffset",
"+",
"(",
"uint64_t",
")",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"3",
")",
".",
"getOffset",
"(",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"3",
")",
".",
"setOffset",
"(",
"Offset",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"X86",
"X86",
"X86",
"X86::TAILJMPm64",
"X86::TAILJMPm",
"X86::TCRETURNmi",
"X86::TCRETURNmi64",
"0",
"0",
"X86::LEA64_32r",
"X86::GR32RegClass",
"X86",
"64",
"\"Expected the FP as base register\"",
"1",
"1",
"3",
"3",
"32",
"\"Requesting 64-bit offset in 32-bit immediate!\"",
"3",
"3",
"3"
] | X86RegisterInfo (2)4 | eliminateFrameIndex | X86 | CPU | LLVM | 16,633 | 502 | 1 | [] |
[
"<s>",
"void",
"applyFixup",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"char",
"*",
"Data",
",",
"unsigned",
"DataSize",
",",
"uint64_t",
"Value",
",",
"bool",
"IsPCRel",
",",
"MCContext",
"&",
"Ctx",
")",
"const",
"override",
"{",
"unsigned",
"Size",
"=",
"1",
"<<",
"getFixupKindLog2Size",
"(",
"Fixup",
".",
"getKind",
"(",
")",
")",
";",
"assert",
"(",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"Size",
"<=",
"DataSize",
"&&",
"\"Invalid fixup offset!\"",
")",
";",
"assert",
"(",
"isIntN",
"(",
"Size",
"*",
"8",
"+",
"1",
",",
"Value",
")",
"&&",
"\"Value does not fit in the Fixup field\"",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"Size",
";",
"++",
"i",
")",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"i",
"]",
"=",
"uint8_t",
"(",
"Value",
">>",
"(",
"i",
"*",
"8",
")",
")",
";",
"}",
"</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",
"."
] | [
"X86",
"1",
"\"Invalid fixup offset!\"",
"8",
"1",
"\"Value does not fit in the Fixup field\"",
"0",
"8"
] | X86AsmBackend18 | applyFixup | X86 | CPU | LLVM | 16,634 | 110 | 1 | [] |
[
"<s>",
"int",
"mve_vector_mem_operand",
"(",
"machine_mode",
"mode",
",",
"rtx",
"op",
",",
"bool",
"strict",
")",
"{",
"enum",
"rtx_code",
"code",
";",
"int",
"val",
",",
"reg_no",
";",
"if",
"(",
"REG_P",
"(",
"op",
")",
")",
"{",
"int",
"reg_no",
"=",
"REGNO",
"(",
"op",
")",
";",
"return",
"(",
"(",
"(",
"mode",
"==",
"E_V8QImode",
"||",
"mode",
"==",
"E_V4QImode",
"||",
"mode",
"==",
"E_V4HImode",
")",
"?",
"reg_no",
"<=",
"LAST_LO_REGNUM",
":",
"(",
"reg_no",
"<",
"LAST_ARM_REGNUM",
"&&",
"reg_no",
"!=",
"SP_REGNUM",
")",
")",
"||",
"(",
"!",
"strict",
"&&",
"reg_no",
">=",
"FIRST_PSEUDO_REGISTER",
")",
")",
";",
"}",
"code",
"=",
"GET_CODE",
"(",
"op",
")",
";",
"if",
"(",
"code",
"==",
"POST_INC",
"||",
"code",
"==",
"PRE_DEC",
"||",
"code",
"==",
"PRE_INC",
"||",
"code",
"==",
"POST_DEC",
")",
"{",
"reg_no",
"=",
"REGNO",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
")",
";",
"return",
"(",
"(",
"mode",
"==",
"E_V8QImode",
"||",
"mode",
"==",
"E_V4QImode",
"||",
"mode",
"==",
"E_V4HImode",
")",
"?",
"reg_no",
"<=",
"LAST_LO_REGNUM",
":",
"(",
"reg_no",
"<",
"LAST_ARM_REGNUM",
"&&",
"reg_no",
"!=",
"SP_REGNUM",
")",
")",
"||",
"reg_no",
">=",
"FIRST_PSEUDO_REGISTER",
";",
"}",
"else",
"if",
"(",
"(",
"(",
"code",
"==",
"POST_MODIFY",
"||",
"code",
"==",
"PRE_MODIFY",
")",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
")",
"==",
"PLUS",
"&&",
"XEXP",
"(",
"op",
",",
"0",
")",
"==",
"XEXP",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
",",
"0",
")",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
")",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
",",
"1",
")",
")",
"==",
"CONST_INT",
")",
"||",
"(",
"reload_completed",
"&&",
"code",
"==",
"PLUS",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
")",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
")",
"==",
"CONST_INT",
")",
")",
"{",
"reg_no",
"=",
"REGNO",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
")",
";",
"if",
"(",
"code",
"==",
"PLUS",
")",
"val",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
")",
";",
"else",
"val",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"XEXP",
"(",
"op",
",",
"1",
")",
",",
"1",
")",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_V16QImode",
":",
"case",
"E_V8QImode",
":",
"case",
"E_V4QImode",
":",
"if",
"(",
"abs",
"(",
"val",
")",
">",
"127",
")",
"return",
"FALSE",
";",
"break",
";",
"case",
"E_V8HImode",
":",
"case",
"E_V8HFmode",
":",
"case",
"E_V4HImode",
":",
"case",
"E_V4HFmode",
":",
"if",
"(",
"val",
"%",
"2",
"!=",
"0",
"||",
"abs",
"(",
"val",
")",
">",
"254",
")",
"return",
"FALSE",
";",
"break",
";",
"case",
"E_V4SImode",
":",
"case",
"E_V4SFmode",
":",
"if",
"(",
"val",
"%",
"4",
"!=",
"0",
"||",
"abs",
"(",
"val",
")",
">",
"508",
")",
"return",
"FALSE",
";",
"break",
";",
"default",
":",
"return",
"FALSE",
";",
"}",
"return",
"reg_no",
">=",
"FIRST_PSEUDO_REGISTER",
"||",
"(",
"MVE_STN_LDW_MODE",
"(",
"mode",
")",
"?",
"reg_no",
"<=",
"LAST_LO_REGNUM",
":",
"(",
"reg_no",
"<",
"LAST_ARM_REGNUM",
"&&",
"reg_no",
"!=",
"SP_REGNUM",
")",
")",
";",
"}",
"return",
"FALSE",
";",
"}",
"</s>"
] | [
"This",
"function",
"returns",
"TRUE",
"on",
"matching",
"mode",
"and",
"op.1",
".",
"For",
"given",
"modes",
",",
"check",
"for",
"[",
"Rn",
"]",
",",
"return",
"TRUE",
"for",
"Rn",
"<",
"=",
"LO_REGS.2",
".",
"For",
"other",
"modes",
",",
"check",
"for",
"[",
"Rn",
"]",
",",
"return",
"TRUE",
"for",
"Rn",
"<",
"R15",
"(",
"expect",
"R13",
")",
"."
] | [
"arm",
"0",
"1",
"0",
"1",
"0",
"0",
"1",
"1",
"0",
"1",
"0",
"1",
"1",
"1",
"127",
"2",
"0",
"254",
"4",
"0",
"508"
] | arm | mve_vector_mem_operand | arm | CPU | GCC | 16,635 | 430 | 1 | [] |
[
"<s>",
"static",
"void",
"s390_optimize_register_info",
"(",
")",
"{",
"char",
"clobbered_regs",
"[",
"32",
"]",
";",
"int",
"i",
",",
"j",
";",
"gcc_assert",
"(",
"epilogue_completed",
")",
";",
"gcc_assert",
"(",
"!",
"cfun",
"->",
"machine",
"->",
"split_branches_pending_p",
")",
";",
"s390_regs_ever_clobbered",
"(",
"clobbered_regs",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"32",
";",
"i",
"++",
")",
"clobbered_regs",
"[",
"i",
"]",
"=",
"clobbered_regs",
"[",
"i",
"]",
"&&",
"!",
"global_regs",
"[",
"i",
"]",
";",
"clobbered_regs",
"[",
"RETURN_REGNUM",
"]",
"|=",
"(",
"TARGET_TPF_PROFILING",
"||",
"cfun_frame_layout",
".",
"save_return_addr_p",
"||",
"crtl",
"->",
"calls_eh_return",
")",
";",
"memset",
"(",
"cfun_frame_layout",
".",
"gpr_save_slots",
",",
"0",
",",
"6",
")",
";",
"for",
"(",
"i",
"=",
"6",
";",
"i",
"<",
"16",
";",
"i",
"++",
")",
"if",
"(",
"!",
"clobbered_regs",
"[",
"i",
"]",
")",
"cfun_gpr_save_slot",
"(",
"i",
")",
"=",
"0",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"16",
"&&",
"cfun_gpr_save_slot",
"(",
"i",
")",
"!=",
"-",
"1",
";",
"i",
"++",
")",
";",
"for",
"(",
"j",
"=",
"15",
";",
"j",
">",
"i",
"&&",
"cfun_gpr_save_slot",
"(",
"j",
")",
"!=",
"-",
"1",
";",
"j",
"--",
")",
";",
"cfun_frame_layout",
".",
"first_restore_gpr",
"=",
"(",
"i",
"==",
"16",
")",
"?",
"-",
"1",
":",
"i",
";",
"cfun_frame_layout",
".",
"last_restore_gpr",
"=",
"(",
"i",
"==",
"16",
")",
"?",
"-",
"1",
":",
"j",
";",
"s390_register_info_stdarg_gpr",
"(",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"16",
"&&",
"cfun_gpr_save_slot",
"(",
"i",
")",
"!=",
"-",
"1",
";",
"i",
"++",
")",
";",
"for",
"(",
"j",
"=",
"15",
";",
"j",
">",
"i",
"&&",
"cfun_gpr_save_slot",
"(",
"j",
")",
"!=",
"-",
"1",
";",
"j",
"--",
")",
";",
"cfun_frame_layout",
".",
"first_save_gpr",
"=",
"(",
"i",
"==",
"16",
")",
"?",
"-",
"1",
":",
"i",
";",
"cfun_frame_layout",
".",
"last_save_gpr",
"=",
"(",
"i",
"==",
"16",
")",
"?",
"-",
"1",
":",
"j",
";",
"}",
"</s>"
] | [
"This",
"function",
"is",
"called",
"by",
"s390_optimize_prologue",
"in",
"order",
"to",
"get",
"rid",
"of",
"unnecessary",
"GPR",
"save/restore",
"instructions",
".",
"The",
"register",
"info",
"for",
"the",
"GPRs",
"is",
"re-computed",
"and",
"the",
"ranges",
"are",
"re-calculated",
"."
] | [
"s390",
"32",
"0",
"32",
"0",
"6",
"6",
"16",
"0",
"0",
"16",
"1",
"15",
"1",
"16",
"1",
"16",
"1",
"0",
"16",
"1",
"15",
"1",
"16",
"1",
"16",
"1"
] | s3904 | s390_optimize_register_info | s390 | MPU | GCC | 16,636 | 275 | 1 | [] |
[
"<s>",
"static",
"bool",
"isF128SoftLibCall",
"(",
"const",
"char",
"*",
"CallSym",
")",
"{",
"const",
"char",
"*",
"const",
"LibCalls",
"[",
"]",
"=",
"{",
"\"__addtf3\"",
",",
"\"__divtf3\"",
",",
"\"__eqtf2\"",
",",
"\"__extenddftf2\"",
",",
"\"__extendsftf2\"",
",",
"\"__fixtfdi\"",
",",
"\"__fixtfsi\"",
",",
"\"__fixtfti\"",
",",
"\"__fixunstfdi\"",
",",
"\"__fixunstfsi\"",
",",
"\"__fixunstfti\"",
",",
"\"__floatditf\"",
",",
"\"__floatsitf\"",
",",
"\"__floattitf\"",
",",
"\"__floatunditf\"",
",",
"\"__floatunsitf\"",
",",
"\"__floatuntitf\"",
",",
"\"__getf2\"",
",",
"\"__gttf2\"",
",",
"\"__letf2\"",
",",
"\"__lttf2\"",
",",
"\"__multf3\"",
",",
"\"__netf2\"",
",",
"\"__powitf2\"",
",",
"\"__subtf3\"",
",",
"\"__trunctfdf2\"",
",",
"\"__trunctfsf2\"",
",",
"\"__unordtf2\"",
",",
"\"ceill\"",
",",
"\"copysignl\"",
",",
"\"cosl\"",
",",
"\"exp2l\"",
",",
"\"expl\"",
",",
"\"floorl\"",
",",
"\"fmal\"",
",",
"\"fmodl\"",
",",
"\"log10l\"",
",",
"\"log2l\"",
",",
"\"logl\"",
",",
"\"nearbyintl\"",
",",
"\"powl\"",
",",
"\"rintl\"",
",",
"\"roundl\"",
",",
"\"sinl\"",
",",
"\"sqrtl\"",
",",
"\"truncl\"",
"}",
";",
"auto",
"Comp",
"=",
"[",
"]",
"(",
"const",
"char",
"*",
"S1",
",",
"const",
"char",
"*",
"S2",
")",
"{",
"return",
"strcmp",
"(",
"S1",
",",
"S2",
")",
"<",
"0",
";",
"}",
";",
"assert",
"(",
"std",
"::",
"is_sorted",
"(",
"std",
"::",
"begin",
"(",
"LibCalls",
")",
",",
"std",
"::",
"end",
"(",
"LibCalls",
")",
",",
"Comp",
")",
")",
";",
"return",
"std",
"::",
"binary_search",
"(",
"std",
"::",
"begin",
"(",
"LibCalls",
")",
",",
"std",
"::",
"end",
"(",
"LibCalls",
")",
",",
"CallSym",
",",
"Comp",
")",
";",
"}",
"</s>"
] | [
"This",
"function",
"returns",
"true",
"if",
"CallSym",
"is",
"a",
"long",
"double",
"emulation",
"routine",
"."
] | [
"Mips",
"\"__addtf3\"",
"\"__divtf3\"",
"\"__eqtf2\"",
"\"__extenddftf2\"",
"\"__extendsftf2\"",
"\"__fixtfdi\"",
"\"__fixtfsi\"",
"\"__fixtfti\"",
"\"__fixunstfdi\"",
"\"__fixunstfsi\"",
"\"__fixunstfti\"",
"\"__floatditf\"",
"\"__floatsitf\"",
"\"__floattitf\"",
"\"__floatunditf\"",
"\"__floatunsitf\"",
"\"__floatuntitf\"",
"\"__getf2\"",
"\"__gttf2\"",
"\"__letf2\"",
"\"__lttf2\"",
"\"__multf3\"",
"\"__netf2\"",
"\"__powitf2\"",
"\"__subtf3\"",
"\"__trunctfdf2\"",
"\"__trunctfsf2\"",
"\"__unordtf2\"",
"\"ceill\"",
"\"copysignl\"",
"\"cosl\"",
"\"exp2l\"",
"\"expl\"",
"\"floorl\"",
"\"fmal\"",
"\"fmodl\"",
"\"log10l\"",
"\"log2l\"",
"\"logl\"",
"\"nearbyintl\"",
"\"powl\"",
"\"rintl\"",
"\"roundl\"",
"\"sinl\"",
"\"sqrtl\"",
"\"truncl\"",
"0"
] | MipsCCState | isF128SoftLibCall | Mips | CPU | LLVM | 16,637 | 190 | 1 | [] |
[
"<s>",
"bool",
"s390_hard_regno_rename_ok",
"(",
"unsigned",
"int",
"old_reg",
",",
"unsigned",
"int",
"new_reg",
")",
"{",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"base_reg",
")",
"if",
"(",
"REGNO",
"(",
"cfun",
"->",
"machine",
"->",
"base_reg",
")",
"==",
"old_reg",
"||",
"REGNO",
"(",
"cfun",
"->",
"machine",
"->",
"base_reg",
")",
"==",
"new_reg",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
"if",
"register",
"OLD_REG",
"can",
"be",
"renamed",
"to",
"register",
"NEW_REG",
"."
] | [
"s390"
] | s3903 | s390_hard_regno_rename_ok | s390 | MPU | GCC | 16,638 | 51 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblySetP2AlignOperands",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"DEBUG",
"(",
"{",
"dbgs",
"(",
")",
"<<",
"\"********** Set p2align Operands **********\\n\"",
"<<",
"\"********** Function: \"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
";",
"}",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"auto",
"&",
"MBB",
":",
"MF",
")",
"{",
"for",
"(",
"auto",
"&",
"MI",
":",
"MBB",
")",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"WebAssembly",
"::",
"LOAD_I32",
":",
"case",
"WebAssembly",
"::",
"LOAD_I64",
":",
"case",
"WebAssembly",
"::",
"LOAD_F32",
":",
"case",
"WebAssembly",
"::",
"LOAD_F64",
":",
"case",
"WebAssembly",
"::",
"LOAD8_S_I32",
":",
"case",
"WebAssembly",
"::",
"LOAD8_U_I32",
":",
"case",
"WebAssembly",
"::",
"LOAD16_S_I32",
":",
"case",
"WebAssembly",
"::",
"LOAD16_U_I32",
":",
"case",
"WebAssembly",
"::",
"LOAD8_S_I64",
":",
"case",
"WebAssembly",
"::",
"LOAD8_U_I64",
":",
"case",
"WebAssembly",
"::",
"LOAD16_S_I64",
":",
"case",
"WebAssembly",
"::",
"LOAD16_U_I64",
":",
"case",
"WebAssembly",
"::",
"LOAD32_S_I64",
":",
"case",
"WebAssembly",
"::",
"LOAD32_U_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD8_U_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD16_U_I32",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD8_U_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD16_U_I64",
":",
"case",
"WebAssembly",
"::",
"ATOMIC_LOAD32_U_I64",
":",
"RewriteP2Align",
"(",
"MI",
",",
"WebAssembly",
"::",
"LoadP2AlignOperandNo",
")",
";",
"break",
";",
"case",
"WebAssembly",
"::",
"STORE_I32",
":",
"case",
"WebAssembly",
"::",
"STORE_I64",
":",
"case",
"WebAssembly",
"::",
"STORE_F32",
":",
"case",
"WebAssembly",
"::",
"STORE_F64",
":",
"case",
"WebAssembly",
"::",
"STORE8_I32",
":",
"case",
"WebAssembly",
"::",
"STORE16_I32",
":",
"case",
"WebAssembly",
"::",
"STORE8_I64",
":",
"case",
"WebAssembly",
"::",
"STORE16_I64",
":",
"case",
"WebAssembly",
"::",
"STORE32_I64",
":",
"RewriteP2Align",
"(",
"MI",
",",
"WebAssembly",
"::",
"StoreP2AlignOperandNo",
")",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"}",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"********** Set p2align Operands **********\\n\"",
"\"********** Function: \"",
"WebAssembly::LOAD_I32",
"WebAssembly::LOAD_I64",
"WebAssembly::LOAD_F32",
"WebAssembly::LOAD_F64",
"WebAssembly::LOAD8_S_I32",
"WebAssembly::LOAD8_U_I32",
"WebAssembly::LOAD16_S_I32",
"WebAssembly::LOAD16_U_I32",
"WebAssembly::LOAD8_S_I64",
"WebAssembly::LOAD8_U_I64",
"WebAssembly::LOAD16_S_I64",
"WebAssembly::LOAD16_U_I64",
"WebAssembly::LOAD32_S_I64",
"WebAssembly::LOAD32_U_I64",
"WebAssembly::ATOMIC_LOAD_I32",
"WebAssembly::ATOMIC_LOAD8_U_I32",
"WebAssembly::ATOMIC_LOAD16_U_I32",
"WebAssembly::ATOMIC_LOAD_I64",
"WebAssembly::ATOMIC_LOAD8_U_I64",
"WebAssembly::ATOMIC_LOAD16_U_I64",
"WebAssembly::ATOMIC_LOAD32_U_I64",
"WebAssembly::LoadP2AlignOperandNo",
"WebAssembly::STORE_I32",
"WebAssembly::STORE_I64",
"WebAssembly::STORE_F32",
"WebAssembly::STORE_F64",
"WebAssembly::STORE8_I32",
"WebAssembly::STORE16_I32",
"WebAssembly::STORE8_I64",
"WebAssembly::STORE16_I64",
"WebAssembly::STORE32_I64",
"WebAssembly::StoreP2AlignOperandNo"
] | WebAssemblySetP2AlignOperands10 | runOnMachineFunction | WebAssembly | Virtual ISA | LLVM | 16,639 | 247 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"OR1KTargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"StringRef",
"Constraint",
",",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"default",
":",
"break",
";",
"case",
"'r'",
":",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"&",
"OR1K",
"::",
"GPRRegClass",
")",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"TRI",
",",
"Constraint",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"OR1K",
"OR1K",
"1",
"0",
"0U",
"OR1K::GPRRegClass"
] | OR1KISelLowering1 | getRegForInlineAsmConstraint | OR1K | CPU | LLVM | 16,640 | 81 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"PASS_NAME",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AMDGPU"
] | SIDebuggerInsertNops1 | getPassName | AMDGPU | GPU | LLVM | 16,641 | 11 | 1 | [] |
[
"<s>",
"void",
"RISCVRegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"unsigned",
"FIOperandNum",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"assert",
"(",
"SPAdj",
"==",
"0",
"&&",
"\"Unexpected non-zero SPAdj value\"",
")",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"int",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"getIndex",
"(",
")",
";",
"unsigned",
"FrameReg",
";",
"int",
"Offset",
"=",
"getFrameLowering",
"(",
"MF",
")",
"->",
"getFrameIndexReference",
"(",
"MF",
",",
"FrameIndex",
",",
"FrameReg",
")",
"+",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"getImm",
"(",
")",
";",
"assert",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
"->",
"hasFP",
"(",
"MF",
")",
"&&",
"\"eliminateFrameIndex currently requires hasFP\"",
")",
";",
"if",
"(",
"!",
"isInt",
"<",
"12",
">",
"(",
"Offset",
")",
")",
"{",
"report_fatal_error",
"(",
"\"Frame offsets outside of the signed 12-bit range not supported\"",
")",
";",
"}",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"ChangeToRegister",
"(",
"FrameReg",
",",
"false",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"RISCV",
"RISCV",
"0",
"\"Unexpected non-zero SPAdj value\"",
"1",
"\"eliminateFrameIndex currently requires hasFP\"",
"12",
"\"Frame offsets outside of the signed 12-bit range not supported\"",
"1"
] | RISCVRegisterInfo27 | eliminateFrameIndex | RISCV | CPU | LLVM | 16,642 | 176 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"hasReassociableOperands",
"(",
"const",
"MachineInstr",
"&",
"Inst",
",",
"const",
"MachineBasicBlock",
"*",
"MBB",
")",
"const",
"{",
"assert",
"(",
"Inst",
".",
"getNumExplicitOperands",
"(",
")",
"==",
"3",
"&&",
"Inst",
".",
"getNumExplicitDefs",
"(",
")",
"==",
"1",
"&&",
"Inst",
".",
"getNumDefs",
"(",
")",
"<=",
"2",
"&&",
"\"Reassociation needs binary operators\"",
")",
";",
"const",
"MachineOperand",
"*",
"FlagDef",
"=",
"Inst",
".",
"findRegisterDefOperand",
"(",
"X86",
"::",
"EFLAGS",
")",
";",
"assert",
"(",
"(",
"Inst",
".",
"getNumDefs",
"(",
")",
"==",
"1",
"||",
"FlagDef",
")",
"&&",
"\"Implicit def isn't flags?\"",
")",
";",
"if",
"(",
"FlagDef",
"&&",
"!",
"FlagDef",
"->",
"isDead",
"(",
")",
")",
"return",
"false",
";",
"return",
"TargetInstrInfo",
"::",
"hasReassociableOperands",
"(",
"Inst",
",",
"MBB",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"when",
"\\P",
"Inst",
"has",
"reassociable",
"operands",
"in",
"the",
"same",
"\\P",
"MBB",
"."
] | [
"X86",
"X86",
"3",
"1",
"2",
"\"Reassociation needs binary operators\"",
"X86::EFLAGS",
"1",
"\"Implicit def isn't flags?\""
] | X86InstrInfo (2)3 | hasReassociableOperands | X86 | CPU | LLVM | 16,643 | 102 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"isLegalAddImmediate",
"(",
"int64_t",
"Immed",
")",
"const",
"{",
"if",
"(",
"Immed",
"==",
"std",
"::",
"numeric_limits",
"<",
"int64_t",
">",
"::",
"min",
"(",
")",
")",
"return",
"false",
";",
"Immed",
"=",
"std",
"::",
"abs",
"(",
"Immed",
")",
";",
"return",
"(",
"(",
"Immed",
">>",
"12",
")",
"==",
"0",
"||",
"(",
"(",
"Immed",
"&",
"0xfff",
")",
"==",
"0",
"&&",
"Immed",
">>",
"24",
"==",
"0",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"specified",
"immediate",
"is",
"legal",
"add",
"immediate",
",",
"that",
"is",
"the",
"target",
"has",
"add",
"instructions",
"which",
"can",
"add",
"a",
"register",
"and",
"the",
"immediate",
"without",
"having",
"to",
"materialize",
"the",
"immediate",
"into",
"a",
"register",
"."
] | [
"AArch64",
"AArch64",
"12",
"0",
"0xfff",
"0",
"24",
"0"
] | AArch64ISelLowering (2) | isLegalAddImmediate | AArch64 | CPU | LLVM | 16,644 | 65 | 1 | [] |
[
"<s>",
"bool",
"PPCPassConfig",
"::",
"addPreRegAlloc",
"(",
")",
"{",
"initializePPCVSXFMAMutatePass",
"(",
"*",
"PassRegistry",
"::",
"getPassRegistry",
"(",
")",
")",
";",
"insertPass",
"(",
"VSXFMAMutateEarly",
"?",
"&",
"RegisterCoalescerID",
":",
"&",
"MachineSchedulerID",
",",
"&",
"PPCVSXFMAMutateID",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"register",
"allocation",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC"
] | PPCTargetMachine | addPreRegAlloc | PowerPC | CPU | LLVM | 16,645 | 35 | 1 | [] |
[
"<s>",
"bool",
"SITargetLowering",
"::",
"allowsMisalignedMemoryAccesses",
"(",
"EVT",
"VT",
",",
"unsigned",
"AddrSpace",
",",
"unsigned",
"Align",
",",
"bool",
"*",
"IsFast",
")",
"const",
"{",
"if",
"(",
"IsFast",
")",
"*",
"IsFast",
"=",
"false",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"Other",
"||",
"(",
"VT",
"!=",
"MVT",
"::",
"Other",
"&&",
"VT",
".",
"getSizeInBits",
"(",
")",
">",
"1024",
"&&",
"VT",
".",
"getStoreSize",
"(",
")",
">",
"16",
")",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"AddrSpace",
"==",
"AMDGPUASI",
".",
"LOCAL_ADDRESS",
"||",
"AddrSpace",
"==",
"AMDGPUASI",
".",
"REGION_ADDRESS",
")",
"{",
"bool",
"AlignedBy4",
"=",
"(",
"Align",
"%",
"4",
"==",
"0",
")",
";",
"if",
"(",
"IsFast",
")",
"*",
"IsFast",
"=",
"AlignedBy4",
";",
"return",
"AlignedBy4",
";",
"}",
"if",
"(",
"!",
"Subtarget",
"->",
"hasUnalignedScratchAccess",
"(",
")",
"&&",
"(",
"AddrSpace",
"==",
"AMDGPUASI",
".",
"PRIVATE_ADDRESS",
"||",
"AddrSpace",
"==",
"AMDGPUASI",
".",
"FLAT_ADDRESS",
")",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"Subtarget",
"->",
"hasUnalignedBufferAccess",
"(",
")",
")",
"{",
"if",
"(",
"IsFast",
")",
"{",
"*",
"IsFast",
"=",
"(",
"AddrSpace",
"==",
"AMDGPUASI",
".",
"CONSTANT_ADDRESS",
")",
"?",
"(",
"Align",
"%",
"4",
"==",
"0",
")",
":",
"true",
";",
"}",
"return",
"true",
";",
"}",
"if",
"(",
"VT",
".",
"bitsLT",
"(",
"MVT",
"::",
"i32",
")",
")",
"return",
"false",
";",
"if",
"(",
"IsFast",
")",
"*",
"IsFast",
"=",
"true",
";",
"return",
"VT",
".",
"bitsGT",
"(",
"MVT",
"::",
"i32",
")",
"&&",
"Align",
"%",
"4",
"==",
"0",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"allows",
"unaligned",
"memory",
"accesses",
"of",
"the",
"specified",
"type",
"."
] | [
"AMDGPU",
"SI",
"MVT::Other",
"MVT::Other",
"1024",
"16",
"SI",
"SI",
"4",
"0",
"SI",
"SI",
"SI",
"4",
"0",
"MVT::i32",
"MVT::i32",
"4",
"0"
] | SIISelLowering114 | allowsMisalignedMemoryAccesses | AMDGPU | GPU | LLVM | 16,646 | 213 | 1 | [] |
[
"<s>",
"void",
"PPCRegisterInfo",
"::",
"lowerCRSpilling",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"unsigned",
"FrameIndex",
")",
"const",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"PPCSubtarget",
"&",
"Subtarget",
"=",
"MF",
".",
"getSubtarget",
"<",
"PPCSubtarget",
">",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"Subtarget",
".",
"getInstrInfo",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"bool",
"LP64",
"=",
"TM",
".",
"isPPC64",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"G8RC",
"=",
"&",
"PPC",
"::",
"G8RCRegClass",
";",
"const",
"TargetRegisterClass",
"*",
"GPRC",
"=",
"&",
"PPC",
"::",
"GPRCRegClass",
";",
"unsigned",
"Reg",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"LP64",
"?",
"G8RC",
":",
"GPRC",
")",
";",
"unsigned",
"SrcReg",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"II",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"LP64",
"?",
"PPC",
"::",
"MFOCRF8",
":",
"PPC",
"::",
"MFOCRF",
")",
",",
"Reg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"isKill",
"(",
")",
")",
")",
";",
"if",
"(",
"SrcReg",
"!=",
"PPC",
"::",
"CR0",
")",
"{",
"unsigned",
"Reg1",
"=",
"Reg",
";",
"Reg",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"LP64",
"?",
"G8RC",
":",
"GPRC",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"II",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"LP64",
"?",
"PPC",
"::",
"RLWINM8",
":",
"PPC",
"::",
"RLWINM",
")",
",",
"Reg",
")",
".",
"addReg",
"(",
"Reg1",
",",
"RegState",
"::",
"Kill",
")",
".",
"addImm",
"(",
"getEncodingValue",
"(",
"SrcReg",
")",
"*",
"4",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addImm",
"(",
"31",
")",
";",
"}",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"II",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"LP64",
"?",
"PPC",
"::",
"STW8",
":",
"PPC",
"::",
"STW",
")",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"Kill",
")",
",",
"FrameIndex",
")",
";",
"MBB",
".",
"erase",
"(",
"II",
")",
";",
"}",
"</s>"
] | [
"lowerCRSpilling",
"-",
"Generate",
"the",
"code",
"for",
"spilling",
"a",
"CR",
"register",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC",
"PPC",
"PPC::G8RCRegClass",
"PPC::GPRCRegClass",
"0",
"PPC::MFOCRF8",
"PPC::MFOCRF",
"0",
"PPC::CR0",
"PPC::RLWINM8",
"PPC::RLWINM",
"4",
"0",
"31",
"PPC::STW8",
"PPC::STW"
] | PPCRegisterInfo (2)1 | lowerCRSpilling | PowerPC | CPU | LLVM | 16,647 | 318 | 1 | [] |
[
"<s>",
"void",
"MipsCodeEmitter",
"::",
"emitInstruction",
"(",
"MachineBasicBlock",
"::",
"instr_iterator",
"MI",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"{",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"JIT: \"",
"<<",
"(",
"void",
"*",
")",
"MCE",
".",
"getCurrentPCValue",
"(",
")",
"<<",
"\":\\t\"",
"<<",
"*",
"MI",
")",
";",
"if",
"(",
"(",
"(",
"MI",
"->",
"getDesc",
"(",
")",
".",
"TSFlags",
"&",
"MipsII",
"::",
"FormMask",
")",
"==",
"MipsII",
"::",
"Pseudo",
")",
"&&",
"!",
"expandPseudos",
"(",
"MI",
",",
"MBB",
")",
")",
"return",
";",
"MCE",
".",
"processDebugLoc",
"(",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"true",
")",
";",
"emitWord",
"(",
"getBinaryCodeForInstr",
"(",
"*",
"MI",
")",
")",
";",
"++",
"NumEmitted",
";",
"MCE",
".",
"processDebugLoc",
"(",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"false",
")",
";",
"}",
"</s>"
] | [
"Targets",
"should",
"implement",
"this",
"to",
"emit",
"instructions",
"."
] | [
"Mips",
"Mips",
"\"JIT: \"",
"\":\\t\"",
"MipsII::FormMask",
"MipsII::Pseudo"
] | MipsCodeEmitter | emitInstruction | Mips | CPU | LLVM | 16,648 | 110 | 1 | [] |
[
"<s>",
"void",
"s390_conditional_register_usage",
"(",
"void",
")",
"{",
"int",
"i",
";",
"if",
"(",
"flag_pic",
")",
"{",
"fixed_regs",
"[",
"PIC_OFFSET_TABLE_REGNUM",
"]",
"=",
"1",
";",
"call_used_regs",
"[",
"PIC_OFFSET_TABLE_REGNUM",
"]",
"=",
"1",
";",
"}",
"if",
"(",
"TARGET_CPU_ZARCH",
")",
"{",
"fixed_regs",
"[",
"BASE_REGNUM",
"]",
"=",
"0",
";",
"call_used_regs",
"[",
"BASE_REGNUM",
"]",
"=",
"0",
";",
"fixed_regs",
"[",
"RETURN_REGNUM",
"]",
"=",
"0",
";",
"call_used_regs",
"[",
"RETURN_REGNUM",
"]",
"=",
"0",
";",
"}",
"if",
"(",
"TARGET_64BIT",
")",
"{",
"for",
"(",
"i",
"=",
"24",
";",
"i",
"<",
"32",
";",
"i",
"++",
")",
"call_used_regs",
"[",
"i",
"]",
"=",
"call_really_used_regs",
"[",
"i",
"]",
"=",
"0",
";",
"}",
"else",
"{",
"for",
"(",
"i",
"=",
"18",
";",
"i",
"<",
"20",
";",
"i",
"++",
")",
"call_used_regs",
"[",
"i",
"]",
"=",
"call_really_used_regs",
"[",
"i",
"]",
"=",
"0",
";",
"}",
"if",
"(",
"TARGET_SOFT_FLOAT",
")",
"{",
"for",
"(",
"i",
"=",
"16",
";",
"i",
"<",
"32",
";",
"i",
"++",
")",
"call_used_regs",
"[",
"i",
"]",
"=",
"fixed_regs",
"[",
"i",
"]",
"=",
"1",
";",
"}",
"}",
"</s>"
] | [
"Implement",
"CONDITIONAL_REGISTER_USAGE",
"."
] | [
"s390",
"1",
"1",
"0",
"0",
"0",
"0",
"24",
"32",
"0",
"18",
"20",
"0",
"16",
"32",
"1"
] | s3903 | s390_conditional_register_usage | s390 | MPU | GCC | 16,649 | 154 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"Cpu0FrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"}",
"</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",
")",
"."
] | [
"Cpu0",
"Cpu0"
] | Cpu0FrameLowering3 | eliminateCallFramePseudoInstr | Cpu0 | CPU | LLVM | 16,650 | 22 | 1 | [] |
[
"<s>",
"unsigned",
"GCNSubtarget",
"::",
"getOccupancyWithNumSGPRs",
"(",
"unsigned",
"SGPRs",
")",
"const",
"{",
"if",
"(",
"getGeneration",
"(",
")",
">=",
"AMDGPUSubtarget",
"::",
"VOLCANIC_ISLANDS",
")",
"{",
"if",
"(",
"SGPRs",
"<=",
"80",
")",
"return",
"10",
";",
"if",
"(",
"SGPRs",
"<=",
"88",
")",
"return",
"9",
";",
"if",
"(",
"SGPRs",
"<=",
"100",
")",
"return",
"8",
";",
"return",
"7",
";",
"}",
"if",
"(",
"SGPRs",
"<=",
"48",
")",
"return",
"10",
";",
"if",
"(",
"SGPRs",
"<=",
"56",
")",
"return",
"9",
";",
"if",
"(",
"SGPRs",
"<=",
"64",
")",
"return",
"8",
";",
"if",
"(",
"SGPRs",
"<=",
"72",
")",
"return",
"7",
";",
"if",
"(",
"SGPRs",
"<=",
"80",
")",
"return",
"6",
";",
"return",
"5",
";",
"}",
"</s>"
] | [
"Return",
"the",
"maximum",
"number",
"of",
"waves",
"per",
"SIMD",
"for",
"kernels",
"using",
"SGPRs",
"SGPRs",
"."
] | [
"AMDGPU",
"AMDGPU",
"80",
"10",
"88",
"9",
"100",
"8",
"7",
"48",
"10",
"56",
"9",
"64",
"8",
"72",
"7",
"80",
"6",
"5"
] | AMDGPUSubtarget | getOccupancyWithNumSGPRs | AMDGPU | GPU | LLVM | 16,651 | 101 | 1 | [] |
[
"<s>",
"SDValue",
"AMDGPUTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"Op",
".",
"getNode",
"(",
")",
"->",
"dump",
"(",
")",
";",
"assert",
"(",
"0",
"&&",
"\"Custom lowering code for this\"",
"\"instruction is not implemented yet!\"",
")",
";",
"break",
";",
"case",
"ISD",
"::",
"SDIV",
":",
"return",
"LowerSDIV",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SREM",
":",
"return",
"LowerSREM",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND_INREG",
":",
"return",
"LowerSIGN_EXTEND_INREG",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BRCOND",
":",
"return",
"LowerBRCOND",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"CONCAT_VECTORS",
":",
"return",
"LowerCONCAT_VECTORS",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
":",
"return",
"LowerEXTRACT_SUBVECTOR",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"LowerINTRINSIC_WO_CHAIN",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"LowerSTORE",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"UDIVREM",
":",
"return",
"LowerUDIVREM",
"(",
"Op",
",",
"DAG",
")",
";",
"}",
"return",
"Op",
";",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"R600",
"0",
"\"Custom lowering code for this\"",
"\"instruction is not implemented yet!\"",
"ISD::SDIV",
"ISD::SREM",
"ISD::SIGN_EXTEND_INREG",
"SI",
"ISD::BRCOND",
"ISD::CONCAT_VECTORS",
"ISD::EXTRACT_SUBVECTOR",
"ISD::INTRINSIC_WO_CHAIN",
"SI",
"ISD::STORE",
"ISD::UDIVREM"
] | AMDGPUISelLowering108 | LowerOperation | R600 | GPU | LLVM | 16,652 | 167 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"output_387_reg_move",
"(",
"rtx",
"insn",
",",
"rtx",
"*",
"operands",
")",
"{",
"if",
"(",
"REG_P",
"(",
"operands",
"[",
"0",
"]",
")",
")",
"{",
"if",
"(",
"REG_P",
"(",
"operands",
"[",
"1",
"]",
")",
"&&",
"find_regno_note",
"(",
"insn",
",",
"REG_DEAD",
",",
"REGNO",
"(",
"operands",
"[",
"1",
"]",
")",
")",
")",
"{",
"if",
"(",
"REGNO",
"(",
"operands",
"[",
"0",
"]",
")",
"==",
"FIRST_STACK_REG",
")",
"return",
"output_387_ffreep",
"(",
"operands",
",",
"0",
")",
";",
"return",
"\"fstp\\t%y0\"",
";",
"}",
"if",
"(",
"STACK_TOP_P",
"(",
"operands",
"[",
"0",
"]",
")",
")",
"return",
"\"fld%Z1\\t%y1\"",
";",
"return",
"\"fst\\t%y0\"",
";",
"}",
"else",
"if",
"(",
"MEM_P",
"(",
"operands",
"[",
"0",
"]",
")",
")",
"{",
"gcc_assert",
"(",
"REG_P",
"(",
"operands",
"[",
"1",
"]",
")",
")",
";",
"if",
"(",
"find_regno_note",
"(",
"insn",
",",
"REG_DEAD",
",",
"REGNO",
"(",
"operands",
"[",
"1",
"]",
")",
")",
")",
"return",
"\"fstp%Z0\\t%y0\"",
";",
"else",
"{",
"if",
"(",
"GET_MODE",
"(",
"operands",
"[",
"0",
"]",
")",
"==",
"XFmode",
")",
"return",
"\"fstp%Z0\\t%y0\\n\\tfld%Z0\\t%y0\"",
";",
"else",
"return",
"\"fst%Z0\\t%y0\"",
";",
"}",
"}",
"else",
"gcc_unreachable",
"(",
")",
";",
"}",
"</s>"
] | [
"Output",
"code",
"to",
"perform",
"an",
"x87",
"FP",
"register",
"move",
",",
"from",
"OPERANDS",
"[",
"1",
"]",
"to",
"OPERANDS",
"[",
"0",
"]",
"."
] | [
"i386",
"0",
"1",
"1",
"0",
"0",
"\"fstp\\t%y0\"",
"0",
"\"fld%Z1\\t%y1\"",
"\"fst\\t%y0\"",
"0",
"1",
"1",
"\"fstp%Z0\\t%y0\"",
"0",
"\"fstp%Z0\\t%y0\\n\\tfld%Z0\\t%y0\"",
"\"fst%Z0\\t%y0\""
] | i3864 | output_387_reg_move | i386 | CPU | GCC | 16,653 | 163 | 1 | [] |
[
"<s>",
"MCObjectWriter",
"*",
"AVRAsmBackend",
"::",
"createObjectWriter",
"(",
"raw_pwrite_stream",
"&",
"OS",
")",
"const",
"{",
"return",
"createAVRELFObjectWriter",
"(",
"OS",
",",
"MCELFObjectTargetWriter",
"::",
"getOSABI",
"(",
"OSType",
")",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"new",
"MCObjectWriter",
"instance",
"for",
"use",
"by",
"the",
"assembler",
"backend",
"to",
"emit",
"the",
"final",
"object",
"file",
"."
] | [
"AVR",
"AVR",
"AVR"
] | AVRAsmBackend14 | createObjectWriter | AVR | MPU | LLVM | 16,654 | 26 | 1 | [] |
[
"<s>",
"void",
"RISCVAsmBackend",
"::",
"applyFixup",
"(",
"const",
"MCAssembler",
"&",
"Asm",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
"Target",
",",
"MutableArrayRef",
"<",
"char",
">",
"Data",
",",
"uint64_t",
"Value",
",",
"bool",
"IsPCRel",
")",
"const",
"{",
"return",
";",
"}",
"</s>"
] | [
"Apply",
"the",
"Value",
"for",
"given",
"Fixup",
"into",
"the",
"provided",
"data",
"fragment",
",",
"at",
"the",
"offset",
"specified",
"by",
"the",
"fixup",
"and",
"following",
"the",
"fixup",
"kind",
"as",
"appropriate",
"."
] | [
"RISCV",
"RISCV"
] | RISCVAsmBackend9 | applyFixup | RISCV | CPU | LLVM | 16,655 | 37 | 1 | [] |
[
"<s>",
"bool",
"SITargetLowering",
"::",
"allowsMisalignedMemoryAccesses",
"(",
"EVT",
"VT",
",",
"unsigned",
"AddrSpace",
",",
"unsigned",
"Align",
",",
"bool",
"*",
"IsFast",
")",
"const",
"{",
"if",
"(",
"IsFast",
")",
"*",
"IsFast",
"=",
"false",
";",
"if",
"(",
"!",
"VT",
".",
"isSimple",
"(",
")",
"||",
"VT",
"==",
"MVT",
"::",
"Other",
")",
"return",
"false",
";",
"if",
"(",
"AddrSpace",
"==",
"AMDGPUAS",
"::",
"LOCAL_ADDRESS",
")",
"{",
"return",
"Align",
"%",
"4",
"==",
"0",
";",
"}",
"if",
"(",
"IsFast",
")",
"*",
"IsFast",
"=",
"true",
";",
"return",
"VT",
".",
"bitsGT",
"(",
"MVT",
"::",
"i32",
")",
"&&",
"Align",
"%",
"4",
"==",
"0",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"allows",
"unaligned",
"memory",
"accesses",
"of",
"the",
"specified",
"type",
"."
] | [
"R600",
"SI",
"MVT::Other",
"AMDGPUAS::LOCAL_ADDRESS",
"4",
"0",
"MVT::i32",
"4",
"0"
] | SIISelLowering51 | allowsMisalignedMemoryAccesses | R600 | GPU | LLVM | 16,656 | 90 | 1 | [] |
[
"<s>",
"bool",
"hasStandaloneRem",
"(",
"EVT",
")",
"const",
"override",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"can",
"handle",
"a",
"standalone",
"remainder",
"operation",
"."
] | [
"VE"
] | VEISelLowering | hasStandaloneRem | VE | CPU | LLVM | 16,657 | 12 | 1 | [] |
[
"<s>",
"char",
"*",
"m32c_output_compare",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"*",
"operands",
")",
"{",
"static",
"char",
"templ",
"[",
"]",
"=",
"\";cmp.b\\t%1,%0\"",
";",
"templ",
"[",
"5",
"]",
"=",
"\" bwll\"",
"[",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"operands",
"[",
"0",
"]",
")",
")",
"]",
";",
"if",
"(",
"m32c_compare_redundant",
"(",
"insn",
",",
"operands",
")",
")",
"{",
"fprintf",
"(",
"stderr",
",",
"\"cbranch: cmp not needed\\n\"",
")",
";",
"return",
"templ",
";",
"}",
"fprintf",
"(",
"stderr",
",",
"\"cbranch: cmp needed: `%s'\\n\"",
",",
"templ",
"+",
"1",
")",
";",
"return",
"templ",
"+",
"1",
";",
"}",
"</s>"
] | [
"Return",
"the",
"pattern",
"for",
"a",
"compare",
".",
"This",
"will",
"be",
"commented",
"out",
"if",
"the",
"compare",
"is",
"redundant",
",",
"else",
"a",
"normal",
"pattern",
"is",
"returned",
".",
"Thus",
",",
"the",
"assembler",
"output",
"says",
"where",
"the",
"compare",
"would",
"have",
"been",
"."
] | [
"m32c",
"\";cmp.b\\t%1,%0\"",
"5",
"\" bwll\"",
"0",
"\"cbranch: cmp not needed\\n\"",
"\"cbranch: cmp needed: `%s'\\n\"",
"1",
"1"
] | m32c | m32c_output_compare | m32c | MPU | GCC | 16,658 | 78 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"AVRMCExpr",
"::",
"getName",
"(",
")",
"const",
"{",
"const",
"auto",
"&",
"Modifier",
"=",
"std",
"::",
"find_if",
"(",
"std",
"::",
"begin",
"(",
"ModifierNames",
")",
",",
"std",
"::",
"end",
"(",
"ModifierNames",
")",
",",
"[",
"this",
"]",
"(",
"ModifierEntry",
"const",
"&",
"Mod",
")",
"{",
"return",
"Mod",
".",
"VariantKind",
"==",
"Kind",
";",
"}",
")",
";",
"if",
"(",
"Modifier",
"!=",
"std",
"::",
"end",
"(",
"ModifierNames",
")",
")",
"{",
"return",
"Modifier",
"->",
"Spelling",
";",
"}",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"Return",
"a",
"string",
"with",
"the",
"name",
"of",
"the",
"plan",
"and",
"the",
"applicable",
"VFs",
"and",
"UFs",
"."
] | [
"AVR",
"AVR"
] | AVRMCExpr | getName | AVR | MPU | LLVM | 16,659 | 75 | 1 | [] |
[
"<s>",
"void",
"WebAssemblyRegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"unsigned",
"FIOperandNum",
",",
"RegScavenger",
"*",
")",
"const",
"{",
"assert",
"(",
"SPAdj",
"==",
"0",
")",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"int",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"getIndex",
"(",
")",
";",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"int64_t",
"FrameOffset",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
"+",
"MFI",
".",
"getObjectOffset",
"(",
"FrameIndex",
")",
";",
"if",
"(",
"MI",
".",
"mayLoadOrStore",
"(",
")",
")",
"{",
"assert",
"(",
"FrameOffset",
">=",
"0",
"&&",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
">=",
"0",
")",
";",
"int64_t",
"Offset",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
"+",
"FrameOffset",
";",
"if",
"(",
"static_cast",
"<",
"uint64_t",
">",
"(",
"Offset",
")",
">",
"std",
"::",
"numeric_limits",
"<",
"uint32_t",
">",
"::",
"max",
"(",
")",
")",
"{",
"report_fatal_error",
"(",
"\"Memory offset field overflow\"",
")",
";",
"}",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"setImm",
"(",
"Offset",
")",
";",
"MI",
".",
"getOperand",
"(",
"2",
")",
".",
"ChangeToRegister",
"(",
"WebAssembly",
"::",
"SP32",
",",
"false",
")",
";",
"}",
"else",
"{",
"auto",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"auto",
"*",
"TII",
"=",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"unsigned",
"FIRegOperand",
"=",
"WebAssembly",
"::",
"SP32",
";",
"if",
"(",
"FrameOffset",
")",
"{",
"FIRegOperand",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"WebAssembly",
"::",
"I32RegClass",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"CONST_I32",
")",
",",
"FIRegOperand",
")",
".",
"addImm",
"(",
"FrameOffset",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"WebAssembly",
"::",
"ADD_I32",
")",
",",
"FIRegOperand",
")",
".",
"addReg",
"(",
"WebAssembly",
"::",
"SP32",
")",
".",
"addReg",
"(",
"FIRegOperand",
")",
";",
"}",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"ChangeToRegister",
"(",
"FIRegOperand",
",",
"false",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"WebAssembly",
"WebAssembly",
"0",
"0",
"1",
"0",
"1",
"\"Memory offset field overflow\"",
"1",
"2",
"WebAssembly::SP32",
"WebAssembly",
"WebAssembly::SP32",
"WebAssembly::I32RegClass",
"WebAssembly::CONST_I32",
"WebAssembly::ADD_I32",
"WebAssembly::SP32"
] | WebAssemblyRegisterInfo12 | eliminateFrameIndex | WebAssembly | Virtual ISA | LLVM | 16,660 | 337 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"SIRegisterInfo",
"::",
"getCompatibleSubRegClass",
"(",
"const",
"TargetRegisterClass",
"*",
"SuperRC",
",",
"const",
"TargetRegisterClass",
"*",
"SubRC",
",",
"unsigned",
"SubIdx",
")",
"const",
"{",
"const",
"TargetRegisterClass",
"*",
"MatchRC",
"=",
"getMatchingSuperRegClass",
"(",
"SuperRC",
",",
"SubRC",
",",
"SubIdx",
")",
";",
"return",
"MatchRC",
"&&",
"MatchRC",
"->",
"hasSubClassEq",
"(",
"SuperRC",
")",
"?",
"MatchRC",
":",
"nullptr",
";",
"}",
"</s>"
] | [
"Returns",
"a",
"register",
"class",
"which",
"is",
"compatible",
"with",
"SuperRC",
",",
"such",
"that",
"a",
"subregister",
"exists",
"with",
"class",
"SubRC",
"with",
"subregister",
"index",
"SubIdx",
"."
] | [
"AMDGPU",
"SI"
] | SIRegisterInfo (3) | getCompatibleSubRegClass | AMDGPU | GPU | LLVM | 16,661 | 51 | 1 | [] |
[
"<s>",
"void",
"printPCRelImm",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"uint64_t",
"Address",
",",
"unsigned",
"opNum",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"printAbsMem",
"(",
"MI",
",",
"opNum",
",",
"O",
")",
";",
"}",
"</s>"
] | [
"value",
"(",
"e.g",
"."
] | [
"M68k"
] | M68kInstPrinter | printPCRelImm | M68k | MPU | LLVM | 16,662 | 29 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"AArch64TargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"AArch64ISD",
"::",
"BR_CC",
":",
"return",
"\"AArch64ISD::BR_CC\"",
";",
"case",
"AArch64ISD",
"::",
"Call",
":",
"return",
"\"AArch64ISD::Call\"",
";",
"case",
"AArch64ISD",
"::",
"FPMOV",
":",
"return",
"\"AArch64ISD::FPMOV\"",
";",
"case",
"AArch64ISD",
"::",
"GOTLoad",
":",
"return",
"\"AArch64ISD::GOTLoad\"",
";",
"case",
"AArch64ISD",
"::",
"BFI",
":",
"return",
"\"AArch64ISD::BFI\"",
";",
"case",
"AArch64ISD",
"::",
"EXTR",
":",
"return",
"\"AArch64ISD::EXTR\"",
";",
"case",
"AArch64ISD",
"::",
"Ret",
":",
"return",
"\"AArch64ISD::Ret\"",
";",
"case",
"AArch64ISD",
"::",
"SBFX",
":",
"return",
"\"AArch64ISD::SBFX\"",
";",
"case",
"AArch64ISD",
"::",
"SELECT_CC",
":",
"return",
"\"AArch64ISD::SELECT_CC\"",
";",
"case",
"AArch64ISD",
"::",
"SETCC",
":",
"return",
"\"AArch64ISD::SETCC\"",
";",
"case",
"AArch64ISD",
"::",
"TC_RETURN",
":",
"return",
"\"AArch64ISD::TC_RETURN\"",
";",
"case",
"AArch64ISD",
"::",
"THREAD_POINTER",
":",
"return",
"\"AArch64ISD::THREAD_POINTER\"",
";",
"case",
"AArch64ISD",
"::",
"TLSDESCCALL",
":",
"return",
"\"AArch64ISD::TLSDESCCALL\"",
";",
"case",
"AArch64ISD",
"::",
"WrapperLarge",
":",
"return",
"\"AArch64ISD::WrapperLarge\"",
";",
"case",
"AArch64ISD",
"::",
"WrapperSmall",
":",
"return",
"\"AArch64ISD::WrapperSmall\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_BSL",
":",
"return",
"\"AArch64ISD::NEON_BSL\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_MOVIMM",
":",
"return",
"\"AArch64ISD::NEON_MOVIMM\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_MVNIMM",
":",
"return",
"\"AArch64ISD::NEON_MVNIMM\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_FMOVIMM",
":",
"return",
"\"AArch64ISD::NEON_FMOVIMM\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_CMP",
":",
"return",
"\"AArch64ISD::NEON_CMP\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_CMPZ",
":",
"return",
"\"AArch64ISD::NEON_CMPZ\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_TST",
":",
"return",
"\"AArch64ISD::NEON_TST\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_QSHLs",
":",
"return",
"\"AArch64ISD::NEON_QSHLs\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_QSHLu",
":",
"return",
"\"AArch64ISD::NEON_QSHLu\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_VDUP",
":",
"return",
"\"AArch64ISD::NEON_VDUP\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_VDUPLANE",
":",
"return",
"\"AArch64ISD::NEON_VDUPLANE\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_REV16",
":",
"return",
"\"AArch64ISD::NEON_REV16\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_REV32",
":",
"return",
"\"AArch64ISD::NEON_REV32\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_REV64",
":",
"return",
"\"AArch64ISD::NEON_REV64\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD1_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD1_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD2_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD2_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD3_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD3_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD4_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD4_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_ST1_UPD",
":",
"return",
"\"AArch64ISD::NEON_ST1_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_ST2_UPD",
":",
"return",
"\"AArch64ISD::NEON_ST2_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_ST3_UPD",
":",
"return",
"\"AArch64ISD::NEON_ST3_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_ST4_UPD",
":",
"return",
"\"AArch64ISD::NEON_ST4_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD1x2_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD1x2_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD1x3_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD1x3_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD1x4_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD1x4_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_ST1x2_UPD",
":",
"return",
"\"AArch64ISD::NEON_ST1x2_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_ST1x3_UPD",
":",
"return",
"\"AArch64ISD::NEON_ST1x3_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_ST1x4_UPD",
":",
"return",
"\"AArch64ISD::NEON_ST1x4_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD2DUP",
":",
"return",
"\"AArch64ISD::NEON_LD2DUP\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD3DUP",
":",
"return",
"\"AArch64ISD::NEON_LD3DUP\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD4DUP",
":",
"return",
"\"AArch64ISD::NEON_LD4DUP\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD2DUP_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD2DUP_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD3DUP_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD3DUP_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD4DUP_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD4DUP_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD2LN_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD2LN_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD3LN_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD3LN_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_LD4LN_UPD",
":",
"return",
"\"AArch64ISD::NEON_LD4LN_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_ST2LN_UPD",
":",
"return",
"\"AArch64ISD::NEON_ST2LN_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_ST3LN_UPD",
":",
"return",
"\"AArch64ISD::NEON_ST3LN_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_ST4LN_UPD",
":",
"return",
"\"AArch64ISD::NEON_ST4LN_UPD\"",
";",
"case",
"AArch64ISD",
"::",
"NEON_VEXTRACT",
":",
"return",
"\"AArch64ISD::NEON_VEXTRACT\"",
";",
"default",
":",
"return",
"NULL",
";",
"}",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"AArch64",
"AArch64",
"AArch64ISD::BR_CC",
"\"AArch64ISD::BR_CC\"",
"AArch64ISD::Call",
"\"AArch64ISD::Call\"",
"AArch64ISD::FPMOV",
"\"AArch64ISD::FPMOV\"",
"AArch64ISD::GOTLoad",
"\"AArch64ISD::GOTLoad\"",
"AArch64ISD::BFI",
"\"AArch64ISD::BFI\"",
"AArch64ISD::EXTR",
"\"AArch64ISD::EXTR\"",
"AArch64ISD::Ret",
"\"AArch64ISD::Ret\"",
"AArch64ISD::SBFX",
"\"AArch64ISD::SBFX\"",
"AArch64ISD::SELECT_CC",
"\"AArch64ISD::SELECT_CC\"",
"AArch64ISD::SETCC",
"\"AArch64ISD::SETCC\"",
"AArch64ISD::TC_RETURN",
"\"AArch64ISD::TC_RETURN\"",
"AArch64ISD::THREAD_POINTER",
"\"AArch64ISD::THREAD_POINTER\"",
"AArch64ISD::TLSDESCCALL",
"\"AArch64ISD::TLSDESCCALL\"",
"AArch64ISD::WrapperLarge",
"\"AArch64ISD::WrapperLarge\"",
"AArch64ISD::WrapperSmall",
"\"AArch64ISD::WrapperSmall\"",
"AArch64ISD::NEON_BSL",
"\"AArch64ISD::NEON_BSL\"",
"AArch64ISD::NEON_MOVIMM",
"\"AArch64ISD::NEON_MOVIMM\"",
"AArch64ISD::NEON_MVNIMM",
"\"AArch64ISD::NEON_MVNIMM\"",
"AArch64ISD::NEON_FMOVIMM",
"\"AArch64ISD::NEON_FMOVIMM\"",
"AArch64ISD::NEON_CMP",
"\"AArch64ISD::NEON_CMP\"",
"AArch64ISD::NEON_CMPZ",
"\"AArch64ISD::NEON_CMPZ\"",
"AArch64ISD::NEON_TST",
"\"AArch64ISD::NEON_TST\"",
"AArch64ISD::NEON_QSHLs",
"\"AArch64ISD::NEON_QSHLs\"",
"AArch64ISD::NEON_QSHLu",
"\"AArch64ISD::NEON_QSHLu\"",
"AArch64ISD::NEON_VDUP",
"\"AArch64ISD::NEON_VDUP\"",
"AArch64ISD::NEON_VDUPLANE",
"\"AArch64ISD::NEON_VDUPLANE\"",
"AArch64ISD::NEON_REV16",
"\"AArch64ISD::NEON_REV16\"",
"AArch64ISD::NEON_REV32",
"\"AArch64ISD::NEON_REV32\"",
"AArch64ISD::NEON_REV64",
"\"AArch64ISD::NEON_REV64\"",
"AArch64ISD::NEON_LD1_UPD",
"\"AArch64ISD::NEON_LD1_UPD\"",
"AArch64ISD::NEON_LD2_UPD",
"\"AArch64ISD::NEON_LD2_UPD\"",
"AArch64ISD::NEON_LD3_UPD",
"\"AArch64ISD::NEON_LD3_UPD\"",
"AArch64ISD::NEON_LD4_UPD",
"\"AArch64ISD::NEON_LD4_UPD\"",
"AArch64ISD::NEON_ST1_UPD",
"\"AArch64ISD::NEON_ST1_UPD\"",
"AArch64ISD::NEON_ST2_UPD",
"\"AArch64ISD::NEON_ST2_UPD\"",
"AArch64ISD::NEON_ST3_UPD",
"\"AArch64ISD::NEON_ST3_UPD\"",
"AArch64ISD::NEON_ST4_UPD",
"\"AArch64ISD::NEON_ST4_UPD\"",
"AArch64ISD::NEON_LD1x2_UPD",
"\"AArch64ISD::NEON_LD1x2_UPD\"",
"AArch64ISD::NEON_LD1x3_UPD",
"\"AArch64ISD::NEON_LD1x3_UPD\"",
"AArch64ISD::NEON_LD1x4_UPD",
"\"AArch64ISD::NEON_LD1x4_UPD\"",
"AArch64ISD::NEON_ST1x2_UPD",
"\"AArch64ISD::NEON_ST1x2_UPD\"",
"AArch64ISD::NEON_ST1x3_UPD",
"\"AArch64ISD::NEON_ST1x3_UPD\"",
"AArch64ISD::NEON_ST1x4_UPD",
"\"AArch64ISD::NEON_ST1x4_UPD\"",
"AArch64ISD::NEON_LD2DUP",
"\"AArch64ISD::NEON_LD2DUP\"",
"AArch64ISD::NEON_LD3DUP",
"\"AArch64ISD::NEON_LD3DUP\"",
"AArch64ISD::NEON_LD4DUP",
"\"AArch64ISD::NEON_LD4DUP\"",
"AArch64ISD::NEON_LD2DUP_UPD",
"\"AArch64ISD::NEON_LD2DUP_UPD\"",
"AArch64ISD::NEON_LD3DUP_UPD",
"\"AArch64ISD::NEON_LD3DUP_UPD\"",
"AArch64ISD::NEON_LD4DUP_UPD",
"\"AArch64ISD::NEON_LD4DUP_UPD\"",
"AArch64ISD::NEON_LD2LN_UPD",
"\"AArch64ISD::NEON_LD2LN_UPD\"",
"AArch64ISD::NEON_LD3LN_UPD",
"\"AArch64ISD::NEON_LD3LN_UPD\"",
"AArch64ISD::NEON_LD4LN_UPD",
"\"AArch64ISD::NEON_LD4LN_UPD\"",
"AArch64ISD::NEON_ST2LN_UPD",
"\"AArch64ISD::NEON_ST2LN_UPD\"",
"AArch64ISD::NEON_ST3LN_UPD",
"\"AArch64ISD::NEON_ST3LN_UPD\"",
"AArch64ISD::NEON_ST4LN_UPD",
"\"AArch64ISD::NEON_ST4LN_UPD\"",
"AArch64ISD::NEON_VEXTRACT",
"\"AArch64ISD::NEON_VEXTRACT\""
] | AArch64ISelLowering140 | getTargetNodeName | AArch64 | CPU | LLVM | 16,663 | 472 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"reduceSelectOfFPConstantLoads",
"(",
"bool",
"IsFPSetCC",
")",
"const",
"{",
"return",
"!",
"IsFPSetCC",
"||",
"!",
"Subtarget",
".",
"isTarget64BitLP64",
"(",
")",
"||",
"!",
"Subtarget",
".",
"hasAVX",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"is",
"profitable",
"to",
"convert",
"a",
"select",
"of",
"FP",
"constants",
"into",
"a",
"constant",
"pool",
"load",
"whose",
"address",
"depends",
"on",
"the",
"select",
"condition",
"."
] | [
"X86",
"X86"
] | X86ISelLowering (2)8 | reduceSelectOfFPConstantLoads | X86 | CPU | LLVM | 16,664 | 29 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"RISCVRegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
"CC",
")",
"const",
"{",
"auto",
"&",
"Subtarget",
"=",
"MF",
".",
"getSubtarget",
"<",
"RISCVSubtarget",
">",
"(",
")",
";",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"GHC",
")",
"return",
"CSR_NoRegs_RegMask",
";",
"switch",
"(",
"Subtarget",
".",
"getTargetABI",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unrecognized ABI\"",
")",
";",
"case",
"RISCVABI",
"::",
"ABI_ILP32",
":",
"case",
"RISCVABI",
"::",
"ABI_LP64",
":",
"return",
"CSR_ILP32_LP64_RegMask",
";",
"case",
"RISCVABI",
"::",
"ABI_ILP32F",
":",
"case",
"RISCVABI",
"::",
"ABI_LP64F",
":",
"return",
"CSR_ILP32F_LP64F_RegMask",
";",
"case",
"RISCVABI",
"::",
"ABI_ILP32D",
":",
"case",
"RISCVABI",
"::",
"ABI_LP64D",
":",
"return",
"CSR_ILP32D_LP64D_RegMask",
";",
"}",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"RISCV",
"RISCV",
"RISCV",
"\"Unrecognized ABI\"",
"RISCVABI::ABI_ILP32",
"RISCVABI::ABI_LP64",
"RISCVABI::ABI_ILP32F",
"RISCVABI::ABI_LP64F",
"RISCVABI::ABI_ILP32D",
"RISCVABI::ABI_LP64D"
] | RISCVRegisterInfo1 | getCallPreservedMask | RISCV | CPU | LLVM | 16,665 | 100 | 1 | [] |
[
"<s>",
"void",
"SparcPassConfig",
"::",
"addPreEmitPass",
"(",
")",
"{",
"addPass",
"(",
"createSparcDelaySlotFillerPass",
"(",
"getSparcTargetMachine",
"(",
")",
")",
")",
";",
"if",
"(",
"this",
"->",
"getSparcTargetMachine",
"(",
")",
".",
"getSubtargetImpl",
"(",
")",
"->",
"insertNOPLoad",
"(",
")",
")",
"{",
"addPass",
"(",
"new",
"InsertNOPLoad",
"(",
"getSparcTargetMachine",
"(",
")",
")",
")",
";",
"}",
"if",
"(",
"this",
"->",
"getSparcTargetMachine",
"(",
")",
".",
"getSubtargetImpl",
"(",
")",
"->",
"fixFSMULD",
"(",
")",
")",
"{",
"addPass",
"(",
"new",
"FixFSMULD",
"(",
"getSparcTargetMachine",
"(",
")",
")",
")",
";",
"}",
"if",
"(",
"this",
"->",
"getSparcTargetMachine",
"(",
")",
".",
"getSubtargetImpl",
"(",
")",
"->",
"replaceFMULS",
"(",
")",
")",
"{",
"addPass",
"(",
"new",
"ReplaceFMULS",
"(",
"getSparcTargetMachine",
"(",
")",
")",
")",
";",
"}",
"if",
"(",
"this",
"->",
"getSparcTargetMachine",
"(",
")",
".",
"getSubtargetImpl",
"(",
")",
"->",
"detectRoundChange",
"(",
")",
")",
"{",
"addPass",
"(",
"new",
"DetectRoundChange",
"(",
"getSparcTargetMachine",
"(",
")",
")",
")",
";",
"}",
"if",
"(",
"this",
"->",
"getSparcTargetMachine",
"(",
")",
".",
"getSubtargetImpl",
"(",
")",
"->",
"fixAllFDIVSQRT",
"(",
")",
")",
"{",
"addPass",
"(",
"new",
"FixAllFDIVSQRT",
"(",
"getSparcTargetMachine",
"(",
")",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"pass",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"machine",
"code",
"is",
"emitted",
"."
] | [
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"Sparc",
"Sparc"
] | SparcTargetMachine16 | addPreEmitPass | Sparc | CPU | LLVM | 16,666 | 163 | 1 | [] |
[
"<s>",
"bool",
"X86CallLowering",
"::",
"splitToValueTypes",
"(",
"const",
"ArgInfo",
"&",
"OrigArg",
",",
"SmallVectorImpl",
"<",
"ArgInfo",
">",
"&",
"SplitArgs",
",",
"const",
"DataLayout",
"&",
"DL",
",",
"MachineRegisterInfo",
"&",
"MRI",
",",
"SplitArgTy",
"PerformArgSplit",
")",
"const",
"{",
"const",
"X86TargetLowering",
"&",
"TLI",
"=",
"*",
"getTLI",
"<",
"X86TargetLowering",
">",
"(",
")",
";",
"LLVMContext",
"&",
"Context",
"=",
"OrigArg",
".",
"Ty",
"->",
"getContext",
"(",
")",
";",
"SmallVector",
"<",
"EVT",
",",
"4",
">",
"SplitVTs",
";",
"SmallVector",
"<",
"uint64_t",
",",
"4",
">",
"Offsets",
";",
"ComputeValueVTs",
"(",
"TLI",
",",
"DL",
",",
"OrigArg",
".",
"Ty",
",",
"SplitVTs",
",",
"&",
"Offsets",
",",
"0",
")",
";",
"if",
"(",
"SplitVTs",
".",
"size",
"(",
")",
"!=",
"1",
")",
"{",
"return",
"false",
";",
"}",
"EVT",
"VT",
"=",
"SplitVTs",
"[",
"0",
"]",
";",
"unsigned",
"NumParts",
"=",
"TLI",
".",
"getNumRegisters",
"(",
"Context",
",",
"VT",
")",
";",
"if",
"(",
"NumParts",
"==",
"1",
")",
"{",
"SplitArgs",
".",
"emplace_back",
"(",
"OrigArg",
".",
"Reg",
",",
"VT",
".",
"getTypeForEVT",
"(",
"Context",
")",
",",
"OrigArg",
".",
"Flags",
",",
"OrigArg",
".",
"IsFixed",
")",
";",
"return",
"true",
";",
"}",
"SmallVector",
"<",
"unsigned",
",",
"8",
">",
"SplitRegs",
";",
"EVT",
"PartVT",
"=",
"TLI",
".",
"getRegisterType",
"(",
"Context",
",",
"VT",
")",
";",
"Type",
"*",
"PartTy",
"=",
"PartVT",
".",
"getTypeForEVT",
"(",
"Context",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"NumParts",
";",
"++",
"i",
")",
"{",
"ArgInfo",
"Info",
"=",
"ArgInfo",
"{",
"MRI",
".",
"createGenericVirtualRegister",
"(",
"getLLTForType",
"(",
"*",
"PartTy",
",",
"DL",
")",
")",
",",
"PartTy",
",",
"OrigArg",
".",
"Flags",
"}",
";",
"SplitArgs",
".",
"push_back",
"(",
"Info",
")",
";",
"SplitRegs",
".",
"push_back",
"(",
"Info",
".",
"Reg",
")",
";",
"}",
"PerformArgSplit",
"(",
"SplitRegs",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Break",
"OrigArgInfo",
"into",
"one",
"or",
"more",
"pieces",
"the",
"calling",
"convention",
"can",
"process",
",",
"returned",
"in",
"SplitArgs",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"4",
"4",
"0",
"1",
"0",
"1",
"8",
"0"
] | X86CallLowering10 | splitToValueTypes | X86 | CPU | LLVM | 16,667 | 257 | 1 | [] |
[
"<s>",
"void",
"VEFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MachineFunction",
"&",
"MF",
",",
"BitVector",
"&",
"SavedRegs",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"TargetFrameLowering",
"::",
"determineCalleeSaves",
"(",
"MF",
",",
"SavedRegs",
",",
"RS",
")",
";",
"if",
"(",
"isLeafProc",
"(",
"MF",
")",
"&&",
"!",
"hasBP",
"(",
"MF",
")",
")",
"{",
"VEMachineFunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
".",
"getInfo",
"<",
"VEMachineFunctionInfo",
">",
"(",
")",
";",
"FuncInfo",
"->",
"setLeafProc",
"(",
"true",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"determines",
"which",
"of",
"the",
"registers",
"reported",
"by",
"TargetRegisterInfo",
":",
":getCalleeSavedRegs",
"(",
")",
"should",
"actually",
"get",
"saved",
"."
] | [
"VE",
"VE",
"VE",
"VE"
] | VEFrameLowering2 | determineCalleeSaves | VE | CPU | LLVM | 16,668 | 66 | 1 | [] |
[
"<s>",
"bool",
"AArch64FastISel",
"::",
"fastSelectInstruction",
"(",
"const",
"Instruction",
"*",
"I",
")",
"{",
"switch",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Instruction",
"::",
"Add",
":",
"case",
"Instruction",
"::",
"Sub",
":",
"return",
"selectAddSub",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Mul",
":",
"return",
"selectMul",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"SDiv",
":",
"return",
"selectSDiv",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"SRem",
":",
"if",
"(",
"!",
"selectBinaryOp",
"(",
"I",
",",
"ISD",
"::",
"SREM",
")",
")",
"return",
"selectRem",
"(",
"I",
",",
"ISD",
"::",
"SREM",
")",
";",
"return",
"true",
";",
"case",
"Instruction",
"::",
"URem",
":",
"if",
"(",
"!",
"selectBinaryOp",
"(",
"I",
",",
"ISD",
"::",
"UREM",
")",
")",
"return",
"selectRem",
"(",
"I",
",",
"ISD",
"::",
"UREM",
")",
";",
"return",
"true",
";",
"case",
"Instruction",
"::",
"Shl",
":",
"case",
"Instruction",
"::",
"LShr",
":",
"case",
"Instruction",
"::",
"AShr",
":",
"return",
"selectShift",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"And",
":",
"case",
"Instruction",
"::",
"Or",
":",
"case",
"Instruction",
"::",
"Xor",
":",
"return",
"selectLogicalOp",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Br",
":",
"return",
"selectBranch",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"IndirectBr",
":",
"return",
"selectIndirectBr",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"BitCast",
":",
"if",
"(",
"!",
"FastISel",
"::",
"selectBitCast",
"(",
"I",
")",
")",
"return",
"selectBitCast",
"(",
"I",
")",
";",
"return",
"true",
";",
"case",
"Instruction",
"::",
"FPToSI",
":",
"if",
"(",
"!",
"selectCast",
"(",
"I",
",",
"ISD",
"::",
"FP_TO_SINT",
")",
")",
"return",
"selectFPToInt",
"(",
"I",
",",
"true",
")",
";",
"return",
"true",
";",
"case",
"Instruction",
"::",
"FPToUI",
":",
"return",
"selectFPToInt",
"(",
"I",
",",
"false",
")",
";",
"case",
"Instruction",
"::",
"ZExt",
":",
"case",
"Instruction",
"::",
"SExt",
":",
"return",
"selectIntExt",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Trunc",
":",
"if",
"(",
"!",
"selectCast",
"(",
"I",
",",
"ISD",
"::",
"TRUNCATE",
")",
")",
"return",
"selectTrunc",
"(",
"I",
")",
";",
"return",
"true",
";",
"case",
"Instruction",
"::",
"FPExt",
":",
"return",
"selectFPExt",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"FPTrunc",
":",
"return",
"selectFPTrunc",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"SIToFP",
":",
"if",
"(",
"!",
"selectCast",
"(",
"I",
",",
"ISD",
"::",
"SINT_TO_FP",
")",
")",
"return",
"selectIntToFP",
"(",
"I",
",",
"true",
")",
";",
"return",
"true",
";",
"case",
"Instruction",
"::",
"UIToFP",
":",
"return",
"selectIntToFP",
"(",
"I",
",",
"false",
")",
";",
"case",
"Instruction",
"::",
"Load",
":",
"return",
"selectLoad",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Store",
":",
"return",
"selectStore",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"FCmp",
":",
"case",
"Instruction",
"::",
"ICmp",
":",
"return",
"selectCmp",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Select",
":",
"return",
"selectSelect",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Ret",
":",
"return",
"selectRet",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"FRem",
":",
"return",
"selectFRem",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"GetElementPtr",
":",
"return",
"selectGetElementPtr",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"AtomicCmpXchg",
":",
"return",
"selectAtomicCmpXchg",
"(",
"cast",
"<",
"AtomicCmpXchgInst",
">",
"(",
"I",
")",
")",
";",
"}",
"return",
"selectOperator",
"(",
"I",
",",
"I",
"->",
"getOpcode",
"(",
")",
")",
";",
"(",
"void",
")",
"&",
"CC_AArch64_DarwinPCS_VarArg",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"by",
"target-independent",
"code",
"when",
"the",
"normal",
"FastISel",
"process",
"fails",
"to",
"select",
"an",
"instruction",
"."
] | [
"AArch64",
"AArch64",
"ISD::SREM",
"ISD::SREM",
"ISD::UREM",
"ISD::UREM",
"ISD::FP_TO_SINT",
"ISD::TRUNCATE",
"ISD::SINT_TO_FP",
"AArch64"
] | AArch64FastISel20 | fastSelectInstruction | AArch64 | CPU | LLVM | 16,669 | 475 | 1 | [] |
[
"<s>",
"void",
"function_expander",
"::",
"add_mem_operand",
"(",
"machine_mode",
"mode",
",",
"unsigned",
"argno",
")",
"{",
"gcc_assert",
"(",
"VECTOR_MODE_P",
"(",
"mode",
")",
")",
";",
"rtx",
"addr",
"=",
"expand_normal",
"(",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"argno",
")",
")",
";",
"rtx",
"mem",
"=",
"gen_rtx_MEM",
"(",
"mode",
",",
"memory_address",
"(",
"mode",
",",
"addr",
")",
")",
";",
"set_mem_align",
"(",
"mem",
",",
"GET_MODE_ALIGNMENT",
"(",
"GET_MODE_INNER",
"(",
"mode",
")",
")",
")",
";",
"add_fixed_operand",
"(",
"mem",
")",
";",
"}",
"</s>"
] | [
"Add",
"a",
"memory",
"operand",
"with",
"mode",
"MODE",
"and",
"address",
"ADDR",
"."
] | [
"riscv"
] | riscv-vector-builtins | add_mem_operand | riscv | CPU | GCC | 16,670 | 67 | 1 | [] |
[
"<s>",
"const",
"InstrItineraryData",
"&",
"getInstrItineraryData",
"(",
")",
"const",
"{",
"return",
"InstrItins",
";",
"}",
"</s>"
] | [
"getInstrItineraryData",
"-",
"Returns",
"instruction",
"itinerary",
"data",
"for",
"the",
"target",
"or",
"specific",
"subtarget",
"."
] | [
"PowerPC"
] | PPCSubtarget (2) | getInstrItineraryData | PowerPC | CPU | LLVM | 16,671 | 12 | 1 | [] |
[
"<s>",
"EVT",
"AArch64TargetLowering",
"::",
"getOptimalMemOpType",
"(",
"uint64_t",
"Size",
",",
"unsigned",
"DstAlign",
",",
"unsigned",
"SrcAlign",
",",
"bool",
"IsMemset",
",",
"bool",
"ZeroMemset",
",",
"bool",
"MemcpyStrSrc",
",",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"Function",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"bool",
"CanImplicitFloat",
"=",
"!",
"F",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"NoImplicitFloat",
")",
";",
"bool",
"CanUseNEON",
"=",
"Subtarget",
"->",
"hasNEON",
"(",
")",
"&&",
"CanImplicitFloat",
";",
"bool",
"CanUseFP",
"=",
"Subtarget",
"->",
"hasFPARMv8",
"(",
")",
"&&",
"CanImplicitFloat",
";",
"bool",
"IsSmallMemset",
"=",
"IsMemset",
"&&",
"Size",
"<",
"32",
";",
"auto",
"AlignmentIsAcceptable",
"=",
"[",
"&",
"]",
"(",
"EVT",
"VT",
",",
"unsigned",
"AlignCheck",
")",
"{",
"if",
"(",
"memOpAlign",
"(",
"SrcAlign",
",",
"DstAlign",
",",
"AlignCheck",
")",
")",
"return",
"true",
";",
"bool",
"Fast",
";",
"return",
"allowsMisalignedMemoryAccesses",
"(",
"VT",
",",
"0",
",",
"1",
",",
"&",
"Fast",
")",
"&&",
"Fast",
";",
"}",
";",
"if",
"(",
"CanUseNEON",
"&&",
"IsMemset",
"&&",
"!",
"IsSmallMemset",
"&&",
"AlignmentIsAcceptable",
"(",
"MVT",
"::",
"v2i64",
",",
"16",
")",
")",
"return",
"MVT",
"::",
"v2i64",
";",
"if",
"(",
"CanUseFP",
"&&",
"!",
"IsSmallMemset",
"&&",
"AlignmentIsAcceptable",
"(",
"MVT",
"::",
"f128",
",",
"16",
")",
")",
"return",
"MVT",
"::",
"f128",
";",
"if",
"(",
"Size",
">=",
"8",
"&&",
"AlignmentIsAcceptable",
"(",
"MVT",
"::",
"i64",
",",
"8",
")",
")",
"return",
"MVT",
"::",
"i64",
";",
"if",
"(",
"Size",
">=",
"4",
"&&",
"AlignmentIsAcceptable",
"(",
"MVT",
"::",
"i32",
",",
"4",
")",
")",
"return",
"MVT",
"::",
"i32",
";",
"return",
"MVT",
"::",
"Other",
";",
"}",
"</s>"
] | [
"It",
"returns",
"EVT",
":",
":Other",
"if",
"the",
"type",
"should",
"be",
"determined",
"using",
"generic",
"target-independent",
"logic",
"."
] | [
"AArch64",
"AArch64",
"32",
"0",
"1",
"MVT::v2i64",
"16",
"MVT::v2i64",
"MVT::f128",
"16",
"MVT::f128",
"8",
"MVT::i64",
"8",
"MVT::i64",
"4",
"MVT::i32",
"4",
"MVT::i32",
"MVT::Other"
] | AArch64ISelLowering114 | getOptimalMemOpType | AArch64 | CPU | LLVM | 16,672 | 222 | 1 | [] |
[
"<s>",
"static",
"bool",
"m68k_save_reg",
"(",
"unsigned",
"int",
"regno",
",",
"bool",
"interrupt_handler",
")",
"{",
"if",
"(",
"flag_pic",
"&&",
"regno",
"==",
"PIC_REG",
")",
"{",
"if",
"(",
"crtl",
"->",
"saves_all_registers",
")",
"return",
"true",
";",
"if",
"(",
"crtl",
"->",
"uses_pic_offset_table",
")",
"return",
"true",
";",
"if",
"(",
"crtl",
"->",
"uses_const_pool",
")",
"return",
"true",
";",
"}",
"if",
"(",
"crtl",
"->",
"calls_eh_return",
")",
"{",
"unsigned",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
";",
"i",
"++",
")",
"{",
"unsigned",
"int",
"test",
"=",
"EH_RETURN_DATA_REGNO",
"(",
"i",
")",
";",
"if",
"(",
"test",
"==",
"INVALID_REGNUM",
")",
"break",
";",
"if",
"(",
"test",
"==",
"regno",
")",
"return",
"true",
";",
"}",
"}",
"if",
"(",
"fixed_regs",
"[",
"regno",
"]",
")",
"return",
"false",
";",
"if",
"(",
"regno",
"==",
"FRAME_POINTER_REGNUM",
"&&",
"frame_pointer_needed",
")",
"return",
"false",
";",
"if",
"(",
"interrupt_handler",
")",
"{",
"if",
"(",
"df_regs_ever_live_p",
"(",
"regno",
")",
")",
"return",
"true",
";",
"if",
"(",
"!",
"crtl",
"->",
"is_leaf",
"&&",
"call_used_or_fixed_reg_p",
"(",
"regno",
")",
")",
"return",
"true",
";",
"}",
"if",
"(",
"!",
"df_regs_ever_live_p",
"(",
"regno",
")",
")",
"return",
"false",
";",
"return",
"!",
"call_used_or_fixed_reg_p",
"(",
"regno",
")",
";",
"}",
"</s>"
] | [
"Refer",
"to",
"the",
"array",
"`",
"regs_ever_live",
"'",
"to",
"determine",
"which",
"registers",
"to",
"save",
";",
"`",
"regs_ever_live",
"[",
"I",
"]",
"'",
"is",
"nonzero",
"if",
"register",
"number",
"I",
"is",
"ever",
"used",
"in",
"the",
"function",
".",
"This",
"function",
"is",
"responsible",
"for",
"knowing",
"which",
"registers",
"should",
"not",
"be",
"saved",
"even",
"if",
"used",
".",
"Return",
"true",
"if",
"we",
"need",
"to",
"save",
"REGNO",
"."
] | [
"m68k",
"0"
] | m68k | m68k_save_reg | m68k | MPU | GCC | 16,673 | 170 | 1 | [] |
[
"<s>",
"unsigned",
"GCNTTIImpl",
"::",
"getNumberOfRegisters",
"(",
"unsigned",
"RCID",
")",
"const",
"{",
"return",
"4",
";",
"}",
"</s>"
] | [
"�",
"?",
"Vector",
"TTI",
"begin",
"�",
"?"
] | [
"AMDGPU",
"4"
] | AMDGPUTargetTransformInfo (2)1 | getNumberOfRegisters | AMDGPU | GPU | LLVM | 16,674 | 14 | 1 | [] |
[
"<s>",
"void",
"SIScheduleBlock",
"::",
"releaseSuccessors",
"(",
"SUnit",
"*",
"SU",
",",
"bool",
"InOrOutBlock",
")",
"{",
"for",
"(",
"SDep",
"&",
"Succ",
":",
"SU",
"->",
"Succs",
")",
"{",
"SUnit",
"*",
"SuccSU",
"=",
"Succ",
".",
"getSUnit",
"(",
")",
";",
"if",
"(",
"BC",
"->",
"isSUInBlock",
"(",
"SuccSU",
",",
"ID",
")",
"!=",
"InOrOutBlock",
")",
"continue",
";",
"releaseSucc",
"(",
"SU",
",",
"&",
"Succ",
")",
";",
"if",
"(",
"SuccSU",
"->",
"NumPredsLeft",
"==",
"0",
"&&",
"InOrOutBlock",
")",
"TopReadySUs",
".",
"push_back",
"(",
"SuccSU",
")",
";",
"}",
"}",
"</s>"
] | [
"releaseSuccessors",
"-",
"Call",
"releaseSucc",
"on",
"each",
"of",
"SU",
"'s",
"successors",
"."
] | [
"AMDGPU",
"SI",
"0"
] | SIMachineScheduler15 | releaseSuccessors | AMDGPU | GPU | LLVM | 16,675 | 76 | 1 | [] |
[
"<s>",
"MachineInstr",
"*",
"SystemZInstrInfo",
"::",
"commuteInstructionImpl",
"(",
"MachineInstr",
"&",
"MI",
",",
"bool",
"NewMI",
",",
"unsigned",
"OpIdx1",
",",
"unsigned",
"OpIdx2",
")",
"const",
"{",
"auto",
"cloneIfNew",
"=",
"[",
"NewMI",
"]",
"(",
"MachineInstr",
"&",
"MI",
")",
"->",
"MachineInstr",
"&",
"{",
"if",
"(",
"NewMI",
")",
"return",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"CloneMachineInstr",
"(",
"&",
"MI",
")",
";",
"return",
"MI",
";",
"}",
";",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"SystemZ",
"::",
"SELRMux",
":",
"case",
"SystemZ",
"::",
"SELFHR",
":",
"case",
"SystemZ",
"::",
"SELR",
":",
"case",
"SystemZ",
"::",
"SELGR",
":",
"case",
"SystemZ",
"::",
"LOCRMux",
":",
"case",
"SystemZ",
"::",
"LOCFHR",
":",
"case",
"SystemZ",
"::",
"LOCR",
":",
"case",
"SystemZ",
"::",
"LOCGR",
":",
"{",
"auto",
"&",
"WorkingMI",
"=",
"cloneIfNew",
"(",
"MI",
")",
";",
"unsigned",
"CCValid",
"=",
"WorkingMI",
".",
"getOperand",
"(",
"3",
")",
".",
"getImm",
"(",
")",
";",
"unsigned",
"CCMask",
"=",
"WorkingMI",
".",
"getOperand",
"(",
"4",
")",
".",
"getImm",
"(",
")",
";",
"WorkingMI",
".",
"getOperand",
"(",
"4",
")",
".",
"setImm",
"(",
"CCMask",
"^",
"CCValid",
")",
";",
"return",
"TargetInstrInfo",
"::",
"commuteInstructionImpl",
"(",
"WorkingMI",
",",
"false",
",",
"OpIdx1",
",",
"OpIdx2",
")",
";",
"}",
"default",
":",
"return",
"TargetInstrInfo",
"::",
"commuteInstructionImpl",
"(",
"MI",
",",
"NewMI",
",",
"OpIdx1",
",",
"OpIdx2",
")",
";",
"}",
"}",
"</s>"
] | [
"Commutes",
"the",
"operands",
"in",
"the",
"given",
"instruction",
"by",
"changing",
"the",
"operands",
"order",
"and/or",
"changing",
"the",
"instruction",
"'s",
"opcode",
"and/or",
"the",
"immediate",
"value",
"operand",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ::SELRMux",
"SystemZ::SELFHR",
"SystemZ::SELR",
"SystemZ::SELGR",
"SystemZ::LOCRMux",
"SystemZ::LOCFHR",
"SystemZ::LOCR",
"SystemZ::LOCGR",
"3",
"4",
"4"
] | SystemZInstrInfo16 | commuteInstructionImpl | SystemZ | CPU | LLVM | 16,676 | 197 | 1 | [] |
[
"<s>",
"bool",
"GBZ80InstrInfo",
"::",
"reverseBranchCondition",
"(",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
")",
"const",
"{",
"assert",
"(",
"(",
"Cond",
".",
"size",
"(",
")",
"%",
"2",
"==",
"0",
")",
"&&",
"\"Invalid GBZ80 branch condition!\"",
")",
";",
"return",
"!",
"invertCondition",
"(",
"Cond",
")",
";",
"}",
"</s>"
] | [
"Reverses",
"the",
"branch",
"condition",
"of",
"the",
"specified",
"condition",
"list",
",",
"returning",
"false",
"on",
"success",
"and",
"true",
"if",
"it",
"can",
"not",
"be",
"reversed",
"."
] | [
"GBZ80",
"GB",
"2",
"0",
"\"Invalid GBZ80 branch condition!\""
] | GBZ80InstrInfo | reverseBranchCondition | GBZ80 | MPU | LLVM | 16,677 | 39 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_use_new_vector_costs_p",
"(",
")",
"{",
"return",
"(",
"aarch64_tune_params",
".",
"extra_tuning_flags",
"&",
"AARCH64_EXTRA_TUNE_USE_NEW_VECTOR_COSTS",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"current",
"CPU",
"should",
"use",
"the",
"new",
"costs",
"defined",
"in",
"GCC",
"11",
".",
"This",
"should",
"be",
"removed",
"for",
"GCC",
"12",
"and",
"above",
",",
"with",
"the",
"costs",
"applying",
"to",
"all",
"CPUs",
"instead",
"."
] | [
"aarch64"
] | aarch641 | aarch64_use_new_vector_costs_p | aarch64 | CPU | GCC | 16,678 | 16 | 1 | [] |
[
"<s>",
"virtual",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"PTX"
] | PTXRegAlloc | runOnMachineFunction | PTX | GPU | LLVM | 16,679 | 13 | 1 | [] |
[
"<s>",
"bool",
"SIFixSGPRLiveRanges",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"SIRegisterInfo",
"*",
"TRI",
"=",
"static_cast",
"<",
"const",
"SIRegisterInfo",
"*",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
")",
";",
"LiveIntervals",
"*",
"LIS",
"=",
"&",
"getAnalysis",
"<",
"LiveIntervals",
">",
"(",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"BI",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"BE",
"=",
"MF",
".",
"end",
"(",
")",
";",
"BI",
"!=",
"BE",
";",
"++",
"BI",
")",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"BI",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"I",
";",
"MachineOperand",
"*",
"ExecUse",
"=",
"MI",
".",
"findRegisterUseOperand",
"(",
"AMDGPU",
"::",
"EXEC",
")",
";",
"if",
"(",
"ExecUse",
")",
"continue",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"Def",
":",
"MI",
".",
"operands",
"(",
")",
")",
"{",
"if",
"(",
"!",
"Def",
".",
"isReg",
"(",
")",
"||",
"!",
"Def",
".",
"isDef",
"(",
")",
"||",
"!",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"Def",
".",
"getReg",
"(",
")",
")",
")",
"continue",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"MRI",
".",
"getRegClass",
"(",
"Def",
".",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"!",
"TRI",
"->",
"isSGPRClass",
"(",
"RC",
")",
")",
"continue",
";",
"LiveInterval",
"&",
"LI",
"=",
"LIS",
"->",
"getInterval",
"(",
"Def",
".",
"getReg",
"(",
")",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"LI",
".",
"size",
"(",
")",
"-",
"1",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"LiveRange",
"::",
"Segment",
"&",
"Seg",
"=",
"LI",
".",
"segments",
"[",
"i",
"]",
";",
"LiveRange",
"::",
"Segment",
"&",
"Next",
"=",
"LI",
".",
"segments",
"[",
"i",
"+",
"1",
"]",
";",
"Seg",
".",
"end",
"=",
"Next",
".",
"start",
";",
"}",
"}",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"R600",
"SI",
"SI",
"SI",
"0",
"1",
"1"
] | SIFixSGPRLiveRanges3 | runOnMachineFunction | R600 | GPU | LLVM | 16,680 | 302 | 1 | [] |
[
"<s>",
"rtx",
"ix86_zero_extend_to_Pmode",
"(",
"rtx",
"exp",
")",
"{",
"rtx",
"r",
";",
"if",
"(",
"GET_MODE",
"(",
"exp",
")",
"==",
"VOIDmode",
")",
"return",
"force_reg",
"(",
"Pmode",
",",
"exp",
")",
";",
"if",
"(",
"GET_MODE",
"(",
"exp",
")",
"==",
"Pmode",
")",
"return",
"copy_to_mode_reg",
"(",
"Pmode",
",",
"exp",
")",
";",
"r",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_insn",
"(",
"gen_zero_extendsidi2",
"(",
"r",
",",
"exp",
")",
")",
";",
"return",
"r",
";",
"}",
"</s>"
] | [
"Zero",
"extend",
"possibly",
"SImode",
"EXP",
"to",
"Pmode",
"register",
"."
] | [
"i386"
] | i3863 | ix86_zero_extend_to_Pmode | i386 | CPU | GCC | 16,681 | 65 | 1 | [] |
[
"<s>",
"int",
"immediate_load_p",
"(",
"rtx",
"op",
",",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"CONSTANT_P",
"(",
"op",
")",
")",
"{",
"enum",
"immediate_class",
"c",
"=",
"classify_immediate",
"(",
"op",
",",
"mode",
")",
";",
"return",
"c",
"==",
"IC_IL1",
"||",
"c",
"==",
"IC_IL1s",
"||",
"(",
"!",
"epilogue_completed",
"&&",
"(",
"c",
"==",
"IC_IL2",
"||",
"c",
"==",
"IC_IL2s",
")",
")",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"true",
"when",
"OP",
"can",
"be",
"loaded",
"by",
"one",
"of",
"the",
"il",
"instructions",
",",
"or",
"when",
"flow2",
"is",
"not",
"completed",
"and",
"OP",
"can",
"be",
"loaded",
"using",
"ilhu",
"and",
"iohl",
"."
] | [
"spu",
"0"
] | spu | immediate_load_p | spu | MPU | GCC | 16,682 | 58 | 1 | [] |
[
"<s>",
"rtx",
"arc_rewrite_small_data",
"(",
"rtx",
"op",
")",
"{",
"op",
"=",
"arc_rewrite_small_data_1",
"(",
"op",
")",
";",
"if",
"(",
"MEM_P",
"(",
"op",
")",
"&&",
"!",
"LEGITIMATE_SMALL_DATA_ADDRESS_P",
"(",
"XEXP",
"(",
"op",
",",
"0",
")",
")",
")",
"{",
"rtx",
"addr",
"=",
"XEXP",
"(",
"op",
",",
"0",
")",
";",
"rtx",
"tmp",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_move_insn",
"(",
"tmp",
",",
"addr",
")",
";",
"op",
"=",
"replace_equiv_address_nv",
"(",
"op",
",",
"tmp",
")",
";",
"}",
"return",
"op",
";",
"}",
"</s>"
] | [
"If",
"possible",
",",
"rewrite",
"OP",
"so",
"that",
"it",
"refers",
"to",
"small",
"data",
"using",
"explicit",
"relocations",
"."
] | [
"arc",
"0",
"0"
] | arc7 | arc_rewrite_small_data | arc | MPU | GCC | 16,683 | 72 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"MBlazeDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"Node",
")",
"{",
"unsigned",
"Opcode",
"=",
"Node",
"->",
"getOpcode",
"(",
")",
";",
"SDLoc",
"dl",
"(",
"Node",
")",
";",
"if",
"(",
"Node",
"->",
"isMachineOpcode",
"(",
")",
")",
"return",
"NULL",
";",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"GLOBAL_OFFSET_TABLE",
":",
"return",
"getGlobalBaseReg",
"(",
")",
";",
"case",
"ISD",
"::",
"FrameIndex",
":",
"{",
"SDValue",
"imm",
"=",
"CurDAG",
"->",
"getTargetConstant",
"(",
"0",
",",
"MVT",
"::",
"i32",
")",
";",
"int",
"FI",
"=",
"dyn_cast",
"<",
"FrameIndexSDNode",
">",
"(",
"Node",
")",
"->",
"getIndex",
"(",
")",
";",
"EVT",
"VT",
"=",
"Node",
"->",
"getValueType",
"(",
"0",
")",
";",
"SDValue",
"TFI",
"=",
"CurDAG",
"->",
"getTargetFrameIndex",
"(",
"FI",
",",
"VT",
")",
";",
"unsigned",
"Opc",
"=",
"MBlaze",
"::",
"ADDIK",
";",
"if",
"(",
"Node",
"->",
"hasOneUse",
"(",
")",
")",
"return",
"CurDAG",
"->",
"SelectNodeTo",
"(",
"Node",
",",
"Opc",
",",
"VT",
",",
"TFI",
",",
"imm",
")",
";",
"return",
"CurDAG",
"->",
"getMachineNode",
"(",
"Opc",
",",
"dl",
",",
"VT",
",",
"TFI",
",",
"imm",
")",
";",
"}",
"case",
"MBlazeISD",
"::",
"JmpLink",
":",
"{",
"if",
"(",
"TM",
".",
"getRelocationModel",
"(",
")",
"==",
"Reloc",
"::",
"PIC_",
")",
"{",
"SDValue",
"Chain",
"=",
"Node",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"Callee",
"=",
"Node",
"->",
"getOperand",
"(",
"1",
")",
";",
"SDValue",
"R20Reg",
"=",
"CurDAG",
"->",
"getRegister",
"(",
"MBlaze",
"::",
"R20",
",",
"MVT",
"::",
"i32",
")",
";",
"SDValue",
"InFlag",
"(",
"0",
",",
"0",
")",
";",
"if",
"(",
"(",
"isa",
"<",
"GlobalAddressSDNode",
">",
"(",
"Callee",
")",
")",
"||",
"(",
"isa",
"<",
"ExternalSymbolSDNode",
">",
"(",
"Callee",
")",
")",
")",
"{",
"SDValue",
"GPReg",
"=",
"CurDAG",
"->",
"getRegister",
"(",
"MBlaze",
"::",
"R15",
",",
"MVT",
"::",
"i32",
")",
";",
"SDValue",
"Ops",
"[",
"]",
"=",
"{",
"Callee",
",",
"GPReg",
",",
"Chain",
"}",
";",
"SDValue",
"Load",
"=",
"SDValue",
"(",
"CurDAG",
"->",
"getMachineNode",
"(",
"MBlaze",
"::",
"LW",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"MVT",
"::",
"Other",
",",
"Ops",
")",
",",
"0",
")",
";",
"Chain",
"=",
"Load",
".",
"getValue",
"(",
"1",
")",
";",
"Chain",
"=",
"CurDAG",
"->",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"R20Reg",
",",
"Load",
",",
"InFlag",
")",
";",
"}",
"else",
"Chain",
"=",
"CurDAG",
"->",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"R20Reg",
",",
"Callee",
",",
"InFlag",
")",
";",
"SDNode",
"*",
"ResNode",
"=",
"CurDAG",
"->",
"getMachineNode",
"(",
"MBlaze",
"::",
"BRLID",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"MVT",
"::",
"Glue",
",",
"R20Reg",
",",
"Chain",
")",
";",
"Chain",
"=",
"SDValue",
"(",
"ResNode",
",",
"0",
")",
";",
"InFlag",
"=",
"SDValue",
"(",
"ResNode",
",",
"1",
")",
";",
"ReplaceUses",
"(",
"SDValue",
"(",
"Node",
",",
"0",
")",
",",
"Chain",
")",
";",
"ReplaceUses",
"(",
"SDValue",
"(",
"Node",
",",
"1",
")",
",",
"InFlag",
")",
";",
"return",
"ResNode",
";",
"}",
"}",
"}",
"SDNode",
"*",
"ResNode",
"=",
"SelectCode",
"(",
"Node",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"=> \"",
")",
";",
"if",
"(",
"ResNode",
"==",
"NULL",
"||",
"ResNode",
"==",
"Node",
")",
"DEBUG",
"(",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
")",
";",
"else",
"DEBUG",
"(",
"ResNode",
"->",
"dump",
"(",
"CurDAG",
")",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"return",
"ResNode",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"MBlaze",
"MBlaze",
"ISD::GLOBAL_OFFSET_TABLE",
"ISD::FrameIndex",
"0",
"MVT::i32",
"0",
"MBlaze::ADDIK",
"MBlazeISD::JmpLink",
"0",
"1",
"MBlaze::R20",
"MVT::i32",
"0",
"0",
"MBlaze::R15",
"MVT::i32",
"MBlaze::LW",
"MVT::i32",
"MVT::Other",
"0",
"1",
"MBlaze::BRLID",
"MVT::Other",
"MVT::Glue",
"0",
"1",
"0",
"1",
"\"=> \"",
"\"\\n\""
] | MBlazeISelDAGToDAG | Select | MBlaze | MPU | LLVM | 16,684 | 487 | 1 | [] |
[
"<s>",
"virtual",
"unsigned",
"int",
"execute",
"(",
"function",
"*",
")",
"{",
"execute_tag_collision_avoidance",
"(",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Main",
"entry",
"point",
"for",
"this",
"pass",
"."
] | [
"aarch64",
"0"
] | falkor-tag-collision-avoidance | execute | aarch64 | CPU | GCC | 16,685 | 17 | 1 | [] |
[
"<s>",
"bool",
"requiresFrameIndexScavenging",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"requires",
"post",
"PEI",
"scavenging",
"of",
"registers",
"for",
"materializing",
"frame",
"index",
"constants",
"."
] | [
"RI5CY"
] | RISCVRegisterInfo | requiresFrameIndexScavenging | RI5CY | CPU | LLVM | 16,686 | 15 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"avr_out_lshrpsi3",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"*",
"op",
",",
"int",
"*",
"plen",
")",
"{",
"int",
"dest",
"=",
"REGNO",
"(",
"op",
"[",
"0",
"]",
")",
";",
"int",
"src",
"=",
"REGNO",
"(",
"op",
"[",
"1",
"]",
")",
";",
"if",
"(",
"CONST_INT_P",
"(",
"op",
"[",
"2",
"]",
")",
")",
"{",
"if",
"(",
"plen",
")",
"*",
"plen",
"=",
"0",
";",
"switch",
"(",
"INTVAL",
"(",
"op",
"[",
"2",
"]",
")",
")",
"{",
"case",
"8",
":",
"if",
"(",
"dest",
"<=",
"src",
")",
"return",
"avr_asm_len",
"(",
"\"mov %A0,%B1\"",
"CR_TAB",
"\"mov %B0,%C1\"",
"CR_TAB",
"\"clr %C0\"",
",",
"op",
",",
"plen",
",",
"3",
")",
";",
"else",
"return",
"avr_asm_len",
"(",
"\"clr %C0\"",
"CR_TAB",
"\"mov %B0,%C1\"",
"CR_TAB",
"\"mov %A0,%B1\"",
",",
"op",
",",
"plen",
",",
"3",
")",
";",
"case",
"16",
":",
"if",
"(",
"dest",
"!=",
"src",
"+",
"2",
")",
"avr_asm_len",
"(",
"\"mov %A0,%C1\"",
",",
"op",
",",
"plen",
",",
"1",
")",
";",
"return",
"avr_asm_len",
"(",
"\"clr %B0\"",
"CR_TAB",
"\"clr %C0\"",
",",
"op",
",",
"plen",
",",
"2",
")",
";",
"default",
":",
"if",
"(",
"INTVAL",
"(",
"op",
"[",
"2",
"]",
")",
"<",
"24",
")",
"break",
";",
"case",
"23",
":",
"return",
"avr_asm_len",
"(",
"\"clr %A0\"",
"CR_TAB",
"\"sbrc %C0,7\"",
"CR_TAB",
"\"inc %A0\"",
"CR_TAB",
"\"clr %B0\"",
"CR_TAB",
"\"clr %C0\"",
",",
"op",
",",
"plen",
",",
"5",
")",
";",
"}",
"}",
"out_shift_with_cnt",
"(",
"\"lsr %C0\"",
"CR_TAB",
"\"ror %B0\"",
"CR_TAB",
"\"ror %A0\"",
",",
"insn",
",",
"op",
",",
"plen",
",",
"3",
")",
";",
"return",
"\"\"",
";",
"}",
"</s>"
] | [
"24-bit",
"logic",
"shift",
"right"
] | [
"avr",
"0",
"1",
"2",
"0",
"2",
"8",
"\"mov %A0,%B1\"",
"\"mov %B0,%C1\"",
"\"clr %C0\"",
"3",
"\"clr %C0\"",
"\"mov %B0,%C1\"",
"\"mov %A0,%B1\"",
"3",
"16",
"2",
"\"mov %A0,%C1\"",
"1",
"\"clr %B0\"",
"\"clr %C0\"",
"2",
"2",
"24",
"23",
"\"clr %A0\"",
"\"sbrc %C0,7\"",
"\"inc %A0\"",
"\"clr %B0\"",
"\"clr %C0\"",
"5",
"\"lsr %C0\"",
"\"ror %B0\"",
"\"ror %A0\"",
"3",
"\"\""
] | avr | avr_out_lshrpsi3 | avr | MPU | GCC | 16,687 | 211 | 1 | [] |
[
"<s>",
"BitVector",
"WDC65816RegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"WDC",
"::",
"P",
")",
";",
"Reserved",
".",
"set",
"(",
"WDC",
"::",
"S",
")",
";",
"Reserved",
".",
"set",
"(",
"WDC",
"::",
"D",
")",
";",
"Reserved",
".",
"set",
"(",
"WDC",
"::",
"K",
")",
";",
"Reserved",
".",
"set",
"(",
"WDC",
"::",
"B",
")",
";",
"Reserved",
".",
"set",
"(",
"WDC",
"::",
"PC",
")",
";",
"Reserved",
".",
"set",
"(",
"WDC",
"::",
"dpI32_0",
")",
";",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"WDC65816",
"WDC",
"WDC::P",
"WDC::S",
"WDC::D",
"WDC::K",
"WDC::B",
"WDC::PC",
"WDC::dpI32_0"
] | WDC65816RegisterInfo | getReservedRegs | WDC65816 | MPU | LLVM | 16,688 | 87 | 1 | [] |
[
"<s>",
"void",
"setReg",
"(",
"unsigned",
"Reg",
")",
"{",
"assert",
"(",
"isRegBase",
"(",
")",
"&&",
"\"Invalid base register access!\"",
")",
";",
"assert",
"(",
"!",
"IsBaseSet",
"&&",
"\"Base cannot be reset\"",
")",
";",
"Base",
".",
"Reg",
"=",
"Reg",
";",
"IsBaseSet",
"=",
"true",
";",
"}",
"</s>"
] | [
"Assigns",
"the",
"associated",
"register",
"for",
"this",
"edge",
"."
] | [
"WebAssembly",
"\"Invalid base register access!\"",
"\"Base cannot be reset\""
] | WebAssemblyFastISel (2)2 | setReg | WebAssembly | Virtual ISA | LLVM | 16,689 | 35 | 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",
"AsmPrinter",
"::",
"PrintAsmOperand",
"(",
"MI",
",",
"OpNo",
",",
"AsmVariant",
",",
"ExtraCode",
",",
"O",
")",
";",
"case",
"'f'",
":",
"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"
] | SparcAsmPrinter12 | PrintAsmOperand | Sparc | CPU | LLVM | 16,690 | 97 | 1 | [] |
[
"<s>",
"bool",
"isNoopAddrSpaceCast",
"(",
"unsigned",
"SrcAS",
",",
"unsigned",
"DestAS",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"a",
"cast",
"between",
"SrcAS",
"and",
"DestAS",
"is",
"a",
"noop",
"."
] | [
"Patmos"
] | PatmosTargetMachine1 | isNoopAddrSpaceCast | Patmos | VLIW | LLVM | 16,691 | 16 | 1 | [] |
[
"<s>",
"bool",
"MipsCallEntry",
"::",
"mayAlias",
"(",
"const",
"MachineFrameInfo",
"*",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"this",
"instruction",
"'s",
"memory",
"access",
"aliases",
"the",
"memory",
"access",
"of",
"Other",
"."
] | [
"Mips",
"Mips"
] | MipsMachineFunction | mayAlias | Mips | CPU | LLVM | 16,692 | 15 | 1 | [] |
[
"<s>",
"bool",
"HexagonInstrInfo",
"::",
"isSchedulingBoundary",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"MachineBasicBlock",
"*",
"MBB",
",",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"isDebugValue",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"MI",
".",
"isCall",
"(",
")",
")",
"{",
"if",
"(",
"doesNotReturn",
"(",
"MI",
")",
")",
"return",
"true",
";",
"for",
"(",
"auto",
"I",
":",
"MBB",
"->",
"successors",
"(",
")",
")",
"if",
"(",
"I",
"->",
"isEHPad",
"(",
")",
")",
"return",
"true",
";",
"}",
"if",
"(",
"MI",
".",
"getDesc",
"(",
")",
".",
"isTerminator",
"(",
")",
"||",
"MI",
".",
"isPosition",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"MI",
".",
"isInlineAsm",
"(",
")",
"&&",
"!",
"ScheduleInlineAsm",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"isSchedulingBoundary",
"-",
"Overrides",
"the",
"isSchedulingBoundary",
"from",
"Codegen/TargetInstrInfo.cpp",
"to",
"make",
"it",
"capable",
"of",
"identifying",
"ENDBR",
"intructions",
"and",
"prevent",
"it",
"from",
"being",
"re-scheduled",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonInstrInfo10 | isSchedulingBoundary | Hexagon | DSP | LLVM | 16,693 | 114 | 1 | [] |
[
"<s>",
"BitVector",
"ARMBaseRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"ARMSubtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"const",
"ARMFrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"SP",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"PC",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"FPSCR",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"APSR_NZCV",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"||",
"STI",
".",
"isTargetDarwin",
"(",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"getFramePointerReg",
"(",
"STI",
")",
")",
";",
"if",
"(",
"hasBasePointer",
"(",
"MF",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"BasePtr",
")",
";",
"if",
"(",
"STI",
".",
"isR9Reserved",
"(",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"R9",
")",
";",
"if",
"(",
"!",
"STI",
".",
"hasD32",
"(",
")",
")",
"{",
"static_assert",
"(",
"ARM",
"::",
"D31",
"==",
"ARM",
"::",
"D16",
"+",
"15",
",",
"\"Register list not consecutive!\"",
")",
";",
"for",
"(",
"unsigned",
"R",
"=",
"0",
";",
"R",
"<",
"16",
";",
"++",
"R",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"D16",
"+",
"R",
")",
";",
"}",
"const",
"TargetRegisterClass",
"&",
"RC",
"=",
"ARM",
"::",
"GPRPairRegClass",
";",
"for",
"(",
"unsigned",
"Reg",
":",
"RC",
")",
"for",
"(",
"MCSubRegIterator",
"SI",
"(",
"Reg",
",",
"this",
")",
";",
"SI",
".",
"isValid",
"(",
")",
";",
"++",
"SI",
")",
"if",
"(",
"Reserved",
".",
"test",
"(",
"*",
"SI",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"Reg",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"ZR",
")",
";",
"assert",
"(",
"checkAllSuperRegsMarked",
"(",
"Reserved",
")",
")",
";",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"ARM::SP",
"ARM::PC",
"ARM::FPSCR",
"ARM::APSR_NZCV",
"ARM::R9",
"ARM::D31",
"ARM::D16",
"15",
"\"Register list not consecutive!\"",
"0",
"16",
"ARM::D16",
"ARM::GPRPairRegClass",
"ARM::ZR"
] | ARMBaseRegisterInfo17 | getReservedRegs | ARM | CPU | LLVM | 16,694 | 260 | 1 | [] |
[
"<s>",
"bool",
"MipsTargetLowering",
"::",
"CanLowerReturn",
"(",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"MachineFunction",
"&",
"MF",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"LLVMContext",
"&",
"Context",
")",
"const",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"MipsCCState",
"CCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"MF",
",",
"RVLocs",
",",
"Context",
")",
";",
"return",
"CCInfo",
".",
"CheckReturn",
"(",
"Outs",
",",
"RetCC_Mips",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"should",
"be",
"implemented",
"to",
"check",
"whether",
"the",
"return",
"values",
"described",
"by",
"the",
"Outs",
"array",
"can",
"fit",
"into",
"the",
"return",
"registers",
"."
] | [
"Mips",
"Mips",
"ISD::OutputArg",
"16",
"Mips",
"Mips"
] | MipsISelLowering (2)4 | CanLowerReturn | Mips | CPU | LLVM | 16,695 | 66 | 1 | [] |
[
"<s>",
"static",
"bool",
"visium_pass_by_reference",
"(",
"cumulative_args_t",
",",
"const",
"function_arg_info",
"&",
"arg",
")",
"{",
"tree",
"type",
"=",
"arg",
".",
"type",
";",
"return",
"type",
"&&",
"(",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
"||",
"TREE_CODE",
"(",
"type",
")",
"==",
"VECTOR_TYPE",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"an",
"argument",
"must",
"be",
"passed",
"by",
"indirect",
"reference",
"."
] | [
"visium"
] | visium | visium_pass_by_reference | visium | Virtual ISA | GCC | 16,696 | 37 | 1 | [] |
[
"<s>",
"virtual",
"MachineInstr",
"*",
"foldMemoryOperandImpl",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineInstr",
"*",
"MI",
",",
"const",
"SmallVectorImpl",
"<",
"unsigned",
">",
"&",
"Ops",
",",
"MachineInstr",
"*",
"LoadMI",
")",
"const",
"{",
"return",
"0",
";",
"}",
"</s>"
] | [
"foldMemoryOperand",
"-",
"Same",
"as",
"the",
"previous",
"version",
"except",
"it",
"allows",
"folding",
"of",
"any",
"load",
"and",
"store",
"from",
"/",
"to",
"any",
"address",
",",
"not",
"just",
"from",
"a",
"specific",
"stack",
"slot",
"."
] | [
"Mips",
"0"
] | MipsInstrInfo30 | foldMemoryOperandImpl | Mips | CPU | LLVM | 16,697 | 31 | 1 | [] |
[
"<s>",
"int",
"tilepro_initial_elimination_offset",
"(",
"int",
"from",
",",
"int",
"to",
")",
"{",
"int",
"total_size",
"=",
"compute_total_frame_size",
"(",
")",
";",
"if",
"(",
"from",
"==",
"FRAME_POINTER_REGNUM",
"&&",
"to",
"==",
"STACK_POINTER_REGNUM",
")",
"{",
"return",
"(",
"total_size",
"-",
"crtl",
"->",
"args",
".",
"pretend_args_size",
"-",
"tilepro_saved_regs_size",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"from",
"==",
"FRAME_POINTER_REGNUM",
"&&",
"to",
"==",
"HARD_FRAME_POINTER_REGNUM",
")",
"{",
"return",
"-",
"(",
"crtl",
"->",
"args",
".",
"pretend_args_size",
"+",
"tilepro_saved_regs_size",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"from",
"==",
"ARG_POINTER_REGNUM",
"&&",
"to",
"==",
"STACK_POINTER_REGNUM",
")",
"{",
"return",
"STACK_POINTER_OFFSET",
"+",
"total_size",
";",
"}",
"else",
"if",
"(",
"from",
"==",
"ARG_POINTER_REGNUM",
"&&",
"to",
"==",
"HARD_FRAME_POINTER_REGNUM",
")",
"{",
"return",
"STACK_POINTER_OFFSET",
";",
"}",
"else",
"gcc_unreachable",
"(",
")",
";",
"}",
"</s>"
] | [
"Implement",
"INITIAL_ELIMINATION_OFFSET",
"."
] | [
"tilepro"
] | tilepro | tilepro_initial_elimination_offset | tilepro | VLIW | GCC | 16,698 | 111 | 1 | [] |
[
"<s>",
"bool",
"PPCSubtarget",
"::",
"enableMachineScheduler",
"(",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Enable",
"the",
"MachineScheduler",
"pass",
"for",
"all",
"X86",
"subtargets",
"."
] | [
"PowerPC",
"PPC"
] | PPCSubtarget | enableMachineScheduler | PowerPC | CPU | LLVM | 16,699 | 12 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.