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>",
"const",
"TargetRegisterClass",
"*",
"ARMBaseRegisterInfo",
"::",
"getLargestLegalSuperClass",
"(",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetRegisterClass",
"*",
"Super",
"=",
"RC",
";",
"TargetRegisterClass",
"::",
"sc_iterator",
"I",
"=",
"RC",
"->",
"getSuperClasses",
"(",
")",
";",
"do",
"{",
"switch",
"(",
"Super",
"->",
"getID",
"(",
")",
")",
"{",
"case",
"ARM",
"::",
"GPRRegClassID",
":",
"case",
"ARM",
"::",
"SPRRegClassID",
":",
"case",
"ARM",
"::",
"DPRRegClassID",
":",
"case",
"ARM",
"::",
"GPRPairRegClassID",
":",
"return",
"Super",
";",
"case",
"ARM",
"::",
"QPRRegClassID",
":",
"case",
"ARM",
"::",
"QQPRRegClassID",
":",
"case",
"ARM",
"::",
"QQQQPRRegClassID",
":",
"if",
"(",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
".",
"hasNEON",
"(",
")",
")",
"return",
"Super",
";",
"break",
";",
"case",
"ARM",
"::",
"MQPRRegClassID",
":",
"case",
"ARM",
"::",
"MQQPRRegClassID",
":",
"case",
"ARM",
"::",
"MQQQQPRRegClassID",
":",
"if",
"(",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
".",
"hasMVEIntegerOps",
"(",
")",
")",
"return",
"Super",
";",
"break",
";",
"}",
"Super",
"=",
"*",
"I",
"++",
";",
"}",
"while",
"(",
"Super",
")",
";",
"return",
"RC",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"largest",
"super",
"class",
"of",
"RC",
"that",
"is",
"legal",
"to",
"use",
"in",
"the",
"current",
"sub-target",
"and",
"has",
"the",
"same",
"spill",
"size",
"."
] | [
"ARM",
"ARM",
"ARM::GPRRegClassID",
"ARM::SPRRegClassID",
"ARM::DPRRegClassID",
"ARM::GPRPairRegClassID",
"ARM::QPRRegClassID",
"ARM::QQPRRegClassID",
"ARM::QQQQPRRegClassID",
"ARM",
"ARM::MQPRRegClassID",
"ARM::MQQPRRegClassID",
"ARM::MQQQQPRRegClassID",
"ARM"
] | ARMBaseRegisterInfo | getLargestLegalSuperClass | ARM | CPU | LLVM | 29,300 | 158 | 1 | [] |
[
"<s>",
"bool",
"X86FrameLowering",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"MachineModuleInfo",
"&",
"MMI",
"=",
"MF",
".",
"getMMI",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"RI",
"=",
"TM",
".",
"getRegisterInfo",
"(",
")",
";",
"return",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"Options",
".",
"DisableFramePointerElim",
"(",
"MF",
")",
"||",
"RI",
"->",
"needsStackRealignment",
"(",
"MF",
")",
"||",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
"||",
"MFI",
"->",
"isFrameAddressTaken",
"(",
")",
"||",
"MF",
".",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
"->",
"getForceFramePointer",
"(",
")",
"||",
"MMI",
".",
"callsUnwindInit",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"X86",
"X86",
"X86"
] | X86FrameLowering128 | hasFP | X86 | CPU | LLVM | 29,301 | 100 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_file_start",
"(",
"void",
")",
"{",
"default_file_start",
"(",
")",
";",
"if",
"(",
"!",
"TARGET_IRIX",
")",
"{",
"const",
"char",
"*",
"abi_string",
"=",
"NULL",
";",
"switch",
"(",
"mips_abi",
")",
"{",
"case",
"ABI_32",
":",
"abi_string",
"=",
"\"abi32\"",
";",
"break",
";",
"case",
"ABI_N32",
":",
"abi_string",
"=",
"\"abiN32\"",
";",
"break",
";",
"case",
"ABI_64",
":",
"abi_string",
"=",
"\"abi64\"",
";",
"break",
";",
"case",
"ABI_O64",
":",
"abi_string",
"=",
"\"abiO64\"",
";",
"break",
";",
"case",
"ABI_EABI",
":",
"abi_string",
"=",
"TARGET_64BIT",
"?",
"\"eabi64\"",
":",
"\"eabi32\"",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.section .mdebug.%s\\n\"",
",",
"abi_string",
")",
";",
"if",
"(",
"mips_abi",
"==",
"ABI_EABI",
")",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.section .gcc_compiled_long%d\\n\"",
",",
"TARGET_LONG64",
"?",
"64",
":",
"32",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.previous\\n\"",
")",
";",
"}",
"if",
"(",
"TARGET_ABICALLS",
")",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.abicalls\\n\"",
")",
";",
"if",
"(",
"TARGET_MIPS16",
")",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\t.set\\tmips16\\n\"",
")",
";",
"if",
"(",
"flag_verbose_asm",
")",
"fprintf",
"(",
"asm_out_file",
",",
"\"\\n%s -G value = %d, Arch = %s, ISA = %d\\n\"",
",",
"ASM_COMMENT_START",
",",
"mips_section_threshold",
",",
"mips_arch_info",
"->",
"name",
",",
"mips_isa",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_ASM_FILE_START",
"."
] | [
"mips",
"\"abi32\"",
"\"abiN32\"",
"\"abi64\"",
"\"abiO64\"",
"\"eabi64\"",
"\"eabi32\"",
"\"\\t.section .mdebug.%s\\n\"",
"\"\\t.section .gcc_compiled_long%d\\n\"",
"64",
"32",
"\"\\t.previous\\n\"",
"\"\\t.abicalls\\n\"",
"\"\\t.set\\tmips16\\n\"",
"\"\\n%s -G value = %d, Arch = %s, ISA = %d\\n\""
] | mips3 | mips_file_start | mips | CPU | GCC | 29,302 | 165 | 1 | [] |
[
"<s>",
"MCAssembler",
"*",
"getAssembler",
"(",
")",
"const",
"{",
"MCAssembler",
"*",
"Assembler",
"=",
"nullptr",
";",
"if",
"(",
"!",
"Parser",
".",
"getStreamer",
"(",
")",
".",
"hasRawTextSupport",
"(",
")",
")",
"{",
"MCELFStreamer",
"*",
"MES",
"=",
"static_cast",
"<",
"MCELFStreamer",
"*",
">",
"(",
"&",
"Parser",
".",
"getStreamer",
"(",
")",
")",
";",
"Assembler",
"=",
"&",
"MES",
"->",
"getAssembler",
"(",
")",
";",
"}",
"return",
"Assembler",
";",
"}",
"</s>"
] | [
"Get",
"the",
"assembler",
"object",
"this",
"is",
"a",
"layout",
"for",
"."
] | [
"Hexagon"
] | HexagonAsmParser | getAssembler | Hexagon | DSP | LLVM | 29,303 | 59 | 1 | [] |
[
"<s>",
"static",
"int",
"arm_barrier_cost",
"(",
"rtx",
"insn",
")",
"{",
"int",
"base_cost",
"=",
"50",
";",
"rtx",
"next",
"=",
"next_nonnote_insn",
"(",
"insn",
")",
";",
"if",
"(",
"next",
"!=",
"NULL",
"&&",
"LABEL_P",
"(",
"next",
")",
")",
"base_cost",
"-=",
"20",
";",
"switch",
"(",
"GET_CODE",
"(",
"insn",
")",
")",
"{",
"case",
"CODE_LABEL",
":",
"return",
"50",
";",
"case",
"INSN",
":",
"case",
"CALL_INSN",
":",
"return",
"base_cost",
";",
"case",
"JUMP_INSN",
":",
"return",
"base_cost",
"-",
"10",
";",
"default",
":",
"return",
"base_cost",
"+",
"10",
";",
"}",
"}",
"</s>"
] | [
"Return",
"the",
"cost",
"of",
"forcibly",
"inserting",
"a",
"barrier",
"after",
"INSN",
"."
] | [
"arm",
"50",
"20",
"50",
"10",
"10"
] | arm4 | arm_barrier_cost | arm | CPU | GCC | 29,304 | 76 | 1 | [] |
[
"<s>",
"SDValue",
"MipsTargetLowering",
"::",
"LowerCallResult",
"(",
"SDValue",
"Chain",
",",
"SDValue",
"InFlag",
",",
"unsigned",
"CallConv",
",",
"bool",
"isVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeCallResult",
"(",
"Ins",
",",
"RetCC_Mips",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"Chain",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"dl",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getLocReg",
"(",
")",
",",
"RVLocs",
"[",
"i",
"]",
".",
"getValVT",
"(",
")",
",",
"InFlag",
")",
".",
"getValue",
"(",
"1",
")",
";",
"InFlag",
"=",
"Chain",
".",
"getValue",
"(",
"2",
")",
";",
"InVals",
".",
"push_back",
"(",
"Chain",
".",
"getValue",
"(",
"0",
")",
")",
";",
"}",
"return",
"Chain",
";",
"}",
"</s>"
] | [
"LowerCallResult",
"-",
"Lower",
"the",
"result",
"values",
"of",
"an",
"ISD",
":",
":CALL",
"into",
"the",
"appropriate",
"copies",
"out",
"of",
"appropriate",
"physical",
"registers",
"."
] | [
"Mips",
"Mips",
"ISD::InputArg",
"16",
"Mips",
"0",
"1",
"2",
"0"
] | MipsISelLowering93 | LowerCallResult | Mips | CPU | LLVM | 29,305 | 161 | 1 | [] |
[
"<s>",
"void",
"setAlignment",
"(",
"unsigned",
"Align",
")",
"{",
"Alignment",
"=",
"Align",
";",
"}",
"</s>"
] | [
"setAlignment",
"-",
"Set",
"the",
"alignment",
"of",
"the",
"function",
"."
] | [
"GBZ80"
] | GBZ80TargetObjectFile | setAlignment | GBZ80 | MPU | LLVM | 29,306 | 12 | 1 | [] |
[
"<s>",
"SDValue",
"DLXTargetLowering",
"::",
"LowerOperation",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"unimplemented operand\"",
")",
";",
"}",
"}",
"</s>"
] | [
"LowerOperation",
"-",
"Provide",
"custom",
"lowering",
"hooks",
"for",
"some",
"operations",
"."
] | [
"DLX",
"DLX",
"\"unimplemented operand\""
] | DLXISelLowering | LowerOperation | DLX | CPU | LLVM | 29,307 | 32 | 1 | [] |
[
"<s>",
"static",
"void",
"cris_file_start",
"(",
"void",
")",
"{",
"targetm",
".",
"file_start_app_off",
"=",
"!",
"(",
"TARGET_PDEBUG",
"||",
"flag_print_asm_name",
")",
";",
"targetm",
".",
"file_start_file_directive",
"=",
"TARGET_ELF",
";",
"default_file_start",
"(",
")",
";",
"}",
"</s>"
] | [
"Boilerplate",
"emitted",
"at",
"start",
"of",
"file",
".",
"NO_APP",
"*",
"only",
"at",
"file",
"start",
"*",
"means",
"faster",
"assembly",
".",
"It",
"also",
"means",
"comments",
"are",
"not",
"allowed",
".",
"In",
"some",
"cases",
"comments",
"will",
"be",
"output",
"for",
"debugging",
"purposes",
".",
"Make",
"sure",
"they",
"are",
"allowed",
"then",
".",
"We",
"want",
"a",
".file",
"directive",
"only",
"if",
"TARGET_ELF",
"."
] | [
"cris"
] | cris3 | cris_file_start | cris | MPU | GCC | 29,308 | 29 | 1 | [] |
[
"<s>",
"static",
"void",
"aarch64_emit_load_exclusive",
"(",
"machine_mode",
"mode",
",",
"rtx",
"rval",
",",
"rtx",
"mem",
",",
"rtx",
"model_rtx",
")",
"{",
"rtx",
"(",
"*",
"gen",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"QImode",
":",
"gen",
"=",
"gen_aarch64_load_exclusiveqi",
";",
"break",
";",
"case",
"HImode",
":",
"gen",
"=",
"gen_aarch64_load_exclusivehi",
";",
"break",
";",
"case",
"SImode",
":",
"gen",
"=",
"gen_aarch64_load_exclusivesi",
";",
"break",
";",
"case",
"DImode",
":",
"gen",
"=",
"gen_aarch64_load_exclusivedi",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"emit_insn",
"(",
"gen",
"(",
"rval",
",",
"mem",
",",
"model_rtx",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"load",
"exclusive",
"."
] | [
"aarch64"
] | aarch642 | aarch64_emit_load_exclusive | aarch64 | CPU | GCC | 29,309 | 91 | 1 | [] |
[
"<s>",
"bool",
"LM32FrameLowering",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"TargetRegisterInfo",
"*",
"RegInfo",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"return",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"Options",
".",
"DisableFramePointerElim",
"(",
"MF",
")",
"||",
"RegInfo",
"->",
"needsStackRealignment",
"(",
"MF",
")",
"||",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"hasVarSizedObjects",
"(",
")",
"||",
"MFI",
"->",
"isFrameAddressTaken",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"LM32",
"LM32"
] | LM32FrameLowering | hasFP | LM32 | MPU | LLVM | 29,310 | 78 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"ix86_minimum_incoming_stack_boundary",
"(",
"bool",
"sibcall",
")",
"{",
"unsigned",
"int",
"incoming_stack_boundary",
";",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"func_type",
"!=",
"TYPE_NORMAL",
")",
"incoming_stack_boundary",
"=",
"TARGET_64BIT",
"?",
"128",
":",
"MIN_STACK_BOUNDARY",
";",
"else",
"if",
"(",
"ix86_user_incoming_stack_boundary",
")",
"incoming_stack_boundary",
"=",
"ix86_user_incoming_stack_boundary",
";",
"else",
"if",
"(",
"!",
"sibcall",
"&&",
"ix86_force_align_arg_pointer",
"&&",
"crtl",
"->",
"stack_alignment_estimated",
"==",
"128",
")",
"incoming_stack_boundary",
"=",
"MIN_STACK_BOUNDARY",
";",
"else",
"incoming_stack_boundary",
"=",
"ix86_default_incoming_stack_boundary",
";",
"if",
"(",
"incoming_stack_boundary",
">",
"MIN_STACK_BOUNDARY",
"&&",
"lookup_attribute",
"(",
"ix86_force_align_arg_pointer_string",
",",
"TYPE_ATTRIBUTES",
"(",
"TREE_TYPE",
"(",
"current_function_decl",
")",
")",
")",
")",
"incoming_stack_boundary",
"=",
"MIN_STACK_BOUNDARY",
";",
"if",
"(",
"incoming_stack_boundary",
"<",
"crtl",
"->",
"parm_stack_boundary",
")",
"incoming_stack_boundary",
"=",
"crtl",
"->",
"parm_stack_boundary",
";",
"if",
"(",
"incoming_stack_boundary",
">",
"MAIN_STACK_BOUNDARY",
"&&",
"DECL_NAME",
"(",
"current_function_decl",
")",
"&&",
"MAIN_NAME_P",
"(",
"DECL_NAME",
"(",
"current_function_decl",
")",
")",
"&&",
"DECL_FILE_SCOPE_P",
"(",
"current_function_decl",
")",
")",
"incoming_stack_boundary",
"=",
"MAIN_STACK_BOUNDARY",
";",
"return",
"incoming_stack_boundary",
";",
"}",
"</s>"
] | [
"Return",
"minimum",
"incoming",
"stack",
"alignment",
"."
] | [
"i386",
"128",
"128"
] | i3866 | ix86_minimum_incoming_stack_boundary | i386 | CPU | GCC | 29,311 | 132 | 1 | [] |
[
"<s>",
"Register",
"SparcRegisterInfo",
"::",
"getFrameRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"SP",
"::",
"I6",
";",
"}",
"</s>"
] | [
"Debug",
"information",
"queries",
"."
] | [
"Sparc",
"Sparc",
"SP::I6"
] | SparcRegisterInfo18 | getFrameRegister | Sparc | CPU | LLVM | 29,312 | 18 | 1 | [] |
[
"<s>",
"bool",
"BTFDebug",
"::",
"InstLower",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"MCInst",
"&",
"OutMI",
")",
"{",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"BPF",
"::",
"LD_imm64",
")",
"{",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
";",
"if",
"(",
"MO",
".",
"isGlobal",
"(",
")",
")",
"{",
"const",
"GlobalValue",
"*",
"GVal",
"=",
"MO",
".",
"getGlobal",
"(",
")",
";",
"auto",
"*",
"GVar",
"=",
"dyn_cast",
"<",
"GlobalVariable",
">",
"(",
"GVal",
")",
";",
"if",
"(",
"GVar",
"&&",
"GVar",
"->",
"hasAttribute",
"(",
"BPFCoreSharedInfo",
"::",
"AmaAttr",
")",
")",
"{",
"uint32_t",
"Imm",
"=",
"PatchImms",
"[",
"GVar",
"->",
"getName",
"(",
")",
".",
"str",
"(",
")",
"]",
";",
"OutMI",
".",
"setOpcode",
"(",
"BPF",
"::",
"MOV_ri",
")",
";",
"OutMI",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createReg",
"(",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
")",
")",
";",
"OutMI",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"Imm",
")",
")",
";",
"return",
"true",
";",
"}",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Emit",
"proper",
"patchable",
"instructions",
"."
] | [
"BPF",
"BPF::LD_imm64",
"1",
"BPFCoreSharedInfo::AmaAttr",
"BPF::MOV_ri",
"0"
] | BTFDebug15 | InstLower | BPF | Virtual ISA | LLVM | 29,313 | 154 | 1 | [] |
[
"<s>",
"void",
"CSKYInstPrinter",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"uint64_t",
"Address",
",",
"StringRef",
"Annot",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"const",
"MCInst",
"*",
"NewMI",
"=",
"MI",
";",
"if",
"(",
"NoAliases",
"||",
"!",
"printAliasInstr",
"(",
"NewMI",
",",
"Address",
",",
"STI",
",",
"O",
")",
")",
"printInstruction",
"(",
"NewMI",
",",
"Address",
",",
"STI",
",",
"O",
")",
";",
"printAnnotation",
"(",
"O",
",",
"Annot",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"CSKY",
"CSKY"
] | CSKYInstPrinter | printInst | CSKY | CPU | LLVM | 29,314 | 68 | 1 | [] |
[
"<s>",
"bool",
"MipsAsmPrinter",
"::",
"isBlockOnlyReachableByFallthrough",
"(",
"const",
"MachineBasicBlock",
"*",
"MBB",
")",
"const",
"{",
"const",
"MachineBasicBlock",
"*",
"Pred",
"=",
"*",
"MBB",
"->",
"pred_begin",
"(",
")",
";",
"if",
"(",
"const",
"BasicBlock",
"*",
"bb",
"=",
"Pred",
"->",
"getBasicBlock",
"(",
")",
")",
"if",
"(",
"isa",
"<",
"SwitchInst",
">",
"(",
"bb",
"->",
"getTerminator",
"(",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"MBB",
"->",
"isLandingPad",
"(",
")",
"||",
"MBB",
"->",
"pred_empty",
"(",
")",
")",
"return",
"false",
";",
"MachineBasicBlock",
"::",
"const_pred_iterator",
"PI",
"=",
"MBB",
"->",
"pred_begin",
"(",
")",
",",
"PI2",
"=",
"PI",
";",
"++",
"PI2",
";",
"if",
"(",
"PI2",
"!=",
"MBB",
"->",
"pred_end",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"Pred",
"->",
"isLayoutSuccessor",
"(",
"MBB",
")",
")",
"return",
"false",
";",
"if",
"(",
"Pred",
"->",
"empty",
"(",
")",
")",
"return",
"true",
";",
"MachineBasicBlock",
"::",
"const_iterator",
"I",
"=",
"Pred",
"->",
"end",
"(",
")",
";",
"while",
"(",
"I",
"!=",
"Pred",
"->",
"begin",
"(",
")",
"&&",
"!",
"(",
"--",
"I",
")",
"->",
"isTerminator",
"(",
")",
")",
";",
"return",
"!",
"I",
"->",
"isBarrier",
"(",
")",
";",
"}",
"</s>"
] | [
"isBlockOnlyReachableByFallthough",
"-",
"Return",
"true",
"if",
"the",
"basic",
"block",
"has",
"exactly",
"one",
"predecessor",
"and",
"the",
"control",
"transfer",
"mechanism",
"between",
"the",
"predecessor",
"and",
"this",
"block",
"is",
"a",
"fall-through",
"."
] | [
"Mips",
"Mips"
] | MipsAsmPrinter100 | isBlockOnlyReachableByFallthrough | Mips | CPU | LLVM | 29,315 | 167 | 1 | [] |
[
"<s>",
"bool",
"isReg",
"(",
")",
"const",
"override",
"{",
"return",
"Kind",
"==",
"OpKind",
"::",
"Reg",
";",
"}",
"</s>"
] | [
"isReg",
"-",
"Is",
"this",
"a",
"register",
"operand",
"?"
] | [
"TPC"
] | TPCAsmParser | isReg | TPC | Virtual ISA | LLVM | 29,316 | 15 | 1 | [] |
[
"<s>",
"static",
"int",
"getRegClass",
"(",
"RegisterKind",
"Is",
",",
"unsigned",
"RegWidth",
")",
"{",
"if",
"(",
"Is",
"==",
"IS_VGPR",
")",
"{",
"switch",
"(",
"RegWidth",
")",
"{",
"default",
":",
"return",
"-",
"1",
";",
"case",
"1",
":",
"return",
"AMDGPU",
"::",
"VGPR_32RegClassID",
";",
"case",
"2",
":",
"return",
"AMDGPU",
"::",
"VReg_64RegClassID",
";",
"case",
"3",
":",
"return",
"AMDGPU",
"::",
"VReg_96RegClassID",
";",
"case",
"4",
":",
"return",
"AMDGPU",
"::",
"VReg_128RegClassID",
";",
"case",
"5",
":",
"return",
"AMDGPU",
"::",
"VReg_160RegClassID",
";",
"case",
"6",
":",
"return",
"AMDGPU",
"::",
"VReg_192RegClassID",
";",
"case",
"8",
":",
"return",
"AMDGPU",
"::",
"VReg_256RegClassID",
";",
"case",
"16",
":",
"return",
"AMDGPU",
"::",
"VReg_512RegClassID",
";",
"case",
"32",
":",
"return",
"AMDGPU",
"::",
"VReg_1024RegClassID",
";",
"}",
"}",
"else",
"if",
"(",
"Is",
"==",
"IS_TTMP",
")",
"{",
"switch",
"(",
"RegWidth",
")",
"{",
"default",
":",
"return",
"-",
"1",
";",
"case",
"1",
":",
"return",
"AMDGPU",
"::",
"TTMP_32RegClassID",
";",
"case",
"2",
":",
"return",
"AMDGPU",
"::",
"TTMP_64RegClassID",
";",
"case",
"4",
":",
"return",
"AMDGPU",
"::",
"TTMP_128RegClassID",
";",
"case",
"8",
":",
"return",
"AMDGPU",
"::",
"TTMP_256RegClassID",
";",
"case",
"16",
":",
"return",
"AMDGPU",
"::",
"TTMP_512RegClassID",
";",
"}",
"}",
"else",
"if",
"(",
"Is",
"==",
"IS_SGPR",
")",
"{",
"switch",
"(",
"RegWidth",
")",
"{",
"default",
":",
"return",
"-",
"1",
";",
"case",
"1",
":",
"return",
"AMDGPU",
"::",
"SGPR_32RegClassID",
";",
"case",
"2",
":",
"return",
"AMDGPU",
"::",
"SGPR_64RegClassID",
";",
"case",
"3",
":",
"return",
"AMDGPU",
"::",
"SGPR_96RegClassID",
";",
"case",
"4",
":",
"return",
"AMDGPU",
"::",
"SGPR_128RegClassID",
";",
"case",
"5",
":",
"return",
"AMDGPU",
"::",
"SGPR_160RegClassID",
";",
"case",
"6",
":",
"return",
"AMDGPU",
"::",
"SGPR_192RegClassID",
";",
"case",
"8",
":",
"return",
"AMDGPU",
"::",
"SGPR_256RegClassID",
";",
"case",
"16",
":",
"return",
"AMDGPU",
"::",
"SGPR_512RegClassID",
";",
"}",
"}",
"else",
"if",
"(",
"Is",
"==",
"IS_AGPR",
")",
"{",
"switch",
"(",
"RegWidth",
")",
"{",
"default",
":",
"return",
"-",
"1",
";",
"case",
"1",
":",
"return",
"AMDGPU",
"::",
"AGPR_32RegClassID",
";",
"case",
"2",
":",
"return",
"AMDGPU",
"::",
"AReg_64RegClassID",
";",
"case",
"3",
":",
"return",
"AMDGPU",
"::",
"AReg_96RegClassID",
";",
"case",
"4",
":",
"return",
"AMDGPU",
"::",
"AReg_128RegClassID",
";",
"case",
"5",
":",
"return",
"AMDGPU",
"::",
"AReg_160RegClassID",
";",
"case",
"6",
":",
"return",
"AMDGPU",
"::",
"AReg_192RegClassID",
";",
"case",
"8",
":",
"return",
"AMDGPU",
"::",
"AReg_256RegClassID",
";",
"case",
"16",
":",
"return",
"AMDGPU",
"::",
"AReg_512RegClassID",
";",
"case",
"32",
":",
"return",
"AMDGPU",
"::",
"AReg_1024RegClassID",
";",
"}",
"}",
"return",
"-",
"1",
";",
"}",
"</s>"
] | [
"Given",
"a",
"machine",
"instruction",
"descriptor",
",",
"returns",
"the",
"register",
"class",
"constraint",
"for",
"OpNum",
",",
"or",
"NULL",
"."
] | [
"AMDGPU",
"1",
"1",
"AMDGPU::VGPR_32RegClassID",
"2",
"AMDGPU::VReg_64RegClassID",
"3",
"AMDGPU::VReg_96RegClassID",
"4",
"AMDGPU::VReg_128RegClassID",
"5",
"AMDGPU::VReg_160RegClassID",
"6",
"AMDGPU::VReg_192RegClassID",
"8",
"AMDGPU::VReg_256RegClassID",
"16",
"AMDGPU::VReg_512RegClassID",
"32",
"AMDGPU::VReg_1024RegClassID",
"1",
"1",
"AMDGPU::TTMP_32RegClassID",
"2",
"AMDGPU::TTMP_64RegClassID",
"4",
"AMDGPU::TTMP_128RegClassID",
"8",
"AMDGPU::TTMP_256RegClassID",
"16",
"AMDGPU::TTMP_512RegClassID",
"1",
"1",
"AMDGPU::SGPR_32RegClassID",
"2",
"AMDGPU::SGPR_64RegClassID",
"3",
"AMDGPU::SGPR_96RegClassID",
"4",
"AMDGPU::SGPR_128RegClassID",
"5",
"AMDGPU::SGPR_160RegClassID",
"6",
"AMDGPU::SGPR_192RegClassID",
"8",
"AMDGPU::SGPR_256RegClassID",
"16",
"AMDGPU::SGPR_512RegClassID",
"1",
"1",
"AMDGPU::AGPR_32RegClassID",
"2",
"AMDGPU::AReg_64RegClassID",
"3",
"AMDGPU::AReg_96RegClassID",
"4",
"AMDGPU::AReg_128RegClassID",
"5",
"AMDGPU::AReg_160RegClassID",
"6",
"AMDGPU::AReg_192RegClassID",
"8",
"AMDGPU::AReg_256RegClassID",
"16",
"AMDGPU::AReg_512RegClassID",
"32",
"AMDGPU::AReg_1024RegClassID",
"1"
] | AMDGPUAsmParser11 | getRegClass | AMDGPU | GPU | LLVM | 29,317 | 347 | 1 | [] |
[
"<s>",
"static",
"int",
"pa_reloc_rw_mask",
"(",
"void",
")",
"{",
"return",
"3",
";",
"}",
"</s>"
] | [
"Implement",
"pa_reloc_rw_mask",
"."
] | [
"pa",
"3"
] | pa4 | pa_reloc_rw_mask | pa | CPU | GCC | 29,318 | 11 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_option_override",
"(",
"void",
")",
"{",
"(",
"void",
")",
"rs6000_option_override_internal",
"(",
"true",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_OPTION_OVERRIDE",
".",
"On",
"the",
"RS/6000",
"this",
"is",
"used",
"to",
"define",
"the",
"target",
"cpu",
"type",
"."
] | [
"rs6000"
] | rs6000 | rs6000_option_override | rs6000 | CPU | GCC | 29,319 | 16 | 1 | [] |
[
"<s>",
"void",
"rs6000_emit_sISEL",
"(",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"rtx",
"operands",
"[",
"]",
")",
"{",
"rs6000_emit_int_cmove",
"(",
"operands",
"[",
"0",
"]",
",",
"operands",
"[",
"1",
"]",
",",
"const1_rtx",
",",
"const0_rtx",
")",
";",
"}",
"</s>"
] | [
"Emit",
"the",
"RTL",
"for",
"an",
"sISEL",
"pattern",
"."
] | [
"powerpcspe",
"0",
"1"
] | powerpcspe | rs6000_emit_sISEL | powerpcspe | CPU | GCC | 29,320 | 31 | 1 | [] |
[
"<s>",
"Register",
"getStackAddress",
"(",
"uint64_t",
"Size",
",",
"int64_t",
"Offset",
",",
"MachinePointerInfo",
"&",
"MPO",
")",
"override",
"{",
"auto",
"&",
"MFI",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
".",
"getFrameInfo",
"(",
")",
";",
"int",
"FI",
"=",
"MFI",
".",
"CreateFixedObject",
"(",
"Size",
",",
"Offset",
",",
"true",
")",
";",
"MPO",
"=",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MIRBuilder",
".",
"getMF",
"(",
")",
",",
"FI",
")",
";",
"Register",
"AddrReg",
"=",
"MRI",
".",
"createGenericVirtualRegister",
"(",
"LLT",
"::",
"pointer",
"(",
"0",
",",
"DL",
".",
"getPointerSizeInBits",
"(",
"0",
")",
")",
")",
";",
"MIRBuilder",
".",
"buildFrameIndex",
"(",
"AddrReg",
",",
"FI",
")",
";",
"return",
"AddrReg",
";",
"}",
"</s>"
] | [
"Materialize",
"a",
"VReg",
"containing",
"the",
"address",
"of",
"the",
"specified",
"stack-based",
"object",
"."
] | [
"X86",
"0",
"0"
] | X86CallLowering14 | getStackAddress | X86 | CPU | LLVM | 29,321 | 93 | 1 | [] |
[
"<s>",
"unsigned",
"MipsSEInstrInfo",
"::",
"isStoreToStackSlot",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"unsigned",
"Opc",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"(",
"Opc",
"==",
"Mips",
"::",
"SW",
")",
"||",
"(",
"Opc",
"==",
"Mips",
"::",
"SD",
")",
"||",
"(",
"Opc",
"==",
"Mips",
"::",
"SWC1",
")",
"||",
"(",
"Opc",
"==",
"Mips",
"::",
"SDC1",
")",
"||",
"(",
"Opc",
"==",
"Mips",
"::",
"SDC164",
")",
")",
"{",
"if",
"(",
"(",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"isFI",
"(",
")",
")",
"&&",
"(",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"isImm",
"(",
")",
")",
"&&",
"(",
"isZeroImm",
"(",
"MI",
"->",
"getOperand",
"(",
"2",
")",
")",
")",
")",
"{",
"FrameIndex",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isStoreToStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"store",
"to",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"source",
"reg",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"Mips",
"Mips",
"Mips::SW",
"Mips::SD",
"Mips::SWC1",
"Mips::SDC1",
"Mips::SDC164",
"1",
"2",
"2",
"1",
"0",
"0"
] | MipsSEInstrInfo15 | isStoreToStackSlot | Mips | CPU | LLVM | 29,322 | 140 | 1 | [] |
[
"<s>",
"bool",
"Z80AsmPrinter",
"::",
"PrintAsmMemoryOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNum",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"int",
"Offset",
"=",
"0",
";",
"if",
"(",
"ExtraCode",
")",
"{",
"return",
"true",
";",
"}",
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNum",
")",
";",
"assert",
"(",
"MO",
".",
"isReg",
"(",
")",
"&&",
"\"unexpected inline asm memory operand\"",
")",
";",
"O",
"<<",
"Offset",
"<<",
"\"(\"",
"<<",
"Z80InstPrinter",
"::",
"getRegisterName",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
"<<",
"\")\"",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"operand",
"of",
"MI",
",",
"an",
"INLINEASM",
"instruction",
",",
"using",
"the",
"specified",
"assembler",
"variant",
"as",
"an",
"address",
"."
] | [
"Z80",
"Z80",
"0",
"\"unexpected inline asm memory operand\"",
"\"(\"",
"Z80",
"\")\""
] | Z80AsmPrinter (2) | PrintAsmMemoryOperand | Z80 | MPU | LLVM | 29,323 | 86 | 1 | [] |
[
"<s>",
"void",
"X86InstrInfo",
"::",
"reMaterialize",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"DestReg",
",",
"unsigned",
"SubIdx",
",",
"const",
"MachineInstr",
"&",
"Orig",
",",
"const",
"TargetRegisterInfo",
"&",
"TRI",
")",
"const",
"{",
"bool",
"ClobbersEFLAGS",
"=",
"Orig",
".",
"modifiesRegister",
"(",
"X86",
"::",
"EFLAGS",
",",
"&",
"TRI",
")",
";",
"if",
"(",
"ClobbersEFLAGS",
"&&",
"!",
"isSafeToClobberEFLAGS",
"(",
"MBB",
",",
"I",
")",
")",
"{",
"int",
"Value",
";",
"switch",
"(",
"Orig",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"X86",
"::",
"MOV32r0",
":",
"Value",
"=",
"0",
";",
"break",
";",
"case",
"X86",
"::",
"MOV32r1",
":",
"Value",
"=",
"1",
";",
"break",
";",
"case",
"X86",
"::",
"MOV32r_1",
":",
"Value",
"=",
"-",
"1",
";",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"Unexpected instruction!\"",
")",
";",
"}",
"const",
"DebugLoc",
"&",
"DL",
"=",
"Orig",
".",
"getDebugLoc",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"X86",
"::",
"MOV32ri",
")",
")",
".",
"add",
"(",
"Orig",
".",
"getOperand",
"(",
"0",
")",
")",
".",
"addImm",
"(",
"Value",
")",
";",
"}",
"else",
"{",
"MachineInstr",
"*",
"MI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"CloneMachineInstr",
"(",
"&",
"Orig",
")",
";",
"MBB",
".",
"insert",
"(",
"I",
",",
"MI",
")",
";",
"}",
"MachineInstr",
"&",
"NewMI",
"=",
"*",
"std",
"::",
"prev",
"(",
"I",
")",
";",
"NewMI",
".",
"substituteRegister",
"(",
"Orig",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
",",
"DestReg",
",",
"SubIdx",
",",
"TRI",
")",
";",
"}",
"</s>"
] | [
"Re-issue",
"the",
"specified",
"'original",
"'",
"instruction",
"at",
"the",
"specific",
"location",
"targeting",
"a",
"new",
"destination",
"register",
"."
] | [
"X86",
"X86",
"X86::EFLAGS",
"X86::MOV32r0",
"0",
"X86::MOV32r1",
"1",
"X86::MOV32r_1",
"1",
"\"Unexpected instruction!\"",
"X86::MOV32ri",
"0",
"0"
] | X86InstrInfo106 | reMaterialize | X86 | CPU | LLVM | 29,324 | 220 | 1 | [] |
[
"<s>",
"static",
"HOST_WIDE_INT",
"xtensa_constant_alignment",
"(",
"const_tree",
"exp",
",",
"HOST_WIDE_INT",
"align",
")",
"{",
"if",
"(",
"(",
"TREE_CODE",
"(",
"exp",
")",
"==",
"STRING_CST",
"||",
"TREE_CODE",
"(",
"exp",
")",
"==",
"CONSTRUCTOR",
")",
"&&",
"!",
"optimize_size",
")",
"return",
"MAX",
"(",
"align",
",",
"BITS_PER_WORD",
")",
";",
"return",
"align",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_CONSTANT_ALIGNMENT",
".",
"Align",
"string",
"constants",
"and",
"constructors",
"to",
"at",
"least",
"a",
"word",
"boundary",
".",
"The",
"typical",
"use",
"of",
"this",
"macro",
"is",
"to",
"increase",
"alignment",
"for",
"string",
"constants",
"to",
"be",
"word",
"aligned",
"so",
"that",
"'strcpy",
"'",
"calls",
"that",
"copy",
"constants",
"can",
"be",
"done",
"inline",
"."
] | [
"xtensa"
] | xtensa | xtensa_constant_alignment | xtensa | MPU | GCC | 29,325 | 44 | 1 | [] |
[
"<s>",
"bool",
"BPFAdjustOptImpl",
"::",
"run",
"(",
")",
"{",
"for",
"(",
"Function",
"&",
"F",
":",
"*",
"M",
")",
"for",
"(",
"auto",
"&",
"BB",
":",
"F",
")",
"{",
"adjustBasicBlock",
"(",
"BB",
")",
";",
"for",
"(",
"auto",
"&",
"I",
":",
"BB",
")",
"adjustInst",
"(",
"I",
")",
";",
"}",
"return",
"insertPassThrough",
"(",
")",
";",
"}",
"</s>"
] | [
"Run",
"the",
"analysis",
"pass",
"over",
"a",
"function",
"and",
"produce",
"a",
"dominator",
"tree",
"."
] | [
"BPF",
"BPF"
] | BPFAdjustOpt1 | run | BPF | Virtual ISA | LLVM | 29,326 | 50 | 1 | [] |
[
"<s>",
"static",
"rtx",
"mips_expand_builtin_bposge",
"(",
"enum",
"mips_builtin_type",
"builtin_type",
",",
"rtx",
"target",
")",
"{",
"rtx",
"condition",
",",
"cmp_result",
";",
"int",
"cmp_value",
";",
"if",
"(",
"target",
"==",
"0",
"||",
"GET_MODE",
"(",
"target",
")",
"!=",
"SImode",
")",
"target",
"=",
"gen_reg_rtx",
"(",
"SImode",
")",
";",
"cmp_result",
"=",
"gen_rtx_REG",
"(",
"CCDSPmode",
",",
"CCDSP_PO_REGNUM",
")",
";",
"if",
"(",
"builtin_type",
"==",
"MIPS_BUILTIN_BPOSGE32",
")",
"cmp_value",
"=",
"32",
";",
"else",
"gcc_assert",
"(",
"0",
")",
";",
"condition",
"=",
"gen_rtx_GE",
"(",
"VOIDmode",
",",
"cmp_result",
",",
"GEN_INT",
"(",
"cmp_value",
")",
")",
";",
"return",
"mips_builtin_branch_and_move",
"(",
"condition",
",",
"target",
",",
"const1_rtx",
",",
"const0_rtx",
")",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"bposge",
"builtin",
"of",
"type",
"BUILTIN_TYPE",
".",
"TARGET",
",",
"if",
"nonnull",
",",
"suggests",
"a",
"good",
"place",
"to",
"put",
"the",
"boolean",
"result",
".",
"The",
"sequence",
"we",
"want",
"is",
"li",
"target",
",",
"0",
"bposge",
"*",
"label1",
"j",
"label2",
"label1",
":",
"li",
"target",
",",
"1",
"label2",
":"
] | [
"mips",
"0",
"32",
"0"
] | mips | mips_expand_builtin_bposge | mips | CPU | GCC | 29,327 | 92 | 1 | [] |
[
"<s>",
"Register",
"getStackAddress",
"(",
"uint64_t",
"Size",
",",
"int64_t",
"Offset",
",",
"MachinePointerInfo",
"&",
"MPO",
",",
"ISD",
"::",
"ArgFlagsTy",
"Flags",
")",
"override",
"{",
"auto",
"&",
"MFI",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"bool",
"IsImmutable",
"=",
"!",
"Flags",
".",
"isByVal",
"(",
")",
";",
"int",
"FI",
"=",
"MFI",
".",
"CreateFixedObject",
"(",
"Size",
",",
"Offset",
",",
"IsImmutable",
")",
";",
"MPO",
"=",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MIRBuilder",
".",
"getMF",
"(",
")",
",",
"FI",
")",
";",
"return",
"MIRBuilder",
".",
"buildFrameIndex",
"(",
"LLT",
"::",
"pointer",
"(",
"0",
",",
"DL",
".",
"getPointerSizeInBits",
"(",
"0",
")",
")",
",",
"FI",
")",
".",
"getReg",
"(",
"0",
")",
";",
"}",
"</s>"
] | [
"Materialize",
"a",
"VReg",
"containing",
"the",
"address",
"of",
"the",
"specified",
"stack-based",
"object",
"."
] | [
"X86",
"ISD::ArgFlagsTy",
"0",
"0",
"0"
] | X86CallLowering11 | getStackAddress | X86 | CPU | LLVM | 29,328 | 102 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_split_v4si_init_di_reg",
"(",
"rtx",
"dest",
",",
"rtx",
"si1",
",",
"rtx",
"si2",
",",
"rtx",
"tmp",
")",
"{",
"const",
"unsigned",
"HOST_WIDE_INT",
"mask_32bit",
"=",
"HOST_WIDE_INT_C",
"(",
"0xffffffff",
")",
";",
"if",
"(",
"CONST_INT_P",
"(",
"si1",
")",
"&&",
"CONST_INT_P",
"(",
"si2",
")",
")",
"{",
"unsigned",
"HOST_WIDE_INT",
"const1",
"=",
"(",
"UINTVAL",
"(",
"si1",
")",
"&",
"mask_32bit",
")",
"<<",
"32",
";",
"unsigned",
"HOST_WIDE_INT",
"const2",
"=",
"UINTVAL",
"(",
"si2",
")",
"&",
"mask_32bit",
";",
"emit_move_insn",
"(",
"dest",
",",
"GEN_INT",
"(",
"const1",
"|",
"const2",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"CONST_INT_P",
"(",
"si1",
")",
")",
"emit_move_insn",
"(",
"dest",
",",
"GEN_INT",
"(",
"(",
"UINTVAL",
"(",
"si1",
")",
"&",
"mask_32bit",
")",
"<<",
"32",
")",
")",
";",
"else",
"{",
"rtx",
"si1_di",
"=",
"gen_rtx_REG",
"(",
"DImode",
",",
"regno_or_subregno",
"(",
"si1",
")",
")",
";",
"rtx",
"shift_rtx",
"=",
"gen_rtx_ASHIFT",
"(",
"DImode",
",",
"si1_di",
",",
"GEN_INT",
"(",
"32",
")",
")",
";",
"rtx",
"mask_rtx",
"=",
"GEN_INT",
"(",
"mask_32bit",
"<<",
"32",
")",
";",
"rtx",
"and_rtx",
"=",
"gen_rtx_AND",
"(",
"DImode",
",",
"shift_rtx",
",",
"mask_rtx",
")",
";",
"gcc_assert",
"(",
"!",
"reg_overlap_mentioned_p",
"(",
"dest",
",",
"si1",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"dest",
",",
"and_rtx",
")",
")",
";",
"}",
"gcc_assert",
"(",
"!",
"reg_overlap_mentioned_p",
"(",
"dest",
",",
"tmp",
")",
")",
";",
"if",
"(",
"CONST_INT_P",
"(",
"si2",
")",
")",
"emit_move_insn",
"(",
"tmp",
",",
"GEN_INT",
"(",
"UINTVAL",
"(",
"si2",
")",
"&",
"mask_32bit",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_zero_extendsidi2",
"(",
"tmp",
",",
"si2",
")",
")",
";",
"emit_insn",
"(",
"gen_iordi3",
"(",
"dest",
",",
"dest",
",",
"tmp",
")",
")",
";",
"return",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"for",
"rs6000_split_v4si_init",
"to",
"build",
"up",
"a",
"DImode",
"value",
"from",
"two",
"SImode",
"values",
"."
] | [
"rs6000",
"0xffffffff",
"32",
"32",
"32",
"32"
] | rs60006 | rs6000_split_v4si_init_di_reg | rs6000 | CPU | GCC | 29,329 | 240 | 1 | [] |
[
"<s>",
"static",
"void",
"s390_init_frame_layout",
"(",
"void",
")",
"{",
"HOST_WIDE_INT",
"frame_size",
";",
"int",
"base_used",
";",
"if",
"(",
"reload_completed",
")",
"return",
";",
"do",
"{",
"frame_size",
"=",
"cfun_frame_layout",
".",
"frame_size",
";",
"base_used",
"=",
"crtl",
"->",
"uses_const_pool",
"||",
"(",
"!",
"DISP_IN_RANGE",
"(",
"frame_size",
")",
"&&",
"!",
"CONST_OK_FOR_K",
"(",
"frame_size",
")",
")",
";",
"if",
"(",
"!",
"base_used",
")",
"cfun",
"->",
"machine",
"->",
"base_reg",
"=",
"NULL_RTX",
";",
"else",
"{",
"int",
"br",
"=",
"0",
";",
"if",
"(",
"crtl",
"->",
"is_leaf",
")",
"for",
"(",
"br",
"=",
"5",
";",
"br",
">=",
"2",
"&&",
"df_regs_ever_live_p",
"(",
"br",
")",
";",
"br",
"--",
")",
";",
"cfun",
"->",
"machine",
"->",
"base_reg",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"(",
"br",
">=",
"2",
")",
"?",
"br",
":",
"BASE_REGNUM",
")",
";",
"}",
"s390_register_info",
"(",
")",
";",
"s390_frame_info",
"(",
")",
";",
"}",
"while",
"(",
"frame_size",
"!=",
"cfun_frame_layout",
".",
"frame_size",
")",
";",
"}",
"</s>"
] | [
"Generate",
"frame",
"layout",
".",
"Fills",
"in",
"register",
"and",
"frame",
"data",
"for",
"the",
"current",
"function",
"in",
"cfun-",
">",
"machine",
".",
"This",
"routine",
"can",
"be",
"called",
"multiple",
"times",
";",
"it",
"will",
"re-do",
"the",
"complete",
"frame",
"layout",
"every",
"time",
"."
] | [
"s390",
"0",
"5",
"2",
"2"
] | s390 | s390_init_frame_layout | s390 | MPU | GCC | 29,330 | 133 | 1 | [] |
[
"<s>",
"int",
"sparc_check_64",
"(",
"rtx",
"x",
",",
"rtx_insn",
"*",
"insn",
")",
"{",
"int",
"set_once",
"=",
"0",
";",
"rtx",
"y",
"=",
"x",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"REG",
")",
";",
"if",
"(",
"GET_MODE",
"(",
"x",
")",
"==",
"DImode",
")",
"y",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"REGNO",
"(",
"x",
")",
"+",
"WORDS_BIG_ENDIAN",
")",
";",
"if",
"(",
"flag_expensive_optimizations",
"&&",
"df",
"&&",
"DF_REG_DEF_COUNT",
"(",
"REGNO",
"(",
"y",
")",
")",
"==",
"1",
")",
"set_once",
"=",
"1",
";",
"if",
"(",
"insn",
"==",
"0",
")",
"{",
"if",
"(",
"set_once",
")",
"insn",
"=",
"get_last_insn_anywhere",
"(",
")",
";",
"else",
"return",
"0",
";",
"}",
"while",
"(",
"(",
"insn",
"=",
"PREV_INSN",
"(",
"insn",
")",
")",
")",
"{",
"switch",
"(",
"GET_CODE",
"(",
"insn",
")",
")",
"{",
"case",
"JUMP_INSN",
":",
"case",
"NOTE",
":",
"break",
";",
"case",
"CODE_LABEL",
":",
"case",
"CALL_INSN",
":",
"default",
":",
"if",
"(",
"!",
"set_once",
")",
"return",
"0",
";",
"break",
";",
"case",
"INSN",
":",
"{",
"rtx",
"pat",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"!=",
"SET",
")",
"return",
"0",
";",
"if",
"(",
"rtx_equal_p",
"(",
"x",
",",
"SET_DEST",
"(",
"pat",
")",
")",
")",
"return",
"set_extends",
"(",
"insn",
")",
";",
"if",
"(",
"y",
"&&",
"rtx_equal_p",
"(",
"y",
",",
"SET_DEST",
"(",
"pat",
")",
")",
")",
"return",
"set_extends",
"(",
"insn",
")",
";",
"if",
"(",
"reg_overlap_mentioned_p",
"(",
"SET_DEST",
"(",
"pat",
")",
",",
"y",
")",
")",
"return",
"0",
";",
"}",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"0",
"if",
"the",
"high",
"32",
"bits",
"of",
"X",
"(",
"the",
"low",
"word",
"of",
"X",
",",
"if",
"DImode",
")",
"are",
"unknown",
".",
"Return",
"1",
"if",
"the",
"high",
"bits",
"are",
"zero",
",",
"-1",
"if",
"the",
"register",
"is",
"sign",
"extended",
"."
] | [
"sparc",
"0",
"1",
"1",
"0",
"0",
"0",
"0",
"0",
"0"
] | sparc | sparc_check_64 | sparc | CPU | GCC | 29,331 | 226 | 1 | [] |
[
"<s>",
"const",
"CAHPInstrInfo",
"*",
"getInstrInfo",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"InstrInfo",
";",
"}",
"</s>"
] | [
"TargetInstrInfo",
"getter",
"."
] | [
"CAHP",
"CAHP"
] | CAHPSubtarget | getInstrInfo | CAHP | CPU | LLVM | 29,332 | 14 | 1 | [] |
[
"<s>",
"static",
"bool",
"fits_dispatch_window",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"dispatch_windows",
"*",
"window_list",
"=",
"dispatch_window_list",
";",
"dispatch_windows",
"*",
"window_list_next",
"=",
"dispatch_window_list",
"->",
"next",
";",
"unsigned",
"int",
"num_restrict",
";",
"enum",
"dispatch_group",
"group",
"=",
"get_insn_group",
"(",
"insn",
")",
";",
"enum",
"insn_path",
"path",
"=",
"get_insn_path",
"(",
"insn",
")",
";",
"int",
"sum",
";",
"if",
"(",
"group",
"==",
"disp_jcc",
"||",
"group",
"==",
"disp_cmp",
")",
"return",
"false",
";",
"if",
"(",
"group",
"==",
"disp_no_group",
"||",
"group",
"==",
"disp_branch",
")",
"return",
"true",
";",
"if",
"(",
"window_list_next",
")",
"window_list",
"=",
"window_list_next",
";",
"if",
"(",
"window_list",
"->",
"window_num",
"==",
"1",
")",
"{",
"sum",
"=",
"window_list",
"->",
"prev",
"->",
"window_size",
"+",
"window_list",
"->",
"window_size",
";",
"if",
"(",
"sum",
"==",
"32",
"||",
"(",
"min_insn_size",
"(",
"insn",
")",
"+",
"sum",
")",
">=",
"48",
")",
"return",
"true",
";",
"}",
"num_restrict",
"=",
"count_num_restricted",
"(",
"insn",
",",
"window_list",
")",
";",
"if",
"(",
"num_restrict",
">",
"num_allowable_groups",
"[",
"group",
"]",
")",
"return",
"false",
";",
"if",
"(",
"window_list",
"->",
"window_num",
"==",
"0",
")",
"{",
"if",
"(",
"path",
"==",
"path_double",
"&&",
"(",
"window_list",
"->",
"num_uops",
"+",
"2",
")",
">",
"MAX_INSN",
")",
"return",
"false",
";",
"else",
"if",
"(",
"path",
"!=",
"path_single",
")",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"function",
"returns",
"true",
"if",
"insn",
"satisfies",
"dispatch",
"rules",
"on",
"the",
"last",
"window",
"scheduled",
"."
] | [
"i386",
"1",
"32",
"48",
"0",
"2"
] | i3864 | fits_dispatch_window | i386 | CPU | GCC | 29,333 | 188 | 1 | [] |
[
"<s>",
"SMLoc",
"getEndLoc",
"(",
")",
"const",
"override",
"{",
"return",
"EndLoc",
";",
"}",
"</s>"
] | [
"getEndLoc",
"-",
"Get",
"the",
"location",
"of",
"the",
"last",
"token",
"of",
"this",
"operand",
"."
] | [
"RISCV"
] | RISCVAsmParser (2) | getEndLoc | RISCV | CPU | LLVM | 29,334 | 11 | 1 | [] |
[
"<s>",
"bool",
"ARMBlockPlacement",
"::",
"fixBackwardsWLS",
"(",
"MachineLoop",
"*",
"ML",
")",
"{",
"MachineInstr",
"*",
"WlsInstr",
"=",
"findWLS",
"(",
"ML",
")",
";",
"if",
"(",
"!",
"WlsInstr",
")",
"return",
"false",
";",
"MachineBasicBlock",
"*",
"Predecessor",
"=",
"WlsInstr",
"->",
"getParent",
"(",
")",
";",
"MachineBasicBlock",
"*",
"LoopExit",
"=",
"getWhileLoopStartTargetBB",
"(",
"*",
"WlsInstr",
")",
";",
"if",
"(",
"!",
"LoopExit",
"->",
"getPrevNode",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"blockIsBefore",
"(",
"Predecessor",
",",
"LoopExit",
")",
")",
"return",
"false",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"DEBUG_PREFIX",
"<<",
"\"Found a backwards WLS from \"",
"<<",
"Predecessor",
"->",
"getFullName",
"(",
")",
"<<",
"\" to \"",
"<<",
"LoopExit",
"->",
"getFullName",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"for",
"(",
"auto",
"It",
"=",
"++",
"LoopExit",
"->",
"getIterator",
"(",
")",
";",
"It",
"!=",
"Predecessor",
"->",
"getIterator",
"(",
")",
";",
"++",
"It",
")",
"{",
"MachineBasicBlock",
"*",
"MBB",
"=",
"&",
"*",
"It",
";",
"for",
"(",
"auto",
"&",
"Terminator",
":",
"MBB",
"->",
"terminators",
"(",
")",
")",
"{",
"if",
"(",
"!",
"isWhileLoopStart",
"(",
"Terminator",
")",
")",
"continue",
";",
"MachineBasicBlock",
"*",
"WLSTarget",
"=",
"getWhileLoopStartTargetBB",
"(",
"Terminator",
")",
";",
"if",
"(",
"WLSTarget",
"==",
"Predecessor",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"DEBUG_PREFIX",
"<<",
"\"Can't move Predecessor\"",
"\"block as it would convert a WLS from forward to a \"",
"\"backwards branching WLS\\n\"",
")",
";",
"return",
"false",
";",
"}",
"}",
"}",
"moveBasicBlock",
"(",
"Predecessor",
",",
"LoopExit",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Checks",
"if",
"loop",
"has",
"a",
"backwards",
"branching",
"WLS",
",",
"and",
"if",
"possible",
",",
"fixes",
"it",
"."
] | [
"ARM",
"ARM",
"\"Found a backwards WLS from \"",
"\" to \"",
"\"\\n\"",
"\"Can't move Predecessor\"",
"\"block as it would convert a WLS from forward to a \"",
"\"backwards branching WLS\\n\""
] | ARMBlockPlacement | fixBackwardsWLS | ARM | CPU | LLVM | 29,335 | 199 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"MSP430RegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"const",
"MSP430FrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"*",
"MF",
")",
";",
"const",
"Function",
"*",
"F",
"=",
"&",
"MF",
"->",
"getFunction",
"(",
")",
";",
"static",
"const",
"MCPhysReg",
"CalleeSavedRegs",
"[",
"]",
"=",
"{",
"MSP430",
"::",
"FP",
",",
"MSP430",
"::",
"R5",
",",
"MSP430",
"::",
"R6",
",",
"MSP430",
"::",
"R7",
",",
"MSP430",
"::",
"R8",
",",
"MSP430",
"::",
"R9",
",",
"MSP430",
"::",
"R10",
",",
"0",
"}",
";",
"static",
"const",
"MCPhysReg",
"CalleeSavedRegsFP",
"[",
"]",
"=",
"{",
"MSP430",
"::",
"R5",
",",
"MSP430",
"::",
"R6",
",",
"MSP430",
"::",
"R7",
",",
"MSP430",
"::",
"R8",
",",
"MSP430",
"::",
"R9",
",",
"MSP430",
"::",
"R10",
",",
"0",
"}",
";",
"static",
"const",
"MCPhysReg",
"CalleeSavedRegsIntr",
"[",
"]",
"=",
"{",
"MSP430",
"::",
"FP",
",",
"MSP430",
"::",
"R5",
",",
"MSP430",
"::",
"R6",
",",
"MSP430",
"::",
"R7",
",",
"MSP430",
"::",
"R8",
",",
"MSP430",
"::",
"R9",
",",
"MSP430",
"::",
"R10",
",",
"MSP430",
"::",
"R11",
",",
"MSP430",
"::",
"R12",
",",
"MSP430",
"::",
"R13",
",",
"MSP430",
"::",
"R14",
",",
"MSP430",
"::",
"R15",
",",
"0",
"}",
";",
"static",
"const",
"MCPhysReg",
"CalleeSavedRegsIntrFP",
"[",
"]",
"=",
"{",
"MSP430",
"::",
"R5",
",",
"MSP430",
"::",
"R6",
",",
"MSP430",
"::",
"R7",
",",
"MSP430",
"::",
"R8",
",",
"MSP430",
"::",
"R9",
",",
"MSP430",
"::",
"R10",
",",
"MSP430",
"::",
"R11",
",",
"MSP430",
"::",
"R12",
",",
"MSP430",
"::",
"R13",
",",
"MSP430",
"::",
"R14",
",",
"MSP430",
"::",
"R15",
",",
"0",
"}",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"*",
"MF",
")",
")",
"return",
"(",
"F",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"MSP430_INTR",
"?",
"CalleeSavedRegsIntrFP",
":",
"CalleeSavedRegsFP",
")",
";",
"else",
"return",
"(",
"F",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"MSP430_INTR",
"?",
"CalleeSavedRegsIntr",
":",
"CalleeSavedRegs",
")",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"MSP430",
"MSP430",
"MSP430",
"MSP430::FP",
"MSP430::R5",
"MSP430::R6",
"MSP430::R7",
"MSP430::R8",
"MSP430::R9",
"MSP430::R10",
"0",
"MSP430::R5",
"MSP430::R6",
"MSP430::R7",
"MSP430::R8",
"MSP430::R9",
"MSP430::R10",
"0",
"MSP430::FP",
"MSP430::R5",
"MSP430::R6",
"MSP430::R7",
"MSP430::R8",
"MSP430::R9",
"MSP430::R10",
"MSP430::R11",
"MSP430::R12",
"MSP430::R13",
"MSP430::R14",
"MSP430::R15",
"0",
"MSP430::R5",
"MSP430::R6",
"MSP430::R7",
"MSP430::R8",
"MSP430::R9",
"MSP430::R10",
"MSP430::R11",
"MSP430::R12",
"MSP430::R13",
"MSP430::R14",
"MSP430::R15",
"0",
"MSP430",
"MSP430"
] | MSP430RegisterInfo24 | getCalleeSavedRegs | MSP430 | MPU | LLVM | 29,336 | 271 | 1 | [] |
[
"<s>",
"static",
"rsqrts_type",
"get_rsqrts_type",
"(",
"machine_mode",
"mode",
")",
"{",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_DFmode",
":",
"return",
"gen_aarch64_rsqrtsdf",
";",
"case",
"E_SFmode",
":",
"return",
"gen_aarch64_rsqrtssf",
";",
"case",
"E_V2DFmode",
":",
"return",
"gen_aarch64_rsqrtsv2df",
";",
"case",
"E_V2SFmode",
":",
"return",
"gen_aarch64_rsqrtsv2sf",
";",
"case",
"E_V4SFmode",
":",
"return",
"gen_aarch64_rsqrtsv4sf",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Select",
"reciprocal",
"square",
"root",
"series",
"step",
"insn",
"depending",
"on",
"machine",
"mode",
"."
] | [
"aarch64"
] | aarch645 | get_rsqrts_type | aarch64 | CPU | GCC | 29,337 | 51 | 1 | [] |
[
"<s>",
"void",
"PPCELFStreamer",
"::",
"emitInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"{",
"PPCMCCodeEmitter",
"*",
"Emitter",
"=",
"static_cast",
"<",
"PPCMCCodeEmitter",
"*",
">",
"(",
"getAssembler",
"(",
")",
".",
"getEmitterPtr",
"(",
")",
")",
";",
"if",
"(",
"!",
"Emitter",
"->",
"isPrefixedInstruction",
"(",
"Inst",
")",
")",
"{",
"MCELFStreamer",
"::",
"emitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"return",
";",
"}",
"emitCodeAlignment",
"(",
"64",
",",
"4",
")",
";",
"MCELFStreamer",
"::",
"emitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"MCFragment",
"*",
"InstructionFragment",
"=",
"getCurrentFragment",
"(",
")",
";",
"SMLoc",
"InstLoc",
"=",
"Inst",
".",
"getLoc",
"(",
")",
";",
"if",
"(",
"LastLabel",
"&&",
"!",
"LastLabel",
"->",
"isUnset",
"(",
")",
"&&",
"LastLabelLoc",
".",
"isValid",
"(",
")",
"&&",
"InstLoc",
".",
"isValid",
"(",
")",
")",
"{",
"const",
"SourceMgr",
"*",
"SourceManager",
"=",
"getContext",
"(",
")",
".",
"getSourceManager",
"(",
")",
";",
"unsigned",
"InstLine",
"=",
"SourceManager",
"->",
"FindLineNumber",
"(",
"InstLoc",
")",
";",
"unsigned",
"LabelLine",
"=",
"SourceManager",
"->",
"FindLineNumber",
"(",
"LastLabelLoc",
")",
";",
"if",
"(",
"InstLine",
"==",
"LabelLine",
")",
"{",
"AssignFragment",
"(",
"LastLabel",
",",
"InstructionFragment",
")",
";",
"LastLabel",
"->",
"setOffset",
"(",
"0",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Targets",
"should",
"implement",
"this",
"to",
"emit",
"instructions",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC",
"64",
"4",
"0"
] | PPCELFStreamer5 | emitInstruction | PowerPC | CPU | LLVM | 29,338 | 172 | 1 | [] |
[
"<s>",
"MCSection",
"*",
"HexagonTargetObjectFile",
"::",
"getExplicitSectionGlobal",
"(",
"const",
"GlobalValue",
"*",
"GV",
",",
"SectionKind",
"Kind",
",",
"Mangler",
"&",
"Mang",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"const",
"{",
"TRACE",
"(",
"\"[getExplicitSectionGlobal] GV(\"",
"<<",
"GV",
"->",
"getName",
"(",
")",
"<<",
"\") from(\"",
"<<",
"GV",
"->",
"getSection",
"(",
")",
"<<",
"\") \"",
")",
";",
"TRACE",
"(",
"(",
"GV",
"->",
"hasPrivateLinkage",
"(",
")",
"?",
"\"private_linkage \"",
":",
"\"\"",
")",
"<<",
"(",
"GV",
"->",
"hasLocalLinkage",
"(",
")",
"?",
"\"local_linkage \"",
":",
"\"\"",
")",
"<<",
"(",
"GV",
"->",
"hasInternalLinkage",
"(",
")",
"?",
"\"internal \"",
":",
"\"\"",
")",
"<<",
"(",
"GV",
"->",
"hasExternalLinkage",
"(",
")",
"?",
"\"external \"",
":",
"\"\"",
")",
"<<",
"(",
"GV",
"->",
"hasCommonLinkage",
"(",
")",
"?",
"\"common_linkage \"",
":",
"\"\"",
")",
"<<",
"(",
"GV",
"->",
"hasCommonLinkage",
"(",
")",
"?",
"\"common \"",
":",
"\"\"",
")",
"<<",
"(",
"Kind",
".",
"isCommon",
"(",
")",
"?",
"\"kind_common \"",
":",
"\"\"",
")",
"<<",
"(",
"Kind",
".",
"isBSS",
"(",
")",
"?",
"\"kind_bss \"",
":",
"\"\"",
")",
"<<",
"(",
"Kind",
".",
"isBSSLocal",
"(",
")",
"?",
"\"kind_bss_local \"",
":",
"\"\"",
")",
")",
";",
"if",
"(",
"GV",
"->",
"hasSection",
"(",
")",
")",
"{",
"StringRef",
"Section",
"=",
"GV",
"->",
"getSection",
"(",
")",
";",
"if",
"(",
"Section",
".",
"find",
"(",
"\".access.text.group\"",
")",
"!=",
"StringRef",
"::",
"npos",
")",
"return",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"GV",
"->",
"getSection",
"(",
")",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"SHF_EXECINSTR",
")",
";",
"if",
"(",
"Section",
".",
"find",
"(",
"\".access.data.group\"",
")",
"!=",
"StringRef",
"::",
"npos",
")",
"return",
"getContext",
"(",
")",
".",
"getELFSection",
"(",
"GV",
"->",
"getSection",
"(",
")",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_WRITE",
"|",
"ELF",
"::",
"SHF_ALLOC",
")",
";",
"}",
"if",
"(",
"isGlobalInSmallSection",
"(",
"GV",
",",
"TM",
")",
")",
"return",
"selectSmallSectionForGlobal",
"(",
"GV",
",",
"Kind",
",",
"Mang",
",",
"TM",
")",
";",
"TRACE",
"(",
"\"default_ELF_section\\n\"",
")",
";",
"return",
"TargetLoweringObjectFileELF",
"::",
"getExplicitSectionGlobal",
"(",
"GV",
",",
"Kind",
",",
"Mang",
",",
"TM",
")",
";",
"}",
"</s>"
] | [
"Targets",
"should",
"implement",
"this",
"method",
"to",
"assign",
"a",
"section",
"to",
"globals",
"with",
"an",
"explicit",
"section",
"specfied",
"."
] | [
"Hexagon",
"Hexagon",
"\"[getExplicitSectionGlobal] GV(\"",
"\") from(\"",
"\") \"",
"\"private_linkage \"",
"\"\"",
"\"local_linkage \"",
"\"\"",
"\"internal \"",
"\"\"",
"\"external \"",
"\"\"",
"\"common_linkage \"",
"\"\"",
"\"common \"",
"\"\"",
"\"kind_common \"",
"\"\"",
"\"kind_bss \"",
"\"\"",
"\"kind_bss_local \"",
"\"\"",
"\".access.text.group\"",
"\".access.data.group\"",
"\"default_ELF_section\\n\""
] | HexagonTargetObjectFile41 | getExplicitSectionGlobal | Hexagon | DSP | LLVM | 29,339 | 295 | 1 | [] |
[
"<s>",
"void",
"X86PassConfig",
"::",
"addPreRegAlloc",
"(",
")",
"{",
"if",
"(",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"{",
"addPass",
"(",
"&",
"LiveRangeShrinkID",
")",
";",
"addPass",
"(",
"createX86FixupSetCC",
"(",
")",
")",
";",
"addPass",
"(",
"createX86OptimizeLEAs",
"(",
")",
")",
";",
"addPass",
"(",
"createX86CallFrameOptimization",
"(",
")",
")",
";",
"addPass",
"(",
"createX86AvoidStoreForwardingBlocks",
"(",
")",
")",
";",
"}",
"addPass",
"(",
"createX86SpeculativeLoadHardeningPass",
"(",
")",
")",
";",
"addPass",
"(",
"createX86FlagsCopyLoweringPass",
"(",
")",
")",
";",
"addPass",
"(",
"createX86WinAllocaExpander",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"register",
"allocation",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86"
] | X86TargetMachine102 | addPreRegAlloc | X86 | CPU | LLVM | 29,340 | 75 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"ARMBaseRegisterInfo",
"::",
"getLargestLegalSuperClass",
"(",
"const",
"TargetRegisterClass",
"*",
"RC",
")",
"const",
"{",
"const",
"TargetRegisterClass",
"*",
"Super",
"=",
"RC",
";",
"TargetRegisterClass",
"::",
"sc_iterator",
"I",
"=",
"RC",
"->",
"getSuperClasses",
"(",
")",
";",
"do",
"{",
"switch",
"(",
"Super",
"->",
"getID",
"(",
")",
")",
"{",
"case",
"ARM",
"::",
"GPRRegClassID",
":",
"case",
"ARM",
"::",
"SPRRegClassID",
":",
"case",
"ARM",
"::",
"DPRRegClassID",
":",
"case",
"ARM",
"::",
"QPRRegClassID",
":",
"case",
"ARM",
"::",
"QQPRRegClassID",
":",
"case",
"ARM",
"::",
"QQQQPRRegClassID",
":",
"return",
"Super",
";",
"}",
"Super",
"=",
"*",
"I",
"++",
";",
"}",
"while",
"(",
"Super",
")",
";",
"return",
"RC",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"largest",
"super",
"class",
"of",
"RC",
"that",
"is",
"legal",
"to",
"use",
"in",
"the",
"current",
"sub-target",
"and",
"has",
"the",
"same",
"spill",
"size",
"."
] | [
"ARM",
"ARM",
"ARM::GPRRegClassID",
"ARM::SPRRegClassID",
"ARM::DPRRegClassID",
"ARM::QPRRegClassID",
"ARM::QQPRRegClassID",
"ARM::QQQQPRRegClassID"
] | ARMBaseRegisterInfo1 | getLargestLegalSuperClass | ARM | CPU | LLVM | 29,341 | 93 | 1 | [] |
[
"<s>",
"void",
"pa_asm_output_aligned_common",
"(",
"FILE",
"*",
"stream",
",",
"const",
"char",
"*",
"name",
",",
"unsigned",
"HOST_WIDE_INT",
"size",
",",
"unsigned",
"int",
"align",
")",
"{",
"unsigned",
"int",
"max_common_align",
";",
"max_common_align",
"=",
"TARGET_64BIT",
"?",
"128",
":",
"(",
"size",
">=",
"4096",
"?",
"256",
":",
"64",
")",
";",
"if",
"(",
"align",
">",
"max_common_align",
")",
"{",
"warning",
"(",
"0",
",",
"\"alignment (%u) for %s exceeds maximum alignment \"",
"\"for global common data. Using %u\"",
",",
"align",
"/",
"BITS_PER_UNIT",
",",
"name",
",",
"max_common_align",
"/",
"BITS_PER_UNIT",
")",
";",
"align",
"=",
"max_common_align",
";",
"}",
"bss_section",
"(",
")",
";",
"assemble_name",
"(",
"stream",
",",
"name",
")",
";",
"fprintf",
"(",
"stream",
",",
"\"\\t.comm \"",
"HOST_WIDE_INT_PRINT_UNSIGNED",
"\"\\n\"",
",",
"MAX",
"(",
"size",
",",
"align",
"/",
"BITS_PER_UNIT",
")",
")",
";",
"}",
"</s>"
] | [
"Both",
"the",
"HP",
"and",
"GNU",
"assemblers",
"under",
"HP-UX",
"provide",
"a",
".comm",
"directive",
"that",
"does",
"n't",
"allow",
"the",
"alignment",
"of",
"global",
"common",
"storage",
"to",
"be",
"directly",
"specified",
".",
"The",
"SOM",
"linker",
"aligns",
"common",
"storage",
"based",
"on",
"the",
"rounded",
"value",
"of",
"the",
"NUM_BYTES",
"parameter",
"in",
"the",
".comm",
"directive",
".",
"It",
"'s",
"not",
"possible",
"to",
"use",
"the",
".align",
"directive",
"as",
"it",
"does",
"n't",
"affect",
"the",
"alignment",
"of",
"the",
"label",
"associated",
"with",
"a",
".comm",
"directive",
"."
] | [
"pa",
"128",
"4096",
"256",
"64",
"0",
"\"alignment (%u) for %s exceeds maximum alignment \"",
"\"for global common data. Using %u\"",
"\"\\t.comm \"",
"\"\\n\""
] | pa3 | pa_asm_output_aligned_common | pa | CPU | GCC | 29,342 | 101 | 1 | [] |
[
"<s>",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"override",
"{",
"Subtarget",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"LoongArchSubtarget",
">",
"(",
")",
";",
"return",
"SelectionDAGISel",
"::",
"runOnMachineFunction",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"LoongArch",
"LoongArch"
] | LoongArchISelDAGToDAG | runOnMachineFunction | LoongArch | CPU | LLVM | 29,343 | 30 | 1 | [] |
[
"<s>",
"MCSection",
"*",
"RISCVELFTargetObjectFile",
"::",
"getSectionForConstant",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"SectionKind",
"Kind",
",",
"const",
"Constant",
"*",
"C",
",",
"unsigned",
"&",
"Align",
")",
"const",
"{",
"if",
"(",
"isConstantInSmallSection",
"(",
"DL",
",",
"C",
")",
")",
"return",
"SmallDataSection",
";",
"return",
"TargetLoweringObjectFileELF",
"::",
"getSectionForConstant",
"(",
"DL",
",",
"Kind",
",",
"C",
",",
"Align",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"constant",
"with",
"the",
"SectionKind",
",",
"return",
"a",
"section",
"that",
"it",
"should",
"be",
"placed",
"in",
"."
] | [
"RISCV",
"RISCV"
] | RISCVTargetObjectFile7 | getSectionForConstant | RISCV | CPU | LLVM | 29,344 | 52 | 1 | [] |
[
"<s>",
"static",
"void",
"s390_z10_prevent_earlyload_conflicts",
"(",
"rtx_insn",
"*",
"*",
"ready",
",",
"int",
"*",
"nready_p",
")",
"{",
"unsigned",
"int",
"regno",
";",
"int",
"nready",
"=",
"*",
"nready_p",
";",
"rtx_insn",
"*",
"tmp",
";",
"int",
"i",
";",
"rtx_insn",
"*",
"insn",
";",
"rtx",
"set",
";",
"enum",
"attr_type",
"flag",
";",
"int",
"distance",
";",
"for",
"(",
"insn",
"=",
"last_scheduled_insn",
",",
"distance",
"=",
"Z10_EARLYLOAD_DISTANCE",
"-",
"1",
";",
"distance",
">",
"0",
"&&",
"insn",
"!=",
"NULL_RTX",
";",
"distance",
"--",
",",
"insn",
"=",
"prev_active_insn",
"(",
"insn",
")",
")",
"if",
"(",
"CALL_P",
"(",
"insn",
")",
"||",
"JUMP_P",
"(",
"insn",
")",
")",
"return",
";",
"if",
"(",
"insn",
"==",
"NULL_RTX",
")",
"return",
";",
"set",
"=",
"single_set",
"(",
"insn",
")",
";",
"if",
"(",
"set",
"==",
"NULL_RTX",
"||",
"!",
"REG_P",
"(",
"SET_DEST",
"(",
"set",
")",
")",
"||",
"GET_MODE_CLASS",
"(",
"GET_MODE",
"(",
"SET_DEST",
"(",
"set",
")",
")",
")",
"!=",
"MODE_FLOAT",
")",
"return",
";",
"flag",
"=",
"s390_safe_attr_type",
"(",
"insn",
")",
";",
"if",
"(",
"flag",
"==",
"TYPE_FLOADSF",
"||",
"flag",
"==",
"TYPE_FLOADDF",
")",
"return",
";",
"regno",
"=",
"REGNO",
"(",
"SET_DEST",
"(",
"set",
")",
")",
";",
"i",
"=",
"nready",
"-",
"1",
";",
"while",
"(",
"!",
"s390_fpload_toreg",
"(",
"ready",
"[",
"i",
"]",
",",
"regno",
")",
"&&",
"i",
">",
"0",
")",
"i",
"--",
";",
"if",
"(",
"!",
"i",
")",
"return",
";",
"tmp",
"=",
"ready",
"[",
"i",
"]",
";",
"memmove",
"(",
"&",
"ready",
"[",
"1",
"]",
",",
"&",
"ready",
"[",
"0",
"]",
",",
"sizeof",
"(",
"rtx_insn",
"*",
")",
"*",
"i",
")",
";",
"ready",
"[",
"0",
"]",
"=",
"tmp",
";",
"}",
"</s>"
] | [
"Rearrange",
"the",
"ready",
"list",
"in",
"order",
"to",
"avoid",
"the",
"situation",
"described",
"for",
"Z10_EARLYLOAD_DISTANCE",
".",
"A",
"problematic",
"load",
"instruction",
"is",
"moved",
"to",
"the",
"very",
"end",
"of",
"the",
"ready",
"list",
"."
] | [
"s390",
"1",
"0",
"1",
"0",
"1",
"0",
"0"
] | s390 | s390_z10_prevent_earlyload_conflicts | s390 | MPU | GCC | 29,345 | 234 | 1 | [] |
[
"<s>",
"static",
"rtx",
"frv_expand_cut_builtin",
"(",
"enum",
"insn_code",
"icode",
",",
"tree",
"call",
",",
"rtx",
"target",
")",
"{",
"rtx",
"pat",
";",
"rtx",
"op0",
"=",
"frv_read_argument",
"(",
"call",
",",
"0",
")",
";",
"rtx",
"op1",
"=",
"frv_read_argument",
"(",
"call",
",",
"1",
")",
";",
"rtx",
"op2",
";",
"target",
"=",
"frv_legitimize_target",
"(",
"icode",
",",
"target",
")",
";",
"op0",
"=",
"frv_int_to_acc",
"(",
"icode",
",",
"1",
",",
"op0",
")",
";",
"if",
"(",
"!",
"op0",
")",
"return",
"NULL_RTX",
";",
"if",
"(",
"icode",
"==",
"CODE_FOR_mdcutssi",
"||",
"GET_CODE",
"(",
"op1",
")",
"==",
"CONST_INT",
")",
"{",
"if",
"(",
"!",
"frv_check_constant_argument",
"(",
"icode",
",",
"2",
",",
"op1",
")",
")",
"return",
"NULL_RTX",
";",
"}",
"else",
"op1",
"=",
"frv_legitimize_argument",
"(",
"icode",
",",
"2",
",",
"op1",
")",
";",
"op2",
"=",
"frv_matching_accg_for_acc",
"(",
"op0",
")",
";",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"target",
",",
"op0",
",",
"op1",
",",
"op2",
")",
";",
"if",
"(",
"!",
"pat",
")",
"return",
"NULL_RTX",
";",
"emit_insn",
"(",
"pat",
")",
";",
"return",
"target",
";",
"}",
"</s>"
] | [
"Expand",
"cut-style",
"builtins",
",",
"which",
"take",
"two",
"operands",
"and",
"an",
"implicit",
"ACCG",
"one",
"."
] | [
"frv",
"0",
"1",
"1",
"2",
"2"
] | frv | frv_expand_cut_builtin | frv | VLIW | GCC | 29,346 | 151 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"sparc_hard_regno_nregs",
"(",
"unsigned",
"int",
"regno",
",",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"regno",
"==",
"SPARC_GSR_REG",
")",
"return",
"1",
";",
"if",
"(",
"TARGET_ARCH64",
")",
"{",
"if",
"(",
"SPARC_INT_REG_P",
"(",
"regno",
")",
"||",
"regno",
"==",
"FRAME_POINTER_REGNUM",
")",
"return",
"CEIL",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
",",
"UNITS_PER_WORD",
")",
";",
"return",
"CEIL",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
",",
"4",
")",
";",
"}",
"return",
"CEIL",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
",",
"UNITS_PER_WORD",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_HARD_REGNO_NREGS",
".",
"On",
"SPARC",
",",
"ordinary",
"registers",
"hold",
"32",
"bits",
"worth",
";",
"this",
"means",
"both",
"integer",
"and",
"floating",
"point",
"registers",
".",
"On",
"v9",
",",
"integer",
"regs",
"hold",
"64",
"bits",
"worth",
";",
"floating",
"point",
"regs",
"hold",
"32",
"bits",
"worth",
"(",
"this",
"includes",
"the",
"new",
"fp",
"regs",
"as",
"even",
"the",
"odd",
"ones",
"are",
"included",
"in",
"the",
"hard",
"register",
"count",
")",
"."
] | [
"sparc",
"1",
"4"
] | sparc | sparc_hard_regno_nregs | sparc | CPU | GCC | 29,347 | 73 | 1 | [] |
[
"<s>",
"static",
"bool",
"nvptx_can_change_mode_class",
"(",
"machine_mode",
",",
"machine_mode",
",",
"reg_class_t",
")",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_CAN_CHANGE_MODE_CLASS",
"."
] | [
"nvptx"
] | nvptx | nvptx_can_change_mode_class | nvptx | GPU | GCC | 29,348 | 15 | 1 | [] |
[
"<s>",
"void",
"ix86_expand_sse2_abs",
"(",
"rtx",
"target",
",",
"rtx",
"input",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"target",
")",
";",
"rtx",
"tmp0",
",",
"tmp1",
",",
"x",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"V4SImode",
":",
"tmp0",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"ASHIFTRT",
",",
"input",
",",
"GEN_INT",
"(",
"GET_MODE_UNIT_BITSIZE",
"(",
"mode",
")",
"-",
"1",
")",
",",
"NULL",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"tmp1",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"XOR",
",",
"tmp0",
",",
"input",
",",
"NULL",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"x",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"MINUS",
",",
"tmp1",
",",
"tmp0",
",",
"target",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"break",
";",
"case",
"V8HImode",
":",
"tmp0",
"=",
"expand_unop",
"(",
"mode",
",",
"neg_optab",
",",
"input",
",",
"NULL_RTX",
",",
"0",
")",
";",
"x",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"SMAX",
",",
"tmp0",
",",
"input",
",",
"target",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"break",
";",
"case",
"V16QImode",
":",
"tmp0",
"=",
"expand_unop",
"(",
"mode",
",",
"neg_optab",
",",
"input",
",",
"NULL_RTX",
",",
"0",
")",
";",
"x",
"=",
"expand_simple_binop",
"(",
"V16QImode",
",",
"UMIN",
",",
"tmp0",
",",
"input",
",",
"target",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"if",
"(",
"x",
"!=",
"target",
")",
"emit_move_insn",
"(",
"target",
",",
"x",
")",
";",
"}",
"</s>"
] | [
"Calculate",
"integer",
"abs",
"(",
")",
"using",
"only",
"SSE2",
"instructions",
"."
] | [
"i386",
"1",
"0",
"0",
"0",
"0",
"0",
"0",
"0"
] | i3865 | ix86_expand_sse2_abs | i386 | CPU | GCC | 29,349 | 199 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"StringRef",
"IDVal",
"=",
"DirectiveID",
".",
"getString",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsa_code_object_version\"",
")",
"return",
"ParseDirectiveHSACodeObjectVersion",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsa_code_object_isa\"",
")",
"return",
"ParseDirectiveHSACodeObjectISA",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amd_kernel_code_t\"",
")",
"return",
"ParseDirectiveAMDKernelCodeT",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsatext\"",
"||",
"IDVal",
"==",
"\".text\"",
")",
"return",
"ParseSectionDirectiveHSAText",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amdgpu_hsa_kernel\"",
")",
"return",
"ParseDirectiveAMDGPUHsaKernel",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amdgpu_hsa_module_global\"",
")",
"return",
"ParseDirectiveAMDGPUHsaModuleGlobal",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".amdgpu_hsa_program_global\"",
")",
"return",
"ParseDirectiveAMDGPUHsaProgramGlobal",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsadata_global_agent\"",
")",
"return",
"ParseSectionDirectiveHSADataGlobalAgent",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsadata_global_program\"",
")",
"return",
"ParseSectionDirectiveHSADataGlobalProgram",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"\".hsarodata_readonly_agent\"",
")",
"return",
"ParseSectionDirectiveHSARodataReadonlyAgent",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"AMDGPU",
"AMDGPU",
"\".hsa_code_object_version\"",
"\".hsa_code_object_isa\"",
"\".amd_kernel_code_t\"",
"\".hsatext\"",
"\".text\"",
"\".amdgpu_hsa_kernel\"",
"AMDGPU",
"\".amdgpu_hsa_module_global\"",
"AMDGPU",
"\".amdgpu_hsa_program_global\"",
"AMDGPU",
"\".hsadata_global_agent\"",
"\".hsadata_global_program\"",
"\".hsarodata_readonly_agent\""
] | AMDGPUAsmParser (2) | ParseDirective | AMDGPU | GPU | LLVM | 29,350 | 136 | 1 | [] |
[
"<s>",
"bool",
"enableEarlyIfConversion",
"(",
")",
"const",
"override",
"{",
"return",
"hasISEL",
"(",
")",
";",
"}",
"</s>"
] | [
"Enable",
"the",
"use",
"of",
"the",
"early",
"if",
"conversion",
"pass",
"."
] | [
"PowerPC"
] | PPCSubtarget (2)1 | enableEarlyIfConversion | PowerPC | CPU | LLVM | 29,351 | 13 | 1 | [] |
[
"<s>",
"bool",
"isImm",
"(",
")",
"const",
"{",
"return",
"Kind",
"==",
"CV_Immediate",
";",
"}",
"</s>"
] | [
"isImm",
"-",
"Is",
"this",
"an",
"immediate",
"operand",
"?"
] | [
"PowerPC"
] | PPCCTRLoops2 | isImm | PowerPC | CPU | LLVM | 29,352 | 12 | 1 | [] |
[
"<s>",
"bool",
"AArch64Subtarget",
"::",
"supportsAddressTopByteIgnored",
"(",
")",
"const",
"{",
"if",
"(",
"!",
"UseAddressTopByteIgnored",
")",
"return",
"false",
";",
"if",
"(",
"TargetTriple",
".",
"isDriverKit",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"TargetTriple",
".",
"isiOS",
"(",
")",
")",
"{",
"return",
"TargetTriple",
".",
"getiOSVersion",
"(",
")",
">=",
"VersionTuple",
"(",
"8",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"CPU",
"has",
"TBI",
"(",
"top",
"byte",
"of",
"addresses",
"is",
"ignored",
"during",
"HW",
"address",
"translation",
")",
"and",
"OS",
"enables",
"it",
"."
] | [
"AArch64",
"AArch64",
"8"
] | AArch64Subtarget36 | supportsAddressTopByteIgnored | AArch64 | CPU | LLVM | 29,353 | 53 | 1 | [] |
[
"<s>",
"int",
"const_ok_for_arm",
"(",
"HOST_WIDE_INT",
"i",
")",
"{",
"int",
"lowbit",
";",
"if",
"(",
"(",
"i",
"&",
"~",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"0xffffffff",
")",
"!=",
"0",
"&&",
"(",
"(",
"i",
"&",
"~",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"0xffffffff",
")",
"!=",
"(",
"(",
"~",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"0",
")",
"&",
"~",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"0xffffffff",
")",
")",
")",
"return",
"FALSE",
";",
"i",
"&=",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"0xffffffff",
";",
"if",
"(",
"(",
"i",
"&",
"~",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"0xff",
")",
"==",
"0",
")",
"return",
"TRUE",
";",
"lowbit",
"=",
"ffs",
"(",
"(",
"int",
")",
"i",
")",
"-",
"1",
";",
"if",
"(",
"TARGET_ARM",
")",
"lowbit",
"&=",
"~",
"1",
";",
"if",
"(",
"(",
"i",
"&",
"~",
"(",
"(",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"0xff",
")",
"<<",
"lowbit",
")",
")",
"==",
"0",
")",
"return",
"TRUE",
";",
"if",
"(",
"TARGET_ARM",
")",
"{",
"if",
"(",
"lowbit",
"<=",
"4",
"&&",
"(",
"(",
"i",
"&",
"~",
"0xc000003f",
")",
"==",
"0",
"||",
"(",
"i",
"&",
"~",
"0xf000000f",
")",
"==",
"0",
"||",
"(",
"i",
"&",
"~",
"0xfc000003",
")",
"==",
"0",
")",
")",
"return",
"TRUE",
";",
"}",
"else",
"{",
"HOST_WIDE_INT",
"v",
";",
"v",
"=",
"i",
"&",
"0xff",
";",
"v",
"|=",
"v",
"<<",
"16",
";",
"if",
"(",
"i",
"==",
"v",
"||",
"i",
"==",
"(",
"v",
"|",
"(",
"v",
"<<",
"8",
")",
")",
")",
"return",
"TRUE",
";",
"v",
"=",
"i",
"&",
"0xff00",
";",
"v",
"|=",
"v",
"<<",
"16",
";",
"if",
"(",
"i",
"==",
"v",
")",
"return",
"TRUE",
";",
"}",
"return",
"FALSE",
";",
"}",
"</s>"
] | [
"Return",
"TRUE",
"if",
"int",
"I",
"is",
"a",
"valid",
"immediate",
"ARM",
"constant",
"."
] | [
"arm",
"0xffffffff",
"0",
"0xffffffff",
"0",
"0xffffffff",
"0xffffffff",
"0xff",
"0",
"1",
"1",
"0xff",
"0",
"4",
"0xc000003f",
"0",
"0xf000000f",
"0",
"0xfc000003",
"0",
"0xff",
"16",
"8",
"0xff00",
"16"
] | arm4 | const_ok_for_arm | arm | CPU | GCC | 29,354 | 238 | 1 | [] |
[
"<s>",
"VariantKind",
"getKind",
"(",
")",
"const",
"{",
"return",
"Kind",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"Kind",
"of",
"lane",
"offset",
"."
] | [
"ARM"
] | ARMMCExpr | getKind | ARM | CPU | LLVM | 29,355 | 10 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"SDValue",
",",
"SDValue",
">",
"SystemZSelectionDAGInfo",
"::",
"EmitTargetCodeForStrcmp",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"SDLoc",
"DL",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Src1",
",",
"SDValue",
"Src2",
",",
"MachinePointerInfo",
"Op1PtrInfo",
",",
"MachinePointerInfo",
"Op2PtrInfo",
")",
"const",
"{",
"SDVTList",
"VTs",
"=",
"DAG",
".",
"getVTList",
"(",
"Src1",
".",
"getValueType",
"(",
")",
",",
"MVT",
"::",
"Other",
",",
"MVT",
"::",
"Glue",
")",
";",
"SDValue",
"Unused",
"=",
"DAG",
".",
"getNode",
"(",
"SystemZISD",
"::",
"STRCMP",
",",
"DL",
",",
"VTs",
",",
"Chain",
",",
"Src1",
",",
"Src2",
",",
"DAG",
".",
"getConstant",
"(",
"0",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"Chain",
"=",
"Unused",
".",
"getValue",
"(",
"1",
")",
";",
"SDValue",
"Glue",
"=",
"Chain",
".",
"getValue",
"(",
"2",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"addIPMSequence",
"(",
"DL",
",",
"Glue",
",",
"DAG",
")",
",",
"Chain",
")",
";",
"}",
"</s>"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"strcmp",
",",
"in",
"cases",
"where",
"that",
"is",
"faster",
"than",
"a",
"libcall",
"."
] | [
"SystemZ",
"SystemZ",
"MVT::Other",
"MVT::Glue",
"SystemZISD::STRCMP",
"0",
"MVT::i32",
"1",
"2"
] | SystemZSelectionDAGInfo (2) | EmitTargetCodeForStrcmp | SystemZ | CPU | LLVM | 29,356 | 130 | 1 | [] |
[
"<s>",
"bool",
"CSKYConstantPool",
"::",
"empty",
"(",
")",
"{",
"return",
"Entries",
".",
"empty",
"(",
")",
";",
"}",
"</s>"
] | [
"Determine",
"whether",
"this",
"version",
"information",
"is",
"empty",
"(",
"e.g.",
",",
"all",
"version",
"components",
"are",
"zero",
")",
"."
] | [
"CSKY",
"CSKY"
] | CSKYTargetStreamer | empty | CSKY | CPU | LLVM | 29,357 | 15 | 1 | [] |
[
"<s>",
"void",
"AArch64PassConfig",
"::",
"addPreLegalizeMachineIR",
"(",
")",
"{",
"if",
"(",
"getOptLevel",
"(",
")",
"==",
"CodeGenOpt",
"::",
"None",
")",
"addPass",
"(",
"createAArch64O0PreLegalizerCombiner",
"(",
")",
")",
";",
"else",
"{",
"addPass",
"(",
"createAArch64PreLegalizerCombiner",
"(",
")",
")",
";",
"if",
"(",
"EnableGISelLoadStoreOptPreLegal",
")",
"addPass",
"(",
"new",
"LoadStoreOpt",
"(",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"immediately",
"before",
"legalization",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine21 | addPreLegalizeMachineIR | AArch64 | CPU | LLVM | 29,358 | 47 | 1 | [] |
[
"<s>",
"void",
"X86FrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"const",
"X86InstrInfo",
"&",
"TII",
"=",
"*",
"TM",
".",
"getInstrInfo",
"(",
")",
";",
"const",
"X86RegisterInfo",
"&",
"RegInfo",
"=",
"*",
"TM",
".",
"getRegisterInfo",
"(",
")",
";",
"unsigned",
"StackPtr",
"=",
"RegInfo",
".",
"getStackRegister",
"(",
")",
";",
"bool",
"reseveCallFrame",
"=",
"hasReservedCallFrame",
"(",
"MF",
")",
";",
"int",
"Opcode",
"=",
"I",
"->",
"getOpcode",
"(",
")",
";",
"bool",
"isDestroy",
"=",
"Opcode",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
";",
"bool",
"IsLP64",
"=",
"STI",
".",
"isTarget64BitLP64",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"uint64_t",
"Amount",
"=",
"!",
"reseveCallFrame",
"?",
"I",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
":",
"0",
";",
"uint64_t",
"CalleeAmt",
"=",
"isDestroy",
"?",
"I",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
":",
"0",
";",
"I",
"=",
"MBB",
".",
"erase",
"(",
"I",
")",
";",
"if",
"(",
"!",
"reseveCallFrame",
")",
"{",
"if",
"(",
"Amount",
"==",
"0",
")",
"return",
";",
"unsigned",
"StackAlign",
"=",
"TM",
".",
"getFrameLowering",
"(",
")",
"->",
"getStackAlignment",
"(",
")",
";",
"Amount",
"=",
"(",
"Amount",
"+",
"StackAlign",
"-",
"1",
")",
"/",
"StackAlign",
"*",
"StackAlign",
";",
"MachineInstr",
"*",
"New",
"=",
"0",
";",
"if",
"(",
"Opcode",
"==",
"TII",
".",
"getCallFrameSetupOpcode",
"(",
")",
")",
"{",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"getSUBriOpcode",
"(",
"IsLP64",
",",
"Amount",
")",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"Opcode",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
")",
";",
"Amount",
"-=",
"CalleeAmt",
";",
"if",
"(",
"Amount",
")",
"{",
"unsigned",
"Opc",
"=",
"getADDriOpcode",
"(",
"IsLP64",
",",
"Amount",
")",
";",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"}",
"}",
"if",
"(",
"New",
")",
"{",
"New",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"MBB",
".",
"insert",
"(",
"I",
",",
"New",
")",
";",
"}",
"return",
";",
"}",
"if",
"(",
"Opcode",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
"&&",
"CalleeAmt",
")",
"{",
"unsigned",
"Opc",
"=",
"getSUBriOpcode",
"(",
"IsLP64",
",",
"CalleeAmt",
")",
";",
"MachineInstr",
"*",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addImm",
"(",
"CalleeAmt",
")",
";",
"New",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"B",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"while",
"(",
"I",
"!=",
"B",
"&&",
"!",
"std",
"::",
"prev",
"(",
"I",
")",
"->",
"isCall",
"(",
")",
")",
"--",
"I",
";",
"MBB",
".",
"insert",
"(",
"I",
",",
"New",
")",
";",
"}",
"}",
"</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",
")",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"0",
"0",
"1",
"0",
"0",
"1",
"0",
"3",
"3"
] | X86FrameLowering (2) | eliminateCallFramePseudoInstr | X86 | CPU | LLVM | 29,359 | 435 | 1 | [] |
[
"<s>",
"bool",
"LC2200FrameLowering",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"STI",
".",
"getRegisterInfo",
"(",
")",
";",
"return",
"MF",
".",
"getTarget",
"(",
")",
".",
"Options",
".",
"DisableFramePointerElim",
"(",
"MF",
")",
"||",
"MFI",
".",
"hasVarSizedObjects",
"(",
")",
"||",
"MFI",
".",
"isFrameAddressTaken",
"(",
")",
"||",
"TRI",
"->",
"needsStackRealignment",
"(",
"MF",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"LC2200",
"LC2200"
] | LC2200FrameLowering | hasFP | LC2200 | CPU | LLVM | 29,360 | 68 | 1 | [] |
[
"<s>",
"SDValue",
"SystemZTargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"ZERO_EXTEND",
":",
"return",
"combineZERO_EXTEND",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND",
":",
"return",
"combineSIGN_EXTEND",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND_INREG",
":",
"return",
"combineSIGN_EXTEND_INREG",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"MERGE_HIGH",
":",
"case",
"SystemZISD",
"::",
"MERGE_LOW",
":",
"return",
"combineMERGE",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"LOAD",
":",
"return",
"combineLOAD",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"combineSTORE",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
":",
"return",
"combineEXTRACT_VECTOR_ELT",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"JOIN_DWORDS",
":",
"return",
"combineJOIN_DWORDS",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"FP_ROUND",
":",
"return",
"combineFP_ROUND",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"BSWAP",
":",
"return",
"combineBSWAP",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"BR_CCMASK",
":",
"return",
"combineBR_CCMASK",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"SELECT_CCMASK",
":",
"return",
"combineSELECT_CCMASK",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"SystemZISD",
"::",
"GET_CCMASK",
":",
"return",
"combineGET_CCMASK",
"(",
"N",
",",
"DCI",
")",
";",
"case",
"ISD",
"::",
"SDIV",
":",
"case",
"ISD",
"::",
"UDIV",
":",
"case",
"ISD",
"::",
"SREM",
":",
"case",
"ISD",
"::",
"UREM",
":",
"return",
"combineIntDIVREM",
"(",
"N",
",",
"DCI",
")",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"will",
"be",
"invoked",
"for",
"all",
"target",
"nodes",
"and",
"for",
"any",
"target-independent",
"nodes",
"that",
"the",
"target",
"has",
"registered",
"with",
"invoke",
"it",
"for",
"."
] | [
"SystemZ",
"SystemZ",
"ISD::ZERO_EXTEND",
"ISD::SIGN_EXTEND",
"ISD::SIGN_EXTEND_INREG",
"SystemZISD::MERGE_HIGH",
"SystemZISD::MERGE_LOW",
"ISD::LOAD",
"ISD::STORE",
"ISD::EXTRACT_VECTOR_ELT",
"SystemZISD::JOIN_DWORDS",
"ISD::FP_ROUND",
"ISD::BSWAP",
"SystemZISD::BR_CCMASK",
"SystemZISD::SELECT_CCMASK",
"SystemZISD::GET_CCMASK",
"ISD::SDIV",
"ISD::UDIV",
"ISD::SREM",
"ISD::UREM"
] | SystemZISelLowering3 | PerformDAGCombine | SystemZ | CPU | LLVM | 29,361 | 237 | 1 | [] |
[
"<s>",
"void",
"alpha_expand_builtin_revert_vms_condition_handler",
"(",
"rtx",
"target",
")",
"{",
"alpha_expand_builtin_establish_vms_condition_handler",
"(",
"target",
",",
"const0_rtx",
")",
";",
"}",
"</s>"
] | [
"Expand",
"code",
"to",
"store",
"the",
"current",
"VMS",
"condition",
"handler",
"into",
"TARGET",
"and",
"nullify",
"it",
"."
] | [
"alpha"
] | alpha | alpha_expand_builtin_revert_vms_condition_handler | alpha | MPU | GCC | 29,362 | 15 | 1 | [] |
[
"<s>",
"static",
"bool",
"sh_can_follow_jump",
"(",
"const",
"rtx_insn",
"*",
"branch1",
",",
"const",
"rtx_insn",
"*",
"branch2",
")",
"{",
"if",
"(",
"flag_reorder_blocks_and_partition",
"&&",
"simplejump_p",
"(",
"branch2",
")",
"&&",
"CROSSING_JUMP_P",
"(",
"branch2",
")",
")",
"return",
"false",
";",
"if",
"(",
"flag_expensive_optimizations",
"&&",
"simplejump_p",
"(",
"branch2",
")",
")",
"{",
"rtx",
"dest",
"=",
"XEXP",
"(",
"SET_SRC",
"(",
"single_set",
"(",
"branch2",
")",
")",
",",
"0",
")",
";",
"rtx_insn",
"*",
"insn",
";",
"int",
"distance",
";",
"for",
"(",
"distance",
"=",
"0",
",",
"insn",
"=",
"NEXT_INSN",
"(",
"branch1",
")",
";",
"insn",
"&&",
"distance",
"<",
"256",
";",
"insn",
"=",
"PREV_INSN",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"insn",
"==",
"dest",
")",
"return",
"true",
";",
"else",
"distance",
"+=",
"get_attr_length",
"(",
"insn",
")",
";",
"}",
"for",
"(",
"distance",
"=",
"0",
",",
"insn",
"=",
"NEXT_INSN",
"(",
"branch1",
")",
";",
"insn",
"&&",
"distance",
"<",
"256",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"insn",
"==",
"dest",
")",
"return",
"true",
";",
"else",
"distance",
"+=",
"get_attr_length",
"(",
"insn",
")",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"'s",
"possible",
"to",
"redirect",
"BRANCH1",
"to",
"the",
"destination",
"of",
"an",
"unconditional",
"jump",
"BRANCH2",
".",
"We",
"only",
"want",
"to",
"do",
"this",
"if",
"the",
"resulting",
"branch",
"will",
"have",
"a",
"short",
"displacement",
"."
] | [
"sh",
"0",
"0",
"256",
"0",
"256"
] | sh | sh_can_follow_jump | sh | CPU | GCC | 29,363 | 160 | 1 | [] |
[
"<s>",
"void",
"expand_prologue",
"(",
"void",
")",
"{",
"tree",
"func_attr",
";",
"int",
"size",
";",
"int",
"regno",
";",
"rtx",
"scratch",
";",
"gcc_assert",
"(",
"reload_completed",
"==",
"1",
")",
";",
"size",
"=",
"get_frame_size",
"(",
")",
";",
"create_regs_rtx",
"(",
")",
";",
"func_attr",
"=",
"TYPE_ATTRIBUTES",
"(",
"TREE_TYPE",
"(",
"current_function_decl",
")",
")",
";",
"current_function_interrupt",
"=",
"lookup_attribute",
"(",
"\"interrupt\"",
",",
"func_attr",
")",
"!=",
"NULL_TREE",
";",
"current_function_trap",
"=",
"lookup_attribute",
"(",
"\"trap\"",
",",
"func_attr",
")",
"!=",
"NULL_TREE",
";",
"if",
"(",
"lookup_attribute",
"(",
"\"far\"",
",",
"func_attr",
")",
"!=",
"NULL_TREE",
")",
"current_function_far",
"=",
"1",
";",
"else",
"if",
"(",
"lookup_attribute",
"(",
"\"near\"",
",",
"func_attr",
")",
"!=",
"NULL_TREE",
")",
"current_function_far",
"=",
"0",
";",
"else",
"current_function_far",
"=",
"(",
"TARGET_LONG_CALLS",
"!=",
"0",
"&&",
"!",
"current_function_interrupt",
"&&",
"!",
"current_function_trap",
")",
";",
"if",
"(",
"current_function_args_info",
".",
"nregs",
"==",
"2",
")",
"scratch",
"=",
"iy_reg",
";",
"else",
"scratch",
"=",
"ix_reg",
";",
"if",
"(",
"frame_pointer_needed",
")",
"emit_move_after_reload",
"(",
"stack_push_word",
",",
"hard_frame_pointer_rtx",
",",
"scratch",
")",
";",
"if",
"(",
"current_function_interrupt",
")",
"{",
"emit_move_after_reload",
"(",
"stack_push_word",
",",
"m68hc11_soft_tmp_reg",
",",
"scratch",
")",
";",
"emit_move_after_reload",
"(",
"stack_push_word",
",",
"gen_rtx_REG",
"(",
"HImode",
",",
"SOFT_Z_REGNUM",
")",
",",
"scratch",
")",
";",
"emit_move_after_reload",
"(",
"stack_push_word",
",",
"gen_rtx_REG",
"(",
"HImode",
",",
"SOFT_SAVED_XY_REGNUM",
")",
",",
"scratch",
")",
";",
"}",
"if",
"(",
"TARGET_M6812",
"&&",
"(",
"size",
">",
"4",
"||",
"size",
"==",
"3",
")",
")",
"{",
"emit_insn",
"(",
"gen_addhi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"-",
"size",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"(",
"!",
"optimize_size",
"&&",
"size",
">",
"8",
")",
"||",
"(",
"optimize_size",
"&&",
"size",
">",
"10",
")",
")",
"{",
"rtx",
"insn",
";",
"insn",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"gen_rtvec",
"(",
"2",
",",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"stack_pointer_rtx",
",",
"gen_rtx_PLUS",
"(",
"HImode",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"-",
"size",
")",
")",
")",
",",
"gen_rtx_CLOBBER",
"(",
"VOIDmode",
",",
"scratch",
")",
")",
")",
";",
"emit_insn",
"(",
"insn",
")",
";",
"}",
"else",
"{",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"2",
";",
"i",
"<=",
"size",
";",
"i",
"+=",
"2",
")",
"emit_move_after_reload",
"(",
"stack_push_word",
",",
"ix_reg",
",",
"0",
")",
";",
"if",
"(",
"size",
"&",
"1",
")",
"emit_insn",
"(",
"gen_addhi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"constm1_rtx",
")",
")",
";",
"}",
"if",
"(",
"frame_pointer_needed",
")",
"emit_move_after_reload",
"(",
"hard_frame_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"scratch",
")",
";",
"for",
"(",
"regno",
"=",
"SOFT_REG_FIRST",
";",
"regno",
"<=",
"SOFT_REG_LAST",
";",
"regno",
"++",
")",
"{",
"if",
"(",
"regs_ever_live",
"[",
"regno",
"]",
"&&",
"!",
"call_used_regs",
"[",
"regno",
"]",
")",
"{",
"emit_move_after_reload",
"(",
"stack_push_word",
",",
"gen_rtx_REG",
"(",
"HImode",
",",
"regno",
")",
",",
"scratch",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Expand",
"the",
"prologue",
"into",
"RTL",
"."
] | [
"m68hc11",
"1",
"\"interrupt\"",
"\"trap\"",
"\"far\"",
"1",
"\"near\"",
"0",
"0",
"2",
"4",
"3",
"8",
"10",
"2",
"2",
"2",
"0",
"1"
] | m68hc111 | expand_prologue | m68hc11 | MPU | GCC | 29,364 | 392 | 1 | [] |
[
"<s>",
"OR1KSubtarget",
"&",
"OR1KSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
")",
"{",
"std",
"::",
"string",
"CPUName",
"=",
"CPU",
";",
"if",
"(",
"CPUName",
".",
"empty",
"(",
")",
")",
"CPUName",
"=",
"\"generic\"",
";",
"ParseSubtargetFeatures",
"(",
"CPUName",
",",
"FS",
")",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"OR1K",
"OR1K",
"OR1K",
"\"generic\""
] | OR1KSubtarget1 | initializeSubtargetDependencies | OR1K | CPU | LLVM | 29,365 | 44 | 1 | [] |
[
"<s>",
"void",
"GCNPassConfig",
"::",
"addPostRegAlloc",
"(",
")",
"{",
"addPass",
"(",
"createSIPrepareScratchRegs",
"(",
")",
",",
"false",
")",
";",
"addPass",
"(",
"createSIShrinkInstructionsPass",
"(",
")",
",",
"false",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"after",
"register",
"allocation",
"pass",
"pipeline",
"but",
"before",
"prolog-epilog",
"insertion",
"."
] | [
"R600",
"SI",
"SI"
] | AMDGPUTargetMachine80 | addPostRegAlloc | R600 | GPU | LLVM | 29,366 | 26 | 1 | [] |
[
"<s>",
"int",
"MSP430RegisterInfo",
"::",
"getDwarfRegNum",
"(",
"unsigned",
"RegNum",
",",
"bool",
"isEH",
")",
"const",
"{",
"assert",
"(",
"0",
"&&",
"\"Not implemented yet!\"",
")",
";",
"}",
"</s>"
] | [
"Map",
"a",
"target",
"register",
"to",
"an",
"equivalent",
"dwarf",
"register",
"number",
"."
] | [
"MSP430",
"MSP430",
"0",
"\"Not implemented yet!\""
] | MSP430RegisterInfo11 | getDwarfRegNum | MSP430 | MPU | LLVM | 29,367 | 21 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"IsDesirableToPromoteOp",
"(",
"SDValue",
"Op",
",",
"EVT",
"&",
"PVT",
")",
"const",
"{",
"EVT",
"VT",
"=",
"Op",
".",
"getValueType",
"(",
")",
";",
"if",
"(",
"VT",
"!=",
"MVT",
"::",
"i16",
")",
"return",
"false",
";",
"auto",
"IsFoldableRMW",
"=",
"[",
"]",
"(",
"SDValue",
"Load",
",",
"SDValue",
"Op",
")",
"{",
"if",
"(",
"!",
"Op",
".",
"hasOneUse",
"(",
")",
")",
"return",
"false",
";",
"SDNode",
"*",
"User",
"=",
"*",
"Op",
"->",
"use_begin",
"(",
")",
";",
"if",
"(",
"!",
"ISD",
"::",
"isNormalStore",
"(",
"User",
")",
")",
"return",
"false",
";",
"auto",
"*",
"Ld",
"=",
"cast",
"<",
"LoadSDNode",
">",
"(",
"Load",
")",
";",
"auto",
"*",
"St",
"=",
"cast",
"<",
"StoreSDNode",
">",
"(",
"User",
")",
";",
"return",
"Ld",
"->",
"getBasePtr",
"(",
")",
"==",
"St",
"->",
"getBasePtr",
"(",
")",
";",
"}",
";",
"auto",
"IsFoldableAtomicRMW",
"=",
"[",
"]",
"(",
"SDValue",
"Load",
",",
"SDValue",
"Op",
")",
"{",
"if",
"(",
"!",
"Load",
".",
"hasOneUse",
"(",
")",
"||",
"Load",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"ATOMIC_LOAD",
")",
"return",
"false",
";",
"if",
"(",
"!",
"Op",
".",
"hasOneUse",
"(",
")",
")",
"return",
"false",
";",
"SDNode",
"*",
"User",
"=",
"*",
"Op",
"->",
"use_begin",
"(",
")",
";",
"if",
"(",
"User",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"ATOMIC_STORE",
")",
"return",
"false",
";",
"auto",
"*",
"Ld",
"=",
"cast",
"<",
"AtomicSDNode",
">",
"(",
"Load",
")",
";",
"auto",
"*",
"St",
"=",
"cast",
"<",
"AtomicSDNode",
">",
"(",
"User",
")",
";",
"return",
"Ld",
"->",
"getBasePtr",
"(",
")",
"==",
"St",
"->",
"getBasePtr",
"(",
")",
";",
"}",
";",
"bool",
"Commute",
"=",
"false",
";",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"ISD",
"::",
"SIGN_EXTEND",
":",
"case",
"ISD",
"::",
"ZERO_EXTEND",
":",
"case",
"ISD",
"::",
"ANY_EXTEND",
":",
"break",
";",
"case",
"ISD",
"::",
"SHL",
":",
"case",
"ISD",
"::",
"SRL",
":",
"{",
"SDValue",
"N0",
"=",
"Op",
".",
"getOperand",
"(",
"0",
")",
";",
"if",
"(",
"MayFoldLoad",
"(",
"N0",
")",
"&&",
"IsFoldableRMW",
"(",
"N0",
",",
"Op",
")",
")",
"return",
"false",
";",
"break",
";",
"}",
"case",
"ISD",
"::",
"ADD",
":",
"case",
"ISD",
"::",
"MUL",
":",
"case",
"ISD",
"::",
"AND",
":",
"case",
"ISD",
"::",
"OR",
":",
"case",
"ISD",
"::",
"XOR",
":",
"Commute",
"=",
"true",
";",
"LLVM_FALLTHROUGH",
";",
"case",
"ISD",
"::",
"SUB",
":",
"{",
"SDValue",
"N0",
"=",
"Op",
".",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"N1",
"=",
"Op",
".",
"getOperand",
"(",
"1",
")",
";",
"if",
"(",
"MayFoldLoad",
"(",
"N1",
")",
"&&",
"(",
"!",
"Commute",
"||",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"N0",
")",
"||",
"(",
"Op",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"MUL",
"&&",
"IsFoldableRMW",
"(",
"N1",
",",
"Op",
")",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"MayFoldLoad",
"(",
"N0",
")",
"&&",
"(",
"(",
"Commute",
"&&",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"N1",
")",
")",
"||",
"(",
"Op",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"MUL",
"&&",
"IsFoldableRMW",
"(",
"N0",
",",
"Op",
")",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"IsFoldableAtomicRMW",
"(",
"N0",
",",
"Op",
")",
"||",
"(",
"Commute",
"&&",
"IsFoldableAtomicRMW",
"(",
"N1",
",",
"Op",
")",
")",
")",
"return",
"false",
";",
"}",
"}",
"PVT",
"=",
"MVT",
"::",
"i32",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"has",
"native",
"support",
"for",
"the",
"specified",
"value",
"type",
"and",
"it",
"is",
"'desirable",
"'",
"to",
"use",
"the",
"type",
"."
] | [
"X86",
"X86",
"MVT::i16",
"ISD::isNormalStore",
"ISD::ATOMIC_LOAD",
"ISD::ATOMIC_STORE",
"ISD::SIGN_EXTEND",
"ISD::ZERO_EXTEND",
"ISD::ANY_EXTEND",
"ISD::SHL",
"ISD::SRL",
"0",
"ISD::ADD",
"ISD::MUL",
"ISD::AND",
"ISD::OR",
"ISD::XOR",
"ISD::SUB",
"0",
"1",
"ISD::MUL",
"ISD::MUL",
"MVT::i32"
] | X86ISelLowering | IsDesirableToPromoteOp | X86 | CPU | LLVM | 29,368 | 490 | 1 | [] |
[
"<s>",
"bool",
"LanaiInstrInfo",
"::",
"analyzeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"&",
"TrueBlock",
",",
"MachineBasicBlock",
"*",
"&",
"FalseBlock",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Condition",
",",
"bool",
"AllowModify",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"Instruction",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"while",
"(",
"Instruction",
"!=",
"MBB",
".",
"begin",
"(",
")",
")",
"{",
"--",
"Instruction",
";",
"if",
"(",
"Instruction",
"->",
"isDebugValue",
"(",
")",
")",
"continue",
";",
"if",
"(",
"!",
"isUnpredicatedTerminator",
"(",
"*",
"Instruction",
")",
")",
"break",
";",
"if",
"(",
"!",
"Instruction",
"->",
"isBranch",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"Instruction",
"->",
"getOpcode",
"(",
")",
"==",
"Lanai",
"::",
"BT",
")",
"{",
"if",
"(",
"!",
"AllowModify",
")",
"{",
"TrueBlock",
"=",
"Instruction",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"continue",
";",
"}",
"while",
"(",
"std",
"::",
"next",
"(",
"Instruction",
")",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"{",
"std",
"::",
"next",
"(",
"Instruction",
")",
"->",
"eraseFromParent",
"(",
")",
";",
"}",
"Condition",
".",
"clear",
"(",
")",
";",
"FalseBlock",
"=",
"nullptr",
";",
"if",
"(",
"MBB",
".",
"isLayoutSuccessor",
"(",
"Instruction",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
")",
")",
"{",
"TrueBlock",
"=",
"nullptr",
";",
"Instruction",
"->",
"eraseFromParent",
"(",
")",
";",
"Instruction",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"continue",
";",
"}",
"TrueBlock",
"=",
"Instruction",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"continue",
";",
"}",
"unsigned",
"Opcode",
"=",
"Instruction",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"Opcode",
"!=",
"Lanai",
"::",
"BRCC",
")",
"return",
"true",
";",
"if",
"(",
"Condition",
".",
"empty",
"(",
")",
")",
"{",
"LPCC",
"::",
"CondCode",
"BranchCond",
"=",
"static_cast",
"<",
"LPCC",
"::",
"CondCode",
">",
"(",
"Instruction",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
")",
";",
"FalseBlock",
"=",
"TrueBlock",
";",
"TrueBlock",
"=",
"Instruction",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"Condition",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateImm",
"(",
"BranchCond",
")",
")",
";",
"continue",
";",
"}",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"analyzeBranch",
"-",
"Analyze",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"MBB",
",",
"returning",
"true",
"if",
"it",
"can",
"not",
"be",
"understood",
"(",
"e.g",
"."
] | [
"Lanai",
"Lanai",
"Lanai::BT",
"0",
"0",
"0",
"Lanai::BRCC",
"1",
"0"
] | LanaiInstrInfo | analyzeBranch | Lanai | CPU | LLVM | 29,369 | 311 | 1 | [] |
[
"<s>",
"static",
"void",
"arc_asm_trampoline_template",
"(",
"FILE",
"*",
"f",
")",
"{",
"asm_fprintf",
"(",
"f",
",",
"\"\\tld_s\\t%s,[pcl,8]\\n\"",
",",
"ARC_TEMP_SCRATCH_REG",
")",
";",
"asm_fprintf",
"(",
"f",
",",
"\"\\tld\\t%s,[pcl,12]\\n\"",
",",
"reg_names",
"[",
"STATIC_CHAIN_REGNUM",
"]",
")",
";",
"asm_fprintf",
"(",
"f",
",",
"\"\\tj_s\\t[%s]\\n\"",
",",
"ARC_TEMP_SCRATCH_REG",
")",
";",
"assemble_aligned_integer",
"(",
"UNITS_PER_WORD",
",",
"const0_rtx",
")",
";",
"assemble_aligned_integer",
"(",
"UNITS_PER_WORD",
",",
"const0_rtx",
")",
";",
"}",
"</s>"
] | [
"Output",
"assembler",
"code",
"for",
"a",
"block",
"containing",
"the",
"constant",
"parts",
"of",
"a",
"trampoline",
",",
"leaving",
"space",
"for",
"variable",
"parts",
".",
"A",
"trampoline",
"looks",
"like",
"this",
":",
"ld_s",
"r12",
",",
"[",
"pcl,8",
"]",
"ld",
"r11",
",",
"[",
"pcl,12",
"]",
"j_s",
"[",
"r12",
"]",
".word",
"function",
"'s",
"address",
".word",
"static",
"chain",
"value"
] | [
"arc",
"\"\\tld_s\\t%s,[pcl,8]\\n\"",
"\"\\tld\\t%s,[pcl,12]\\n\"",
"\"\\tj_s\\t[%s]\\n\""
] | arc | arc_asm_trampoline_template | arc | MPU | GCC | 29,370 | 54 | 1 | [] |
[
"<s>",
"bool",
"SIRegisterInfo",
"::",
"isFrameOffsetLegal",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"BaseReg",
",",
"int64_t",
"Offset",
")",
"const",
"{",
"return",
"SIInstrInfo",
"::",
"isMUBUF",
"(",
"*",
"MI",
")",
"&&",
"isUInt",
"<",
"12",
">",
"(",
"Offset",
")",
";",
"}",
"</s>"
] | [
"Determine",
"whether",
"a",
"given",
"base",
"register",
"plus",
"offset",
"immediate",
"is",
"encodable",
"to",
"resolve",
"a",
"frame",
"index",
"."
] | [
"AMDGPU",
"SI",
"SI",
"12"
] | SIRegisterInfo106 | isFrameOffsetLegal | AMDGPU | GPU | LLVM | 29,371 | 36 | 1 | [] |
[
"<s>",
"void",
"tilepro_expand_builtin_vector_binop",
"(",
"rtx",
"(",
"*",
"gen",
")",
"(",
"rtx",
",",
"rtx",
",",
"rtx",
")",
",",
"machine_mode",
"dest_mode",
",",
"rtx",
"dest",
",",
"machine_mode",
"src_mode",
",",
"rtx",
"src0",
",",
"rtx",
"src1",
",",
"bool",
"do_src1",
")",
"{",
"dest",
"=",
"gen_lowpart",
"(",
"dest_mode",
",",
"dest",
")",
";",
"if",
"(",
"src0",
"==",
"const0_rtx",
")",
"src0",
"=",
"CONST0_RTX",
"(",
"src_mode",
")",
";",
"else",
"src0",
"=",
"gen_lowpart",
"(",
"src_mode",
",",
"src0",
")",
";",
"if",
"(",
"do_src1",
")",
"{",
"if",
"(",
"src1",
"==",
"const0_rtx",
")",
"src1",
"=",
"CONST0_RTX",
"(",
"src_mode",
")",
";",
"else",
"src1",
"=",
"gen_lowpart",
"(",
"src_mode",
",",
"src1",
")",
";",
"}",
"emit_insn",
"(",
"(",
"*",
"gen",
")",
"(",
"dest",
",",
"src0",
",",
"src1",
")",
")",
";",
"}",
"</s>"
] | [
"Expand",
"a",
"builtin",
"vector",
"binary",
"op",
",",
"by",
"calling",
"gen",
"function",
"GEN",
"with",
"operands",
"in",
"the",
"proper",
"modes",
".",
"DEST",
"is",
"converted",
"to",
"DEST_MODE",
",",
"and",
"src0",
"and",
"src1",
"(",
"if",
"DO_SRC1",
"is",
"true",
")",
"is",
"converted",
"to",
"SRC_MODE",
"."
] | [
"tilepro"
] | tilepro | tilepro_expand_builtin_vector_binop | tilepro | VLIW | GCC | 29,372 | 112 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"isLegalAddressingMode",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"const",
"AddrMode",
"&",
"AM",
",",
"Type",
"*",
"Ty",
",",
"unsigned",
"AS",
")",
"const",
"{",
"EVT",
"VT",
"=",
"getValueType",
"(",
"DL",
",",
"Ty",
",",
"true",
")",
";",
"if",
"(",
"!",
"isLegalAddressImmediate",
"(",
"AM",
".",
"BaseOffs",
",",
"VT",
",",
"Subtarget",
")",
")",
"return",
"false",
";",
"if",
"(",
"AM",
".",
"BaseGV",
")",
"return",
"false",
";",
"switch",
"(",
"AM",
".",
"Scale",
")",
"{",
"case",
"0",
":",
"break",
";",
"case",
"1",
":",
"if",
"(",
"Subtarget",
"->",
"isThumb1Only",
"(",
")",
")",
"return",
"false",
";",
"default",
":",
"if",
"(",
"AM",
".",
"BaseOffs",
")",
"return",
"false",
";",
"if",
"(",
"!",
"VT",
".",
"isSimple",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"Subtarget",
"->",
"isThumb2",
"(",
")",
")",
"return",
"isLegalT2ScaledAddressingMode",
"(",
"AM",
",",
"VT",
")",
";",
"int",
"Scale",
"=",
"AM",
".",
"Scale",
";",
"switch",
"(",
"VT",
".",
"getSimpleVT",
"(",
")",
".",
"SimpleTy",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"MVT",
"::",
"i1",
":",
"case",
"MVT",
"::",
"i8",
":",
"case",
"MVT",
"::",
"i32",
":",
"if",
"(",
"Scale",
"<",
"0",
")",
"Scale",
"=",
"-",
"Scale",
";",
"if",
"(",
"Scale",
"==",
"1",
")",
"return",
"true",
";",
"return",
"isPowerOf2_32",
"(",
"Scale",
"&",
"~",
"1",
")",
";",
"case",
"MVT",
"::",
"i16",
":",
"case",
"MVT",
"::",
"i64",
":",
"if",
"(",
"(",
"(",
"unsigned",
")",
"AM",
".",
"HasBaseReg",
"+",
"Scale",
")",
"<=",
"2",
")",
"return",
"true",
";",
"return",
"false",
";",
"case",
"MVT",
"::",
"isVoid",
":",
"if",
"(",
"Scale",
"&",
"1",
")",
"return",
"false",
";",
"return",
"isPowerOf2_32",
"(",
"Scale",
")",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"isLegalAddressingMode",
"-",
"Return",
"true",
"if",
"the",
"addressing",
"mode",
"represented",
"by",
"AM",
"is",
"legal",
"for",
"this",
"target",
",",
"for",
"a",
"load/store",
"of",
"the",
"specified",
"type",
"."
] | [
"ARM",
"ARM",
"0",
"1",
"MVT::i1",
"MVT::i8",
"MVT::i32",
"0",
"1",
"1",
"MVT::i16",
"MVT::i64",
"2",
"MVT::isVoid",
"1"
] | ARMISelLowering (2)2 | isLegalAddressingMode | ARM | CPU | LLVM | 29,373 | 251 | 1 | [] |
[
"<s>",
"bool",
"processBlock",
"(",
"MachineBasicBlock",
"&",
"MBB",
")",
"{",
"bool",
"Changed",
"=",
"false",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MBB",
".",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"begin",
"(",
")",
",",
"IE",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"I",
"!=",
"IE",
";",
"++",
"I",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"I",
";",
"if",
"(",
"!",
"MI",
"->",
"isFullCopy",
"(",
")",
")",
"continue",
";",
"MachineOperand",
"&",
"DstMO",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
";",
"MachineOperand",
"&",
"SrcMO",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
";",
"if",
"(",
"IsVSReg",
"(",
"DstMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
"&&",
"!",
"IsVSReg",
"(",
"SrcMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
")",
"{",
"Changed",
"=",
"true",
";",
"const",
"TargetRegisterClass",
"*",
"SrcRC",
"=",
"IsVRReg",
"(",
"SrcMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
"?",
"&",
"PPC",
"::",
"VSHRCRegClass",
":",
"&",
"PPC",
"::",
"VSLRCRegClass",
";",
"assert",
"(",
"(",
"IsF8Reg",
"(",
"SrcMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
"||",
"IsVRReg",
"(",
"SrcMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
"||",
"IsVSFReg",
"(",
"SrcMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
")",
"&&",
"\"Unknown source for a VSX copy\"",
")",
";",
"unsigned",
"NewVReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"SrcRC",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"TargetOpcode",
"::",
"SUBREG_TO_REG",
")",
",",
"NewVReg",
")",
".",
"addImm",
"(",
"1",
")",
".",
"addOperand",
"(",
"SrcMO",
")",
".",
"addImm",
"(",
"IsVRReg",
"(",
"SrcMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
"?",
"PPC",
"::",
"sub_128",
":",
"PPC",
"::",
"sub_64",
")",
";",
"SrcMO",
".",
"setReg",
"(",
"NewVReg",
")",
";",
"}",
"else",
"if",
"(",
"!",
"IsVSReg",
"(",
"DstMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
"&&",
"IsVSReg",
"(",
"SrcMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
")",
"{",
"Changed",
"=",
"true",
";",
"const",
"TargetRegisterClass",
"*",
"DstRC",
"=",
"IsVRReg",
"(",
"DstMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
"?",
"&",
"PPC",
"::",
"VSHRCRegClass",
":",
"&",
"PPC",
"::",
"VSLRCRegClass",
";",
"assert",
"(",
"(",
"IsF8Reg",
"(",
"DstMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
"||",
"IsVSFReg",
"(",
"DstMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
"||",
"IsVRReg",
"(",
"DstMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
")",
"&&",
"\"Unknown destination for a VSX copy\"",
")",
";",
"unsigned",
"NewVReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"DstRC",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"TargetOpcode",
"::",
"COPY",
")",
",",
"NewVReg",
")",
".",
"addOperand",
"(",
"SrcMO",
")",
";",
"SrcMO",
".",
"setReg",
"(",
"NewVReg",
")",
";",
"SrcMO",
".",
"setSubReg",
"(",
"IsVRReg",
"(",
"DstMO",
".",
"getReg",
"(",
")",
",",
"MRI",
")",
"?",
"PPC",
"::",
"sub_128",
":",
"PPC",
"::",
"sub_64",
")",
";",
"}",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"processBlock",
"-",
"If",
"there",
"are",
"any",
"predecessors",
"whose",
"control",
"can",
"be",
"threaded",
"through",
"to",
"a",
"successor",
",",
"transform",
"them",
"now",
"."
] | [
"PowerPC",
"0",
"1",
"PPC::VSHRCRegClass",
"PPC::VSLRCRegClass",
"\"Unknown source for a VSX copy\"",
"1",
"PPC::sub_128",
"PPC::sub_64",
"PPC::VSHRCRegClass",
"PPC::VSLRCRegClass",
"\"Unknown destination for a VSX copy\"",
"PPC::sub_128",
"PPC::sub_64"
] | PPCVSXCopy7 | processBlock | PowerPC | CPU | LLVM | 29,374 | 438 | 1 | [] |
[
"<s>",
"MachineInstr",
"*",
"SystemZInstrInfo",
"::",
"convertToThreeAddress",
"(",
"MachineFunction",
"::",
"iterator",
"&",
"MFI",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"MBBI",
",",
"LiveVariables",
"*",
"LV",
")",
"const",
"{",
"MachineInstr",
"*",
"MI",
"=",
"MBBI",
";",
"MachineBasicBlock",
"*",
"MBB",
"=",
"MI",
"->",
"getParent",
"(",
")",
";",
"unsigned",
"Opcode",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"unsigned",
"NumOps",
"=",
"MI",
"->",
"getNumOperands",
"(",
")",
";",
"if",
"(",
"TM",
".",
"getSubtargetImpl",
"(",
")",
"->",
"hasDistinctOps",
"(",
")",
")",
"{",
"int",
"ThreeOperandOpcode",
"=",
"SystemZ",
"::",
"getThreeOperandOpcode",
"(",
"Opcode",
")",
";",
"if",
"(",
"ThreeOperandOpcode",
">=",
"0",
")",
"{",
"MachineOperand",
"&",
"Dest",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
";",
"MachineOperand",
"&",
"Src",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
";",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"*",
"MBB",
",",
"MBBI",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"ThreeOperandOpcode",
")",
")",
".",
"addOperand",
"(",
"Dest",
")",
";",
"MIB",
".",
"addReg",
"(",
"Src",
".",
"getReg",
"(",
")",
",",
"getKillRegState",
"(",
"Src",
".",
"isKill",
"(",
")",
")",
",",
"Src",
".",
"getSubReg",
"(",
")",
")",
";",
"for",
"(",
"unsigned",
"I",
"=",
"2",
";",
"I",
"<",
"NumOps",
";",
"++",
"I",
")",
"MIB",
".",
"addOperand",
"(",
"MI",
"->",
"getOperand",
"(",
"I",
")",
")",
";",
"return",
"finishConvertToThreeAddress",
"(",
"MI",
",",
"MIB",
",",
"LV",
")",
";",
"}",
"}",
"if",
"(",
"LogicOp",
"And",
"=",
"interpretAndImmediate",
"(",
"Opcode",
")",
")",
"{",
"unsigned",
"NewOpcode",
";",
"if",
"(",
"And",
".",
"RegSize",
"==",
"64",
")",
"NewOpcode",
"=",
"SystemZ",
"::",
"RISBG",
";",
"else",
"if",
"(",
"TM",
".",
"getSubtargetImpl",
"(",
")",
"->",
"hasHighWord",
"(",
")",
")",
"NewOpcode",
"=",
"SystemZ",
"::",
"RISBLG32",
";",
"else",
"NewOpcode",
"=",
"0",
";",
"if",
"(",
"NewOpcode",
")",
"{",
"uint64_t",
"Imm",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
"<<",
"And",
".",
"ImmLSB",
";",
"Imm",
"|=",
"allOnes",
"(",
"And",
".",
"RegSize",
")",
"&",
"~",
"(",
"allOnes",
"(",
"And",
".",
"ImmSize",
")",
"<<",
"And",
".",
"ImmLSB",
")",
";",
"unsigned",
"Start",
",",
"End",
";",
"if",
"(",
"isRxSBGMask",
"(",
"Imm",
",",
"And",
".",
"RegSize",
",",
"Start",
",",
"End",
")",
")",
"{",
"if",
"(",
"NewOpcode",
"==",
"SystemZ",
"::",
"RISBLG32",
")",
"{",
"Start",
"&=",
"31",
";",
"End",
"&=",
"31",
";",
"}",
"MachineOperand",
"&",
"Dest",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
";",
"MachineOperand",
"&",
"Src",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
";",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"NewOpcode",
")",
")",
".",
"addOperand",
"(",
"Dest",
")",
".",
"addReg",
"(",
"0",
")",
".",
"addReg",
"(",
"Src",
".",
"getReg",
"(",
")",
",",
"getKillRegState",
"(",
"Src",
".",
"isKill",
"(",
")",
")",
",",
"Src",
".",
"getSubReg",
"(",
")",
")",
".",
"addImm",
"(",
"Start",
")",
".",
"addImm",
"(",
"End",
"+",
"128",
")",
".",
"addImm",
"(",
"0",
")",
";",
"return",
"finishConvertToThreeAddress",
"(",
"MI",
",",
"MIB",
",",
"LV",
")",
";",
"}",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"convertToThreeAddress",
"-",
"This",
"method",
"must",
"be",
"implemented",
"by",
"targets",
"that",
"set",
"the",
"M_CONVERTIBLE_TO_3_ADDR",
"flag",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ::getThreeOperandOpcode",
"0",
"0",
"1",
"2",
"64",
"SystemZ::RISBG",
"SystemZ::RISBLG32",
"0",
"2",
"SystemZ::RISBLG32",
"31",
"31",
"0",
"1",
"0",
"128",
"0",
"0"
] | SystemZInstrInfo (2) | convertToThreeAddress | SystemZ | CPU | LLVM | 29,375 | 450 | 1 | [] |
[
"<s>",
"virtual",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"{",
"TargetTransformInfo",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"ARM"
] | ARMTargetTransformInfo | getAnalysisUsage | ARM | CPU | LLVM | 29,376 | 18 | 1 | [] |
[
"<s>",
"void",
"NVPTXAsmPrinter",
"::",
"emitImplicitDef",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"unsigned",
"RegNo",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"RegNo",
")",
")",
"{",
"OutStreamer",
".",
"AddComment",
"(",
"Twine",
"(",
"\"implicit-def: \"",
")",
"+",
"getVirtualRegisterName",
"(",
"RegNo",
")",
")",
";",
"}",
"else",
"{",
"OutStreamer",
".",
"AddComment",
"(",
"Twine",
"(",
"\"implicit-def: \"",
")",
"+",
"nvptxSubtarget",
"->",
"getRegisterInfo",
"(",
")",
"->",
"getName",
"(",
"RegNo",
")",
")",
";",
"}",
"OutStreamer",
".",
"AddBlankLine",
"(",
")",
";",
"}",
"</s>"
] | [
"Targets",
"can",
"override",
"this",
"to",
"customize",
"the",
"output",
"of",
"IMPLICIT_DEF",
"instructions",
"in",
"verbose",
"mode",
"."
] | [
"NVPTX",
"NVPTX",
"0",
"\"implicit-def: \"",
"\"implicit-def: \""
] | NVPTXAsmPrinter25 | emitImplicitDef | NVPTX | GPU | LLVM | 29,377 | 83 | 1 | [] |
[
"<s>",
"const",
"uint32_t",
"*",
"HexagonRegisterInfo",
"::",
"getCallPreservedMask",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"CallingConv",
"::",
"ID",
")",
"const",
"{",
"return",
"HexagonCSR_RegMask",
";",
"}",
"</s>"
] | [
"Return",
"a",
"mask",
"of",
"call-preserved",
"registers",
"for",
"the",
"given",
"calling",
"convention",
"on",
"the",
"current",
"function",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon"
] | HexagonRegisterInfo12 | getCallPreservedMask | Hexagon | DSP | LLVM | 29,378 | 22 | 1 | [] |
[
"<s>",
"bool",
"RISCVPassConfig",
"::",
"addRegBankSelect",
"(",
")",
"{",
"addPass",
"(",
"new",
"RegBankSelect",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"method",
"should",
"install",
"a",
"register",
"bank",
"selector",
"pass",
",",
"which",
"assigns",
"register",
"banks",
"to",
"virtual",
"registers",
"without",
"a",
"register",
"class",
"or",
"register",
"banks",
"."
] | [
"RISCV",
"RISCV"
] | RISCVTargetMachine1 | addRegBankSelect | RISCV | CPU | LLVM | 29,379 | 19 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"isCoalescableExtInstr",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"&",
"SrcReg",
",",
"unsigned",
"&",
"DstReg",
",",
"unsigned",
"&",
"SubIdx",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"X86",
"::",
"MOVSX16rr8",
":",
"case",
"X86",
"::",
"MOVZX16rr8",
":",
"case",
"X86",
"::",
"MOVSX32rr8",
":",
"case",
"X86",
"::",
"MOVZX32rr8",
":",
"case",
"X86",
"::",
"MOVSX64rr8",
":",
"if",
"(",
"!",
"Subtarget",
".",
"is64Bit",
"(",
")",
")",
"return",
"false",
";",
"case",
"X86",
"::",
"MOVSX32rr16",
":",
"case",
"X86",
"::",
"MOVZX32rr16",
":",
"case",
"X86",
"::",
"MOVSX64rr16",
":",
"case",
"X86",
"::",
"MOVSX64rr32",
":",
"{",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getSubReg",
"(",
")",
"||",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getSubReg",
"(",
")",
")",
"return",
"false",
";",
"SrcReg",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"DstReg",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unreachable!\"",
")",
";",
"case",
"X86",
"::",
"MOVSX16rr8",
":",
"case",
"X86",
"::",
"MOVZX16rr8",
":",
"case",
"X86",
"::",
"MOVSX32rr8",
":",
"case",
"X86",
"::",
"MOVZX32rr8",
":",
"case",
"X86",
"::",
"MOVSX64rr8",
":",
"SubIdx",
"=",
"X86",
"::",
"sub_8bit",
";",
"break",
";",
"case",
"X86",
"::",
"MOVSX32rr16",
":",
"case",
"X86",
"::",
"MOVZX32rr16",
":",
"case",
"X86",
"::",
"MOVSX64rr16",
":",
"SubIdx",
"=",
"X86",
"::",
"sub_16bit",
";",
"break",
";",
"case",
"X86",
"::",
"MOVSX64rr32",
":",
"SubIdx",
"=",
"X86",
"::",
"sub_32bit",
";",
"break",
";",
"}",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"isCoalescableExtInstr",
"-",
"Return",
"true",
"if",
"the",
"instruction",
"is",
"a",
"``",
"coalescable",
"''",
"extension",
"instruction",
"."
] | [
"X86",
"X86",
"X86::MOVSX16rr8",
"X86::MOVZX16rr8",
"X86::MOVSX32rr8",
"X86::MOVZX32rr8",
"X86::MOVSX64rr8",
"X86::MOVSX32rr16",
"X86::MOVZX32rr16",
"X86::MOVSX64rr16",
"X86::MOVSX64rr32",
"0",
"1",
"1",
"0",
"\"Unreachable!\"",
"X86::MOVSX16rr8",
"X86::MOVZX16rr8",
"X86::MOVSX32rr8",
"X86::MOVZX32rr8",
"X86::MOVSX64rr8",
"X86::sub_8bit",
"X86::MOVSX32rr16",
"X86::MOVZX32rr16",
"X86::MOVSX64rr16",
"X86::sub_16bit",
"X86::MOVSX64rr32",
"X86::sub_32bit"
] | X86InstrInfo (2)1 | isCoalescableExtInstr | X86 | CPU | LLVM | 29,380 | 243 | 1 | [] |
[
"<s>",
"bool",
"AArch64LoadStoreOpt",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"Fn",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"Subtarget",
"=",
"&",
"Fn",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
";",
"TII",
"=",
"static_cast",
"<",
"const",
"AArch64InstrInfo",
"*",
">",
"(",
"Subtarget",
"->",
"getInstrInfo",
"(",
")",
")",
";",
"TRI",
"=",
"Subtarget",
"->",
"getRegisterInfo",
"(",
")",
";",
"AA",
"=",
"&",
"getAnalysis",
"<",
"AAResultsWrapperPass",
">",
"(",
")",
".",
"getAAResults",
"(",
")",
";",
"ModifiedRegUnits",
".",
"init",
"(",
"*",
"TRI",
")",
";",
"UsedRegUnits",
".",
"init",
"(",
"*",
"TRI",
")",
";",
"DefinedInBB",
".",
"init",
"(",
"*",
"TRI",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"bool",
"enableNarrowZeroStOpt",
"=",
"!",
"Subtarget",
"->",
"requiresStrictAlign",
"(",
")",
";",
"for",
"(",
"auto",
"&",
"MBB",
":",
"Fn",
")",
"{",
"auto",
"M",
"=",
"optimizeBlock",
"(",
"MBB",
",",
"enableNarrowZeroStOpt",
")",
";",
"Modified",
"|=",
"M",
";",
"}",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64LoadStoreOptimizer (2)1 | runOnMachineFunction | AArch64 | CPU | LLVM | 29,381 | 141 | 1 | [] |
[
"<s>",
"static",
"void",
"avr_asm_named_section",
"(",
"const",
"char",
"*",
"name",
",",
"unsigned",
"int",
"flags",
",",
"tree",
"decl",
")",
"{",
"if",
"(",
"flags",
"&",
"AVR_SECTION_PROGMEM",
")",
"{",
"addr_space_t",
"as",
"=",
"(",
"flags",
"&",
"AVR_SECTION_PROGMEM",
")",
"/",
"SECTION_MACH_DEP",
";",
"const",
"char",
"*",
"old_prefix",
"=",
"\".rodata\"",
";",
"const",
"char",
"*",
"new_prefix",
"=",
"avr_addrspace",
"[",
"as",
"]",
".",
"section_name",
";",
"if",
"(",
"startswith",
"(",
"name",
",",
"old_prefix",
")",
")",
"{",
"const",
"char",
"*",
"sname",
"=",
"ACONCAT",
"(",
"(",
"new_prefix",
",",
"name",
"+",
"strlen",
"(",
"old_prefix",
")",
",",
"NULL",
")",
")",
";",
"default_elf_asm_named_section",
"(",
"sname",
",",
"flags",
",",
"decl",
")",
";",
"return",
";",
"}",
"default_elf_asm_named_section",
"(",
"new_prefix",
",",
"flags",
",",
"decl",
")",
";",
"return",
";",
"}",
"if",
"(",
"!",
"avr_need_copy_data_p",
")",
"avr_need_copy_data_p",
"=",
"(",
"startswith",
"(",
"name",
",",
"\".data\"",
")",
"||",
"startswith",
"(",
"name",
",",
"\".gnu.linkonce.d\"",
")",
")",
";",
"if",
"(",
"!",
"avr_need_copy_data_p",
"&&",
"avr_arch",
"->",
"flash_pm_offset",
"==",
"0",
")",
"avr_need_copy_data_p",
"=",
"(",
"startswith",
"(",
"name",
",",
"\".rodata\"",
")",
"||",
"startswith",
"(",
"name",
",",
"\".gnu.linkonce.r\"",
")",
")",
";",
"if",
"(",
"!",
"avr_need_clear_bss_p",
")",
"avr_need_clear_bss_p",
"=",
"startswith",
"(",
"name",
",",
"\".bss\"",
")",
";",
"default_elf_asm_named_section",
"(",
"name",
",",
"flags",
",",
"decl",
")",
";",
"}",
"</s>"
] | [
"Track",
"need",
"of",
"__do_clear_bss",
",",
"__do_copy_data",
"for",
"named",
"sections",
"."
] | [
"avr",
"\".rodata\"",
"\".data\"",
"\".gnu.linkonce.d\"",
"0",
"\".rodata\"",
"\".gnu.linkonce.r\"",
"\".bss\""
] | avr | avr_asm_named_section | avr | MPU | GCC | 29,382 | 185 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"CSKYFrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
")",
"const",
"{",
"Register",
"SPReg",
"=",
"CSKY",
"::",
"R14",
";",
"DebugLoc",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"!",
"hasReservedCallFrame",
"(",
"MF",
")",
")",
"{",
"int64_t",
"Amount",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Amount",
"!=",
"0",
")",
"{",
"Amount",
"=",
"alignSPAdjust",
"(",
"Amount",
")",
";",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"CSKY",
"::",
"ADJCALLSTACKDOWN",
")",
"Amount",
"=",
"-",
"Amount",
";",
"adjustReg",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"SPReg",
",",
"SPReg",
",",
"Amount",
",",
"MachineInstr",
"::",
"NoFlags",
")",
";",
"}",
"}",
"return",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"</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",
")",
"."
] | [
"CSKY",
"CSKY",
"CSKY::R14",
"0",
"0",
"CSKY::ADJCALLSTACKDOWN"
] | CSKYFrameLowering1 | eliminateCallFramePseudoInstr | CSKY | CPU | LLVM | 29,383 | 122 | 1 | [] |
[
"<s>",
"int",
"AArch64TTIImpl",
"::",
"getArithmeticInstrCost",
"(",
"unsigned",
"Opcode",
",",
"Type",
"*",
"Ty",
",",
"TTI",
"::",
"OperandValueKind",
"Opd1Info",
",",
"TTI",
"::",
"OperandValueKind",
"Opd2Info",
",",
"TTI",
"::",
"OperandValueProperties",
"Opd1PropInfo",
",",
"TTI",
"::",
"OperandValueProperties",
"Opd2PropInfo",
")",
"{",
"std",
"::",
"pair",
"<",
"int",
",",
"MVT",
">",
"LT",
"=",
"TLI",
"->",
"getTypeLegalizationCost",
"(",
"DL",
",",
"Ty",
")",
";",
"int",
"ISD",
"=",
"TLI",
"->",
"InstructionOpcodeToISD",
"(",
"Opcode",
")",
";",
"if",
"(",
"ISD",
"==",
"ISD",
"::",
"SDIV",
"&&",
"Opd2Info",
"==",
"TargetTransformInfo",
"::",
"OK_UniformConstantValue",
"&&",
"Opd2PropInfo",
"==",
"TargetTransformInfo",
"::",
"OP_PowerOf2",
")",
"{",
"int",
"Cost",
"=",
"getArithmeticInstrCost",
"(",
"Instruction",
"::",
"Add",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"TargetTransformInfo",
"::",
"OP_None",
",",
"TargetTransformInfo",
"::",
"OP_None",
")",
";",
"Cost",
"+=",
"getArithmeticInstrCost",
"(",
"Instruction",
"::",
"Sub",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"TargetTransformInfo",
"::",
"OP_None",
",",
"TargetTransformInfo",
"::",
"OP_None",
")",
";",
"Cost",
"+=",
"getArithmeticInstrCost",
"(",
"Instruction",
"::",
"Select",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"TargetTransformInfo",
"::",
"OP_None",
",",
"TargetTransformInfo",
"::",
"OP_None",
")",
";",
"Cost",
"+=",
"getArithmeticInstrCost",
"(",
"Instruction",
"::",
"AShr",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"TargetTransformInfo",
"::",
"OP_None",
",",
"TargetTransformInfo",
"::",
"OP_None",
")",
";",
"return",
"Cost",
";",
"}",
"switch",
"(",
"ISD",
")",
"{",
"default",
":",
"return",
"BaseT",
"::",
"getArithmeticInstrCost",
"(",
"Opcode",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"Opd1PropInfo",
",",
"Opd2PropInfo",
")",
";",
"case",
"ISD",
"::",
"ADD",
":",
"case",
"ISD",
"::",
"MUL",
":",
"case",
"ISD",
"::",
"XOR",
":",
"case",
"ISD",
"::",
"OR",
":",
"case",
"ISD",
"::",
"AND",
":",
"return",
"1",
"*",
"LT",
".",
"first",
";",
"}",
"}",
"</s>"
] | [
"This",
"is",
"an",
"approximation",
"of",
"reciprocal",
"throughput",
"of",
"a",
"math/logic",
"op",
"."
] | [
"AArch64",
"AArch64",
"ISD::SDIV",
"ISD::ADD",
"ISD::MUL",
"ISD::XOR",
"ISD::OR",
"ISD::AND",
"1"
] | AArch64TargetTransformInfo (2) | getArithmeticInstrCost | AArch64 | CPU | LLVM | 29,384 | 239 | 1 | [] |
[
"<s>",
"void",
"X86PassConfig",
"::",
"addIRPasses",
"(",
")",
"{",
"addPass",
"(",
"createAtomicExpandPass",
"(",
")",
")",
";",
"TargetPassConfig",
"::",
"addIRPasses",
"(",
")",
";",
"if",
"(",
"TM",
"->",
"getOptLevel",
"(",
")",
"!=",
"CodeGenOpt",
"::",
"None",
")",
"{",
"addPass",
"(",
"createInterleavedAccessPass",
"(",
")",
")",
";",
"addPass",
"(",
"createX86PartialReductionPass",
"(",
")",
")",
";",
"}",
"addPass",
"(",
"createIndirectBrExpandPass",
"(",
")",
")",
";",
"const",
"Triple",
"&",
"TT",
"=",
"TM",
"->",
"getTargetTriple",
"(",
")",
";",
"if",
"(",
"TT",
".",
"isOSWindows",
"(",
")",
")",
"{",
"if",
"(",
"TT",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86_64",
")",
"{",
"addPass",
"(",
"createCFGuardDispatchPass",
"(",
")",
")",
";",
"}",
"else",
"{",
"addPass",
"(",
"createCFGuardCheckPass",
"(",
")",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Add",
"common",
"target",
"configurable",
"passes",
"that",
"perform",
"LLVM",
"IR",
"to",
"IR",
"transforms",
"following",
"machine",
"independent",
"optimization",
"."
] | [
"X86",
"X86",
"X86"
] | X86TargetMachine16 | addIRPasses | X86 | CPU | LLVM | 29,385 | 108 | 1 | [] |
[
"<s>",
"SDValue",
"PPCTargetLowering",
"::",
"LowerCall",
"(",
"SDValue",
"Chain",
",",
"SDValue",
"Callee",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"isVarArg",
",",
"bool",
"doesNotRet",
",",
"bool",
"&",
"isTailCall",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
",",
"const",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"OutVals",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"DebugLoc",
"dl",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"if",
"(",
"isTailCall",
")",
"isTailCall",
"=",
"IsEligibleForTailCallOptimization",
"(",
"Callee",
",",
"CallConv",
",",
"isVarArg",
",",
"Ins",
",",
"DAG",
")",
";",
"if",
"(",
"PPCSubTarget",
".",
"isSVR4ABI",
"(",
")",
"&&",
"!",
"PPCSubTarget",
".",
"isPPC64",
"(",
")",
")",
"return",
"LowerCall_SVR4",
"(",
"Chain",
",",
"Callee",
",",
"CallConv",
",",
"isVarArg",
",",
"isTailCall",
",",
"Outs",
",",
"OutVals",
",",
"Ins",
",",
"dl",
",",
"DAG",
",",
"InVals",
")",
";",
"return",
"LowerCall_Darwin",
"(",
"Chain",
",",
"Callee",
",",
"CallConv",
",",
"isVarArg",
",",
"isTailCall",
",",
"Outs",
",",
"OutVals",
",",
"Ins",
",",
"dl",
",",
"DAG",
",",
"InVals",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"calls",
"into",
"the",
"specified",
"DAG",
"."
] | [
"PowerPC",
"PPC",
"ISD::OutputArg",
"ISD::InputArg",
"PPC",
"PPC",
"PPC"
] | PPCISelLowering114 | LowerCall | PowerPC | CPU | LLVM | 29,386 | 157 | 1 | [] |
[
"<s>",
"int",
"main",
"(",
"int",
"argc",
",",
"char",
"*",
"*",
"argv",
")",
"{",
"progname",
"=",
"\"mkoffload-intelmic\"",
";",
"gcc_init_libintl",
"(",
")",
";",
"diagnostic_initialize",
"(",
"global_dc",
",",
"0",
")",
";",
"if",
"(",
"atexit",
"(",
"mkoffload_atexit",
")",
"!=",
"0",
")",
"fatal_error",
"(",
"input_location",
",",
"\"atexit failed\"",
")",
";",
"const",
"char",
"*",
"host_compiler",
"=",
"getenv",
"(",
"\"COLLECT_GCC\"",
")",
";",
"if",
"(",
"!",
"host_compiler",
")",
"fatal_error",
"(",
"input_location",
",",
"\"COLLECT_GCC must be set\"",
")",
";",
"const",
"char",
"*",
"target_driver_name",
"=",
"GCC_INSTALL_NAME",
";",
"char",
"*",
"target_compiler",
"=",
"find_target_compiler",
"(",
"target_driver_name",
")",
";",
"if",
"(",
"target_compiler",
"==",
"NULL",
")",
"fatal_error",
"(",
"input_location",
",",
"\"offload compiler %s not found\"",
",",
"target_driver_name",
")",
";",
"expandargv",
"(",
"&",
"argc",
",",
"&",
"argv",
")",
";",
"for",
"(",
"int",
"i",
"=",
"argc",
"-",
"1",
";",
"i",
">",
"0",
";",
"i",
"--",
")",
"if",
"(",
"strncmp",
"(",
"argv",
"[",
"i",
"]",
",",
"\"-foffload-abi=\"",
",",
"sizeof",
"(",
"\"-foffload-abi=\"",
")",
"-",
"1",
")",
"==",
"0",
")",
"{",
"if",
"(",
"strstr",
"(",
"argv",
"[",
"i",
"]",
",",
"\"ilp32\"",
")",
")",
"target_ilp32",
"=",
"true",
";",
"else",
"if",
"(",
"!",
"strstr",
"(",
"argv",
"[",
"i",
"]",
",",
"\"lp64\"",
")",
")",
"fatal_error",
"(",
"input_location",
",",
"\"unrecognizable argument of option -foffload-abi\"",
")",
";",
"break",
";",
"}",
"const",
"char",
"*",
"target_so_filename",
"=",
"prepare_target_image",
"(",
"target_compiler",
",",
"argc",
",",
"argv",
")",
";",
"const",
"char",
"*",
"host_descr_filename",
"=",
"generate_host_descr_file",
"(",
"host_compiler",
")",
";",
"unsigned",
"new_argc",
"=",
"0",
";",
"const",
"char",
"*",
"new_argv",
"[",
"9",
"]",
";",
"new_argv",
"[",
"new_argc",
"++",
"]",
"=",
"\"ld\"",
";",
"new_argv",
"[",
"new_argc",
"++",
"]",
"=",
"\"-m\"",
";",
"if",
"(",
"target_ilp32",
")",
"new_argv",
"[",
"new_argc",
"++",
"]",
"=",
"\"elf_i386\"",
";",
"else",
"new_argv",
"[",
"new_argc",
"++",
"]",
"=",
"\"elf_x86_64\"",
";",
"new_argv",
"[",
"new_argc",
"++",
"]",
"=",
"\"--relocatable\"",
";",
"new_argv",
"[",
"new_argc",
"++",
"]",
"=",
"host_descr_filename",
";",
"new_argv",
"[",
"new_argc",
"++",
"]",
"=",
"target_so_filename",
";",
"new_argv",
"[",
"new_argc",
"++",
"]",
"=",
"\"-o\"",
";",
"new_argv",
"[",
"new_argc",
"++",
"]",
"=",
"out_obj_filename",
";",
"new_argv",
"[",
"new_argc",
"++",
"]",
"=",
"NULL",
";",
"fork_execute",
"(",
"new_argv",
"[",
"0",
"]",
",",
"CONST_CAST",
"(",
"char",
"*",
"*",
",",
"new_argv",
")",
",",
"false",
")",
";",
"new_argv",
"[",
"0",
"]",
"=",
"\"objcopy\"",
";",
"new_argv",
"[",
"1",
"]",
"=",
"\"-L\"",
";",
"new_argv",
"[",
"2",
"]",
"=",
"symbols",
"[",
"0",
"]",
";",
"new_argv",
"[",
"3",
"]",
"=",
"\"-L\"",
";",
"new_argv",
"[",
"4",
"]",
"=",
"symbols",
"[",
"1",
"]",
";",
"new_argv",
"[",
"5",
"]",
"=",
"\"-L\"",
";",
"new_argv",
"[",
"6",
"]",
"=",
"symbols",
"[",
"2",
"]",
";",
"new_argv",
"[",
"7",
"]",
"=",
"out_obj_filename",
";",
"new_argv",
"[",
"8",
"]",
"=",
"NULL",
";",
"fork_execute",
"(",
"new_argv",
"[",
"0",
"]",
",",
"CONST_CAST",
"(",
"char",
"*",
"*",
",",
"new_argv",
")",
",",
"false",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Main",
"program",
"to",
"convert",
"flat",
"files",
"into",
"built-in",
"initialization",
"code",
"."
] | [
"i386",
"\"mkoffload-intelmic\"",
"0",
"0",
"\"atexit failed\"",
"\"COLLECT_GCC\"",
"\"COLLECT_GCC must be set\"",
"\"offload compiler %s not found\"",
"1",
"0",
"\"-foffload-abi=\"",
"\"-foffload-abi=\"",
"1",
"0",
"\"ilp32\"",
"\"lp64\"",
"\"unrecognizable argument of option -foffload-abi\"",
"0",
"9",
"\"ld\"",
"\"-m\"",
"\"elf_i386\"",
"\"elf_x86_64\"",
"\"--relocatable\"",
"\"-o\"",
"0",
"0",
"\"objcopy\"",
"1",
"\"-L\"",
"2",
"0",
"3",
"\"-L\"",
"4",
"1",
"5",
"\"-L\"",
"6",
"2",
"7",
"8",
"0",
"0"
] | intelmic-mkoffload2 | main | i386 | CPU | GCC | 29,387 | 419 | 1 | [] |
[
"<s>",
"bool",
"SNESFrameLowering",
"::",
"spillCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"unsigned",
"CalleeFrameSize",
"=",
"0",
";",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"SNESSubtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"SNESSubtarget",
">",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"SNESMachineFunctionInfo",
"*",
"SNESFI",
"=",
"MF",
".",
"getInfo",
"<",
"SNESMachineFunctionInfo",
">",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"0",
";",
"--",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"-",
"1",
"]",
".",
"getReg",
"(",
")",
";",
"bool",
"IsNotLiveIn",
"=",
"!",
"MBB",
".",
"isLiveIn",
"(",
"Reg",
")",
";",
"assert",
"(",
"TRI",
"->",
"getRegSizeInBits",
"(",
"*",
"TRI",
"->",
"getMinimalPhysRegClass",
"(",
"Reg",
")",
")",
"==",
"16",
"&&",
"\"Invalid register size\"",
")",
";",
"if",
"(",
"IsNotLiveIn",
")",
"{",
"MBB",
".",
"addLiveIn",
"(",
"Reg",
")",
";",
"}",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"SNES",
"::",
"PHAstk",
")",
")",
".",
"addReg",
"(",
"Reg",
",",
"getKillRegState",
"(",
"IsNotLiveIn",
")",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameSetup",
")",
";",
"++",
"CalleeFrameSize",
";",
"}",
"SNESFI",
"->",
"setCalleeSavedFrameSize",
"(",
"CalleeFrameSize",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"spillCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"spill",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"store",
"instructions",
"via",
"storeRegToStackSlot",
"(",
")",
"."
] | [
"SNES",
"SNES",
"0",
"SNES",
"SNES",
"SNES",
"SNES",
"SNES",
"0",
"1",
"16",
"\"Invalid register size\"",
"SNES::PHAstk",
"SNES"
] | SNESFrameLowering | spillCalleeSavedRegisters | SNES | DSP | LLVM | 29,388 | 236 | 1 | [] |
[
"<s>",
"bool",
"HexagonShuffler",
"::",
"check",
"(",
")",
"{",
"const",
"HexagonPacketSummary",
"Summary",
"=",
"GetPacketSummary",
"(",
")",
";",
"if",
"(",
"!",
"applySlotRestrictions",
"(",
"Summary",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"ValidPacketMemoryOps",
"(",
"Summary",
")",
")",
"{",
"reportError",
"(",
"\"invalid instruction packet\"",
")",
";",
"return",
"false",
";",
"}",
"ValidResourceUsage",
"(",
"Summary",
")",
";",
"return",
"!",
"CheckFailure",
";",
"}",
"</s>"
] | [
"Check",
"if",
"the",
"constraints",
"are",
"satisfiable",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon",
"\"invalid instruction packet\""
] | HexagonShuffler10 | check | Hexagon | DSP | LLVM | 29,389 | 54 | 1 | [] |
[
"<s>",
"int",
"pru_get_ctable_base_index",
"(",
"unsigned",
"HOST_WIDE_INT",
"caddr",
")",
"{",
"unsigned",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"pru_ctable",
")",
";",
"i",
"++",
")",
"{",
"if",
"(",
"pru_ctable",
"[",
"i",
"]",
".",
"valid",
"&&",
"IN_RANGE",
"(",
"caddr",
",",
"pru_ctable",
"[",
"i",
"]",
".",
"base",
",",
"pru_ctable",
"[",
"i",
"]",
".",
"base",
"+",
"0xff",
")",
")",
"return",
"i",
";",
"}",
"return",
"-",
"1",
";",
"}",
"</s>"
] | [
"Check",
"if",
"the",
"given",
"address",
"can",
"be",
"addressed",
"via",
"CTABLE_BASE",
"+",
"UBYTE_OFFS",
",",
"and",
"return",
"the",
"base",
"CTABLE",
"index",
"if",
"possible",
"."
] | [
"pru",
"0",
"0xff",
"1"
] | pru | pru_get_ctable_base_index | pru | CPU | GCC | 29,390 | 68 | 1 | [] |
[
"<s>",
"RCPair",
"ARMTargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"std",
"::",
"string",
"&",
"Constraint",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"case",
"'l'",
":",
"if",
"(",
"Subtarget",
"->",
"isThumb",
"(",
")",
")",
"return",
"RCPair",
"(",
"0U",
",",
"ARM",
"::",
"tGPRRegisterClass",
")",
";",
"else",
"return",
"RCPair",
"(",
"0U",
",",
"ARM",
"::",
"GPRRegisterClass",
")",
";",
"case",
"'h'",
":",
"if",
"(",
"Subtarget",
"->",
"isThumb",
"(",
")",
")",
"return",
"RCPair",
"(",
"0U",
",",
"ARM",
"::",
"hGPRRegisterClass",
")",
";",
"break",
";",
"case",
"'r'",
":",
"return",
"RCPair",
"(",
"0U",
",",
"ARM",
"::",
"GPRRegisterClass",
")",
";",
"case",
"'w'",
":",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
")",
"return",
"RCPair",
"(",
"0U",
",",
"ARM",
"::",
"SPRRegisterClass",
")",
";",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"64",
")",
"return",
"RCPair",
"(",
"0U",
",",
"ARM",
"::",
"DPRRegisterClass",
")",
";",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"128",
")",
"return",
"RCPair",
"(",
"0U",
",",
"ARM",
"::",
"QPRRegisterClass",
")",
";",
"break",
";",
"case",
"'x'",
":",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
")",
"return",
"RCPair",
"(",
"0U",
",",
"ARM",
"::",
"SPR_8RegisterClass",
")",
";",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"64",
")",
"return",
"RCPair",
"(",
"0U",
",",
"ARM",
"::",
"DPR_8RegisterClass",
")",
";",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"128",
")",
"return",
"RCPair",
"(",
"0U",
",",
"ARM",
"::",
"QPR_8RegisterClass",
")",
";",
"break",
";",
"case",
"'t'",
":",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
")",
"return",
"RCPair",
"(",
"0U",
",",
"ARM",
"::",
"SPRRegisterClass",
")",
";",
"break",
";",
"}",
"}",
"if",
"(",
"StringRef",
"(",
"\"{cc}\"",
")",
".",
"equals_lower",
"(",
"Constraint",
")",
")",
"return",
"std",
"::",
"make_pair",
"(",
"unsigned",
"(",
"ARM",
"::",
"CPSR",
")",
",",
"ARM",
"::",
"CCRRegisterClass",
")",
";",
"return",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"Constraint",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"ARM",
"ARM",
"1",
"0",
"0U",
"ARM::tGPRRegisterClass",
"0U",
"ARM::GPRRegisterClass",
"0U",
"ARM::hGPRRegisterClass",
"0U",
"ARM::GPRRegisterClass",
"MVT::f32",
"0U",
"ARM::SPRRegisterClass",
"64",
"0U",
"ARM::DPRRegisterClass",
"128",
"0U",
"ARM::QPRRegisterClass",
"MVT::f32",
"0U",
"ARM::SPR_8RegisterClass",
"64",
"0U",
"ARM::DPR_8RegisterClass",
"128",
"0U",
"ARM::QPR_8RegisterClass",
"MVT::f32",
"0U",
"ARM::SPRRegisterClass",
"\"{cc}\"",
"ARM::CPSR",
"ARM::CCRRegisterClass"
] | ARMISelLowering114 | getRegForInlineAsmConstraint | ARM | CPU | LLVM | 29,391 | 295 | 1 | [] |
[
"<s>",
"bool",
"movd44_insn_p",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"if",
"(",
"get_attr_type",
"(",
"insn",
")",
"==",
"TYPE_ALU",
"&&",
"(",
"INSN_CODE",
"(",
"insn",
")",
"==",
"CODE_FOR_move_di",
"||",
"INSN_CODE",
"(",
"insn",
")",
"==",
"CODE_FOR_move_df",
")",
")",
"{",
"rtx",
"body",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"body",
")",
"==",
"SET",
")",
";",
"rtx",
"src",
"=",
"SET_SRC",
"(",
"body",
")",
";",
"rtx",
"dest",
"=",
"SET_DEST",
"(",
"body",
")",
";",
"if",
"(",
"(",
"REG_P",
"(",
"src",
")",
"||",
"GET_CODE",
"(",
"src",
")",
"==",
"SUBREG",
")",
"&&",
"(",
"REG_P",
"(",
"dest",
")",
"||",
"GET_CODE",
"(",
"dest",
")",
"==",
"SUBREG",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Check",
"if",
"INSN",
"is",
"a",
"movd44",
"insn",
"."
] | [
"nds32"
] | nds32-utils | movd44_insn_p | nds32 | CPU | GCC | 29,392 | 109 | 1 | [] |
[
"<s>",
"void",
"AMDGPUInstrInfo",
"::",
"insertNoop",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
")",
"const",
"{",
"}",
"</s>"
] | [
"Insert",
"a",
"noop",
"into",
"the",
"instruction",
"stream",
"at",
"the",
"specified",
"point",
"."
] | [
"R600"
] | AMDGPUInstrInfo10 | insertNoop | R600 | GPU | LLVM | 29,393 | 17 | 1 | [] |
[
"<s>",
"int",
"aarch64_asm_preferred_eh_data_format",
"(",
"int",
"code",
"ATTRIBUTE_UNUSED",
",",
"int",
"global",
")",
"{",
"int",
"type",
";",
"switch",
"(",
"aarch64_cmodel",
")",
"{",
"case",
"AARCH64_CMODEL_TINY",
":",
"case",
"AARCH64_CMODEL_TINY_PIC",
":",
"case",
"AARCH64_CMODEL_SMALL",
":",
"case",
"AARCH64_CMODEL_SMALL_PIC",
":",
"type",
"=",
"DW_EH_PE_sdata4",
";",
"break",
";",
"default",
":",
"type",
"=",
"DW_EH_PE_sdata8",
";",
"break",
";",
"}",
"return",
"(",
"global",
"?",
"DW_EH_PE_indirect",
":",
"0",
")",
"|",
"DW_EH_PE_pcrel",
"|",
"type",
";",
"}",
"</s>"
] | [
"Select",
"a",
"format",
"to",
"encode",
"pointers",
"in",
"exception",
"handling",
"data",
"."
] | [
"aarch64",
"0"
] | aarch642 | aarch64_asm_preferred_eh_data_format | aarch64 | CPU | GCC | 29,394 | 60 | 1 | [] |
[
"<s>",
"void",
"TPCSymbolizer",
"::",
"tryAddingPcLoadReferenceComment",
"(",
"raw_ostream",
"&",
"cStream",
",",
"int64_t",
"Value",
",",
"uint64_t",
"Address",
")",
"{",
"llvm_unreachable",
"(",
"\"unimplemented\"",
")",
";",
"}",
"</s>"
] | [
"Try",
"to",
"add",
"a",
"comment",
"on",
"the",
"PC-relative",
"load",
"."
] | [
"TPC",
"TPC",
"\"unimplemented\""
] | TPCDisassembler | tryAddingPcLoadReferenceComment | TPC | Virtual ISA | LLVM | 29,395 | 22 | 1 | [] |
[
"<s>",
"static",
"bool",
"sparc_cannot_force_const_mem",
"(",
"machine_mode",
"mode",
",",
"rtx",
"x",
")",
"{",
"switch",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"{",
"case",
"CONST_INT",
":",
"case",
"CONST_WIDE_INT",
":",
"case",
"CONST_DOUBLE",
":",
"case",
"CONST_VECTOR",
":",
"return",
"false",
";",
"case",
"LABEL_REF",
":",
"return",
"flag_pic",
"!=",
"0",
";",
"case",
"SYMBOL_REF",
":",
"if",
"(",
"SYMBOL_REF_TLS_MODEL",
"(",
"x",
")",
")",
"return",
"true",
";",
"else",
"return",
"flag_pic",
"!=",
"0",
";",
"case",
"CONST",
":",
"return",
"sparc_cannot_force_const_mem",
"(",
"mode",
",",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
";",
"case",
"PLUS",
":",
"case",
"MINUS",
":",
"return",
"sparc_cannot_force_const_mem",
"(",
"mode",
",",
"XEXP",
"(",
"x",
",",
"0",
")",
")",
"||",
"sparc_cannot_force_const_mem",
"(",
"mode",
",",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
";",
"case",
"UNSPEC",
":",
"return",
"true",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Determine",
"if",
"it",
"'s",
"legal",
"to",
"put",
"X",
"into",
"the",
"constant",
"pool",
".",
"This",
"is",
"not",
"possible",
"if",
"X",
"contains",
"the",
"address",
"of",
"a",
"symbol",
"that",
"is",
"not",
"constant",
"(",
"TLS",
")",
"or",
"not",
"known",
"at",
"final",
"link",
"time",
"(",
"PIC",
")",
"."
] | [
"sparc",
"0",
"0",
"0",
"0",
"1"
] | sparc | sparc_cannot_force_const_mem | sparc | CPU | GCC | 29,396 | 122 | 1 | [] |
[
"<s>",
"static",
"bool",
"riscv_valid_base_register_p",
"(",
"rtx",
"x",
",",
"machine_mode",
"mode",
",",
"bool",
"strict_p",
")",
"{",
"if",
"(",
"!",
"strict_p",
"&&",
"GET_CODE",
"(",
"x",
")",
"==",
"SUBREG",
")",
"x",
"=",
"SUBREG_REG",
"(",
"x",
")",
";",
"return",
"(",
"REG_P",
"(",
"x",
")",
"&&",
"riscv_regno_mode_ok_for_base_p",
"(",
"REGNO",
"(",
"x",
")",
",",
"mode",
",",
"strict_p",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"X",
"is",
"a",
"valid",
"base",
"register",
"for",
"mode",
"MODE",
".",
"STRICT_P",
"is",
"true",
"if",
"REG_OK_STRICT",
"is",
"in",
"effect",
"."
] | [
"riscv"
] | riscv | riscv_valid_base_register_p | riscv | CPU | GCC | 29,397 | 54 | 1 | [] |
[
"<s>",
"void",
"R600MCInstLower",
"::",
"lower",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"MCInst",
"&",
"OutMI",
")",
"const",
"{",
"OutMI",
".",
"setOpcode",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"MI",
"->",
"explicit_operands",
"(",
")",
")",
"{",
"MCOperand",
"MCOp",
";",
"lowerOperand",
"(",
"MO",
",",
"MCOp",
")",
";",
"OutMI",
".",
"addOperand",
"(",
"MCOp",
")",
";",
"}",
"}",
"</s>"
] | [
"The",
"instruction",
"is",
"lowered",
"."
] | [
"AMDGPU",
"R600"
] | AMDGPUMCInstLower20 | lower | AMDGPU | GPU | LLVM | 29,398 | 60 | 1 | [] |
[
"<s>",
"void",
"BPFMCCodeEmitter",
"::",
"encodeInstruction",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"verifyInstructionPredicates",
"(",
"MI",
",",
"computeAvailableFeatures",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
")",
")",
";",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"support",
"::",
"endian",
"::",
"Writer",
"<",
"support",
"::",
"little",
">",
"LE",
"(",
"OS",
")",
";",
"support",
"::",
"endian",
"::",
"Writer",
"<",
"support",
"::",
"big",
">",
"BE",
"(",
"OS",
")",
";",
"if",
"(",
"Opcode",
"==",
"BPF",
"::",
"LD_imm64",
"||",
"Opcode",
"==",
"BPF",
"::",
"LD_pseudo",
")",
"{",
"uint64_t",
"Value",
"=",
"getBinaryCodeForInstr",
"(",
"MI",
",",
"Fixups",
",",
"STI",
")",
";",
"LE",
".",
"write",
"<",
"uint8_t",
">",
"(",
"Value",
">>",
"56",
")",
";",
"if",
"(",
"IsLittleEndian",
")",
"LE",
".",
"write",
"<",
"uint8_t",
">",
"(",
"(",
"Value",
">>",
"48",
")",
"&",
"0xff",
")",
";",
"else",
"LE",
".",
"write",
"<",
"uint8_t",
">",
"(",
"SwapBits",
"(",
"(",
"Value",
">>",
"48",
")",
"&",
"0xff",
")",
")",
";",
"LE",
".",
"write",
"<",
"uint16_t",
">",
"(",
"0",
")",
";",
"if",
"(",
"IsLittleEndian",
")",
"LE",
".",
"write",
"<",
"uint32_t",
">",
"(",
"Value",
"&",
"0xffffFFFF",
")",
";",
"else",
"BE",
".",
"write",
"<",
"uint32_t",
">",
"(",
"Value",
"&",
"0xffffFFFF",
")",
";",
"const",
"MCOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"1",
")",
";",
"uint64_t",
"Imm",
"=",
"MO",
".",
"isImm",
"(",
")",
"?",
"MO",
".",
"getImm",
"(",
")",
":",
"0",
";",
"LE",
".",
"write",
"<",
"uint8_t",
">",
"(",
"0",
")",
";",
"LE",
".",
"write",
"<",
"uint8_t",
">",
"(",
"0",
")",
";",
"LE",
".",
"write",
"<",
"uint16_t",
">",
"(",
"0",
")",
";",
"if",
"(",
"IsLittleEndian",
")",
"LE",
".",
"write",
"<",
"uint32_t",
">",
"(",
"Imm",
">>",
"32",
")",
";",
"else",
"BE",
".",
"write",
"<",
"uint32_t",
">",
"(",
"Imm",
">>",
"32",
")",
";",
"}",
"else",
"{",
"uint64_t",
"Value",
"=",
"getBinaryCodeForInstr",
"(",
"MI",
",",
"Fixups",
",",
"STI",
")",
";",
"LE",
".",
"write",
"<",
"uint8_t",
">",
"(",
"Value",
">>",
"56",
")",
";",
"if",
"(",
"IsLittleEndian",
")",
"{",
"LE",
".",
"write",
"<",
"uint8_t",
">",
"(",
"(",
"Value",
">>",
"48",
")",
"&",
"0xff",
")",
";",
"LE",
".",
"write",
"<",
"uint16_t",
">",
"(",
"(",
"Value",
">>",
"32",
")",
"&",
"0xffff",
")",
";",
"LE",
".",
"write",
"<",
"uint32_t",
">",
"(",
"Value",
"&",
"0xffffFFFF",
")",
";",
"}",
"else",
"{",
"LE",
".",
"write",
"<",
"uint8_t",
">",
"(",
"SwapBits",
"(",
"(",
"Value",
">>",
"48",
")",
"&",
"0xff",
")",
")",
";",
"BE",
".",
"write",
"<",
"uint16_t",
">",
"(",
"(",
"Value",
">>",
"32",
")",
"&",
"0xffff",
")",
";",
"BE",
".",
"write",
"<",
"uint32_t",
">",
"(",
"Value",
"&",
"0xffffFFFF",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Encode",
"the",
"given",
"Inst",
"to",
"bytes",
"and",
"append",
"to",
"CB",
"."
] | [
"BPF",
"BPF",
"support::endian",
"support::little",
"support::endian",
"support::big",
"BPF::LD_imm64",
"BPF::LD_pseudo",
"56",
"48",
"0xff",
"48",
"0xff",
"0",
"0xffffFFFF",
"0xffffFFFF",
"1",
"0",
"0",
"0",
"0",
"32",
"32",
"56",
"48",
"0xff",
"32",
"0xffff",
"0xffffFFFF",
"48",
"0xff",
"32",
"0xffff",
"0xffffFFFF"
] | BPFMCCodeEmitter12 | encodeInstruction | BPF | Virtual ISA | LLVM | 29,399 | 416 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.