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>",
"static",
"void",
"ix86_conditional_register_usage",
"(",
"void",
")",
"{",
"int",
"i",
",",
"c_mask",
";",
"if",
"(",
"!",
"TARGET_64BIT",
")",
"{",
"for",
"(",
"i",
"=",
"FIRST_REX_INT_REG",
";",
"i",
"<=",
"LAST_REX_INT_REG",
";",
"i",
"++",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"call_used_regs",
"[",
"i",
"]",
"=",
"1",
",",
"reg_names",
"[",
"i",
"]",
"=",
"\"\"",
";",
"for",
"(",
"i",
"=",
"FIRST_REX_SSE_REG",
";",
"i",
"<=",
"LAST_REX_SSE_REG",
";",
"i",
"++",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"call_used_regs",
"[",
"i",
"]",
"=",
"1",
",",
"reg_names",
"[",
"i",
"]",
"=",
"\"\"",
";",
"for",
"(",
"i",
"=",
"FIRST_EXT_REX_SSE_REG",
";",
"i",
"<=",
"LAST_EXT_REX_SSE_REG",
";",
"i",
"++",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"call_used_regs",
"[",
"i",
"]",
"=",
"1",
",",
"reg_names",
"[",
"i",
"]",
"=",
"\"\"",
";",
"}",
"c_mask",
"=",
"CALL_USED_REGISTERS_MASK",
"(",
"TARGET_64BIT_MS_ABI",
")",
";",
"CLEAR_HARD_REG_SET",
"(",
"reg_class_contents",
"[",
"(",
"int",
")",
"CLOBBERED_REGS",
"]",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"i",
"++",
")",
"{",
"if",
"(",
"call_used_regs",
"[",
"i",
"]",
">",
"1",
")",
"call_used_regs",
"[",
"i",
"]",
"=",
"!",
"!",
"(",
"call_used_regs",
"[",
"i",
"]",
"&",
"c_mask",
")",
";",
"if",
"(",
"TEST_HARD_REG_BIT",
"(",
"reg_class_contents",
"[",
"(",
"int",
")",
"GENERAL_REGS",
"]",
",",
"i",
")",
"&&",
"call_used_regs",
"[",
"i",
"]",
")",
"SET_HARD_REG_BIT",
"(",
"reg_class_contents",
"[",
"(",
"int",
")",
"CLOBBERED_REGS",
"]",
",",
"i",
")",
";",
"}",
"if",
"(",
"!",
"TARGET_MMX",
")",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"i",
"++",
")",
"if",
"(",
"TEST_HARD_REG_BIT",
"(",
"reg_class_contents",
"[",
"(",
"int",
")",
"MMX_REGS",
"]",
",",
"i",
")",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"call_used_regs",
"[",
"i",
"]",
"=",
"1",
",",
"reg_names",
"[",
"i",
"]",
"=",
"\"\"",
";",
"if",
"(",
"!",
"TARGET_SSE",
")",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"i",
"++",
")",
"if",
"(",
"TEST_HARD_REG_BIT",
"(",
"reg_class_contents",
"[",
"(",
"int",
")",
"SSE_REGS",
"]",
",",
"i",
")",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"call_used_regs",
"[",
"i",
"]",
"=",
"1",
",",
"reg_names",
"[",
"i",
"]",
"=",
"\"\"",
";",
"if",
"(",
"!",
"(",
"TARGET_80387",
"||",
"TARGET_FLOAT_RETURNS_IN_80387",
")",
")",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"FIRST_PSEUDO_REGISTER",
";",
"i",
"++",
")",
"if",
"(",
"TEST_HARD_REG_BIT",
"(",
"reg_class_contents",
"[",
"(",
"int",
")",
"FLOAT_REGS",
"]",
",",
"i",
")",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"call_used_regs",
"[",
"i",
"]",
"=",
"1",
",",
"reg_names",
"[",
"i",
"]",
"=",
"\"\"",
";",
"if",
"(",
"!",
"TARGET_AVX512F",
")",
"{",
"for",
"(",
"i",
"=",
"FIRST_EXT_REX_SSE_REG",
";",
"i",
"<=",
"LAST_EXT_REX_SSE_REG",
";",
"i",
"++",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"call_used_regs",
"[",
"i",
"]",
"=",
"1",
",",
"reg_names",
"[",
"i",
"]",
"=",
"\"\"",
";",
"for",
"(",
"i",
"=",
"FIRST_MASK_REG",
";",
"i",
"<=",
"LAST_MASK_REG",
";",
"i",
"++",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"call_used_regs",
"[",
"i",
"]",
"=",
"1",
",",
"reg_names",
"[",
"i",
"]",
"=",
"\"\"",
";",
"}",
"if",
"(",
"!",
"TARGET_MPX",
")",
"for",
"(",
"i",
"=",
"FIRST_BND_REG",
";",
"i",
"<=",
"LAST_BND_REG",
";",
"i",
"++",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"call_used_regs",
"[",
"i",
"]",
"=",
"1",
",",
"reg_names",
"[",
"i",
"]",
"=",
"\"\"",
";",
"}",
"</s>"
] | [
"Update",
"register",
"usage",
"after",
"having",
"seen",
"the",
"compiler",
"flags",
"."
] | [
"i386",
"1",
"\"\"",
"1",
"\"\"",
"1",
"\"\"",
"0",
"1",
"0",
"1",
"\"\"",
"0",
"1",
"\"\"",
"0",
"1",
"\"\"",
"1",
"\"\"",
"1",
"\"\"",
"1",
"\"\""
] | i3865 | ix86_conditional_register_usage | i386 | CPU | GCC | 16,900 | 475 | 1 | [] |
[
"<s>",
"void",
"print",
"(",
"raw_ostream",
"&",
"O",
")",
"const",
"override",
"{",
"switch",
"(",
"Kind",
")",
"{",
"case",
"k_Tok",
":",
"O",
"<<",
"\"Token \"",
"<<",
"Tok",
";",
"break",
";",
"case",
"k_Reg",
":",
"O",
"<<",
"\"Register \"",
"<<",
"Reg",
";",
"break",
";",
"case",
"k_Imm",
":",
"O",
"<<",
"\"Immediate \"",
"<<",
"*",
"Imm",
";",
"break",
";",
"case",
"k_Mem",
":",
"O",
"<<",
"\"Memory \"",
";",
"O",
"<<",
"*",
"Mem",
".",
"Offset",
"<<",
"\"(\"",
"<<",
"Reg",
"<<",
"\")\"",
";",
"break",
";",
"case",
"k_IndReg",
":",
"O",
"<<",
"\"RegInd \"",
"<<",
"Reg",
";",
"break",
";",
"case",
"k_PostIndReg",
":",
"O",
"<<",
"\"PostInc \"",
"<<",
"Reg",
";",
"break",
";",
"}",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"MSP430",
"\"Token \"",
"\"Register \"",
"\"Immediate \"",
"\"Memory \"",
"\"(\"",
"\")\"",
"\"RegInd \"",
"\"PostInc \""
] | MSP430AsmParser11 | print | MSP430 | MPU | LLVM | 16,901 | 95 | 1 | [] |
[
"<s>",
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"setPreservesCFG",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"DominatorTreeWrapperPass",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"DominatorTreeWrapperPass",
">",
"(",
")",
";",
"FunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"WebAssembly"
] | WebAssemblyOptimizeReturned (2) | getAnalysisUsage | WebAssembly | Virtual ISA | LLVM | 16,902 | 42 | 1 | [] |
[
"<s>",
"void",
"pru_expand_prologue",
"(",
"void",
")",
"{",
"int",
"regno_start",
";",
"int",
"total_frame_size",
";",
"int",
"sp_offset",
";",
"int",
"save_regs_base",
";",
"int",
"save_offset",
";",
"total_frame_size",
"=",
"cfun",
"->",
"machine",
"->",
"total_size",
";",
"if",
"(",
"flag_stack_usage_info",
")",
"current_function_static_stack_size",
"=",
"total_frame_size",
";",
"if",
"(",
"!",
"UBYTE_INT",
"(",
"total_frame_size",
")",
")",
"{",
"pru_add_to_sp",
"(",
"cfun",
"->",
"machine",
"->",
"save_regs_offset",
"-",
"total_frame_size",
",",
"REG_NOTE_MAX",
")",
";",
"save_regs_base",
"=",
"0",
";",
"sp_offset",
"=",
"-",
"cfun",
"->",
"machine",
"->",
"save_regs_offset",
";",
"}",
"else",
"if",
"(",
"total_frame_size",
")",
"{",
"pru_add_to_sp",
"(",
"-",
"total_frame_size",
",",
"REG_NOTE_MAX",
")",
";",
"save_regs_base",
"=",
"cfun",
"->",
"machine",
"->",
"save_regs_offset",
";",
"sp_offset",
"=",
"0",
";",
"}",
"else",
"save_regs_base",
"=",
"sp_offset",
"=",
"0",
";",
"regno_start",
"=",
"0",
";",
"save_offset",
"=",
"save_regs_base",
";",
"do",
"regno_start",
"=",
"xbbo_next_reg_cluster",
"(",
"regno_start",
",",
"&",
"save_offset",
",",
"true",
")",
";",
"while",
"(",
"regno_start",
">=",
"0",
")",
";",
"if",
"(",
"frame_pointer_needed",
")",
"{",
"int",
"fp_offset",
"=",
"total_frame_size",
"-",
"crtl",
"->",
"args",
".",
"pretend_args_size",
"+",
"sp_offset",
";",
"pru_add3_frame_adjust",
"(",
"hard_frame_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"fp_offset",
",",
"REG_NOTE_MAX",
")",
";",
"}",
"if",
"(",
"sp_offset",
")",
"pru_add_to_sp",
"(",
"sp_offset",
",",
"REG_FRAME_RELATED_EXPR",
")",
";",
"if",
"(",
"crtl",
"->",
"profile",
")",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"function",
"prologue",
"."
] | [
"pru",
"0",
"0",
"0",
"0",
"0"
] | pru | pru_expand_prologue | pru | CPU | GCC | 16,903 | 190 | 1 | [] |
[
"<s>",
"void",
"Thumb1InstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"DestReg",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
")",
"const",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"assert",
"(",
"(",
"RC",
"==",
"ARM",
"::",
"tGPRRegisterClass",
"||",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"DestReg",
")",
"&&",
"isARMLowRegister",
"(",
"DestReg",
")",
")",
")",
"&&",
"\"Unknown regclass!\"",
")",
";",
"if",
"(",
"RC",
"==",
"ARM",
"::",
"tGPRRegisterClass",
"||",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"DestReg",
")",
"&&",
"isARMLowRegister",
"(",
"DestReg",
")",
")",
")",
"{",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"PseudoSourceValue",
"::",
"getFixedStack",
"(",
"FI",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"0",
",",
"MFI",
".",
"getObjectSize",
"(",
"FI",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
")",
";",
"AddDefaultPred",
"(",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ARM",
"::",
"tRestore",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"ARM",
"ARM::tGPRRegisterClass",
"ARM",
"\"Unknown regclass!\"",
"ARM::tGPRRegisterClass",
"ARM",
"0",
"ARM::tRestore",
"0"
] | Thumb1InstrInfo2 | loadRegFromStackSlot | ARM | CPU | LLVM | 16,904 | 194 | 1 | [] |
[
"<s>",
"bool",
"riscv_split_symbol",
"(",
"rtx",
"temp",
",",
"rtx",
"addr",
",",
"machine_mode",
"mode",
",",
"rtx",
"*",
"low_out",
")",
"{",
"enum",
"riscv_symbol_type",
"symbol_type",
";",
"if",
"(",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"HIGH",
"&&",
"mode",
"==",
"MAX_MACHINE_MODE",
")",
"||",
"!",
"riscv_symbolic_constant_p",
"(",
"addr",
",",
"&",
"symbol_type",
")",
"||",
"riscv_symbol_insns",
"(",
"symbol_type",
")",
"==",
"0",
"||",
"!",
"riscv_split_symbol_type",
"(",
"symbol_type",
")",
")",
"return",
"false",
";",
"if",
"(",
"low_out",
")",
"switch",
"(",
"symbol_type",
")",
"{",
"case",
"SYMBOL_ABSOLUTE",
":",
"{",
"rtx",
"high",
"=",
"gen_rtx_HIGH",
"(",
"Pmode",
",",
"copy_rtx",
"(",
"addr",
")",
")",
";",
"high",
"=",
"riscv_force_temporary",
"(",
"temp",
",",
"high",
")",
";",
"*",
"low_out",
"=",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"high",
",",
"addr",
")",
";",
"}",
"break",
";",
"case",
"SYMBOL_PCREL",
":",
"{",
"static",
"unsigned",
"seqno",
";",
"char",
"buf",
"[",
"32",
"]",
";",
"rtx",
"label",
";",
"ssize_t",
"bytes",
"=",
"snprintf",
"(",
"buf",
",",
"sizeof",
"(",
"buf",
")",
",",
"\".LA%u\"",
",",
"seqno",
")",
";",
"gcc_assert",
"(",
"(",
"size_t",
")",
"bytes",
"<",
"sizeof",
"(",
"buf",
")",
")",
";",
"label",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"ggc_strdup",
"(",
"buf",
")",
")",
";",
"SYMBOL_REF_FLAGS",
"(",
"label",
")",
"|=",
"SYMBOL_FLAG_LOCAL",
";",
"if",
"(",
"temp",
"==",
"NULL",
")",
"temp",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"if",
"(",
"Pmode",
"==",
"DImode",
")",
"emit_insn",
"(",
"gen_auipcdi",
"(",
"temp",
",",
"copy_rtx",
"(",
"addr",
")",
",",
"GEN_INT",
"(",
"seqno",
")",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_auipcsi",
"(",
"temp",
",",
"copy_rtx",
"(",
"addr",
")",
",",
"GEN_INT",
"(",
"seqno",
")",
")",
")",
";",
"*",
"low_out",
"=",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"temp",
",",
"label",
")",
";",
"seqno",
"++",
";",
"}",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"If",
"MODE",
"is",
"MAX_MACHINE_MODE",
",",
"ADDR",
"appears",
"as",
"a",
"move",
"operand",
",",
"otherwise",
"it",
"appears",
"in",
"a",
"MEM",
"of",
"that",
"mode",
".",
"Return",
"true",
"if",
"ADDR",
"is",
"a",
"legitimate",
"constant",
"in",
"that",
"context",
"and",
"can",
"be",
"split",
"into",
"high",
"and",
"low",
"parts",
".",
"If",
"so",
",",
"and",
"if",
"LOW_OUT",
"is",
"nonnull",
",",
"emit",
"the",
"high",
"part",
"and",
"store",
"the",
"low",
"part",
"in",
"*",
"LOW_OUT",
".",
"Leave",
"*",
"LOW_OUT",
"unchanged",
"otherwise",
".",
"TEMP",
"is",
"as",
"for",
"riscv_force_temporary",
"and",
"is",
"used",
"to",
"load",
"the",
"high",
"part",
"into",
"a",
"register",
".",
"When",
"MODE",
"is",
"MAX_MACHINE_MODE",
",",
"the",
"low",
"part",
"is",
"guaranteed",
"to",
"be",
"a",
"legitimize",
"SET_SRC",
"for",
"an",
".md",
"pattern",
",",
"otherwise",
"the",
"low",
"part",
"is",
"guaranteed",
"to",
"be",
"a",
"legitimate",
"address",
"for",
"mode",
"MODE",
"."
] | [
"riscv",
"0",
"32",
"\".LA%u\""
] | riscv3 | riscv_split_symbol | riscv | CPU | GCC | 16,905 | 262 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"MipsTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"MipsISD",
"::",
"JmpLink",
":",
"return",
"\"MipsISD::JmpLink\"",
";",
"case",
"MipsISD",
"::",
"Hi",
":",
"return",
"\"MipsISD::Hi\"",
";",
"case",
"MipsISD",
"::",
"Lo",
":",
"return",
"\"MipsISD::Lo\"",
";",
"case",
"MipsISD",
"::",
"GPRel",
":",
"return",
"\"MipsISD::GPRel\"",
";",
"case",
"MipsISD",
"::",
"ThreadPointer",
":",
"return",
"\"MipsISD::ThreadPointer\"",
";",
"case",
"MipsISD",
"::",
"Ret",
":",
"return",
"\"MipsISD::Ret\"",
";",
"case",
"MipsISD",
"::",
"FPBrcond",
":",
"return",
"\"MipsISD::FPBrcond\"",
";",
"case",
"MipsISD",
"::",
"FPCmp",
":",
"return",
"\"MipsISD::FPCmp\"",
";",
"case",
"MipsISD",
"::",
"CMovFP_T",
":",
"return",
"\"MipsISD::CMovFP_T\"",
";",
"case",
"MipsISD",
"::",
"CMovFP_F",
":",
"return",
"\"MipsISD::CMovFP_F\"",
";",
"case",
"MipsISD",
"::",
"FPRound",
":",
"return",
"\"MipsISD::FPRound\"",
";",
"case",
"MipsISD",
"::",
"MAdd",
":",
"return",
"\"MipsISD::MAdd\"",
";",
"case",
"MipsISD",
"::",
"MAddu",
":",
"return",
"\"MipsISD::MAddu\"",
";",
"case",
"MipsISD",
"::",
"MSub",
":",
"return",
"\"MipsISD::MSub\"",
";",
"case",
"MipsISD",
"::",
"MSubu",
":",
"return",
"\"MipsISD::MSubu\"",
";",
"case",
"MipsISD",
"::",
"DivRem",
":",
"return",
"\"MipsISD::DivRem\"",
";",
"case",
"MipsISD",
"::",
"DivRemU",
":",
"return",
"\"MipsISD::DivRemU\"",
";",
"case",
"MipsISD",
"::",
"BuildPairF64",
":",
"return",
"\"MipsISD::BuildPairF64\"",
";",
"case",
"MipsISD",
"::",
"ExtractElementF64",
":",
"return",
"\"MipsISD::ExtractElementF64\"",
";",
"case",
"MipsISD",
"::",
"Wrapper",
":",
"return",
"\"MipsISD::Wrapper\"",
";",
"case",
"MipsISD",
"::",
"DynAlloc",
":",
"return",
"\"MipsISD::DynAlloc\"",
";",
"case",
"MipsISD",
"::",
"Sync",
":",
"return",
"\"MipsISD::Sync\"",
";",
"case",
"MipsISD",
"::",
"Ext",
":",
"return",
"\"MipsISD::Ext\"",
";",
"case",
"MipsISD",
"::",
"Ins",
":",
"return",
"\"MipsISD::Ins\"",
";",
"case",
"MipsISD",
"::",
"LWL",
":",
"return",
"\"MipsISD::LWL\"",
";",
"case",
"MipsISD",
"::",
"LWR",
":",
"return",
"\"MipsISD::LWR\"",
";",
"case",
"MipsISD",
"::",
"SWL",
":",
"return",
"\"MipsISD::SWL\"",
";",
"case",
"MipsISD",
"::",
"SWR",
":",
"return",
"\"MipsISD::SWR\"",
";",
"case",
"MipsISD",
"::",
"LDL",
":",
"return",
"\"MipsISD::LDL\"",
";",
"case",
"MipsISD",
"::",
"LDR",
":",
"return",
"\"MipsISD::LDR\"",
";",
"case",
"MipsISD",
"::",
"SDL",
":",
"return",
"\"MipsISD::SDL\"",
";",
"case",
"MipsISD",
"::",
"SDR",
":",
"return",
"\"MipsISD::SDR\"",
";",
"case",
"MipsISD",
"::",
"EXTP",
":",
"return",
"\"MipsISD::EXTP\"",
";",
"case",
"MipsISD",
"::",
"EXTPDP",
":",
"return",
"\"MipsISD::EXTPDP\"",
";",
"case",
"MipsISD",
"::",
"EXTR_S_H",
":",
"return",
"\"MipsISD::EXTR_S_H\"",
";",
"case",
"MipsISD",
"::",
"EXTR_W",
":",
"return",
"\"MipsISD::EXTR_W\"",
";",
"case",
"MipsISD",
"::",
"EXTR_R_W",
":",
"return",
"\"MipsISD::EXTR_R_W\"",
";",
"case",
"MipsISD",
"::",
"EXTR_RS_W",
":",
"return",
"\"MipsISD::EXTR_RS_W\"",
";",
"case",
"MipsISD",
"::",
"SHILO",
":",
"return",
"\"MipsISD::SHILO\"",
";",
"case",
"MipsISD",
"::",
"MTHLIP",
":",
"return",
"\"MipsISD::MTHLIP\"",
";",
"case",
"MipsISD",
"::",
"MULT",
":",
"return",
"\"MipsISD::MULT\"",
";",
"case",
"MipsISD",
"::",
"MULTU",
":",
"return",
"\"MipsISD::MULTU\"",
";",
"case",
"MipsISD",
"::",
"MADD_DSP",
":",
"return",
"\"MipsISD::MADD_DSPDSP\"",
";",
"case",
"MipsISD",
"::",
"MADDU_DSP",
":",
"return",
"\"MipsISD::MADDU_DSP\"",
";",
"case",
"MipsISD",
"::",
"MSUB_DSP",
":",
"return",
"\"MipsISD::MSUB_DSP\"",
";",
"case",
"MipsISD",
"::",
"MSUBU_DSP",
":",
"return",
"\"MipsISD::MSUBU_DSP\"",
";",
"default",
":",
"return",
"NULL",
";",
"}",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"Mips",
"Mips",
"MipsISD::JmpLink",
"\"MipsISD::JmpLink\"",
"MipsISD::Hi",
"\"MipsISD::Hi\"",
"MipsISD::Lo",
"\"MipsISD::Lo\"",
"MipsISD::GPRel",
"\"MipsISD::GPRel\"",
"MipsISD::ThreadPointer",
"\"MipsISD::ThreadPointer\"",
"MipsISD::Ret",
"\"MipsISD::Ret\"",
"MipsISD::FPBrcond",
"\"MipsISD::FPBrcond\"",
"MipsISD::FPCmp",
"\"MipsISD::FPCmp\"",
"MipsISD::CMovFP_T",
"\"MipsISD::CMovFP_T\"",
"MipsISD::CMovFP_F",
"\"MipsISD::CMovFP_F\"",
"MipsISD::FPRound",
"\"MipsISD::FPRound\"",
"MipsISD::MAdd",
"\"MipsISD::MAdd\"",
"MipsISD::MAddu",
"\"MipsISD::MAddu\"",
"MipsISD::MSub",
"\"MipsISD::MSub\"",
"MipsISD::MSubu",
"\"MipsISD::MSubu\"",
"MipsISD::DivRem",
"\"MipsISD::DivRem\"",
"MipsISD::DivRemU",
"\"MipsISD::DivRemU\"",
"MipsISD::BuildPairF64",
"\"MipsISD::BuildPairF64\"",
"MipsISD::ExtractElementF64",
"\"MipsISD::ExtractElementF64\"",
"MipsISD::Wrapper",
"\"MipsISD::Wrapper\"",
"MipsISD::DynAlloc",
"\"MipsISD::DynAlloc\"",
"MipsISD::Sync",
"\"MipsISD::Sync\"",
"MipsISD::Ext",
"\"MipsISD::Ext\"",
"MipsISD::Ins",
"\"MipsISD::Ins\"",
"MipsISD::LWL",
"\"MipsISD::LWL\"",
"MipsISD::LWR",
"\"MipsISD::LWR\"",
"MipsISD::SWL",
"\"MipsISD::SWL\"",
"MipsISD::SWR",
"\"MipsISD::SWR\"",
"MipsISD::LDL",
"\"MipsISD::LDL\"",
"MipsISD::LDR",
"\"MipsISD::LDR\"",
"MipsISD::SDL",
"\"MipsISD::SDL\"",
"MipsISD::SDR",
"\"MipsISD::SDR\"",
"MipsISD::EXTP",
"\"MipsISD::EXTP\"",
"MipsISD::EXTPDP",
"\"MipsISD::EXTPDP\"",
"MipsISD::EXTR_S_H",
"\"MipsISD::EXTR_S_H\"",
"MipsISD::EXTR_W",
"\"MipsISD::EXTR_W\"",
"MipsISD::EXTR_R_W",
"\"MipsISD::EXTR_R_W\"",
"MipsISD::EXTR_RS_W",
"\"MipsISD::EXTR_RS_W\"",
"MipsISD::SHILO",
"\"MipsISD::SHILO\"",
"MipsISD::MTHLIP",
"\"MipsISD::MTHLIP\"",
"MipsISD::MULT",
"\"MipsISD::MULT\"",
"MipsISD::MULTU",
"\"MipsISD::MULTU\"",
"MipsISD::MADD_DSP",
"\"MipsISD::MADD_DSPDSP\"",
"MipsISD::MADDU_DSP",
"\"MipsISD::MADDU_DSP\"",
"MipsISD::MSUB_DSP",
"\"MipsISD::MSUB_DSP\"",
"MipsISD::MSUBU_DSP",
"\"MipsISD::MSUBU_DSP\""
] | MipsISelLowering98 | getTargetNodeName | Mips | CPU | LLVM | 16,906 | 392 | 1 | [] |
[
"<s>",
"Optional",
"<",
"MCFixupKind",
">",
"ELFPPCAsmBackend",
"::",
"getFixupKind",
"(",
"StringRef",
"Name",
")",
"const",
"{",
"if",
"(",
"TT",
".",
"isPPC64",
"(",
")",
")",
"{",
"if",
"(",
"Name",
"==",
"\"R_PPC64_NONE\"",
")",
"return",
"FK_NONE",
";",
"}",
"else",
"{",
"if",
"(",
"Name",
"==",
"\"R_PPC_NONE\"",
")",
"return",
"FK_NONE",
";",
"}",
"return",
"MCAsmBackend",
"::",
"getFixupKind",
"(",
"Name",
")",
";",
"}",
"</s>"
] | [
"getFixupKind",
"-",
"Get",
"the",
"fixup",
"kind",
"of",
"this",
"expression",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"\"R_PPC64_NONE\"",
"\"R_PPC_NONE\""
] | PPCAsmBackend35 | getFixupKind | PowerPC | CPU | LLVM | 16,907 | 53 | 1 | [] |
[
"<s>",
"bool",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"override",
"{",
"FeatureBitset",
"Features",
"=",
"coalesceFeatures",
"(",
"M",
")",
";",
"std",
"::",
"string",
"FeatureStr",
"=",
"getFeatureString",
"(",
"Features",
")",
";",
"for",
"(",
"auto",
"&",
"F",
":",
"M",
")",
"replaceFeatures",
"(",
"F",
",",
"FeatureStr",
")",
";",
"bool",
"Stripped",
"=",
"false",
";",
"if",
"(",
"!",
"Features",
"[",
"WebAssembly",
"::",
"FeatureAtomics",
"]",
")",
"{",
"Stripped",
"|=",
"stripAtomics",
"(",
"M",
")",
";",
"Stripped",
"|=",
"stripThreadLocals",
"(",
"M",
")",
";",
"}",
"recordFeatures",
"(",
"M",
",",
"Features",
",",
"Stripped",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] | [
"WebAssembly",
"WebAssembly::FeatureAtomics"
] | WebAssemblyTargetMachine27 | runOnModule | WebAssembly | Virtual ISA | LLVM | 16,908 | 86 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"R600 Texture Intrinsics Replacer\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"R600",
"\"R600 Texture Intrinsics Replacer\""
] | R600TextureIntrinsicsReplacer2 | getPassName | R600 | GPU | LLVM | 16,909 | 13 | 1 | [] |
[
"<s>",
"bool",
"supportSwiftError",
"(",
")",
"const",
"override",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"target",
"supports",
"swifterror",
"attribute",
"."
] | [
"SystemZ"
] | SystemZISelLowering | supportSwiftError | SystemZ | CPU | LLVM | 16,910 | 11 | 1 | [] |
[
"<s>",
"bool",
"FISCFrameLowering",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"MF",
".",
"getTarget",
"(",
")",
".",
"Options",
".",
"DisableFramePointerElim",
"(",
"MF",
")",
"||",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"hasVarSizedObjects",
"(",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"FISC",
"FISC"
] | FISCFrameLowering | hasFP | FISC | CPU | LLVM | 16,911 | 37 | 1 | [] |
[
"<s>",
"Value",
"*",
"AArch64TargetLowering",
"::",
"getIRStackGuard",
"(",
"IRBuilder",
"<",
">",
"&",
"IRB",
")",
"const",
"{",
"if",
"(",
"Subtarget",
"->",
"isTargetAndroid",
"(",
")",
")",
"return",
"UseTlsOffset",
"(",
"IRB",
",",
"0x28",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isTargetFuchsia",
"(",
")",
")",
"return",
"UseTlsOffset",
"(",
"IRB",
",",
"-",
"0x10",
")",
";",
"return",
"TargetLowering",
"::",
"getIRStackGuard",
"(",
"IRB",
")",
";",
"}",
"</s>"
] | [
"If",
"the",
"target",
"has",
"a",
"standard",
"location",
"for",
"the",
"stack",
"protector",
"cookie",
",",
"returns",
"the",
"address",
"of",
"that",
"location",
"."
] | [
"AArch64",
"AArch64",
"0x28",
"0x10"
] | AArch64ISelLowering (2)3 | getIRStackGuard | AArch64 | CPU | LLVM | 16,912 | 56 | 1 | [] |
[
"<s>",
"static",
"int",
"access_check",
"(",
"const",
"char",
"*",
"name",
",",
"int",
"mode",
")",
"{",
"if",
"(",
"mode",
"==",
"X_OK",
")",
"{",
"struct",
"stat",
"st",
";",
"if",
"(",
"stat",
"(",
"name",
",",
"&",
"st",
")",
"<",
"0",
"||",
"S_ISDIR",
"(",
"st",
".",
"st_mode",
")",
")",
"return",
"-",
"1",
";",
"}",
"return",
"access",
"(",
"name",
",",
"mode",
")",
";",
"}",
"</s>"
] | [
"Check",
"whether",
"NAME",
"can",
"be",
"accessed",
"in",
"MODE",
".",
"This",
"is",
"like",
"access",
",",
"except",
"that",
"it",
"never",
"considers",
"directories",
"to",
"be",
"executable",
"."
] | [
"nvptx",
"0",
"1"
] | mkoffload | access_check | nvptx | GPU | GCC | 16,913 | 57 | 1 | [] |
[
"<s>",
"void",
"ARCompactFrameLowering",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"ARCompactFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARCompactFunctionInfo",
">",
"(",
")",
";",
"const",
"ARCompactInstrInfo",
"&",
"TII",
"=",
"*",
"static_cast",
"<",
"const",
"ARCompactInstrInfo",
"*",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"DebugLoc",
"dl",
"=",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"?",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
":",
"DebugLoc",
"(",
")",
";",
"EmitComment",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
",",
"\"PROLOGUE START\"",
")",
";",
"unsigned",
"int",
"NumBytes",
"=",
"MFI",
"->",
"getStackSize",
"(",
")",
";",
"NumBytes",
"=",
"(",
"NumBytes",
"+",
"3",
")",
"&",
"~",
"3",
";",
"unsigned",
"VARegSaveSize",
"=",
"AFI",
"->",
"getVarArgsRegSaveSize",
"(",
")",
";",
"if",
"(",
"VARegSaveSize",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"ARC",
"::",
"SUBrsi",
")",
",",
"ARC",
"::",
"SP",
")",
".",
"addReg",
"(",
"ARC",
"::",
"SP",
")",
".",
"addImm",
"(",
"VARegSaveSize",
")",
";",
"}",
"if",
"(",
"MFI",
"->",
"adjustsStack",
"(",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"ARC",
"::",
"STrri_a",
")",
")",
".",
"addReg",
"(",
"ARC",
"::",
"SP",
")",
".",
"addImm",
"(",
"-",
"UNITS_PER_WORD",
")",
".",
"addReg",
"(",
"ARC",
"::",
"BLINK",
")",
";",
"}",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"ARC",
"::",
"STrri_a",
")",
")",
".",
"addReg",
"(",
"ARC",
"::",
"SP",
")",
".",
"addImm",
"(",
"-",
"UNITS_PER_WORD",
")",
".",
"addReg",
"(",
"ARC",
"::",
"FP",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"ARC",
"::",
"MOVrr",
")",
",",
"ARC",
"::",
"FP",
")",
".",
"addReg",
"(",
"ARC",
"::",
"SP",
")",
";",
"if",
"(",
"NumBytes",
">",
"0",
")",
"{",
"assert",
"(",
"(",
"NumBytes",
"&",
"0x3",
")",
"==",
"0",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"ARC",
"::",
"SUBrsi",
")",
",",
"ARC",
"::",
"SP",
")",
".",
"addReg",
"(",
"ARC",
"::",
"SP",
")",
".",
"addImm",
"(",
"NumBytes",
")",
";",
"}",
"EmitComment",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
",",
"\"PROLOGUE END\"",
")",
";",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"ARCompact",
"ARC",
"ARC",
"ARC",
"ARC",
"ARC",
"\"PROLOGUE START\"",
"3",
"3",
"ARC::SUBrsi",
"ARC::SP",
"ARC::SP",
"ARC::STrri_a",
"ARC::SP",
"ARC::BLINK",
"ARC::STrri_a",
"ARC::SP",
"ARC::FP",
"ARC::MOVrr",
"ARC::FP",
"ARC::SP",
"0",
"0x3",
"0",
"ARC::SUBrsi",
"ARC::SP",
"ARC::SP",
"\"PROLOGUE END\""
] | ARCompactFrameLowering | emitPrologue | ARCompact | MPU | LLVM | 16,914 | 365 | 1 | [] |
[
"<s>",
"bool",
"ARMPreAllocLoadStoreOpt",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"TD",
"=",
"Fn",
".",
"getTarget",
"(",
")",
".",
"getDataLayout",
"(",
")",
";",
"TII",
"=",
"Fn",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"Fn",
".",
"getTarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"STI",
"=",
"&",
"Fn",
".",
"getTarget",
"(",
")",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"MRI",
"=",
"&",
"Fn",
".",
"getRegInfo",
"(",
")",
";",
"MF",
"=",
"&",
"Fn",
";",
"bool",
"Modified",
"=",
"false",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MFI",
"=",
"Fn",
".",
"begin",
"(",
")",
",",
"E",
"=",
"Fn",
".",
"end",
"(",
")",
";",
"MFI",
"!=",
"E",
";",
"++",
"MFI",
")",
"Modified",
"|=",
"RescheduleLoadStoreInstrs",
"(",
"MFI",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM"
] | ARMLoadStoreOptimizer16 | runOnMachineFunction | ARM | CPU | LLVM | 16,915 | 120 | 1 | [] |
[
"<s>",
"const",
"TPCTargetLowering",
"*",
"getTLI",
"(",
")",
"const",
"{",
"return",
"TLI",
";",
"}",
"</s>"
] | [
"Getter",
"for",
"generic",
"TargetLowering",
"class",
"."
] | [
"TPC",
"TPC"
] | TPCTargetTransformInfo | getTLI | TPC | Virtual ISA | LLVM | 16,916 | 12 | 1 | [] |
[
"<s>",
"const",
"DataLayout",
"*",
"getDataLayout",
"(",
")",
"const",
"override",
"{",
"return",
"getSubtargetImpl",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"DataLayout",
"associated",
"with",
"the",
"module",
"this",
"SCEV",
"instance",
"is",
"operating",
"on",
"."
] | [
"NVPTX"
] | NVPTXTargetMachine | getDataLayout | NVPTX | GPU | LLVM | 16,917 | 19 | 1 | [] |
[
"<s>",
"static",
"void",
"nvptx_file_end",
"(",
"void",
")",
"{",
"hash_table",
"<",
"tree_hasher",
">",
"::",
"iterator",
"iter",
";",
"tree",
"decl",
";",
"FOR_EACH_HASH_TABLE_ELEMENT",
"(",
"*",
"needed_fndecls_htab",
",",
"decl",
",",
"tree",
",",
"iter",
")",
"nvptx_record_fndecl",
"(",
"decl",
")",
";",
"fputs",
"(",
"func_decls",
".",
"str",
"(",
")",
".",
"c_str",
"(",
")",
",",
"asm_out_file",
")",
";",
"if",
"(",
"worker_bcast_size",
")",
"write_worker_buffer",
"(",
"asm_out_file",
",",
"worker_bcast_sym",
",",
"worker_bcast_align",
",",
"worker_bcast_size",
")",
";",
"if",
"(",
"worker_red_size",
")",
"write_worker_buffer",
"(",
"asm_out_file",
",",
"worker_red_sym",
",",
"worker_red_align",
",",
"worker_red_size",
")",
";",
"if",
"(",
"need_softstack_decl",
")",
"{",
"write_var_marker",
"(",
"asm_out_file",
",",
"false",
",",
"true",
",",
"\"__nvptx_stacks\"",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\".extern .shared .u%d __nvptx_stacks[32];\\n\"",
",",
"POINTER_SIZE",
")",
";",
"}",
"if",
"(",
"need_unisimt_decl",
")",
"{",
"write_var_marker",
"(",
"asm_out_file",
",",
"false",
",",
"true",
",",
"\"__nvptx_uni\"",
")",
";",
"fprintf",
"(",
"asm_out_file",
",",
"\".extern .shared .u32 __nvptx_uni[32];\\n\"",
")",
";",
"}",
"}",
"</s>"
] | [
"Write",
"out",
"the",
"function",
"declarations",
"we",
"'ve",
"collected",
"."
] | [
"nvptx",
"\"__nvptx_stacks\"",
"\".extern .shared .u%d __nvptx_stacks[32];\\n\"",
"\"__nvptx_uni\"",
"\".extern .shared .u32 __nvptx_uni[32];\\n\""
] | nvptx4 | nvptx_file_end | nvptx | GPU | GCC | 16,918 | 130 | 1 | [] |
[
"<s>",
"NVPTXSubtarget",
"::",
"NVPTXSubtarget",
"(",
"const",
"Triple",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"const",
"NVPTXTargetMachine",
"&",
"TM",
")",
":",
"NVPTXGenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"PTXVersion",
"(",
"0",
")",
",",
"SmVersion",
"(",
"20",
")",
",",
"TM",
"(",
"TM",
")",
",",
"InstrInfo",
"(",
")",
",",
"TLInfo",
"(",
"TM",
",",
"initializeSubtargetDependencies",
"(",
"CPU",
",",
"FS",
")",
")",
",",
"FrameLowering",
"(",
")",
"{",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"module",
"."
] | [
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"NVPTX",
"0",
"20"
] | NVPTXSubtarget (2) | NVPTXSubtarget | NVPTX | GPU | LLVM | 16,919 | 74 | 1 | [] |
[
"<s>",
"bool",
"X86ExpandPseudo",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"STI",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"TII",
"=",
"STI",
"->",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"STI",
"->",
"getRegisterInfo",
"(",
")",
";",
"X86FI",
"=",
"MF",
".",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
";",
"X86FL",
"=",
"STI",
"->",
"getFrameLowering",
"(",
")",
";",
"bool",
"Modified",
"=",
"ExpandPseudosWhichAffectControlFlow",
"(",
"MF",
")",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"Modified",
"|=",
"ExpandMBB",
"(",
"MBB",
")",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86"
] | X86ExpandPseudo11 | runOnMachineFunction | X86 | CPU | LLVM | 16,920 | 84 | 1 | [] |
[
"<s>",
"unsigned",
"WebAssemblyFastISel",
"::",
"signExtend",
"(",
"unsigned",
"Reg",
",",
"const",
"Value",
"*",
"V",
",",
"MVT",
"::",
"SimpleValueType",
"From",
",",
"MVT",
"::",
"SimpleValueType",
"To",
")",
"{",
"if",
"(",
"To",
"==",
"MVT",
"::",
"i64",
")",
"{",
"if",
"(",
"From",
"==",
"MVT",
"::",
"i64",
")",
"return",
"copyValue",
"(",
"Reg",
")",
";",
"Reg",
"=",
"signExtendToI32",
"(",
"Reg",
",",
"V",
",",
"From",
")",
";",
"unsigned",
"Result",
"=",
"createResultReg",
"(",
"&",
"WebAssembly",
"::",
"I64RegClass",
")",
";",
"BuildMI",
"(",
"*",
"FuncInfo",
".",
"MBB",
",",
"FuncInfo",
".",
"InsertPt",
",",
"DbgLoc",
",",
"TII",
".",
"get",
"(",
"WebAssembly",
"::",
"I64_EXTEND_S_I32",
")",
",",
"Result",
")",
".",
"addReg",
"(",
"Reg",
")",
";",
"return",
"Result",
";",
"}",
"return",
"signExtendToI32",
"(",
"Reg",
",",
"V",
",",
"From",
")",
";",
"}",
"</s>"
] | [
"Return",
"a",
"new",
"range",
"in",
"the",
"specified",
"integer",
"type",
",",
"which",
"must",
"be",
"strictly",
"larger",
"than",
"the",
"current",
"type",
"."
] | [
"WebAssembly",
"WebAssembly",
"MVT::SimpleValueType",
"MVT::SimpleValueType",
"MVT::i64",
"MVT::i64",
"WebAssembly::I64RegClass",
"WebAssembly::I64_EXTEND_S_I32"
] | WebAssemblyFastISel | signExtend | WebAssembly | Virtual ISA | LLVM | 16,921 | 114 | 1 | [] |
[
"<s>",
"bool",
"VETargetLowering",
"::",
"isOffsetFoldingLegal",
"(",
"const",
"GlobalAddressSDNode",
"*",
"GA",
")",
"const",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"folding",
"a",
"constant",
"offset",
"with",
"the",
"given",
"GlobalAddress",
"is",
"legal",
"."
] | [
"VE",
"VE"
] | VEISelLowering1 | isOffsetFoldingLegal | VE | CPU | LLVM | 16,922 | 16 | 1 | [] |
[
"<s>",
"static",
"enum",
"aarch64_parse_opt_result",
"aarch64_parse_arch",
"(",
"const",
"char",
"*",
"to_parse",
",",
"const",
"struct",
"processor",
"*",
"*",
"res",
",",
"uint64_t",
"*",
"isa_flags",
",",
"std",
"::",
"string",
"*",
"invalid_extension",
")",
"{",
"const",
"char",
"*",
"ext",
";",
"const",
"struct",
"processor",
"*",
"arch",
";",
"size_t",
"len",
";",
"ext",
"=",
"strchr",
"(",
"to_parse",
",",
"'+'",
")",
";",
"if",
"(",
"ext",
"!=",
"NULL",
")",
"len",
"=",
"ext",
"-",
"to_parse",
";",
"else",
"len",
"=",
"strlen",
"(",
"to_parse",
")",
";",
"if",
"(",
"len",
"==",
"0",
")",
"return",
"AARCH64_PARSE_MISSING_ARG",
";",
"for",
"(",
"arch",
"=",
"all_architectures",
";",
"arch",
"->",
"name",
"!=",
"NULL",
";",
"arch",
"++",
")",
"{",
"if",
"(",
"strlen",
"(",
"arch",
"->",
"name",
")",
"==",
"len",
"&&",
"strncmp",
"(",
"arch",
"->",
"name",
",",
"to_parse",
",",
"len",
")",
"==",
"0",
")",
"{",
"uint64_t",
"isa_temp",
"=",
"arch",
"->",
"flags",
";",
"if",
"(",
"ext",
"!=",
"NULL",
")",
"{",
"enum",
"aarch64_parse_opt_result",
"ext_res",
"=",
"aarch64_parse_extension",
"(",
"ext",
",",
"&",
"isa_temp",
",",
"invalid_extension",
")",
";",
"if",
"(",
"ext_res",
"!=",
"AARCH64_PARSE_OK",
")",
"return",
"ext_res",
";",
"}",
"*",
"res",
"=",
"arch",
";",
"*",
"isa_flags",
"=",
"isa_temp",
";",
"return",
"AARCH64_PARSE_OK",
";",
"}",
"}",
"return",
"AARCH64_PARSE_INVALID_ARG",
";",
"}",
"</s>"
] | [
"Parse",
"the",
"TO_PARSE",
"string",
"and",
"put",
"the",
"architecture",
"struct",
"that",
"it",
"selects",
"into",
"RES",
"and",
"the",
"architectural",
"features",
"into",
"ISA_FLAGS",
".",
"Return",
"an",
"aarch64_parse_opt_result",
"describing",
"the",
"parse",
"result",
".",
"If",
"there",
"is",
"an",
"error",
"parsing",
",",
"RES",
"and",
"ISA_FLAGS",
"are",
"left",
"unchanged",
"."
] | [
"aarch64",
"0",
"0"
] | aarch64 | aarch64_parse_arch | aarch64 | CPU | GCC | 16,923 | 178 | 1 | [] |
[
"<s>",
"void",
"X86InstrInfo",
"::",
"breakPartialRegDependency",
"(",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"OpNum",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"unsigned",
"Reg",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNum",
")",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"MI",
"->",
"killsRegister",
"(",
"Reg",
",",
"TRI",
")",
")",
"return",
";",
"if",
"(",
"X86",
"::",
"VR128RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"{",
"bool",
"HasAVX",
"=",
"TM",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
".",
"hasAVX",
"(",
")",
";",
"unsigned",
"Opc",
"=",
"HasAVX",
"?",
"X86",
"::",
"VXORPSrr",
":",
"X86",
"::",
"XORPSrr",
";",
"BuildMI",
"(",
"*",
"MI",
"->",
"getParent",
"(",
")",
",",
"MI",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"Opc",
")",
",",
"Reg",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"Undef",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"Undef",
")",
";",
"}",
"else",
"if",
"(",
"X86",
"::",
"VR256RegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"{",
"unsigned",
"XReg",
"=",
"TRI",
"->",
"getSubReg",
"(",
"Reg",
",",
"X86",
"::",
"sub_xmm",
")",
";",
"BuildMI",
"(",
"*",
"MI",
"->",
"getParent",
"(",
")",
",",
"MI",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"X86",
"::",
"VXORPSrr",
")",
",",
"XReg",
")",
".",
"addReg",
"(",
"XReg",
",",
"RegState",
"::",
"Undef",
")",
".",
"addReg",
"(",
"XReg",
",",
"RegState",
"::",
"Undef",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";",
"}",
"else",
"return",
";",
"MI",
"->",
"addRegisterKilled",
"(",
"Reg",
",",
"TRI",
",",
"true",
")",
";",
"}",
"</s>"
] | [
"Insert",
"a",
"dependency-breaking",
"instruction",
"before",
"MI",
"to",
"eliminate",
"an",
"unwanted",
"dependency",
"on",
"OpNum",
"."
] | [
"X86",
"X86",
"X86::VR128RegClass",
"X86",
"X86::VXORPSrr",
"X86::XORPSrr",
"X86::VR256RegClass",
"X86::sub_xmm",
"X86::VXORPSrr"
] | X86InstrInfo (2) | breakPartialRegDependency | X86 | CPU | LLVM | 16,924 | 229 | 1 | [] |
[
"<s>",
"SmallPtrSetImpl",
"<",
"MachineBasicBlock",
"*",
">",
"&",
"getBlocksSet",
"(",
")",
"{",
"return",
"BlockSet",
";",
"}",
"</s>"
] | [
"Return",
"a",
"direct",
",",
"immutable",
"handle",
"to",
"the",
"blocks",
"set",
"."
] | [
"WebAssembly"
] | WebAssemblyExceptionInfo4 | getBlocksSet | WebAssembly | Virtual ISA | LLVM | 16,925 | 14 | 1 | [] |
[
"<s>",
"static",
"void",
"compute_zdepwi_operands",
"(",
"unsigned",
"HOST_WIDE_INT",
"imm",
",",
"unsigned",
"*",
"op",
")",
"{",
"int",
"lsb",
",",
"len",
";",
"for",
"(",
"lsb",
"=",
"0",
";",
"lsb",
"<",
"32",
";",
"lsb",
"++",
")",
"{",
"if",
"(",
"(",
"imm",
"&",
"1",
")",
"!=",
"0",
")",
"break",
";",
"imm",
">>=",
"1",
";",
"}",
"if",
"(",
"(",
"imm",
"&",
"0x10",
")",
"==",
"0",
")",
"len",
"=",
"(",
"lsb",
"<=",
"28",
")",
"?",
"4",
":",
"32",
"-",
"lsb",
";",
"else",
"{",
"for",
"(",
"len",
"=",
"5",
";",
"len",
"<",
"32",
"-",
"lsb",
";",
"len",
"++",
")",
"{",
"if",
"(",
"(",
"imm",
"&",
"(",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"1",
"<<",
"len",
")",
")",
"==",
"0",
")",
"break",
";",
"}",
"imm",
"=",
"(",
"imm",
"&",
"0xf",
")",
"-",
"0x10",
";",
"}",
"op",
"[",
"0",
"]",
"=",
"imm",
";",
"op",
"[",
"1",
"]",
"=",
"31",
"-",
"lsb",
";",
"op",
"[",
"2",
"]",
"=",
"len",
";",
"}",
"</s>"
] | [
"Compute",
"position",
"(",
"in",
"OP",
"[",
"1",
"]",
")",
"and",
"width",
"(",
"in",
"OP",
"[",
"2",
"]",
")",
"useful",
"for",
"copying",
"IMM",
"to",
"a",
"register",
"using",
"the",
"zdepi",
"instructions",
".",
"Store",
"the",
"immediate",
"value",
"to",
"insert",
"in",
"OP",
"[",
"0",
"]",
"."
] | [
"pa",
"0",
"32",
"1",
"0",
"1",
"0x10",
"0",
"28",
"4",
"32",
"5",
"32",
"1",
"0",
"0xf",
"0x10",
"0",
"1",
"31",
"2"
] | pa | compute_zdepwi_operands | pa | CPU | GCC | 16,926 | 147 | 1 | [] |
[
"<s>",
"bool",
"X86AsmParser",
"::",
"parsePrimaryExpr",
"(",
"const",
"MCExpr",
"*",
"&",
"Res",
",",
"SMLoc",
"&",
"EndLoc",
")",
"{",
"MCAsmParser",
"&",
"Parser",
"=",
"getParser",
"(",
")",
";",
"if",
"(",
"getTok",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Percent",
")",
"||",
"(",
"isParsingIntelSyntax",
"(",
")",
"&&",
"getTok",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Identifier",
")",
"&&",
"MatchRegisterName",
"(",
"Parser",
".",
"getTok",
"(",
")",
".",
"getString",
"(",
")",
")",
")",
")",
"{",
"SMLoc",
"StartLoc",
"=",
"Parser",
".",
"getTok",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"unsigned",
"RegNo",
";",
"if",
"(",
"ParseRegister",
"(",
"RegNo",
",",
"StartLoc",
",",
"EndLoc",
")",
")",
"return",
"true",
";",
"Res",
"=",
"X86MCExpr",
"::",
"create",
"(",
"RegNo",
",",
"Parser",
".",
"getContext",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"return",
"Parser",
".",
"parsePrimaryExpr",
"(",
"Res",
",",
"EndLoc",
")",
";",
"}",
"</s>"
] | [
"Parse",
"a",
"primary",
"expression",
"."
] | [
"X86",
"X86",
"X86MCExpr::create"
] | X86AsmParser (2)5 | parsePrimaryExpr | X86 | CPU | LLVM | 16,927 | 128 | 1 | [] |
[
"<s>",
"int",
"AArch64AsmParser",
"::",
"tryParseRegister",
"(",
")",
"{",
"MCAsmParser",
"&",
"Parser",
"=",
"getParser",
"(",
")",
";",
"const",
"AsmToken",
"&",
"Tok",
"=",
"Parser",
".",
"getTok",
"(",
")",
";",
"assert",
"(",
"Tok",
".",
"is",
"(",
"AsmToken",
"::",
"Identifier",
")",
"&&",
"\"Token is not an Identifier\"",
")",
";",
"std",
"::",
"string",
"lowerCase",
"=",
"Tok",
".",
"getString",
"(",
")",
".",
"lower",
"(",
")",
";",
"if",
"(",
"isSVEVectorOrPredicateRegister",
"(",
"lowerCase",
")",
")",
"return",
"-",
"1",
";",
"unsigned",
"RegNum",
"=",
"matchRegisterNameAlias",
"(",
"lowerCase",
",",
"false",
")",
";",
"if",
"(",
"RegNum",
"==",
"0",
")",
"RegNum",
"=",
"StringSwitch",
"<",
"unsigned",
">",
"(",
"lowerCase",
")",
".",
"Case",
"(",
"\"fp\"",
",",
"AArch64",
"::",
"FP",
")",
".",
"Case",
"(",
"\"lr\"",
",",
"AArch64",
"::",
"LR",
")",
".",
"Case",
"(",
"\"x31\"",
",",
"AArch64",
"::",
"XZR",
")",
".",
"Case",
"(",
"\"w31\"",
",",
"AArch64",
"::",
"WZR",
")",
".",
"Default",
"(",
"0",
")",
";",
"if",
"(",
"RegNum",
"==",
"0",
")",
"return",
"-",
"1",
";",
"Parser",
".",
"Lex",
"(",
")",
";",
"return",
"RegNum",
";",
"}",
"</s>"
] | [
"tryParseRegister",
"-",
"parse",
"one",
"register",
"if",
"possible"
] | [
"AArch64",
"AArch64",
"\"Token is not an Identifier\"",
"1",
"0",
"\"fp\"",
"AArch64::FP",
"\"lr\"",
"AArch64::LR",
"\"x31\"",
"AArch64::XZR",
"\"w31\"",
"AArch64::WZR",
"0",
"0",
"1"
] | AArch64AsmParser59 | tryParseRegister | AArch64 | CPU | LLVM | 16,928 | 153 | 1 | [] |
[
"<s>",
"void",
"X86TargetLowering",
"::",
"computeKnownBitsForTargetNode",
"(",
"const",
"SDValue",
"Op",
",",
"APInt",
"&",
"KnownZero",
",",
"APInt",
"&",
"KnownOne",
",",
"const",
"SelectionDAG",
"&",
"DAG",
",",
"unsigned",
"Depth",
")",
"const",
"{",
"unsigned",
"BitWidth",
"=",
"KnownZero",
".",
"getBitWidth",
"(",
")",
";",
"unsigned",
"Opc",
"=",
"Op",
".",
"getOpcode",
"(",
")",
";",
"assert",
"(",
"(",
"Opc",
">=",
"ISD",
"::",
"BUILTIN_OP_END",
"||",
"Opc",
"==",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
"||",
"Opc",
"==",
"ISD",
"::",
"INTRINSIC_W_CHAIN",
"||",
"Opc",
"==",
"ISD",
"::",
"INTRINSIC_VOID",
")",
"&&",
"\"Should use MaskedValueIsZero if you don't know whether Op\"",
"\" is a target node!\"",
")",
";",
"KnownZero",
"=",
"KnownOne",
"=",
"APInt",
"(",
"BitWidth",
",",
"0",
")",
";",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"break",
";",
"case",
"X86ISD",
"::",
"ADD",
":",
"case",
"X86ISD",
"::",
"SUB",
":",
"case",
"X86ISD",
"::",
"ADC",
":",
"case",
"X86ISD",
"::",
"SBB",
":",
"case",
"X86ISD",
"::",
"SMUL",
":",
"case",
"X86ISD",
"::",
"UMUL",
":",
"case",
"X86ISD",
"::",
"INC",
":",
"case",
"X86ISD",
"::",
"DEC",
":",
"case",
"X86ISD",
"::",
"OR",
":",
"case",
"X86ISD",
"::",
"XOR",
":",
"case",
"X86ISD",
"::",
"AND",
":",
"if",
"(",
"Op",
".",
"getResNo",
"(",
")",
"==",
"0",
")",
"break",
";",
"LLVM_FALLTHROUGH",
";",
"case",
"X86ISD",
"::",
"SETCC",
":",
"KnownZero",
".",
"setBits",
"(",
"1",
",",
"BitWidth",
")",
";",
"break",
";",
"case",
"X86ISD",
"::",
"MOVMSK",
":",
"{",
"unsigned",
"NumLoBits",
"=",
"Op",
".",
"getOperand",
"(",
"0",
")",
".",
"getValueType",
"(",
")",
".",
"getVectorNumElements",
"(",
")",
";",
"KnownZero",
".",
"setBits",
"(",
"NumLoBits",
",",
"BitWidth",
")",
";",
"break",
";",
"}",
"case",
"X86ISD",
"::",
"VZEXT",
":",
"{",
"SDValue",
"N0",
"=",
"Op",
".",
"getOperand",
"(",
"0",
")",
";",
"unsigned",
"NumElts",
"=",
"Op",
".",
"getValueType",
"(",
")",
".",
"getVectorNumElements",
"(",
")",
";",
"EVT",
"SrcVT",
"=",
"N0",
".",
"getValueType",
"(",
")",
";",
"unsigned",
"InNumElts",
"=",
"SrcVT",
".",
"getVectorNumElements",
"(",
")",
";",
"unsigned",
"InBitWidth",
"=",
"SrcVT",
".",
"getScalarSizeInBits",
"(",
")",
";",
"assert",
"(",
"InNumElts",
">=",
"NumElts",
"&&",
"\"Illegal VZEXT input\"",
")",
";",
"KnownZero",
"=",
"KnownOne",
"=",
"APInt",
"(",
"InBitWidth",
",",
"0",
")",
";",
"APInt",
"DemandedSrcElts",
"=",
"APInt",
"::",
"getLowBitsSet",
"(",
"InNumElts",
",",
"NumElts",
")",
";",
"DAG",
".",
"computeKnownBits",
"(",
"N0",
",",
"KnownZero",
",",
"KnownOne",
",",
"DemandedSrcElts",
",",
"Depth",
"+",
"1",
")",
";",
"KnownOne",
"=",
"KnownOne",
".",
"zext",
"(",
"BitWidth",
")",
";",
"KnownZero",
"=",
"KnownZero",
".",
"zext",
"(",
"BitWidth",
")",
";",
"KnownZero",
".",
"setBits",
"(",
"InBitWidth",
",",
"BitWidth",
")",
";",
"break",
";",
"}",
"}",
"}",
"</s>"
] | [
"Determine",
"which",
"of",
"the",
"bits",
"specified",
"in",
"Mask",
"are",
"known",
"to",
"be",
"either",
"zero",
"or",
"one",
"and",
"return",
"them",
"in",
"the",
"KnownZero/KnownOne",
"bitsets",
"."
] | [
"X86",
"X86",
"ISD::BUILTIN_OP_END",
"ISD::INTRINSIC_WO_CHAIN",
"ISD::INTRINSIC_W_CHAIN",
"ISD::INTRINSIC_VOID",
"\"Should use MaskedValueIsZero if you don't know whether Op\"",
"\" is a target node!\"",
"0",
"X86ISD::ADD",
"X86ISD::SUB",
"X86ISD::ADC",
"X86ISD::SBB",
"X86ISD::SMUL",
"X86ISD::UMUL",
"X86ISD::INC",
"X86ISD::DEC",
"X86ISD::OR",
"X86ISD::XOR",
"X86ISD::AND",
"0",
"X86ISD::SETCC",
"1",
"X86ISD::MOVMSK",
"0",
"X86ISD::VZEXT",
"0",
"\"Illegal VZEXT input\"",
"0",
"1"
] | X86ISelLowering115 | computeKnownBitsForTargetNode | X86 | CPU | LLVM | 16,929 | 355 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"RISCV_MERGE_BASE_OFFSET_NAME",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"RI5CY",
"RISCV"
] | RISCVMergeBaseOffset | getPassName | RI5CY | CPU | LLVM | 16,930 | 11 | 1 | [] |
[
"<s>",
"virtual",
"const",
"TargetSubtargetInfo",
"*",
"getSubtargetImpl",
"(",
"const",
"Function",
"&",
")",
"const",
"override",
"{",
"return",
"&",
"Subtarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"FISC"
] | FISCTargetMachine | getSubtargetImpl | FISC | CPU | LLVM | 16,931 | 18 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseInstrInfo",
"::",
"isPredicable",
"(",
"MachineInstr",
"&",
"MI",
")",
"const",
"{",
"if",
"(",
"!",
"MI",
".",
"isPredicable",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"MI",
".",
"isBundle",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"isEligibleForITBlock",
"(",
"&",
"MI",
")",
")",
"return",
"false",
";",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"AFI",
"->",
"isThumb2Function",
"(",
")",
")",
"{",
"if",
"(",
"getSubtarget",
"(",
")",
".",
"restrictIT",
"(",
")",
")",
"return",
"isV8EligibleForIT",
"(",
"&",
"MI",
")",
";",
"}",
"else",
"{",
"if",
"(",
"(",
"MI",
".",
"getDesc",
"(",
")",
".",
"TSFlags",
"&",
"ARMII",
"::",
"DomainMask",
")",
"==",
"ARMII",
"::",
"DomainNEON",
")",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"specified",
"instruction",
"can",
"be",
"predicated",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARMII::DomainMask",
"ARMII::DomainNEON"
] | ARMBaseInstrInfo63 | isPredicable | ARM | CPU | LLVM | 16,932 | 124 | 1 | [] |
[
"<s>",
"void",
"X86FrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
")",
"const",
"{",
"const",
"X86Subtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"const",
"X86RegisterInfo",
"&",
"RegInfo",
"=",
"*",
"STI",
".",
"getRegisterInfo",
"(",
")",
";",
"unsigned",
"StackPtr",
"=",
"RegInfo",
".",
"getStackRegister",
"(",
")",
";",
"bool",
"reserveCallFrame",
"=",
"hasReservedCallFrame",
"(",
"MF",
")",
";",
"int",
"Opcode",
"=",
"I",
"->",
"getOpcode",
"(",
")",
";",
"bool",
"isDestroy",
"=",
"Opcode",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
";",
"const",
"bool",
"Uses64BitStackPtr",
"=",
"STI",
".",
"isTarget64BitLP64",
"(",
")",
"||",
"STI",
".",
"isTargetNaCl64",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"uint64_t",
"Amount",
"=",
"!",
"reserveCallFrame",
"?",
"I",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
":",
"0",
";",
"uint64_t",
"InternalAmt",
"=",
"(",
"isDestroy",
"||",
"Amount",
")",
"?",
"I",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
":",
"0",
";",
"I",
"=",
"MBB",
".",
"erase",
"(",
"I",
")",
";",
"if",
"(",
"!",
"reserveCallFrame",
")",
"{",
"if",
"(",
"Amount",
"==",
"0",
")",
"return",
";",
"unsigned",
"StackAlign",
"=",
"getStackAlignment",
"(",
")",
";",
"Amount",
"=",
"RoundUpToAlignment",
"(",
"Amount",
",",
"StackAlign",
")",
";",
"MachineInstr",
"*",
"New",
"=",
"nullptr",
";",
"Amount",
"-=",
"InternalAmt",
";",
"if",
"(",
"Amount",
")",
"{",
"if",
"(",
"Opcode",
"==",
"TII",
".",
"getCallFrameSetupOpcode",
"(",
")",
")",
"{",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"getSUBriOpcode",
"(",
"Uses64BitStackPtr",
",",
"Amount",
")",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addImm",
"(",
"Amount",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"Opcode",
"==",
"TII",
".",
"getCallFrameDestroyOpcode",
"(",
")",
")",
";",
"unsigned",
"Opc",
"=",
"getADDriOpcode",
"(",
"Uses64BitStackPtr",
",",
"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",
"(",
")",
"&&",
"InternalAmt",
")",
"{",
"unsigned",
"Opc",
"=",
"getSUBriOpcode",
"(",
"Uses64BitStackPtr",
",",
"InternalAmt",
")",
";",
"MachineInstr",
"*",
"New",
"=",
"BuildMI",
"(",
"MF",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addImm",
"(",
"InternalAmt",
")",
";",
"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",
"X86",
"0",
"0",
"1",
"0",
"0",
"3",
"3"
] | X86FrameLowering109 | eliminateCallFramePseudoInstr | X86 | CPU | LLVM | 16,933 | 449 | 1 | [] |
[
"<s>",
"void",
"NVPTXAsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"SmallString",
"<",
"128",
">",
"Str",
";",
"raw_svector_ostream",
"OS",
"(",
"Str",
")",
";",
"if",
"(",
"nvptxSubtarget",
".",
"getDrvInterface",
"(",
")",
"==",
"NVPTX",
"::",
"CUDA",
")",
"emitLineNumberAsDotLoc",
"(",
"*",
"MI",
")",
";",
"MCInst",
"Inst",
";",
"lowerToMCInst",
"(",
"MI",
",",
"Inst",
")",
";",
"OutStreamer",
".",
"EmitInstruction",
"(",
"Inst",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"NVPTX",
"NVPTX",
"128",
"NVPTX::CUDA"
] | NVPTXAsmPrinter10 | EmitInstruction | NVPTX | GPU | LLVM | 16,934 | 59 | 1 | [] |
[
"<s>",
"SDValue",
"AArch64TargetLowering",
"::",
"PerformDAGCombine",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"SelectionDAG",
"&",
"DAG",
"=",
"DCI",
".",
"DAG",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"ADD",
":",
"case",
"ISD",
"::",
"SUB",
":",
"return",
"performAddSubLongCombine",
"(",
"N",
",",
"DCI",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"XOR",
":",
"return",
"performXorCombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"MUL",
":",
"return",
"performMulCombine",
"(",
"N",
",",
"DAG",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"SINT_TO_FP",
":",
"case",
"ISD",
"::",
"UINT_TO_FP",
":",
"return",
"performIntToFpCombine",
"(",
"N",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"OR",
":",
"return",
"performORCombine",
"(",
"N",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"return",
"performIntrinsicCombine",
"(",
"N",
",",
"DCI",
",",
"Subtarget",
")",
";",
"case",
"ISD",
"::",
"ANY_EXTEND",
":",
"case",
"ISD",
"::",
"ZERO_EXTEND",
":",
"case",
"ISD",
"::",
"SIGN_EXTEND",
":",
"return",
"performExtendCombine",
"(",
"N",
",",
"DCI",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"BITCAST",
":",
"return",
"performBitcastCombine",
"(",
"N",
",",
"DCI",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"CONCAT_VECTORS",
":",
"return",
"performConcatVectorsCombine",
"(",
"N",
",",
"DCI",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SELECT",
":",
"return",
"performSelectCombine",
"(",
"N",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"VSELECT",
":",
"return",
"performVSelectCombine",
"(",
"N",
",",
"DCI",
".",
"DAG",
")",
";",
"case",
"ISD",
"::",
"STORE",
":",
"return",
"performSTORECombine",
"(",
"N",
",",
"DCI",
",",
"DAG",
",",
"Subtarget",
")",
";",
"case",
"AArch64ISD",
"::",
"BRCOND",
":",
"return",
"performBRCONDCombine",
"(",
"N",
",",
"DCI",
",",
"DAG",
")",
";",
"case",
"AArch64ISD",
"::",
"DUP",
":",
"return",
"performPostLD1Combine",
"(",
"N",
",",
"DCI",
",",
"false",
")",
";",
"case",
"ISD",
"::",
"INSERT_VECTOR_ELT",
":",
"return",
"performPostLD1Combine",
"(",
"N",
",",
"DCI",
",",
"true",
")",
";",
"case",
"ISD",
"::",
"INTRINSIC_VOID",
":",
"case",
"ISD",
"::",
"INTRINSIC_W_CHAIN",
":",
"switch",
"(",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"N",
"->",
"getOperand",
"(",
"1",
")",
")",
"->",
"getZExtValue",
"(",
")",
")",
"{",
"case",
"Intrinsic",
"::",
"aarch64_neon_ld2",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_ld3",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_ld4",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_ld1x2",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_ld1x3",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_ld1x4",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_ld2lane",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_ld3lane",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_ld4lane",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_ld2r",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_ld3r",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_ld4r",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_st2",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_st3",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_st4",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_st1x2",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_st1x3",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_st1x4",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_st2lane",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_st3lane",
":",
"case",
"Intrinsic",
"::",
"aarch64_neon_st4lane",
":",
"return",
"performNEONPostLDSTCombine",
"(",
"N",
",",
"DCI",
",",
"DAG",
")",
";",
"default",
":",
"break",
";",
"}",
"}",
"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",
"."
] | [
"AArch64",
"AArch64",
"ISD::ADD",
"ISD::SUB",
"ISD::XOR",
"ISD::MUL",
"ISD::SINT_TO_FP",
"ISD::UINT_TO_FP",
"ISD::OR",
"ISD::INTRINSIC_WO_CHAIN",
"ISD::ANY_EXTEND",
"ISD::ZERO_EXTEND",
"ISD::SIGN_EXTEND",
"ISD::BITCAST",
"ISD::CONCAT_VECTORS",
"ISD::SELECT",
"ISD::VSELECT",
"ISD::STORE",
"AArch64ISD::BRCOND",
"AArch64ISD::DUP",
"ISD::INSERT_VECTOR_ELT",
"ISD::INTRINSIC_VOID",
"ISD::INTRINSIC_W_CHAIN",
"1",
"Intrinsic::aarch64_neon_ld2",
"Intrinsic::aarch64_neon_ld3",
"Intrinsic::aarch64_neon_ld4",
"Intrinsic::aarch64_neon_ld1x2",
"Intrinsic::aarch64_neon_ld1x3",
"Intrinsic::aarch64_neon_ld1x4",
"Intrinsic::aarch64_neon_ld2lane",
"Intrinsic::aarch64_neon_ld3lane",
"Intrinsic::aarch64_neon_ld4lane",
"Intrinsic::aarch64_neon_ld2r",
"Intrinsic::aarch64_neon_ld3r",
"Intrinsic::aarch64_neon_ld4r",
"Intrinsic::aarch64_neon_st2",
"Intrinsic::aarch64_neon_st3",
"Intrinsic::aarch64_neon_st4",
"Intrinsic::aarch64_neon_st1x2",
"Intrinsic::aarch64_neon_st1x3",
"Intrinsic::aarch64_neon_st1x4",
"Intrinsic::aarch64_neon_st2lane",
"Intrinsic::aarch64_neon_st3lane",
"Intrinsic::aarch64_neon_st4lane"
] | AArch64ISelLowering23 | PerformDAGCombine | AArch64 | CPU | LLVM | 16,935 | 440 | 1 | [] |
[
"<s>",
"unsigned",
"SIInstrInfo",
"::",
"removeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"int",
"*",
"BytesRemoved",
")",
"const",
"{",
"unsigned",
"Count",
"=",
"0",
";",
"unsigned",
"RemovedSize",
"=",
"0",
";",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"llvm",
"::",
"make_early_inc_range",
"(",
"MBB",
".",
"terminators",
"(",
")",
")",
")",
"{",
"if",
"(",
"MI",
".",
"isBranch",
"(",
")",
"||",
"MI",
".",
"isReturn",
"(",
")",
")",
"{",
"RemovedSize",
"+=",
"getInstSizeInBytes",
"(",
"MI",
")",
";",
"MI",
".",
"eraseFromParent",
"(",
")",
";",
"++",
"Count",
";",
"}",
"}",
"if",
"(",
"BytesRemoved",
")",
"*",
"BytesRemoved",
"=",
"RemovedSize",
";",
"return",
"Count",
";",
"}",
"</s>"
] | [
"Remove",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"the",
"specific",
"MBB",
"."
] | [
"AMDGPU",
"SI",
"0",
"0"
] | SIInstrInfo11 | removeBranch | AMDGPU | GPU | LLVM | 16,936 | 89 | 1 | [] |
[
"<s>",
"void",
"TPCSchedStrategy",
"::",
"schedNode",
"(",
"SUnit",
"*",
"SU",
",",
"bool",
"IsTopNode",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"SU",
"->",
"getInstr",
"(",
")",
";",
"(",
"void",
")",
"MI",
";",
"lastScheduledSU",
"=",
"SU",
";",
"if",
"(",
"IsTopNode",
")",
"{",
"Top",
".",
"bumpNode",
"(",
"SU",
",",
"isPostRA",
")",
";",
"SU",
"->",
"TopReadyCycle",
"=",
"Top",
".",
"CurrCycle",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\" ** TopReadyCycle = \"",
"<<",
"SU",
"->",
"TopReadyCycle",
"<<",
"\"\\n\"",
")",
";",
"}",
"else",
"{",
"Bot",
".",
"bumpNode",
"(",
"SU",
",",
"isPostRA",
")",
";",
"SU",
"->",
"BotReadyCycle",
"=",
"Bot",
".",
"CurrCycle",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\" ** BotReadyCycle = \"",
"<<",
"SU",
"->",
"BotReadyCycle",
"<<",
"\"\\n\"",
")",
";",
"}",
"}",
"</s>"
] | [
"ScheduleDAGMI",
"has",
"scheduled",
"an",
"instruction",
"-",
"tell",
"HazardRec",
"about",
"it",
"."
] | [
"TPC",
"TPC",
"\" ** TopReadyCycle = \"",
"\"\\n\"",
"\" ** BotReadyCycle = \"",
"\"\\n\""
] | TPCMachineScheduler | schedNode | TPC | Virtual ISA | LLVM | 16,937 | 106 | 1 | [] |
[
"<s>",
"void",
"rs6000_emit_epilogue_components",
"(",
"sbitmap",
"components",
")",
"{",
"rs6000_stack_t",
"*",
"info",
"=",
"rs6000_stack_info",
"(",
")",
";",
"rtx",
"ptr_reg",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"frame_pointer_needed_indeed",
"?",
"HARD_FRAME_POINTER_REGNUM",
":",
"STACK_POINTER_REGNUM",
")",
";",
"machine_mode",
"reg_mode",
"=",
"Pmode",
";",
"int",
"reg_size",
"=",
"TARGET_32BIT",
"?",
"4",
":",
"8",
";",
"machine_mode",
"fp_reg_mode",
"=",
"TARGET_HARD_FLOAT",
"?",
"DFmode",
":",
"SFmode",
";",
"int",
"fp_reg_size",
"=",
"8",
";",
"int",
"offset",
"=",
"info",
"->",
"fp_save_offset",
";",
"if",
"(",
"info",
"->",
"push_p",
")",
"offset",
"+=",
"info",
"->",
"total_size",
";",
"for",
"(",
"int",
"i",
"=",
"info",
"->",
"first_fp_reg_save",
";",
"i",
"<",
"64",
";",
"i",
"++",
")",
"{",
"if",
"(",
"bitmap_bit_p",
"(",
"components",
",",
"i",
")",
")",
"{",
"rtx",
"reg",
"=",
"gen_rtx_REG",
"(",
"fp_reg_mode",
",",
"i",
")",
";",
"rtx_insn",
"*",
"insn",
"=",
"emit_insn",
"(",
"gen_frame_load",
"(",
"reg",
",",
"ptr_reg",
",",
"offset",
")",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_RESTORE",
",",
"reg",
")",
";",
"}",
"offset",
"+=",
"fp_reg_size",
";",
"}",
"offset",
"=",
"info",
"->",
"gp_save_offset",
";",
"if",
"(",
"info",
"->",
"push_p",
")",
"offset",
"+=",
"info",
"->",
"total_size",
";",
"for",
"(",
"int",
"i",
"=",
"info",
"->",
"first_gp_reg_save",
";",
"i",
"<",
"32",
";",
"i",
"++",
")",
"{",
"if",
"(",
"bitmap_bit_p",
"(",
"components",
",",
"i",
")",
")",
"{",
"rtx",
"reg",
"=",
"gen_rtx_REG",
"(",
"reg_mode",
",",
"i",
")",
";",
"rtx_insn",
"*",
"insn",
"=",
"emit_insn",
"(",
"gen_frame_load",
"(",
"reg",
",",
"ptr_reg",
",",
"offset",
")",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_RESTORE",
",",
"reg",
")",
";",
"}",
"offset",
"+=",
"reg_size",
";",
"}",
"if",
"(",
"bitmap_bit_p",
"(",
"components",
",",
"0",
")",
")",
"{",
"int",
"offset",
"=",
"info",
"->",
"lr_save_offset",
";",
"if",
"(",
"info",
"->",
"push_p",
")",
"offset",
"+=",
"info",
"->",
"total_size",
";",
"rtx",
"reg",
"=",
"gen_rtx_REG",
"(",
"reg_mode",
",",
"0",
")",
";",
"rtx_insn",
"*",
"insn",
"=",
"emit_insn",
"(",
"gen_frame_load",
"(",
"reg",
",",
"ptr_reg",
",",
"offset",
")",
")",
";",
"rtx",
"lr",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"LR_REGNO",
")",
";",
"insn",
"=",
"emit_move_insn",
"(",
"lr",
",",
"reg",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_RESTORE",
",",
"lr",
")",
";",
"}",
"}",
"</s>"
] | [
"Implement",
"TARGET_SHRINK_WRAP_EMIT_EPILOGUE_COMPONENTS",
"."
] | [
"rs6000",
"4",
"8",
"8",
"64",
"1",
"32",
"1",
"0",
"0",
"1"
] | rs6000-logue | rs6000_emit_epilogue_components | rs6000 | CPU | GCC | 16,938 | 336 | 1 | [] |
[
"<s>",
"const",
"InstrItineraryData",
"*",
"getInstrItineraryData",
"(",
")",
"const",
"override",
"{",
"return",
"&",
"InstrItins",
";",
"}",
"</s>"
] | [
"getInstrItineraryData",
"-",
"Returns",
"instruction",
"itinerary",
"data",
"for",
"the",
"target",
"or",
"specific",
"subtarget",
"."
] | [
"TPC"
] | TPCSubtarget | getInstrItineraryData | TPC | Virtual ISA | LLVM | 16,939 | 14 | 1 | [] |
[
"<s>",
"static",
"void",
"crx_compute_frame",
"(",
"void",
")",
"{",
"int",
"stack_alignment",
"=",
"STACK_BOUNDARY",
"/",
"BITS_PER_UNIT",
";",
"int",
"padding_locals",
";",
"local_vars_size",
"=",
"get_frame_size",
"(",
")",
";",
"padding_locals",
"=",
"local_vars_size",
"%",
"stack_alignment",
";",
"if",
"(",
"padding_locals",
")",
"padding_locals",
"=",
"stack_alignment",
"-",
"padding_locals",
";",
"local_vars_size",
"+=",
"padding_locals",
";",
"size_for_adjusting_sp",
"=",
"local_vars_size",
"+",
"(",
"ACCUMULATE_OUTGOING_ARGS",
"?",
"current_function_outgoing_args_size",
":",
"0",
")",
";",
"}",
"</s>"
] | [
"Compute",
"the",
"size",
"of",
"the",
"local",
"area",
"and",
"the",
"size",
"to",
"be",
"adjusted",
"by",
"the",
"*",
"prologue",
"and",
"epilogue",
"."
] | [
"crx",
"0"
] | crx | crx_compute_frame | crx | CPU | GCC | 16,940 | 56 | 1 | [] |
[
"<s>",
"Register",
"MipsFunctionInfo",
"::",
"getGlobalBaseReg",
"(",
"MachineFunction",
"&",
"MF",
",",
"bool",
"IsForTls",
")",
"{",
"if",
"(",
"IsForTls",
")",
"UsesTlsViaGlobalReg",
"=",
"true",
";",
"else",
"assert",
"(",
"!",
"static_cast",
"<",
"const",
"MipsSubtarget",
"&",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
")",
".",
"useCheriCapTable",
"(",
")",
"&&",
"\"$gp should only be used for TLS in cap-table mode\"",
")",
";",
"if",
"(",
"!",
"GlobalBaseReg",
")",
"GlobalBaseReg",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"&",
"getGlobalBaseRegClass",
"(",
"MF",
")",
")",
";",
"return",
"GlobalBaseReg",
";",
"}",
"</s>"
] | [
"getGlobalBaseReg",
"-",
"Return",
"a",
"virtual",
"register",
"initialized",
"with",
"the",
"the",
"global",
"base",
"register",
"value",
"."
] | [
"Mips",
"Mips",
"Mips",
"\"$gp should only be used for TLS in cap-table mode\""
] | MipsMachineFunction24 | getGlobalBaseReg | Mips | CPU | LLVM | 16,941 | 72 | 1 | [] |
[
"<s>",
"static",
"void",
"avr_asm_init_sections",
"(",
"void",
")",
"{",
"if",
"(",
"avr_arch",
"->",
"flash_pm_offset",
"==",
"0",
")",
"readonly_data_section",
"->",
"unnamed",
".",
"callback",
"=",
"avr_output_data_section_asm_op",
";",
"data_section",
"->",
"unnamed",
".",
"callback",
"=",
"avr_output_data_section_asm_op",
";",
"bss_section",
"->",
"unnamed",
".",
"callback",
"=",
"avr_output_bss_section_asm_op",
";",
"}",
"</s>"
] | [
"Implement",
"`",
"TARGET_ASM_INIT_SECTIONS",
"'",
"."
] | [
"avr",
"0"
] | avr | avr_asm_init_sections | avr | MPU | GCC | 16,942 | 40 | 1 | [] |
[
"<s>",
"class",
"LLVM_LIBRARY_VISIBILITY",
"SystemZMCInstLower",
"{",
"MCContext",
"&",
"Ctx",
";",
"SystemZAsmPrinter",
"&",
"AsmPrinter",
";",
"public",
":",
"SystemZMCInstLower",
"(",
"MCContext",
"&",
"ctx",
",",
"SystemZAsmPrinter",
"&",
"asmPrinter",
")",
";",
"void",
"lower",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"MCInst",
"&",
"OutMI",
")",
"const",
";",
"MCOperand",
"lowerOperand",
"(",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
";",
"const",
"MCExpr",
"*",
"getExpr",
"(",
"const",
"MachineOperand",
"&",
"MO",
",",
"MCSymbolRefExpr",
"::",
"VariantKind",
"Kind",
")",
"const",
";",
"}",
"</s>"
] | [
"Implementation",
"of",
"the",
"SCEVPredicate",
"interface",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ"
] | SystemZMCInstLower12 | getExpr | SystemZ | CPU | LLVM | 16,943 | 67 | 1 | [] |
[
"<s>",
"rtx",
"legitimize_pic_address",
"(",
"rtx",
"orig",
",",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"rtx",
"reg",
")",
"{",
"if",
"(",
"tls_symbolic_operand",
"(",
"orig",
",",
"Pmode",
")",
"!=",
"TLS_MODEL_NONE",
")",
"return",
"orig",
";",
"if",
"(",
"GET_CODE",
"(",
"orig",
")",
"==",
"LABEL_REF",
"||",
"(",
"GET_CODE",
"(",
"orig",
")",
"==",
"SYMBOL_REF",
"&&",
"SYMBOL_REF_LOCAL_P",
"(",
"orig",
")",
")",
")",
"{",
"if",
"(",
"reg",
"==",
"NULL_RTX",
")",
"reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_insn",
"(",
"gen_symGOTOFF2reg",
"(",
"reg",
",",
"orig",
")",
")",
";",
"return",
"reg",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"orig",
")",
"==",
"SYMBOL_REF",
")",
"{",
"if",
"(",
"reg",
"==",
"NULL_RTX",
")",
"reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"emit_insn",
"(",
"gen_symGOT2reg",
"(",
"reg",
",",
"orig",
")",
")",
";",
"return",
"reg",
";",
"}",
"return",
"orig",
";",
"}",
"</s>"
] | [
"Legitimize",
"PIC",
"addresses",
".",
"If",
"the",
"address",
"is",
"already",
"position-independent",
",",
"we",
"return",
"ORIG",
".",
"Newly",
"generated",
"position-independent",
"addresses",
"go",
"into",
"a",
"reg",
".",
"This",
"is",
"REG",
"if",
"nonzero",
",",
"otherwise",
"we",
"allocate",
"register",
"(",
"s",
")",
"as",
"necessary",
"."
] | [
"sh"
] | sh4 | legitimize_pic_address | sh | CPU | GCC | 16,944 | 121 | 1 | [] |
[
"<s>",
"static",
"void",
"nios2_alternate_compare_const",
"(",
"enum",
"rtx_code",
"code",
",",
"rtx",
"op",
",",
"enum",
"rtx_code",
"*",
"alt_code",
",",
"rtx",
"*",
"alt_op",
",",
"machine_mode",
"mode",
")",
"{",
"HOST_WIDE_INT",
"opval",
"=",
"INTVAL",
"(",
"op",
")",
";",
"enum",
"rtx_code",
"scode",
"=",
"signed_condition",
"(",
"code",
")",
";",
"bool",
"dec_p",
"=",
"(",
"scode",
"==",
"LT",
"||",
"scode",
"==",
"GE",
")",
";",
"if",
"(",
"code",
"==",
"EQ",
"||",
"code",
"==",
"NE",
")",
"{",
"*",
"alt_code",
"=",
"code",
";",
"*",
"alt_op",
"=",
"op",
";",
"return",
";",
"}",
"*",
"alt_op",
"=",
"(",
"dec_p",
"?",
"gen_int_mode",
"(",
"opval",
"-",
"1",
",",
"mode",
")",
":",
"gen_int_mode",
"(",
"opval",
"+",
"1",
",",
"mode",
")",
")",
";",
"*",
"alt_code",
"=",
"reverse_condition",
"(",
"swap_condition",
"(",
"code",
")",
")",
";",
"{",
"unsigned",
"HOST_WIDE_INT",
"alt_opval",
"=",
"INTVAL",
"(",
"*",
"alt_op",
")",
";",
"if",
"(",
"code",
"==",
"scode",
")",
"alt_opval",
"^=",
"(",
"1",
"<<",
"(",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
"-",
"1",
")",
")",
";",
"alt_opval",
"&=",
"GET_MODE_MASK",
"(",
"mode",
")",
";",
"gcc_assert",
"(",
"dec_p",
"?",
"alt_opval",
"!=",
"GET_MODE_MASK",
"(",
"mode",
")",
":",
"alt_opval",
"!=",
"0",
")",
";",
"}",
"}",
"</s>"
] | [
"Return",
"in",
"*",
"ALT_CODE",
"and",
"*",
"ALT_OP",
",",
"an",
"alternate",
"equivalent",
"constant",
"comparison",
",",
"e.g",
".",
">",
"=",
"1",
"into",
">",
"0",
"."
] | [
"nios2",
"1",
"1",
"1",
"1",
"0"
] | nios22 | nios2_alternate_compare_const | nios2 | MPU | GCC | 16,945 | 171 | 1 | [] |
[
"<s>",
"void",
"PPCTargetLowering",
"::",
"computeKnownBitsForTargetNode",
"(",
"const",
"SDValue",
"Op",
",",
"APInt",
"&",
"KnownZero",
",",
"APInt",
"&",
"KnownOne",
",",
"const",
"SelectionDAG",
"&",
"DAG",
",",
"unsigned",
"Depth",
")",
"const",
"{",
"KnownZero",
"=",
"KnownOne",
"=",
"APInt",
"(",
"KnownZero",
".",
"getBitWidth",
"(",
")",
",",
"0",
")",
";",
"switch",
"(",
"Op",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"PPCISD",
"::",
"LBRX",
":",
"{",
"if",
"(",
"cast",
"<",
"VTSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"2",
")",
")",
"->",
"getVT",
"(",
")",
"==",
"MVT",
"::",
"i16",
")",
"KnownZero",
"=",
"0xFFFF0000",
";",
"break",
";",
"}",
"case",
"ISD",
"::",
"INTRINSIC_WO_CHAIN",
":",
"{",
"switch",
"(",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"0",
")",
")",
"->",
"getZExtValue",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpbfp_p",
":",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpeqfp_p",
":",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpequb_p",
":",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpequh_p",
":",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpequw_p",
":",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpgefp_p",
":",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpgtfp_p",
":",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpgtsb_p",
":",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpgtsh_p",
":",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpgtsw_p",
":",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpgtub_p",
":",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpgtuh_p",
":",
"case",
"Intrinsic",
"::",
"ppc_altivec_vcmpgtuw_p",
":",
"KnownZero",
"=",
"~",
"1U",
";",
"break",
";",
"}",
"}",
"}",
"}",
"</s>"
] | [
"Determine",
"which",
"of",
"the",
"bits",
"specified",
"in",
"Mask",
"are",
"known",
"to",
"be",
"either",
"zero",
"or",
"one",
"and",
"return",
"them",
"in",
"the",
"KnownZero/KnownOne",
"bitsets",
"."
] | [
"PowerPC",
"PPC",
"0",
"PPCISD::LBRX",
"2",
"MVT::i16",
"0xFFFF0000",
"ISD::INTRINSIC_WO_CHAIN",
"0",
"Intrinsic::ppc_altivec_vcmpbfp_p",
"Intrinsic::ppc_altivec_vcmpeqfp_p",
"Intrinsic::ppc_altivec_vcmpequb_p",
"Intrinsic::ppc_altivec_vcmpequh_p",
"Intrinsic::ppc_altivec_vcmpequw_p",
"Intrinsic::ppc_altivec_vcmpgefp_p",
"Intrinsic::ppc_altivec_vcmpgtfp_p",
"Intrinsic::ppc_altivec_vcmpgtsb_p",
"Intrinsic::ppc_altivec_vcmpgtsh_p",
"Intrinsic::ppc_altivec_vcmpgtsw_p",
"Intrinsic::ppc_altivec_vcmpgtub_p",
"Intrinsic::ppc_altivec_vcmpgtuh_p",
"Intrinsic::ppc_altivec_vcmpgtuw_p",
"1U"
] | PPCISelLowering148 | computeKnownBitsForTargetNode | PowerPC | CPU | LLVM | 16,946 | 197 | 1 | [] |
[
"<s>",
"X86Subtarget",
"::",
"X86Subtarget",
"(",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"unsigned",
"StackAlignOverride",
",",
"bool",
"is64Bit",
")",
":",
"X86GenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"X86ProcFamily",
"(",
"Others",
")",
",",
"PICStyle",
"(",
"PICStyles",
"::",
"None",
")",
",",
"X86SSELevel",
"(",
"NoMMXSSE",
")",
",",
"X863DNowLevel",
"(",
"NoThreeDNow",
")",
",",
"HasCMov",
"(",
"false",
")",
",",
"HasX86_64",
"(",
"false",
")",
",",
"HasPOPCNT",
"(",
"false",
")",
",",
"HasSSE4A",
"(",
"false",
")",
",",
"HasAES",
"(",
"false",
")",
",",
"HasPCLMUL",
"(",
"false",
")",
",",
"HasFMA",
"(",
"false",
")",
",",
"HasFMA4",
"(",
"false",
")",
",",
"HasXOP",
"(",
"false",
")",
",",
"HasMOVBE",
"(",
"false",
")",
",",
"HasRDRAND",
"(",
"false",
")",
",",
"HasF16C",
"(",
"false",
")",
",",
"HasFSGSBase",
"(",
"false",
")",
",",
"HasLZCNT",
"(",
"false",
")",
",",
"HasBMI",
"(",
"false",
")",
",",
"HasBMI2",
"(",
"false",
")",
",",
"IsBTMemSlow",
"(",
"false",
")",
",",
"IsUAMemFast",
"(",
"false",
")",
",",
"HasVectorUAMem",
"(",
"false",
")",
",",
"HasCmpxchg16b",
"(",
"false",
")",
",",
"UseLeaForSP",
"(",
"false",
")",
",",
"PostRAScheduler",
"(",
"false",
")",
",",
"stackAlignment",
"(",
"4",
")",
",",
"MaxInlineSizeThreshold",
"(",
"128",
")",
",",
"TargetTriple",
"(",
"TT",
")",
",",
"In64BitMode",
"(",
"is64Bit",
")",
"{",
"std",
"::",
"string",
"CPUName",
"=",
"CPU",
";",
"if",
"(",
"!",
"FS",
".",
"empty",
"(",
")",
"||",
"!",
"CPU",
".",
"empty",
"(",
")",
")",
"{",
"if",
"(",
"CPUName",
".",
"empty",
"(",
")",
")",
"{",
"||",
"defined",
"(",
"__x86_64__",
")",
"||",
"defined",
"(",
"_M_AMD64",
")",
"||",
"defined",
"(",
"_M_X64",
")",
"CPUName",
"=",
"sys",
"::",
"getHostCPUName",
"(",
")",
";",
"CPUName",
"=",
"\"generic\"",
";",
"}",
"std",
"::",
"string",
"FullFS",
"=",
"FS",
";",
"if",
"(",
"In64BitMode",
")",
"{",
"if",
"(",
"!",
"FullFS",
".",
"empty",
"(",
")",
")",
"FullFS",
"=",
"\"+64bit,+sse2,\"",
"+",
"FullFS",
";",
"else",
"FullFS",
"=",
"\"+64bit,+sse2\"",
";",
"}",
"ParseSubtargetFeatures",
"(",
"CPUName",
",",
"FullFS",
")",
";",
"}",
"else",
"{",
"if",
"(",
"CPUName",
".",
"empty",
"(",
")",
")",
"{",
"CPUName",
"=",
"sys",
"::",
"getHostCPUName",
"(",
")",
";",
"CPUName",
"=",
"\"generic\"",
";",
"}",
"AutoDetectSubtargetFeatures",
"(",
")",
";",
"if",
"(",
"In64BitMode",
")",
"{",
"HasX86_64",
"=",
"true",
";",
"ToggleFeature",
"(",
"X86",
"::",
"Feature64Bit",
")",
";",
"HasCMov",
"=",
"true",
";",
"ToggleFeature",
"(",
"X86",
"::",
"FeatureCMOV",
")",
";",
"if",
"(",
"X86SSELevel",
"<",
"SSE2",
")",
"{",
"X86SSELevel",
"=",
"SSE2",
";",
"ToggleFeature",
"(",
"X86",
"::",
"FeatureSSE1",
")",
";",
"ToggleFeature",
"(",
"X86",
"::",
"FeatureSSE2",
")",
";",
"}",
"}",
"}",
"if",
"(",
"X86ProcFamily",
"==",
"IntelAtom",
")",
"{",
"PostRAScheduler",
"=",
"true",
";",
"InstrItins",
"=",
"getInstrItineraryForCPU",
"(",
"CPUName",
")",
";",
"}",
"if",
"(",
"In64BitMode",
")",
"ToggleFeature",
"(",
"X86",
"::",
"Mode64Bit",
")",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Subtarget features: SSELevel \"",
"<<",
"X86SSELevel",
"<<",
"\", 3DNowLevel \"",
"<<",
"X863DNowLevel",
"<<",
"\", 64bit \"",
"<<",
"HasX86_64",
"<<",
"\"\\n\"",
")",
";",
"assert",
"(",
"(",
"!",
"In64BitMode",
"||",
"HasX86_64",
")",
"&&",
"\"64-bit code requested on a subtarget that doesn't support it!\"",
")",
";",
"if",
"(",
"StackAlignOverride",
")",
"stackAlignment",
"=",
"StackAlignOverride",
";",
"else",
"if",
"(",
"isTargetDarwin",
"(",
")",
"||",
"isTargetFreeBSD",
"(",
")",
"||",
"isTargetLinux",
"(",
")",
"||",
"isTargetSolaris",
"(",
")",
"||",
"In64BitMode",
")",
"stackAlignment",
"=",
"16",
";",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"4",
"128",
"\"generic\"",
"\"+64bit,+sse2,\"",
"\"+64bit,+sse2\"",
"\"generic\"",
"X86",
"X86::Feature64Bit",
"X86::FeatureCMOV",
"X86",
"X86",
"X86::FeatureSSE1",
"X86::FeatureSSE2",
"X86",
"X86::Mode64Bit",
"\"Subtarget features: SSELevel \"",
"X86",
"\", 3DNowLevel \"",
"X86",
"\", 64bit \"",
"X86",
"\"\\n\"",
"X86",
"\"64-bit code requested on a subtarget that doesn't support it!\"",
"16"
] | X86Subtarget31 | X86Subtarget | X86 | CPU | LLVM | 16,947 | 475 | 1 | [] |
[
"<s>",
"bool",
"X86TargetLowering",
"::",
"isNarrowingProfitable",
"(",
"MVT",
"VT1",
",",
"MVT",
"VT2",
")",
"const",
"{",
"return",
"!",
"(",
"VT1",
"==",
"MVT",
"::",
"i32",
"&&",
"VT2",
"==",
"MVT",
"::",
"i16",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"it",
"'s",
"profitable",
"to",
"narrow",
"operations",
"of",
"type",
"SrcVT",
"to",
"DestVT",
"."
] | [
"X86",
"X86",
"MVT::i32",
"MVT::i16"
] | X86ISelLowering77 | isNarrowingProfitable | X86 | CPU | LLVM | 16,948 | 30 | 1 | [] |
[
"<s>",
"MCSymbol",
"*",
"ARM64MCInstLower",
"::",
"GetExternalSymbolSymbol",
"(",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
"{",
"return",
"Printer",
".",
"GetExternalSymbolSymbol",
"(",
"MO",
".",
"getSymbolName",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"MCSymbol",
"for",
"the",
"specified",
"ExternalSymbol",
"."
] | [
"ARM64",
"ARM64"
] | ARM64MCInstLower | GetExternalSymbolSymbol | ARM64 | CPU | LLVM | 16,949 | 26 | 1 | [] |
[
"<s>",
"bool",
"ARMAsmBackend",
"::",
"fixupNeedsRelaxation",
"(",
"const",
"MCFixup",
"&",
"Fixup",
",",
"uint64_t",
"Value",
",",
"const",
"MCInstFragment",
"*",
"DF",
",",
"const",
"MCAsmLayout",
"&",
"Layout",
")",
"const",
"{",
"switch",
"(",
"(",
"unsigned",
")",
"Fixup",
".",
"getKind",
"(",
")",
")",
"{",
"case",
"ARM",
"::",
"fixup_arm_thumb_bcc",
":",
"{",
"int64_t",
"Offset",
"=",
"int64_t",
"(",
"Value",
")",
"-",
"4",
";",
"return",
"Offset",
">",
"254",
"||",
"Offset",
"<",
"-",
"256",
";",
"}",
"case",
"ARM",
"::",
"fixup_thumb_adr_pcrel_10",
":",
"case",
"ARM",
"::",
"fixup_arm_thumb_cp",
":",
"{",
"int64_t",
"Offset",
"=",
"int64_t",
"(",
"Value",
")",
"-",
"4",
";",
"return",
"Offset",
">",
"1020",
"||",
"Offset",
"<",
"0",
"||",
"Offset",
"&",
"3",
";",
"}",
"}",
"llvm_unreachable",
"(",
"\"Unexpected fixup kind in fixupNeedsRelaxation()!\"",
")",
";",
"}",
"</s>"
] | [
"Simple",
"predicate",
"for",
"targets",
"where",
"!",
"Resolved",
"implies",
"requiring",
"relaxation",
"."
] | [
"ARM",
"ARM",
"ARM::fixup_arm_thumb_bcc",
"4",
"254",
"256",
"ARM::fixup_thumb_adr_pcrel_10",
"ARM::fixup_arm_thumb_cp",
"4",
"1020",
"0",
"3",
"\"Unexpected fixup kind in fixupNeedsRelaxation()!\""
] | ARMAsmBackend49 | fixupNeedsRelaxation | ARM | CPU | LLVM | 16,950 | 106 | 1 | [] |
[
"<s>",
"static",
"int",
"const_ok_for_op",
"(",
"HOST_WIDE_INT",
"i",
",",
"enum",
"rtx_code",
"code",
")",
"{",
"if",
"(",
"const_ok_for_arm",
"(",
"i",
")",
")",
"return",
"1",
";",
"switch",
"(",
"code",
")",
"{",
"case",
"PLUS",
":",
"return",
"const_ok_for_arm",
"(",
"ARM_SIGN_EXTEND",
"(",
"-",
"i",
")",
")",
";",
"case",
"MINUS",
":",
"case",
"XOR",
":",
"case",
"IOR",
":",
"return",
"0",
";",
"case",
"AND",
":",
"return",
"const_ok_for_arm",
"(",
"ARM_SIGN_EXTEND",
"(",
"~",
"i",
")",
")",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"I",
"is",
"a",
"valid",
"constant",
"for",
"the",
"operation",
"CODE",
"."
] | [
"arm",
"1",
"0"
] | arm3 | const_ok_for_op | arm | CPU | GCC | 16,951 | 73 | 1 | [] |
[
"<s>",
"void",
"SHUXIFrameLowering",
"::",
"emitEpilogue",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"}",
"</s>"
] | [
"Insert",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"SHUXI",
"SHUXI"
] | SHUXIFrameLowering | emitEpilogue | SHUXI | CPU | LLVM | 16,952 | 16 | 1 | [] |
[
"<s>",
"bool",
"HexagonInstrInfo",
"::",
"isValidOffset",
"(",
"const",
"int",
"Opcode",
",",
"const",
"int",
"Offset",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"Hexagon",
"::",
"LDriw",
":",
"case",
"Hexagon",
"::",
"STriw",
":",
"case",
"Hexagon",
"::",
"STriwt",
":",
"assert",
"(",
"(",
"Offset",
"%",
"4",
"==",
"0",
")",
"&&",
"\"Offset has incorrect alignment\"",
")",
";",
"return",
"(",
"Offset",
">=",
"Hexagon_MEMW_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_MEMW_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"LDrid",
":",
"case",
"Hexagon",
"::",
"STrid",
":",
"assert",
"(",
"(",
"Offset",
"%",
"8",
"==",
"0",
")",
"&&",
"\"Offset has incorrect alignment\"",
")",
";",
"return",
"(",
"Offset",
">=",
"Hexagon_MEMD_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_MEMD_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"LDrih",
":",
"case",
"Hexagon",
"::",
"LDriuh",
":",
"case",
"Hexagon",
"::",
"STrih",
":",
"case",
"Hexagon",
"::",
"LDrih_ae",
":",
"assert",
"(",
"(",
"Offset",
"%",
"2",
"==",
"0",
")",
"&&",
"\"Offset has incorrect alignment\"",
")",
";",
"return",
"(",
"Offset",
">=",
"Hexagon_MEMH_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_MEMH_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"LDrib",
":",
"case",
"Hexagon",
"::",
"STrib",
":",
"case",
"Hexagon",
"::",
"LDriub",
":",
"case",
"Hexagon",
"::",
"LDriubit",
":",
"case",
"Hexagon",
"::",
"LDrib_ae",
":",
"case",
"Hexagon",
"::",
"LDriub_ae",
":",
"return",
"(",
"Offset",
">=",
"Hexagon_MEMB_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_MEMB_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"ADD_ri",
":",
"case",
"Hexagon",
"::",
"TFR_FI",
":",
"return",
"(",
"Offset",
">=",
"Hexagon_ADDI_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_ADDI_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"MEMw_ADDSUBi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ADDi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_SUBi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ADDr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_SUBr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ANDr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ORr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ADDSUBi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ADDi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_SUBi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ADDr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_SUBr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ANDr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMw_ORr_MEM_V4",
":",
"assert",
"(",
"(",
"Offset",
"%",
"4",
")",
"==",
"0",
"&&",
"\"MEMOPw offset is not aligned correctly.\"",
")",
";",
"return",
"(",
"0",
"<=",
"Offset",
"&&",
"Offset",
"<=",
"255",
")",
";",
"case",
"Hexagon",
"::",
"MEMh_ADDSUBi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ADDi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_SUBi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ADDr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_SUBr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ANDr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ORr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ADDSUBi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ADDi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_SUBi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ADDr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_SUBr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ANDr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMh_ORr_MEM_V4",
":",
"assert",
"(",
"(",
"Offset",
"%",
"2",
")",
"==",
"0",
"&&",
"\"MEMOPh offset is not aligned correctly.\"",
")",
";",
"return",
"(",
"0",
"<=",
"Offset",
"&&",
"Offset",
"<=",
"127",
")",
";",
"case",
"Hexagon",
"::",
"MEMb_ADDSUBi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ADDi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_SUBi_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ADDr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_SUBr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ANDr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ORr_indexed_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ADDSUBi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ADDi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_SUBi_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ADDr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_SUBr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ANDr_MEM_V4",
":",
"case",
"Hexagon",
"::",
"MEMb_ORr_MEM_V4",
":",
"return",
"(",
"0",
"<=",
"Offset",
"&&",
"Offset",
"<=",
"63",
")",
";",
"case",
"Hexagon",
"::",
"STriw_pred",
":",
"case",
"Hexagon",
"::",
"LDriw_pred",
":",
"return",
"true",
";",
"case",
"Hexagon",
"::",
"INLINEASM",
":",
"return",
"true",
";",
"}",
"llvm_unreachable",
"(",
"\"No offset range is defined for this opcode. \"",
"\"Please define it in the above switch statement!\"",
")",
";",
"}",
"</s>"
] | [
"Test",
"the",
"validity",
"of",
"offset",
"."
] | [
"Hexagon",
"Hexagon",
"Hexagon::LDriw",
"Hexagon::STriw",
"Hexagon::STriwt",
"4",
"0",
"\"Offset has incorrect alignment\"",
"Hexagon",
"Hexagon",
"Hexagon::LDrid",
"Hexagon::STrid",
"8",
"0",
"\"Offset has incorrect alignment\"",
"Hexagon",
"Hexagon",
"Hexagon::LDrih",
"Hexagon::LDriuh",
"Hexagon::STrih",
"Hexagon::LDrih_ae",
"2",
"0",
"\"Offset has incorrect alignment\"",
"Hexagon",
"Hexagon",
"Hexagon::LDrib",
"Hexagon::STrib",
"Hexagon::LDriub",
"Hexagon::LDriubit",
"Hexagon::LDrib_ae",
"Hexagon::LDriub_ae",
"Hexagon",
"Hexagon",
"Hexagon::ADD_ri",
"Hexagon::TFR_FI",
"Hexagon",
"Hexagon",
"Hexagon::MEMw_ADDSUBi_indexed_MEM_V4",
"Hexagon::MEMw_ADDi_indexed_MEM_V4",
"Hexagon::MEMw_SUBi_indexed_MEM_V4",
"Hexagon::MEMw_ADDr_indexed_MEM_V4",
"Hexagon::MEMw_SUBr_indexed_MEM_V4",
"Hexagon::MEMw_ANDr_indexed_MEM_V4",
"Hexagon::MEMw_ORr_indexed_MEM_V4",
"Hexagon::MEMw_ADDSUBi_MEM_V4",
"Hexagon::MEMw_ADDi_MEM_V4",
"Hexagon::MEMw_SUBi_MEM_V4",
"Hexagon::MEMw_ADDr_MEM_V4",
"Hexagon::MEMw_SUBr_MEM_V4",
"Hexagon::MEMw_ANDr_MEM_V4",
"Hexagon::MEMw_ORr_MEM_V4",
"4",
"0",
"\"MEMOPw offset is not aligned correctly.\"",
"0",
"255",
"Hexagon::MEMh_ADDSUBi_indexed_MEM_V4",
"Hexagon::MEMh_ADDi_indexed_MEM_V4",
"Hexagon::MEMh_SUBi_indexed_MEM_V4",
"Hexagon::MEMh_ADDr_indexed_MEM_V4",
"Hexagon::MEMh_SUBr_indexed_MEM_V4",
"Hexagon::MEMh_ANDr_indexed_MEM_V4",
"Hexagon::MEMh_ORr_indexed_MEM_V4",
"Hexagon::MEMh_ADDSUBi_MEM_V4",
"Hexagon::MEMh_ADDi_MEM_V4",
"Hexagon::MEMh_SUBi_MEM_V4",
"Hexagon::MEMh_ADDr_MEM_V4",
"Hexagon::MEMh_SUBr_MEM_V4",
"Hexagon::MEMh_ANDr_MEM_V4",
"Hexagon::MEMh_ORr_MEM_V4",
"2",
"0",
"\"MEMOPh offset is not aligned correctly.\"",
"0",
"127",
"Hexagon::MEMb_ADDSUBi_indexed_MEM_V4",
"Hexagon::MEMb_ADDi_indexed_MEM_V4",
"Hexagon::MEMb_SUBi_indexed_MEM_V4",
"Hexagon::MEMb_ADDr_indexed_MEM_V4",
"Hexagon::MEMb_SUBr_indexed_MEM_V4",
"Hexagon::MEMb_ANDr_indexed_MEM_V4",
"Hexagon::MEMb_ORr_indexed_MEM_V4",
"Hexagon::MEMb_ADDSUBi_MEM_V4",
"Hexagon::MEMb_ADDi_MEM_V4",
"Hexagon::MEMb_SUBi_MEM_V4",
"Hexagon::MEMb_ADDr_MEM_V4",
"Hexagon::MEMb_SUBr_MEM_V4",
"Hexagon::MEMb_ANDr_MEM_V4",
"Hexagon::MEMb_ORr_MEM_V4",
"0",
"63",
"Hexagon::STriw_pred",
"Hexagon::LDriw_pred",
"Hexagon::INLINEASM",
"\"No offset range is defined for this opcode. \"",
"\"Please define it in the above switch statement!\""
] | HexagonInstrInfo57 | isValidOffset | Hexagon | DSP | LLVM | 16,953 | 507 | 1 | [] |
[
"<s>",
"static",
"void",
"arm_trampoline_init",
"(",
"rtx",
"m_tramp",
",",
"tree",
"fndecl",
",",
"rtx",
"chain_value",
")",
"{",
"rtx",
"fnaddr",
",",
"mem",
",",
"a_tramp",
";",
"emit_block_move",
"(",
"m_tramp",
",",
"assemble_trampoline_template",
"(",
")",
",",
"GEN_INT",
"(",
"TRAMPOLINE_SIZE",
")",
",",
"BLOCK_OP_NORMAL",
")",
";",
"mem",
"=",
"adjust_address",
"(",
"m_tramp",
",",
"SImode",
",",
"TARGET_32BIT",
"?",
"8",
":",
"12",
")",
";",
"emit_move_insn",
"(",
"mem",
",",
"chain_value",
")",
";",
"mem",
"=",
"adjust_address",
"(",
"m_tramp",
",",
"SImode",
",",
"TARGET_32BIT",
"?",
"12",
":",
"16",
")",
";",
"fnaddr",
"=",
"XEXP",
"(",
"DECL_RTL",
"(",
"fndecl",
")",
",",
"0",
")",
";",
"emit_move_insn",
"(",
"mem",
",",
"fnaddr",
")",
";",
"a_tramp",
"=",
"XEXP",
"(",
"m_tramp",
",",
"0",
")",
";",
"emit_library_call",
"(",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"\"__clear_cache\"",
")",
",",
"LCT_NORMAL",
",",
"VOIDmode",
",",
"a_tramp",
",",
"Pmode",
",",
"plus_constant",
"(",
"Pmode",
",",
"a_tramp",
",",
"TRAMPOLINE_SIZE",
")",
",",
"Pmode",
")",
";",
"}",
"</s>"
] | [
"Emit",
"RTL",
"insns",
"to",
"initialize",
"the",
"variable",
"parts",
"of",
"a",
"trampoline",
"."
] | [
"arm",
"8",
"12",
"12",
"16",
"0",
"0",
"\"__clear_cache\""
] | arm7 | arm_trampoline_init | arm | CPU | GCC | 16,954 | 132 | 1 | [] |
[
"<s>",
"static",
"int",
"v850_arg_partial_bytes",
"(",
"CUMULATIVE_ARGS",
"*",
"cum",
",",
"enum",
"machine_mode",
"mode",
",",
"tree",
"type",
",",
"bool",
"named",
")",
"{",
"int",
"size",
",",
"align",
";",
"if",
"(",
"TARGET_GHS",
"&&",
"!",
"named",
")",
"return",
"0",
";",
"if",
"(",
"mode",
"==",
"BLKmode",
")",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"else",
"size",
"=",
"GET_MODE_SIZE",
"(",
"mode",
")",
";",
"if",
"(",
"type",
")",
"align",
"=",
"TYPE_ALIGN",
"(",
"type",
")",
"/",
"BITS_PER_UNIT",
";",
"else",
"align",
"=",
"size",
";",
"cum",
"->",
"nbytes",
"=",
"(",
"cum",
"->",
"nbytes",
"+",
"align",
"-",
"1",
")",
"&",
"~",
"(",
"align",
"-",
"1",
")",
";",
"if",
"(",
"cum",
"->",
"nbytes",
">",
"4",
"*",
"UNITS_PER_WORD",
")",
"return",
"0",
";",
"if",
"(",
"cum",
"->",
"nbytes",
"+",
"size",
"<=",
"4",
"*",
"UNITS_PER_WORD",
")",
"return",
"0",
";",
"if",
"(",
"type",
"==",
"NULL_TREE",
"&&",
"cum",
"->",
"nbytes",
"+",
"size",
">",
"4",
"*",
"UNITS_PER_WORD",
")",
"return",
"0",
";",
"return",
"4",
"*",
"UNITS_PER_WORD",
"-",
"cum",
"->",
"nbytes",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"bytes",
"which",
"must",
"be",
"put",
"into",
"registers",
"for",
"values",
"which",
"are",
"part",
"in",
"registers",
"and",
"part",
"in",
"memory",
"."
] | [
"v850",
"0",
"1",
"1",
"4",
"0",
"4",
"0",
"4",
"0",
"4"
] | v8503 | v850_arg_partial_bytes | v850 | MPU | GCC | 16,955 | 151 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"restoreCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"DebugLoc",
"DL",
"=",
"DebugLoc",
"::",
"getUnknownLoc",
"(",
")",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"bool",
"is64Bit",
"=",
"TM",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
".",
"is64Bit",
"(",
")",
";",
"unsigned",
"Opc",
"=",
"is64Bit",
"?",
"X86",
"::",
"POP64r",
":",
"X86",
"::",
"POP32r",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"]",
".",
"getReg",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
",",
"Reg",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"restoreCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"restore",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"load",
"instructions",
"via",
"loadRegToStackSlot",
"(",
")",
"."
] | [
"X86",
"X86",
"X86",
"X86::POP64r",
"X86::POP32r",
"0"
] | X86InstrInfo101 | restoreCalleeSavedRegisters | X86 | CPU | LLVM | 16,956 | 149 | 1 | [] |
[
"<s>",
"void",
"X86TargetLowering",
"::",
"insertSSPDeclarations",
"(",
"Module",
"&",
"M",
")",
"const",
"{",
"if",
"(",
"Subtarget",
".",
"getTargetTriple",
"(",
")",
".",
"isWindowsMSVCEnvironment",
"(",
")",
"||",
"Subtarget",
".",
"getTargetTriple",
"(",
")",
".",
"isWindowsItaniumEnvironment",
"(",
")",
")",
"{",
"M",
".",
"getOrInsertGlobal",
"(",
"\"__security_cookie\"",
",",
"Type",
"::",
"getInt8PtrTy",
"(",
"M",
".",
"getContext",
"(",
")",
")",
")",
";",
"FunctionCallee",
"SecurityCheckCookie",
"=",
"M",
".",
"getOrInsertFunction",
"(",
"\"__security_check_cookie\"",
",",
"Type",
"::",
"getVoidTy",
"(",
"M",
".",
"getContext",
"(",
")",
")",
",",
"Type",
"::",
"getInt8PtrTy",
"(",
"M",
".",
"getContext",
"(",
")",
")",
")",
";",
"if",
"(",
"Function",
"*",
"F",
"=",
"dyn_cast",
"<",
"Function",
">",
"(",
"SecurityCheckCookie",
".",
"getCallee",
"(",
")",
")",
")",
"{",
"F",
"->",
"setCallingConv",
"(",
"CallingConv",
"::",
"X86_FastCall",
")",
";",
"F",
"->",
"addAttribute",
"(",
"1",
",",
"Attribute",
"::",
"AttrKind",
"::",
"InReg",
")",
";",
"}",
"return",
";",
"}",
"auto",
"GuardMode",
"=",
"getTargetMachine",
"(",
")",
".",
"Options",
".",
"StackProtectorGuard",
";",
"if",
"(",
"(",
"GuardMode",
"==",
"llvm",
"::",
"StackProtectorGuards",
"::",
"TLS",
"||",
"GuardMode",
"==",
"llvm",
"::",
"StackProtectorGuards",
"::",
"None",
")",
"&&",
"hasStackGuardSlotTLS",
"(",
"Subtarget",
".",
"getTargetTriple",
"(",
")",
")",
")",
"return",
";",
"TargetLowering",
"::",
"insertSSPDeclarations",
"(",
"M",
")",
";",
"}",
"</s>"
] | [
"Inserts",
"necessary",
"declarations",
"for",
"SSP",
"(",
"stack",
"protection",
")",
"purpose",
"."
] | [
"X86",
"X86",
"\"__security_cookie\"",
"\"__security_check_cookie\"",
"X86",
"1"
] | X86ISelLowering101 | insertSSPDeclarations | X86 | CPU | LLVM | 16,957 | 179 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"TOYTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"return",
"0",
";",
"case",
"TOYISD",
"::",
"CALL",
":",
"return",
"\"TOYISD::CALL\"",
";",
"case",
"TOYISD",
"::",
"BR_CC",
":",
"return",
"\"TOYISD::BR_CC\"",
";",
"case",
"TOYISD",
"::",
"CMPEQ",
":",
"return",
"\"TOYISD::CMPEQ\"",
";",
"case",
"TOYISD",
"::",
"CMPNE",
":",
"return",
"\"TOYISD::CMPNE\"",
";",
"case",
"TOYISD",
"::",
"CMPLT",
":",
"return",
"\"TOYISD::CMPLT\"",
";",
"case",
"TOYISD",
"::",
"CMPLE",
":",
"return",
"\"TOYISD::CMPLE\"",
";",
"case",
"TOYISD",
"::",
"CMPGT",
":",
"return",
"\"TOYISD::CMPGT\"",
";",
"case",
"TOYISD",
"::",
"CMPGE",
":",
"return",
"\"TOYISD::CMPGE\"",
";",
"case",
"TOYISD",
"::",
"RET_FLAG",
":",
"return",
"\"TOYIDS::RET_FLAG\"",
";",
"}",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"TOY",
"TOY",
"0",
"TOYISD::CALL",
"\"TOYISD::CALL\"",
"TOYISD::BR_CC",
"\"TOYISD::BR_CC\"",
"TOYISD::CMPEQ",
"\"TOYISD::CMPEQ\"",
"TOYISD::CMPNE",
"\"TOYISD::CMPNE\"",
"TOYISD::CMPLT",
"\"TOYISD::CMPLT\"",
"TOYISD::CMPLE",
"\"TOYISD::CMPLE\"",
"TOYISD::CMPGT",
"\"TOYISD::CMPGT\"",
"TOYISD::CMPGE",
"\"TOYISD::CMPGE\"",
"TOYISD::RET_FLAG",
"\"TOYIDS::RET_FLAG\""
] | TOYISelDAGToDAG | getTargetNodeName | TOY | CPU | LLVM | 16,958 | 96 | 1 | [] |
[
"<s>",
"virtual",
"const",
"X86Subtarget",
"*",
"getSubtargetImpl",
"(",
")",
"const",
"{",
"return",
"&",
"Subtarget",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"X86",
"X86"
] | X86TargetMachine13 | getSubtargetImpl | X86 | CPU | LLVM | 16,959 | 14 | 1 | [] |
[
"<s>",
"bool",
"tilepro_expand_addsi",
"(",
"rtx",
"op0",
",",
"rtx",
"op1",
",",
"rtx",
"op2",
")",
"{",
"rtx",
"temp",
";",
"HOST_WIDE_INT",
"n",
";",
"HOST_WIDE_INT",
"high",
";",
"if",
"(",
"add_operand",
"(",
"op2",
",",
"SImode",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"op2",
")",
")",
"return",
"false",
";",
"temp",
"=",
"create_temp_reg_if_possible",
"(",
"SImode",
",",
"op0",
")",
";",
"n",
"=",
"INTVAL",
"(",
"op2",
")",
";",
"high",
"=",
"(",
"n",
"+",
"(",
"n",
"&",
"0x8000",
")",
")",
"&",
"~",
"0xffff",
";",
"emit_move_insn",
"(",
"temp",
",",
"gen_rtx_PLUS",
"(",
"SImode",
",",
"op1",
",",
"gen_int_si",
"(",
"high",
")",
")",
")",
";",
"emit_move_insn",
"(",
"op0",
",",
"gen_rtx_PLUS",
"(",
"SImode",
",",
"temp",
",",
"gen_int_si",
"(",
"n",
"-",
"high",
")",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Implement",
"the",
"addsi3",
"pattern",
"."
] | [
"tilepro",
"0x8000",
"0xffff"
] | tilepro | tilepro_expand_addsi | tilepro | VLIW | GCC | 16,960 | 116 | 1 | [] |
[
"<s>",
"unsigned",
"HexagonTTIImpl",
"::",
"getArithmeticInstrCost",
"(",
"unsigned",
"Opcode",
",",
"Type",
"*",
"Ty",
",",
"TTI",
"::",
"OperandValueKind",
"Opd1Info",
",",
"TTI",
"::",
"OperandValueKind",
"Opd2Info",
",",
"TTI",
"::",
"OperandValueProperties",
"Opd1PropInfo",
",",
"TTI",
"::",
"OperandValueProperties",
"Opd2PropInfo",
",",
"ArrayRef",
"<",
"const",
"Value",
"*",
">",
"Args",
")",
"{",
"return",
"BaseT",
"::",
"getArithmeticInstrCost",
"(",
"Opcode",
",",
"Ty",
",",
"Opd1Info",
",",
"Opd2Info",
",",
"Opd1PropInfo",
",",
"Opd2PropInfo",
",",
"Args",
")",
";",
"}",
"</s>"
] | [
"This",
"is",
"an",
"approximation",
"of",
"reciprocal",
"throughput",
"of",
"a",
"math/logic",
"op",
"."
] | [
"Hexagon",
"Hexagon"
] | HexagonTargetTransformInfo12 | getArithmeticInstrCost | Hexagon | DSP | LLVM | 16,961 | 62 | 1 | [] |
[
"<s>",
"static",
"void",
"add_constant",
"(",
"int",
"dest",
",",
"int",
"src",
",",
"int",
"value",
",",
"int",
"mark_frame",
")",
"{",
"rtx_insn",
"*",
"insn",
";",
"int",
"hi",
",",
"lo",
";",
"if",
"(",
"src",
"==",
"dest",
"&&",
"value",
"==",
"0",
")",
"return",
";",
"if",
"(",
"value",
"==",
"0",
")",
"{",
"insn",
"=",
"emit_move_insn",
"(",
"gen_rtx_REG",
"(",
"SImode",
",",
"dest",
")",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"src",
")",
")",
";",
"if",
"(",
"mark_frame",
")",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"return",
";",
"}",
"if",
"(",
"value",
">=",
"-",
"32768",
"&&",
"value",
"<=",
"32767",
")",
"{",
"insn",
"=",
"emit_insn",
"(",
"gen_addsi3",
"(",
"gen_rtx_REG",
"(",
"SImode",
",",
"dest",
")",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"src",
")",
",",
"GEN_INT",
"(",
"value",
")",
")",
")",
";",
"if",
"(",
"mark_frame",
")",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"return",
";",
"}",
"hi",
"=",
"trunc_int_for_mode",
"(",
"value",
"&",
"0xffff0000",
",",
"SImode",
")",
";",
"lo",
"=",
"value",
"&",
"0xffff",
";",
"insn",
"=",
"emit_move_insn",
"(",
"gen_rtx_REG",
"(",
"SImode",
",",
"REGSAVE_CONTROL_TEMP",
")",
",",
"GEN_INT",
"(",
"hi",
")",
")",
";",
"if",
"(",
"lo",
")",
"{",
"insn",
"=",
"emit_insn",
"(",
"gen_iorsi3",
"(",
"gen_rtx_REG",
"(",
"SImode",
",",
"REGSAVE_CONTROL_TEMP",
")",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"REGSAVE_CONTROL_TEMP",
")",
",",
"GEN_INT",
"(",
"lo",
")",
")",
")",
";",
"}",
"insn",
"=",
"emit_insn",
"(",
"gen_addsi3",
"(",
"gen_rtx_REG",
"(",
"SImode",
",",
"dest",
")",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"src",
")",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"REGSAVE_CONTROL_TEMP",
")",
")",
")",
";",
"if",
"(",
"mark_frame",
")",
"{",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"1",
";",
"add_reg_note",
"(",
"insn",
",",
"REG_FRAME_RELATED_EXPR",
",",
"gen_rtx_SET",
"(",
"SImode",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"dest",
")",
",",
"gen_rtx_PLUS",
"(",
"SImode",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"dest",
")",
",",
"GEN_INT",
"(",
"value",
")",
")",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Add",
"a",
"constant",
"to",
"the",
"pool",
"and",
"return",
"its",
"label",
"."
] | [
"mep",
"0",
"0",
"1",
"32768",
"32767",
"1",
"0xffff0000",
"0xffff",
"1"
] | mep | add_constant | mep | CPU | GCC | 16,962 | 277 | 1 | [] |
[
"<s>",
"bool",
"BlackfinAsmPrinter",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"SetupMachineFunction",
"(",
"MF",
")",
";",
"EmitConstantPool",
"(",
"MF",
".",
"getConstantPool",
"(",
")",
")",
";",
"EmitJumpTableInfo",
"(",
"MF",
".",
"getJumpTableInfo",
"(",
")",
",",
"MF",
")",
";",
"const",
"Function",
"*",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"OutStreamer",
".",
"SwitchSection",
"(",
"getObjFileLowering",
"(",
")",
".",
"SectionForGlobal",
"(",
"F",
",",
"Mang",
",",
"TM",
")",
")",
";",
"EmitAlignment",
"(",
"2",
",",
"F",
")",
";",
"emitLinkage",
"(",
"CurrentFnName",
",",
"F",
"->",
"getLinkage",
"(",
")",
")",
";",
"printVisibility",
"(",
"CurrentFnName",
",",
"F",
"->",
"getVisibility",
"(",
")",
")",
";",
"O",
"<<",
"\"\\t.type\\t\"",
"<<",
"CurrentFnName",
"<<",
"\", STT_FUNC\\n\"",
"<<",
"CurrentFnName",
"<<",
"\":\\n\"",
";",
"if",
"(",
"DW",
")",
"DW",
"->",
"BeginFunction",
"(",
"&",
"MF",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"const_iterator",
"I",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"!",
"VerboseAsm",
"&&",
"(",
"I",
"->",
"pred_empty",
"(",
")",
"||",
"I",
"->",
"isOnlyReachableByFallthrough",
"(",
")",
")",
")",
"{",
"}",
"else",
"{",
"printBasicBlockLabel",
"(",
"I",
",",
"true",
",",
"true",
",",
"VerboseAsm",
")",
";",
"O",
"<<",
"'\\n'",
";",
"}",
"for",
"(",
"MachineBasicBlock",
"::",
"const_iterator",
"II",
"=",
"I",
"->",
"begin",
"(",
")",
",",
"E",
"=",
"I",
"->",
"end",
"(",
")",
";",
"II",
"!=",
"E",
";",
"++",
"II",
")",
"{",
"printInstruction",
"(",
"II",
")",
";",
"++",
"EmittedInsts",
";",
"}",
"}",
"O",
"<<",
"\"\\t.size \"",
"<<",
"CurrentFnName",
"<<",
"\", .-\"",
"<<",
"CurrentFnName",
"<<",
"\"\\n\"",
";",
"if",
"(",
"DW",
")",
"DW",
"->",
"EndFunction",
"(",
"&",
"MF",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"Blackfin",
"2",
"\"\\t.type\\t\"",
"\", STT_FUNC\\n\"",
"\":\\n\"",
"\"\\t.size \"",
"\", .-\"",
"\"\\n\""
] | BlackfinAsmPrinter1 | runOnMachineFunction | Blackfin | DSP | LLVM | 16,963 | 252 | 1 | [] |
[
"<s>",
"bool",
"X86IndirectThunks",
"::",
"doInitialization",
"(",
"Module",
"&",
"M",
")",
"{",
"initTIs",
"(",
"M",
",",
"TIs",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Set",
"up",
"the",
"AsmPrinter",
"when",
"we",
"are",
"working",
"on",
"a",
"new",
"module",
"."
] | [
"X86",
"X86"
] | X86IndirectThunks | doInitialization | X86 | CPU | LLVM | 16,964 | 21 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAnnotateUniformValues",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"F",
")",
")",
"return",
"false",
";",
"DA",
"=",
"&",
"getAnalysis",
"<",
"DivergenceAnalysis",
">",
"(",
")",
";",
"MDR",
"=",
"&",
"getAnalysis",
"<",
"MemoryDependenceWrapperPass",
">",
"(",
")",
".",
"getMemDep",
"(",
")",
";",
"LI",
"=",
"&",
"getAnalysis",
"<",
"LoopInfoWrapperPass",
">",
"(",
")",
".",
"getLoopInfo",
"(",
")",
";",
"isKernelFunc",
"=",
"F",
".",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"AMDGPU_KERNEL",
";",
"visit",
"(",
"F",
")",
";",
"noClobberClones",
".",
"clear",
"(",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] | [
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | AMDGPUAnnotateUniformValues17 | runOnFunction | AMDGPU | GPU | LLVM | 16,965 | 85 | 1 | [] |
[
"<s>",
"static",
"bool",
"bpf_core_is_maybe_aggregate_access",
"(",
"tree",
"expr",
")",
"{",
"switch",
"(",
"TREE_CODE",
"(",
"expr",
")",
")",
"{",
"case",
"COMPONENT_REF",
":",
"case",
"BIT_FIELD_REF",
":",
"case",
"ARRAY_REF",
":",
"case",
"ARRAY_RANGE_REF",
":",
"return",
"true",
";",
"case",
"ADDR_EXPR",
":",
"case",
"NOP_EXPR",
":",
"return",
"bpf_core_is_maybe_aggregate_access",
"(",
"TREE_OPERAND",
"(",
"expr",
",",
"0",
")",
")",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"</s>"
] | [
"Return",
"whether",
"EXPR",
"could",
"access",
"some",
"aggregate",
"data",
"structure",
"that",
"BPF",
"CO-RE",
"support",
"needs",
"to",
"know",
"about",
"."
] | [
"bpf",
"0"
] | bpf1 | bpf_core_is_maybe_aggregate_access | bpf | Virtual ISA | GCC | 16,966 | 55 | 1 | [] |
[
"<s>",
"OperandMatchResultTy",
"BPFAsmParser",
"::",
"tryParseRegister",
"(",
"unsigned",
"&",
"RegNo",
",",
"SMLoc",
"&",
"StartLoc",
",",
"SMLoc",
"&",
"EndLoc",
")",
"{",
"const",
"AsmToken",
"&",
"Tok",
"=",
"getParser",
"(",
")",
".",
"getTok",
"(",
")",
";",
"StartLoc",
"=",
"Tok",
".",
"getLoc",
"(",
")",
";",
"EndLoc",
"=",
"Tok",
".",
"getEndLoc",
"(",
")",
";",
"RegNo",
"=",
"0",
";",
"StringRef",
"Name",
"=",
"getLexer",
"(",
")",
".",
"getTok",
"(",
")",
".",
"getIdentifier",
"(",
")",
";",
"if",
"(",
"!",
"MatchRegisterName",
"(",
"Name",
")",
")",
"{",
"getParser",
"(",
")",
".",
"Lex",
"(",
")",
";",
"return",
"MatchOperand_Success",
";",
"}",
"return",
"MatchOperand_NoMatch",
";",
"}",
"</s>"
] | [
"tryParseRegister",
"-",
"parse",
"one",
"register",
"if",
"possible"
] | [
"BPF",
"BPF",
"0"
] | BPFAsmParser1 | tryParseRegister | BPF | Virtual ISA | LLVM | 16,967 | 91 | 1 | [] |
[
"<s>",
"uint64_t",
"PPCFrameLowering",
"::",
"determineFrameLayout",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"bool",
"UseEstimate",
",",
"unsigned",
"*",
"NewMaxCallFrameSize",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"PPCFunctionInfo",
"*",
"FI",
"=",
"MF",
".",
"getInfo",
"<",
"PPCFunctionInfo",
">",
"(",
")",
";",
"uint64_t",
"FrameSize",
"=",
"UseEstimate",
"?",
"MFI",
".",
"estimateStackSize",
"(",
"MF",
")",
":",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"Align",
"TargetAlign",
"=",
"getStackAlign",
"(",
")",
";",
"Align",
"MaxAlign",
"=",
"MFI",
".",
"getMaxAlign",
"(",
")",
";",
"Align",
"Alignment",
"=",
"std",
"::",
"max",
"(",
"TargetAlign",
",",
"MaxAlign",
")",
";",
"const",
"PPCRegisterInfo",
"*",
"RegInfo",
"=",
"Subtarget",
".",
"getRegisterInfo",
"(",
")",
";",
"unsigned",
"LR",
"=",
"RegInfo",
"->",
"getRARegister",
"(",
")",
";",
"bool",
"DisableRedZone",
"=",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"NoRedZone",
")",
";",
"bool",
"CanUseRedZone",
"=",
"!",
"MFI",
".",
"hasVarSizedObjects",
"(",
")",
"&&",
"!",
"MFI",
".",
"adjustsStack",
"(",
")",
"&&",
"!",
"MustSaveLR",
"(",
"MF",
",",
"LR",
")",
"&&",
"!",
"FI",
"->",
"mustSaveTOC",
"(",
")",
"&&",
"!",
"RegInfo",
"->",
"hasBasePointer",
"(",
"MF",
")",
";",
"bool",
"FitsInRedZone",
"=",
"FrameSize",
"<=",
"Subtarget",
".",
"getRedZoneSize",
"(",
")",
";",
"if",
"(",
"!",
"DisableRedZone",
"&&",
"CanUseRedZone",
"&&",
"FitsInRedZone",
")",
"{",
"return",
"0",
";",
"}",
"unsigned",
"maxCallFrameSize",
"=",
"MFI",
".",
"getMaxCallFrameSize",
"(",
")",
";",
"unsigned",
"minCallFrameSize",
"=",
"getLinkageSize",
"(",
")",
";",
"maxCallFrameSize",
"=",
"std",
"::",
"max",
"(",
"maxCallFrameSize",
",",
"minCallFrameSize",
")",
";",
"if",
"(",
"MFI",
".",
"hasVarSizedObjects",
"(",
")",
")",
"maxCallFrameSize",
"=",
"alignTo",
"(",
"maxCallFrameSize",
",",
"Alignment",
")",
";",
"if",
"(",
"NewMaxCallFrameSize",
")",
"*",
"NewMaxCallFrameSize",
"=",
"maxCallFrameSize",
";",
"FrameSize",
"+=",
"maxCallFrameSize",
";",
"FrameSize",
"=",
"alignTo",
"(",
"FrameSize",
",",
"Alignment",
")",
";",
"return",
"FrameSize",
";",
"}",
"</s>"
] | [
"Determine",
"the",
"frame",
"layout",
"but",
"do",
"not",
"update",
"the",
"machine",
"function",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC",
"PPC",
"0"
] | PPCFrameLowering16 | determineFrameLayout | PowerPC | CPU | LLVM | 16,968 | 261 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_add_new_builtins",
"(",
"HOST_WIDE_INT",
"isa",
")",
"{",
"if",
"(",
"(",
"isa",
"&",
"deferred_isa_values",
")",
"==",
"0",
")",
"return",
";",
"deferred_isa_values",
"&=",
"~",
"isa",
";",
"int",
"i",
";",
"tree",
"saved_current_target_pragma",
"=",
"current_target_pragma",
";",
"current_target_pragma",
"=",
"NULL_TREE",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"(",
"int",
")",
"IX86_BUILTIN_MAX",
";",
"i",
"++",
")",
"{",
"if",
"(",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"isa",
"&",
"isa",
")",
"!=",
"0",
"&&",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"set_and_not_built_p",
")",
"{",
"tree",
"decl",
",",
"type",
";",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"set_and_not_built_p",
"=",
"false",
";",
"type",
"=",
"ix86_get_builtin_func_type",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"tcode",
")",
";",
"decl",
"=",
"add_builtin_function_ext_scope",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"name",
",",
"type",
",",
"i",
",",
"BUILT_IN_MD",
",",
"NULL",
",",
"NULL_TREE",
")",
";",
"ix86_builtins",
"[",
"i",
"]",
"=",
"decl",
";",
"if",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"const_p",
")",
"TREE_READONLY",
"(",
"decl",
")",
"=",
"1",
";",
"if",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"leaf_p",
")",
"DECL_ATTRIBUTES",
"(",
"decl",
")",
"=",
"build_tree_list",
"(",
"get_identifier",
"(",
"\"leaf\"",
")",
",",
"NULL_TREE",
")",
";",
"if",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"nothrow_p",
")",
"TREE_NOTHROW",
"(",
"decl",
")",
"=",
"1",
";",
"}",
"}",
"current_target_pragma",
"=",
"saved_current_target_pragma",
";",
"}",
"</s>"
] | [
"Add",
"any",
"new",
"builtin",
"functions",
"for",
"a",
"given",
"ISA",
"that",
"may",
"not",
"have",
"been",
"declared",
".",
"This",
"saves",
"a",
"bit",
"of",
"space",
"compared",
"to",
"adding",
"all",
"of",
"the",
"declarations",
"to",
"the",
"tree",
",",
"even",
"if",
"we",
"did",
"n't",
"use",
"them",
"."
] | [
"i386",
"0",
"0",
"0",
"1",
"\"leaf\"",
"1"
] | i3864 | ix86_add_new_builtins | i386 | CPU | GCC | 16,969 | 195 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"ptrreg_to_str",
"(",
"int",
"regno",
")",
"{",
"switch",
"(",
"regno",
")",
"{",
"case",
"REG_X",
":",
"return",
"\"X\"",
";",
"case",
"REG_Y",
":",
"return",
"\"Y\"",
";",
"case",
"REG_Z",
":",
"return",
"\"Z\"",
";",
"default",
":",
"output_operand_lossage",
"(",
"\"address operand requires constraint for\"",
"\" X, Y, or Z register\"",
")",
";",
"}",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"Return",
"a",
"pointer",
"register",
"name",
"as",
"a",
"string"
] | [
"avr",
"\"X\"",
"\"Y\"",
"\"Z\"",
"\"address operand requires constraint for\"",
"\" X, Y, or Z register\""
] | avr | ptrreg_to_str | avr | MPU | GCC | 16,970 | 46 | 1 | [] |
[
"<s>",
"void",
"Z80InstPrinterBase",
"::",
"printInst",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"raw_ostream",
"&",
"OS",
",",
"StringRef",
"Annot",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"{",
"printInstruction",
"(",
"MI",
",",
"OS",
")",
";",
"printAnnotation",
"(",
"OS",
",",
"Annot",
")",
";",
"}",
"</s>"
] | [
"Print",
"the",
"specified",
"MCInst",
"to",
"the",
"specified",
"raw_ostream",
"."
] | [
"Z80",
"Z80"
] | Z80InstPrinterBase | printInst | Z80 | MPU | LLVM | 16,971 | 38 | 1 | [] |
[
"<s>",
"static",
"bool",
"sparc_handle_option",
"(",
"size_t",
"code",
",",
"const",
"char",
"*",
"arg",
",",
"int",
"value",
"ATTRIBUTE_UNUSED",
")",
"{",
"switch",
"(",
"code",
")",
"{",
"case",
"OPT_mfpu",
":",
"case",
"OPT_mhard_float",
":",
"case",
"OPT_msoft_float",
":",
"fpu_option_set",
"=",
"true",
";",
"break",
";",
"case",
"OPT_mcpu_",
":",
"sparc_select",
"[",
"1",
"]",
".",
"string",
"=",
"arg",
";",
"break",
";",
"case",
"OPT_mtune_",
":",
"sparc_select",
"[",
"2",
"]",
".",
"string",
"=",
"arg",
";",
"break",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_HANDLE_OPTION",
"."
] | [
"sparc",
"1",
"2"
] | sparc3 | sparc_handle_option | sparc | CPU | GCC | 16,972 | 70 | 1 | [] |
[
"<s>",
"static",
"void",
"unicosmk_output_dex",
"(",
"FILE",
"*",
"file",
")",
"{",
"struct",
"unicosmk_dex",
"*",
"dex",
";",
"int",
"i",
";",
"if",
"(",
"unicosmk_dex_list",
"==",
"NULL",
")",
"return",
";",
"fprintf",
"(",
"file",
",",
"\"\\t.dexstart\\n\"",
")",
";",
"i",
"=",
"unicosmk_dex_count",
";",
"for",
"(",
"dex",
"=",
"unicosmk_dex_list",
";",
"dex",
";",
"dex",
"=",
"dex",
"->",
"next",
")",
"{",
"fprintf",
"(",
"file",
",",
"\"\\tDEX (%d) = \"",
",",
"i",
")",
";",
"assemble_name",
"(",
"file",
",",
"dex",
"->",
"name",
")",
";",
"putc",
"(",
"'\\n'",
",",
"file",
")",
";",
"--",
"i",
";",
"}",
"fprintf",
"(",
"file",
",",
"\"\\t.dexend\\n\"",
")",
";",
"}",
"</s>"
] | [
"Output",
"the",
"DEX",
"definitions",
"for",
"this",
"file",
"."
] | [
"alpha",
"\"\\t.dexstart\\n\"",
"\"\\tDEX (%d) = \"",
"\"\\t.dexend\\n\""
] | alpha3 | unicosmk_output_dex | alpha | MPU | GCC | 16,973 | 88 | 1 | [] |
[
"<s>",
"static",
"void",
"s390_chunkify_finish",
"(",
"struct",
"constant_pool",
"*",
"pool_list",
")",
"{",
"struct",
"constant_pool",
"*",
"curr_pool",
"=",
"NULL",
";",
"rtx_insn",
"*",
"insn",
";",
"for",
"(",
"insn",
"=",
"get_insns",
"(",
")",
";",
"insn",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"INSN_P",
"(",
"insn",
")",
")",
"replace_ltrel_base",
"(",
"&",
"PATTERN",
"(",
"insn",
")",
")",
";",
"curr_pool",
"=",
"s390_find_pool",
"(",
"pool_list",
",",
"insn",
")",
";",
"if",
"(",
"!",
"curr_pool",
")",
"continue",
";",
"if",
"(",
"NONJUMP_INSN_P",
"(",
"insn",
")",
"||",
"CALL_P",
"(",
"insn",
")",
")",
"{",
"rtx",
"addr",
",",
"pool_ref",
"=",
"NULL_RTX",
";",
"find_constant_pool_ref",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"&",
"pool_ref",
")",
";",
"if",
"(",
"pool_ref",
")",
"{",
"if",
"(",
"s390_execute_label",
"(",
"insn",
")",
")",
"addr",
"=",
"s390_find_execute",
"(",
"curr_pool",
",",
"insn",
")",
";",
"else",
"addr",
"=",
"s390_find_constant",
"(",
"curr_pool",
",",
"get_pool_constant",
"(",
"pool_ref",
")",
",",
"get_pool_mode",
"(",
"pool_ref",
")",
")",
";",
"replace_constant_pool_ref",
"(",
"&",
"PATTERN",
"(",
"insn",
")",
",",
"pool_ref",
",",
"addr",
")",
";",
"INSN_CODE",
"(",
"insn",
")",
"=",
"-",
"1",
";",
"}",
"}",
"}",
"for",
"(",
"curr_pool",
"=",
"pool_list",
";",
"curr_pool",
";",
"curr_pool",
"=",
"curr_pool",
"->",
"next",
")",
"s390_dump_pool",
"(",
"curr_pool",
",",
"0",
")",
";",
"while",
"(",
"pool_list",
")",
"{",
"struct",
"constant_pool",
"*",
"next",
"=",
"pool_list",
"->",
"next",
";",
"s390_free_pool",
"(",
"pool_list",
")",
";",
"pool_list",
"=",
"next",
";",
"}",
"}",
"</s>"
] | [
"POOL_LIST",
"is",
"a",
"chunk",
"list",
"as",
"prepared",
"by",
"s390_chunkify_start",
".",
"After",
"we",
"have",
"decided",
"to",
"use",
"this",
"list",
",",
"finish",
"implementing",
"all",
"changes",
"to",
"the",
"current",
"function",
"as",
"required",
"."
] | [
"s390",
"1",
"0"
] | s3904 | s390_chunkify_finish | s390 | MPU | GCC | 16,974 | 211 | 1 | [] |
[
"<s>",
"void",
"Cpu0AsmPrinter",
"::",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
"{",
"if",
"(",
"MI",
"->",
"isDebugValue",
"(",
")",
")",
"{",
"SmallString",
"<",
"128",
">",
"Str",
";",
"raw_svector_ostream",
"OS",
"(",
"Str",
")",
";",
"PrintDebugValueComment",
"(",
"MI",
",",
"OS",
")",
";",
"return",
";",
"}",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"I",
"=",
"MI",
"->",
"getIterator",
"(",
")",
";",
"MachineBasicBlock",
"::",
"const_instr_iterator",
"E",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"instr_end",
"(",
")",
";",
"do",
"{",
"if",
"(",
"emitPseudoExpansionLowering",
"(",
"*",
"OutStreamer",
",",
"&",
"*",
"I",
")",
")",
"continue",
";",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"==",
"Cpu0",
"::",
"CPRESTORE",
")",
"{",
"emitPseudoCPRestore",
"(",
"*",
"OutStreamer",
",",
"&",
"*",
"I",
")",
";",
"continue",
";",
"}",
"if",
"(",
"I",
"->",
"isPseudo",
"(",
")",
"&&",
"!",
"isLongBranchPseudo",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
")",
"llvm_unreachable",
"(",
"\"Pseudo opcode found in EmitInstruction()\"",
")",
";",
"MCInst",
"TmpInst0",
";",
"MCInstLowering",
".",
"Lower",
"(",
"&",
"*",
"I",
",",
"TmpInst0",
")",
";",
"OutStreamer",
"->",
"EmitInstruction",
"(",
"TmpInst0",
",",
"getSubtargetInfo",
"(",
")",
")",
";",
"}",
"while",
"(",
"(",
"++",
"I",
"!=",
"E",
")",
"&&",
"I",
"->",
"isInsideBundle",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"Cpu0",
"Cpu0",
"128",
"Cpu0::CPRESTORE",
"\"Pseudo opcode found in EmitInstruction()\""
] | Cpu0AsmPrinter | EmitInstruction | Cpu0 | CPU | LLVM | 16,975 | 176 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"MSP430TargetLowering",
"::",
"LowerCallResult",
"(",
"SDValue",
"Chain",
",",
"SDValue",
"InFlag",
",",
"CallSDNode",
"*",
"TheCall",
",",
"unsigned",
"CallingConv",
",",
"SelectionDAG",
"&",
"DAG",
")",
"{",
"bool",
"isVarArg",
"=",
"TheCall",
"->",
"isVarArg",
"(",
")",
";",
"DebugLoc",
"dl",
"=",
"TheCall",
"->",
"getDebugLoc",
"(",
")",
";",
"SmallVector",
"<",
"CCValAssign",
",",
"16",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallingConv",
",",
"isVarArg",
",",
"getTargetMachine",
"(",
")",
",",
"RVLocs",
")",
";",
"CCInfo",
".",
"AnalyzeCallResult",
"(",
"TheCall",
",",
"RetCC_MSP430",
")",
";",
"SmallVector",
"<",
"SDValue",
",",
"8",
">",
"ResultVals",
";",
"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",
")",
";",
"ResultVals",
".",
"push_back",
"(",
"Chain",
".",
"getValue",
"(",
"0",
")",
")",
";",
"}",
"ResultVals",
".",
"push_back",
"(",
"Chain",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"MERGE_VALUES",
",",
"dl",
",",
"TheCall",
"->",
"getVTList",
"(",
")",
",",
"&",
"ResultVals",
"[",
"0",
"]",
",",
"ResultVals",
".",
"size",
"(",
")",
")",
".",
"getNode",
"(",
")",
";",
"}",
"</s>"
] | [
"LowerCallResult",
"-",
"Lower",
"the",
"result",
"values",
"of",
"an",
"ISD",
":",
":CALL",
"into",
"the",
"appropriate",
"copies",
"out",
"of",
"appropriate",
"physical",
"registers",
"."
] | [
"MSP430",
"MSP430",
"16",
"MSP430",
"8",
"0",
"1",
"2",
"0",
"ISD::MERGE_VALUES",
"0"
] | MSP430ISelLowering22 | LowerCallResult | MSP430 | MPU | LLVM | 16,976 | 200 | 1 | [] |
[
"<s>",
"bool",
"Cpu0InstrInfo",
"::",
"expandPostRAPseudo",
"(",
"MachineBasicBlock",
"::",
"iterator",
"MI",
")",
"const",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
"->",
"getParent",
"(",
")",
";",
"switch",
"(",
"MI",
"->",
"getDesc",
"(",
")",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"}",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"This",
"function",
"is",
"called",
"for",
"all",
"pseudo",
"instructions",
"that",
"remain",
"after",
"register",
"allocation",
"."
] | [
"Cpu0",
"Cpu0"
] | Cpu0InstrInfo1 | expandPostRAPseudo | Cpu0 | CPU | LLVM | 16,977 | 53 | 1 | [] |
[
"<s>",
"SDValue",
"AMDGPUTargetLowering",
"::",
"CreateLiveInRegister",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"unsigned",
"Reg",
",",
"EVT",
"VT",
",",
"const",
"SDLoc",
"&",
"SL",
",",
"bool",
"RawReg",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"unsigned",
"VReg",
";",
"if",
"(",
"!",
"MRI",
".",
"isLiveIn",
"(",
"Reg",
")",
")",
"{",
"VReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"RC",
")",
";",
"MRI",
".",
"addLiveIn",
"(",
"Reg",
",",
"VReg",
")",
";",
"}",
"else",
"{",
"VReg",
"=",
"MRI",
".",
"getLiveInVirtReg",
"(",
"Reg",
")",
";",
"}",
"if",
"(",
"RawReg",
")",
"return",
"DAG",
".",
"getRegister",
"(",
"VReg",
",",
"VT",
")",
";",
"return",
"DAG",
".",
"getCopyFromReg",
"(",
"DAG",
".",
"getEntryNode",
"(",
")",
",",
"SL",
",",
"VReg",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"that",
"adds",
"Reg",
"to",
"the",
"LiveIn",
"list",
"of",
"the",
"DAG",
"'s",
"MachineFunction",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPUISelLowering (2)2 | CreateLiveInRegister | AMDGPU | GPU | LLVM | 16,978 | 128 | 1 | [] |
[
"<s>",
"bool",
"NyuziAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"ParseDirective",
"-",
"Parse",
"a",
"target",
"specific",
"assembler",
"directive",
"This",
"method",
"is",
"deprecated",
",",
"use",
"'parseDirective",
"'",
"instead",
"."
] | [
"Nyuzi",
"Nyuzi"
] | NyuziAsmParser | ParseDirective | Nyuzi | GPU | LLVM | 16,979 | 13 | 1 | [] |
[
"<s>",
"void",
"XCoreRegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"unsigned",
"FIOperandNum",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"assert",
"(",
"SPAdj",
"==",
"0",
"&&",
"\"Unexpected\"",
")",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineOperand",
"&",
"FrameOp",
"=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
";",
"int",
"FrameIndex",
"=",
"FrameOp",
".",
"getIndex",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"XCoreInstrInfo",
"&",
"TII",
"=",
"*",
"static_cast",
"<",
"const",
"XCoreInstrInfo",
"*",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"const",
"XCoreFrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"int",
"Offset",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"getObjectOffset",
"(",
"FrameIndex",
")",
";",
"int",
"StackSize",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"getStackSize",
"(",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"\\nFunction : \"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"\"\\n\"",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"<--------->\\n\"",
")",
";",
"DEBUG",
"(",
"MI",
".",
"print",
"(",
"errs",
"(",
")",
")",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"FrameIndex : \"",
"<<",
"FrameIndex",
"<<",
"\"\\n\"",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"FrameOffset : \"",
"<<",
"Offset",
"<<",
"\"\\n\"",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"StackSize : \"",
"<<",
"StackSize",
"<<",
"\"\\n\"",
")",
";",
"Offset",
"+=",
"StackSize",
";",
"unsigned",
"FrameReg",
"=",
"getFrameRegister",
"(",
"MF",
")",
";",
"if",
"(",
"MI",
".",
"isDebugValue",
"(",
")",
")",
"{",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"ChangeToRegister",
"(",
"FrameReg",
",",
"false",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"return",
";",
"}",
"Offset",
"+=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"getImm",
"(",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"1",
")",
".",
"ChangeToImmediate",
"(",
"0",
")",
";",
"assert",
"(",
"Offset",
"%",
"4",
"==",
"0",
"&&",
"\"Misaligned stack offset\"",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"\"Offset : \"",
"<<",
"Offset",
"<<",
"\"\\n\"",
"<<",
"\"<--------->\\n\"",
")",
";",
"Offset",
"/=",
"4",
";",
"unsigned",
"Reg",
"=",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"assert",
"(",
"XCore",
"::",
"GRRegsRegClass",
".",
"contains",
"(",
"Reg",
")",
"&&",
"\"Unexpected register operand\"",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
")",
"{",
"if",
"(",
"isImmUs",
"(",
"Offset",
")",
")",
"InsertFPImmInst",
"(",
"II",
",",
"TII",
",",
"Reg",
",",
"FrameReg",
",",
"Offset",
")",
";",
"else",
"InsertFPConstInst",
"(",
"II",
",",
"TII",
",",
"Reg",
",",
"FrameReg",
",",
"Offset",
",",
"RS",
")",
";",
"}",
"else",
"{",
"if",
"(",
"isImmU16",
"(",
"Offset",
")",
")",
"InsertSPImmInst",
"(",
"II",
",",
"TII",
",",
"Reg",
",",
"Offset",
")",
";",
"else",
"InsertSPConstInst",
"(",
"II",
",",
"TII",
",",
"Reg",
",",
"Offset",
",",
"RS",
")",
";",
"}",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"MBB",
".",
"erase",
"(",
"II",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] | [
"XCore",
"XCore",
"0",
"\"Unexpected\"",
"XCore",
"XCore",
"XCore",
"\"\\nFunction : \"",
"\"\\n\"",
"\"<--------->\\n\"",
"\"FrameIndex : \"",
"\"\\n\"",
"\"FrameOffset : \"",
"\"\\n\"",
"\"StackSize : \"",
"\"\\n\"",
"1",
"1",
"1",
"0",
"4",
"0",
"\"Misaligned stack offset\"",
"\"Offset : \"",
"\"\\n\"",
"\"<--------->\\n\"",
"4",
"0",
"XCore::GRRegsRegClass",
"\"Unexpected register operand\""
] | XCoreRegisterInfo30 | eliminateFrameIndex | XCore | MPU | LLVM | 16,980 | 451 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"CAHPTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"(",
"CAHPISD",
"::",
"NodeType",
")",
"Opcode",
")",
"{",
"case",
"CAHPISD",
"::",
"FIRST_NUMBER",
":",
"break",
";",
"case",
"CAHPISD",
"::",
"BR_CC",
":",
"return",
"\"CAHPISD::BR_CC\"",
";",
"case",
"CAHPISD",
"::",
"CALL",
":",
"return",
"\"CAHPISD::CALL\"",
";",
"case",
"CAHPISD",
"::",
"SELECT_CC",
":",
"return",
"\"CAHPISD::SELECT_CC\"",
";",
"case",
"CAHPISD",
"::",
"RET_FLAG",
":",
"return",
"\"CAHPISD::RET_FLAG\"",
";",
"}",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"CAHP",
"CAHP",
"CAHPISD::NodeType",
"CAHPISD::FIRST_NUMBER",
"CAHPISD::BR_CC",
"\"CAHPISD::BR_CC\"",
"CAHPISD::CALL",
"\"CAHPISD::CALL\"",
"CAHPISD::SELECT_CC",
"\"CAHPISD::SELECT_CC\"",
"CAHPISD::RET_FLAG",
"\"CAHPISD::RET_FLAG\""
] | CAHPISelLowering | getTargetNodeName | CAHP | CPU | LLVM | 16,981 | 66 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"AMDGPU OpenCL Image Type Pass\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AMDGPU",
"\"AMDGPU OpenCL Image Type Pass\""
] | AMDGPUOpenCLImageTypeLoweringPass | getPassName | AMDGPU | GPU | LLVM | 16,982 | 13 | 1 | [] |
[
"<s>",
"static",
"bool",
"must_reload_pic_reg_p",
"(",
"void",
")",
"{",
"if",
"(",
"!",
"TARGET_DSBT",
")",
"return",
"false",
";",
"cgraph_node",
"*",
"local_info_node",
"=",
"cgraph_node",
"::",
"local_info_node",
"(",
"current_function_decl",
")",
";",
"if",
"(",
"(",
"crtl",
"->",
"uses_pic_offset_table",
"||",
"!",
"crtl",
"->",
"is_leaf",
")",
"&&",
"!",
"local_info_node",
"->",
"local",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"we",
"need",
"to",
"save",
"and",
"modify",
"the",
"PIC",
"register",
"in",
"the",
"prologue",
"."
] | [
"c6x"
] | c6x | must_reload_pic_reg_p | c6x | VLIW | GCC | 16,983 | 51 | 1 | [] |
[
"<s>",
"unsigned",
"int",
"rs6000_special_round_type_align",
"(",
"tree",
"type",
",",
"unsigned",
"int",
"computed",
",",
"unsigned",
"int",
"specified",
")",
"{",
"unsigned",
"int",
"align",
"=",
"MAX",
"(",
"computed",
",",
"specified",
")",
";",
"tree",
"field",
"=",
"TYPE_FIELDS",
"(",
"type",
")",
";",
"while",
"(",
"field",
"!=",
"NULL",
"&&",
"TREE_CODE",
"(",
"field",
")",
"!=",
"FIELD_DECL",
")",
"field",
"=",
"DECL_CHAIN",
"(",
"field",
")",
";",
"if",
"(",
"field",
"!=",
"NULL",
"&&",
"field",
"!=",
"type",
")",
"{",
"type",
"=",
"TREE_TYPE",
"(",
"field",
")",
";",
"while",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"ARRAY_TYPE",
")",
"type",
"=",
"TREE_TYPE",
"(",
"type",
")",
";",
"if",
"(",
"type",
"!=",
"error_mark_node",
"&&",
"TYPE_MODE",
"(",
"type",
")",
"==",
"DFmode",
")",
"align",
"=",
"MAX",
"(",
"align",
",",
"64",
")",
";",
"}",
"return",
"align",
";",
"}",
"</s>"
] | [
"Darwin",
",",
"AIX",
"increases",
"natural",
"record",
"alignment",
"to",
"doubleword",
"if",
"the",
"first",
"field",
"is",
"an",
"FP",
"double",
"while",
"the",
"FP",
"fields",
"remain",
"word",
"aligned",
"."
] | [
"powerpcspe",
"64"
] | powerpcspe | rs6000_special_round_type_align | powerpcspe | CPU | GCC | 16,984 | 116 | 1 | [] |
[
"<s>",
"Register",
"(",
"const",
"MachineOperand",
"&",
"MO",
")",
":",
"R",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
",",
"S",
"(",
"MO",
".",
"getSubReg",
"(",
")",
")",
"{",
"}",
"</s>"
] | [
"Base",
"register",
"."
] | [
"Hexagon"
] | HexagonGenPredicate (2) | Register | Hexagon | DSP | LLVM | 16,985 | 27 | 1 | [] |
[
"<s>",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"\"ARM Machine Code Emitter\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"ARM",
"\"ARM Machine Code Emitter\""
] | ARMCodeEmitter | getPassName | ARM | CPU | LLVM | 16,986 | 13 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"PASS_NAME",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AMDGPU"
] | SIDebuggerInsertNops | getPassName | AMDGPU | GPU | LLVM | 16,987 | 13 | 1 | [] |
[
"<s>",
"unsigned",
"X86InstrInfo",
"::",
"isLoadFromStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
",",
"unsigned",
"&",
"MemBytes",
")",
"const",
"{",
"if",
"(",
"isFrameLoadOpcode",
"(",
"MI",
".",
"getOpcode",
"(",
")",
",",
"MemBytes",
")",
")",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getSubReg",
"(",
")",
"==",
"0",
"&&",
"isFrameOperand",
"(",
"MI",
",",
"1",
",",
"FrameIndex",
")",
")",
"return",
"MI",
".",
"getOperand",
"(",
"0",
")",
".",
"getReg",
"(",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"isLoadFromStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"load",
"from",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"destination",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"X86",
"X86",
"0",
"0",
"1",
"0",
"0"
] | X86InstrInfo (2)3 | isLoadFromStackSlot | X86 | CPU | LLVM | 16,988 | 73 | 1 | [] |
[
"<s>",
"EVT",
"CSKYTargetLowering",
"::",
"getSetCCResultType",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"LLVMContext",
"&",
"Context",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"!",
"VT",
".",
"isVector",
"(",
")",
")",
"return",
"MVT",
"::",
"i32",
";",
"return",
"VT",
".",
"changeVectorElementTypeToInteger",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"value",
"type",
"to",
"use",
"for",
"ISD",
":",
":SETCC",
"."
] | [
"CSKY",
"CSKY",
"MVT::i32"
] | CSKYISelLowering | getSetCCResultType | CSKY | CPU | LLVM | 16,989 | 41 | 1 | [] |
[
"<s>",
"static",
"bool",
"rs6000_can_eliminate",
"(",
"const",
"int",
"from",
",",
"const",
"int",
"to",
")",
"{",
"return",
"(",
"from",
"==",
"ARG_POINTER_REGNUM",
"&&",
"to",
"==",
"STACK_POINTER_REGNUM",
"?",
"!",
"frame_pointer_needed",
":",
"from",
"==",
"RS6000_PIC_OFFSET_TABLE_REGNUM",
"?",
"!",
"TARGET_MINIMAL_TOC",
"||",
"TARGET_NO_TOC_OR_PCREL",
"||",
"constant_pool_empty_p",
"(",
")",
":",
"true",
")",
";",
"}",
"</s>"
] | [
"Given",
"FROM",
"and",
"TO",
"register",
"numbers",
",",
"say",
"whether",
"this",
"elimination",
"is",
"allowed",
".",
"Frame",
"pointer",
"elimination",
"is",
"automatically",
"handled",
".",
"For",
"the",
"RS/6000",
",",
"if",
"frame",
"pointer",
"elimination",
"is",
"being",
"done",
",",
"we",
"would",
"like",
"to",
"convert",
"ap",
"into",
"fp",
",",
"not",
"sp",
".",
"We",
"need",
"r30",
"if",
"-mminimal-toc",
"was",
"specified",
",",
"and",
"there",
"are",
"constant",
"pool",
"references",
"."
] | [
"rs6000"
] | rs6000 | rs6000_can_eliminate | rs6000 | CPU | GCC | 16,990 | 43 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"frame_header_opt",
"(",
")",
"{",
"struct",
"cgraph_node",
"*",
"node",
";",
"function",
"*",
"fn",
";",
"FOR_EACH_DEFINED_FUNCTION",
"(",
"node",
")",
"{",
"fn",
"=",
"node",
"->",
"get_fun",
"(",
")",
";",
"if",
"(",
"fn",
"!=",
"NULL",
")",
"fn",
"->",
"machine",
"->",
"does_not_use_frame_header",
"=",
"!",
"needs_frame_header_p",
"(",
"fn",
")",
";",
"}",
"FOR_EACH_DEFINED_FUNCTION",
"(",
"node",
")",
"{",
"fn",
"=",
"node",
"->",
"get_fun",
"(",
")",
";",
"if",
"(",
"fn",
"!=",
"NULL",
")",
"fn",
"->",
"machine",
"->",
"optimize_call_stack",
"=",
"!",
"callees_functions_use_frame_header",
"(",
"fn",
")",
"&&",
"!",
"is_leaf_function",
"(",
"fn",
")",
";",
"}",
"FOR_EACH_DEFINED_FUNCTION",
"(",
"node",
")",
"{",
"fn",
"=",
"node",
"->",
"get_fun",
"(",
")",
";",
"if",
"(",
"fn",
"!=",
"NULL",
"&&",
"fn",
"->",
"machine",
"->",
"optimize_call_stack",
")",
"set_callers_may_not_allocate_frame",
"(",
"fn",
")",
";",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"Scan",
"each",
"function",
"to",
"determine",
"those",
"that",
"need",
"its",
"frame",
"headers",
".",
"Perform",
"a",
"second",
"scan",
"to",
"determine",
"if",
"the",
"allocation",
"can",
"be",
"skipped",
"because",
"none",
"of",
"their",
"callees",
"require",
"the",
"frame",
"header",
"."
] | [
"mips",
"0"
] | frame-header-opt | frame_header_opt | mips | CPU | GCC | 16,991 | 121 | 1 | [] |
[
"<s>",
"SDValue",
"AMDGPUTargetLowering",
"::",
"SplitVectorLoad",
"(",
"const",
"SDValue",
"&",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"LoadSDNode",
"*",
"Load",
"=",
"dyn_cast",
"<",
"LoadSDNode",
">",
"(",
"Op",
")",
";",
"EVT",
"MemEltVT",
"=",
"Load",
"->",
"getMemoryVT",
"(",
")",
".",
"getVectorElementType",
"(",
")",
";",
"EVT",
"EltVT",
"=",
"Op",
".",
"getValueType",
"(",
")",
".",
"getVectorElementType",
"(",
")",
";",
"EVT",
"PtrVT",
"=",
"Load",
"->",
"getBasePtr",
"(",
")",
".",
"getValueType",
"(",
")",
";",
"unsigned",
"NumElts",
"=",
"Load",
"->",
"getMemoryVT",
"(",
")",
".",
"getVectorNumElements",
"(",
")",
";",
"SmallVector",
"<",
"SDValue",
",",
"8",
">",
"Loads",
";",
"SDLoc",
"SL",
"(",
"Op",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"NumElts",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"SDValue",
"Ptr",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"SL",
",",
"PtrVT",
",",
"Load",
"->",
"getBasePtr",
"(",
")",
",",
"DAG",
".",
"getConstant",
"(",
"i",
"*",
"(",
"MemEltVT",
".",
"getSizeInBits",
"(",
")",
"/",
"8",
")",
",",
"PtrVT",
")",
")",
";",
"Loads",
".",
"push_back",
"(",
"DAG",
".",
"getExtLoad",
"(",
"Load",
"->",
"getExtensionType",
"(",
")",
",",
"SL",
",",
"EltVT",
",",
"Load",
"->",
"getChain",
"(",
")",
",",
"Ptr",
",",
"MachinePointerInfo",
"(",
"Load",
"->",
"getMemOperand",
"(",
")",
"->",
"getValue",
"(",
")",
")",
",",
"MemEltVT",
",",
"Load",
"->",
"isVolatile",
"(",
")",
",",
"Load",
"->",
"isNonTemporal",
"(",
")",
",",
"Load",
"->",
"getAlignment",
"(",
")",
")",
")",
";",
"}",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BUILD_VECTOR",
",",
"SL",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Loads",
")",
";",
"}",
"</s>"
] | [
"Split",
"a",
"vector",
"load",
"into",
"2",
"loads",
"of",
"half",
"the",
"vector",
"."
] | [
"R600",
"8",
"0",
"ISD::ADD",
"8",
"ISD::BUILD_VECTOR"
] | AMDGPUISelLowering67 | SplitVectorLoad | R600 | GPU | LLVM | 16,992 | 237 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_secondary_reload_trace",
"(",
"int",
"line",
",",
"rtx",
"reg",
",",
"rtx",
"mem",
",",
"rtx",
"scratch",
",",
"bool",
"store_p",
")",
"{",
"rtx",
"set",
",",
"clobber",
";",
"gcc_assert",
"(",
"reg",
"!=",
"NULL_RTX",
"&&",
"mem",
"!=",
"NULL_RTX",
"&&",
"scratch",
"!=",
"NULL_RTX",
")",
";",
"fprintf",
"(",
"stderr",
",",
"\"rs6000_secondary_reload_inner:%d, type = %s\\n\"",
",",
"line",
",",
"store_p",
"?",
"\"store\"",
":",
"\"load\"",
")",
";",
"if",
"(",
"store_p",
")",
"set",
"=",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"mem",
",",
"reg",
")",
";",
"else",
"set",
"=",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"reg",
",",
"mem",
")",
";",
"clobber",
"=",
"gen_rtx_CLOBBER",
"(",
"VOIDmode",
",",
"scratch",
")",
";",
"debug_rtx",
"(",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"gen_rtvec",
"(",
"2",
",",
"set",
",",
"clobber",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Better",
"tracing",
"for",
"rs6000_secondary_reload_inner",
"."
] | [
"rs6000",
"\"rs6000_secondary_reload_inner:%d, type = %s\\n\"",
"\"store\"",
"\"load\"",
"2"
] | rs60004 | rs6000_secondary_reload_trace | rs6000 | CPU | GCC | 16,993 | 109 | 1 | [] |
[
"<s>",
"bool",
"VETargetLowering",
"::",
"allowsMisalignedMemoryAccesses",
"(",
"EVT",
"VT",
",",
"unsigned",
"AddrSpace",
",",
"Align",
"A",
",",
"MachineMemOperand",
"::",
"Flags",
",",
"bool",
"*",
"Fast",
")",
"const",
"{",
"if",
"(",
"Fast",
")",
"{",
"*",
"Fast",
"=",
"true",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"allows",
"unaligned",
"memory",
"accesses",
"of",
"the",
"specified",
"type",
"."
] | [
"VE",
"VE"
] | VEISelLowering11 | allowsMisalignedMemoryAccesses | VE | CPU | LLVM | 16,994 | 39 | 1 | [] |
[
"<s>",
"void",
"X86PassConfig",
"::",
"addPostRegAlloc",
"(",
")",
"{",
"addPass",
"(",
"createX86FloatingPointStackifierPass",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"may",
"be",
"implemented",
"by",
"targets",
"that",
"want",
"to",
"run",
"passes",
"after",
"register",
"allocation",
"pass",
"pipeline",
"but",
"before",
"prolog-epilog",
"insertion",
"."
] | [
"X86",
"X86",
"X86"
] | X86TargetMachine10 | addPostRegAlloc | X86 | CPU | LLVM | 16,995 | 15 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"elf_platform",
"(",
"void",
")",
"{",
"static",
"const",
"char",
"*",
"cpu",
"=",
"NULL",
";",
"if",
"(",
"cpu",
"!=",
"NULL",
")",
"return",
"cpu",
";",
"int",
"fd",
"=",
"open",
"(",
"\"/proc/self/auxv\"",
",",
"O_RDONLY",
")",
";",
"if",
"(",
"fd",
"!=",
"-",
"1",
")",
"{",
"char",
"buf",
"[",
"1024",
"]",
";",
"ElfW",
"(",
"auxv_t",
")",
"*",
"av",
";",
"ssize_t",
"n",
";",
"n",
"=",
"read",
"(",
"fd",
",",
"buf",
",",
"sizeof",
"(",
"buf",
")",
")",
";",
"close",
"(",
"fd",
")",
";",
"if",
"(",
"n",
">",
"0",
")",
"{",
"for",
"(",
"av",
"=",
"(",
"ElfW",
"(",
"auxv_t",
")",
"*",
")",
"buf",
";",
"av",
"->",
"a_type",
"!=",
"AT_NULL",
";",
"++",
"av",
")",
"if",
"(",
"av",
"->",
"a_type",
"==",
"AT_PLATFORM",
")",
"{",
"cpu",
"=",
"(",
"const",
"char",
"*",
")",
"av",
"->",
"a_un",
".",
"a_val",
";",
"break",
";",
"}",
"}",
"if",
"(",
"cpu",
"!=",
"NULL",
")",
"{",
"size_t",
"i",
",",
"j",
";",
"char",
"*",
"s",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"rs6000_supported_cpu_names",
")",
";",
"i",
"++",
")",
"if",
"(",
"!",
"strcmp",
"(",
"cpu",
",",
"rs6000_supported_cpu_names",
"[",
"i",
"]",
")",
")",
"return",
"cpu",
";",
"for",
"(",
"i",
"=",
"0",
";",
"linux_cpu_translation_table",
"[",
"i",
"]",
"[",
"0",
"]",
"!=",
"NULL",
";",
"i",
"++",
")",
"{",
"const",
"char",
"*",
"canonical",
"=",
"linux_cpu_translation_table",
"[",
"i",
"]",
"[",
"0",
"]",
";",
"for",
"(",
"j",
"=",
"1",
";",
"linux_cpu_translation_table",
"[",
"i",
"]",
"[",
"j",
"]",
"!=",
"NULL",
";",
"j",
"++",
")",
"if",
"(",
"!",
"strcmp",
"(",
"cpu",
",",
"linux_cpu_translation_table",
"[",
"i",
"]",
"[",
"j",
"]",
")",
")",
"{",
"cpu",
"=",
"canonical",
";",
"return",
"cpu",
";",
"}",
"}",
"auto_vec",
"<",
"const",
"char",
"*",
">",
"candidates",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"rs6000_supported_cpu_names",
")",
";",
"i",
"++",
")",
"candidates",
".",
"safe_push",
"(",
"rs6000_supported_cpu_names",
"[",
"i",
"]",
")",
";",
"candidates_list_and_hint",
"(",
"cpu",
",",
"s",
",",
"candidates",
")",
";",
"fatal_error",
"(",
"input_location",
",",
"\"Unsupported cpu name returned from kernel for \"",
"\"%<-mcpu=native%>: %s\\n\"",
"\"Please use an explicit cpu name. Valid cpu names are: %s\"",
",",
"cpu",
",",
"s",
")",
";",
"}",
"}",
"return",
"NULL",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"canonical",
"AT_PLATFORM",
"if",
"present",
",",
"otherwise",
"NULL",
"."
] | [
"rs6000",
"\"/proc/self/auxv\"",
"1",
"1024",
"0",
"0",
"0",
"0",
"0",
"1",
"0",
"\"Unsupported cpu name returned from kernel for \"",
"\"%<-mcpu=native%>: %s\\n\"",
"\"Please use an explicit cpu name. Valid cpu names are: %s\""
] | driver-rs60006 | elf_platform | rs6000 | CPU | GCC | 16,996 | 322 | 1 | [] |
[
"<s>",
"void",
"tilegx_compute_pcrel_address",
"(",
"rtx",
"result",
",",
"rtx",
"addr",
")",
"{",
"rtx",
"text_label_symbol",
"=",
"tilegx_text_label_symbol",
"(",
")",
";",
"rtx",
"text_label_rtx",
"=",
"tilegx_text_label_rtx",
"(",
")",
";",
"rtx",
"temp",
",",
"temp2",
",",
"temp3",
";",
"temp",
"=",
"create_temp_reg_if_possible",
"(",
"Pmode",
",",
"result",
")",
";",
"temp2",
"=",
"create_temp_reg_if_possible",
"(",
"Pmode",
",",
"result",
")",
";",
"if",
"(",
"TARGET_32BIT",
")",
"{",
"emit_insn",
"(",
"gen_mov_pcrel_step1_32bit",
"(",
"temp",
",",
"addr",
",",
"text_label_symbol",
")",
")",
";",
"emit_insn",
"(",
"gen_mov_pcrel_step2_32bit",
"(",
"temp2",
",",
"temp",
",",
"addr",
",",
"text_label_symbol",
")",
")",
";",
"emit_insn",
"(",
"gen_mov_pcrel_step3_32bit",
"(",
"result",
",",
"temp2",
",",
"text_label_rtx",
",",
"addr",
",",
"text_label_symbol",
")",
")",
";",
"}",
"else",
"if",
"(",
"tilegx_cmodel",
"==",
"CM_LARGE_PIC",
")",
"{",
"temp3",
"=",
"create_temp_reg_if_possible",
"(",
"Pmode",
",",
"result",
")",
";",
"emit_insn",
"(",
"gen_mov_large_pcrel_step1",
"(",
"temp",
",",
"addr",
",",
"text_label_symbol",
")",
")",
";",
"emit_insn",
"(",
"gen_mov_large_pcrel_step2",
"(",
"temp2",
",",
"temp",
",",
"addr",
",",
"text_label_symbol",
")",
")",
";",
"emit_insn",
"(",
"gen_mov_large_pcrel_step3",
"(",
"temp3",
",",
"temp2",
",",
"addr",
",",
"text_label_symbol",
")",
")",
";",
"emit_insn",
"(",
"gen_mov_large_pcrel_step4",
"(",
"result",
",",
"temp3",
",",
"text_label_rtx",
",",
"addr",
",",
"text_label_symbol",
")",
")",
";",
"}",
"else",
"{",
"emit_insn",
"(",
"gen_mov_pcrel_step1",
"(",
"temp",
",",
"addr",
",",
"text_label_symbol",
")",
")",
";",
"emit_insn",
"(",
"gen_mov_pcrel_step2",
"(",
"temp2",
",",
"temp",
",",
"addr",
",",
"text_label_symbol",
")",
")",
";",
"emit_insn",
"(",
"gen_mov_pcrel_step3",
"(",
"result",
",",
"temp2",
",",
"text_label_rtx",
",",
"addr",
",",
"text_label_symbol",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Returns",
"a",
"register",
"that",
"points",
"to",
"ADDR",
",",
"a",
"symbolic",
"address",
",",
"by",
"computing",
"its",
"address",
"relative",
"to",
"tilegx_text_label_symbol",
"."
] | [
"tilegx"
] | tilegx | tilegx_compute_pcrel_address | tilegx | VLIW | GCC | 16,997 | 217 | 1 | [] |
[
"<s>",
"int",
"RISCVFrameLowering",
"::",
"getFrameIndexReference",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"int",
"FI",
",",
"unsigned",
"&",
"FrameReg",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"RI",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
"=",
"MFI",
".",
"getCalleeSavedInfo",
"(",
")",
";",
"int",
"MinCSFI",
"=",
"0",
";",
"int",
"MaxCSFI",
"=",
"-",
"1",
";",
"int",
"Offset",
"=",
"MFI",
".",
"getObjectOffset",
"(",
"FI",
")",
"-",
"getOffsetOfLocalArea",
"(",
")",
"+",
"MFI",
".",
"getOffsetAdjustment",
"(",
")",
";",
"if",
"(",
"CSI",
".",
"size",
"(",
")",
")",
"{",
"MinCSFI",
"=",
"CSI",
"[",
"0",
"]",
".",
"getFrameIdx",
"(",
")",
";",
"MaxCSFI",
"=",
"CSI",
"[",
"CSI",
".",
"size",
"(",
")",
"-",
"1",
"]",
".",
"getFrameIdx",
"(",
")",
";",
"}",
"FrameReg",
"=",
"RI",
"->",
"getFrameRegister",
"(",
"MF",
")",
";",
"if",
"(",
"FI",
">=",
"MinCSFI",
"&&",
"FI",
"<=",
"MaxCSFI",
")",
"{",
"FrameReg",
"=",
"RISCV",
"::",
"X2",
";",
"Offset",
"+=",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"getStackSize",
"(",
")",
";",
"}",
"return",
"Offset",
";",
"}",
"</s>"
] | [
"getFrameIndexReference",
"-",
"This",
"method",
"should",
"return",
"the",
"base",
"register",
"and",
"offset",
"used",
"to",
"reference",
"a",
"frame",
"index",
"location",
"."
] | [
"RISCV",
"RISCV",
"0",
"1",
"0",
"1",
"RISCV::X2"
] | RISCVFrameLowering30 | getFrameIndexReference | RISCV | CPU | LLVM | 16,998 | 173 | 1 | [] |
[
"<s>",
"HOST_WIDE_INT",
"loongarch_initial_elimination_offset",
"(",
"int",
"from",
",",
"int",
"to",
")",
"{",
"HOST_WIDE_INT",
"src",
",",
"dest",
";",
"loongarch_compute_frame_info",
"(",
")",
";",
"if",
"(",
"to",
"==",
"HARD_FRAME_POINTER_REGNUM",
")",
"dest",
"=",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"hard_frame_pointer_offset",
";",
"else",
"if",
"(",
"to",
"==",
"STACK_POINTER_REGNUM",
")",
"dest",
"=",
"0",
";",
"else",
"gcc_unreachable",
"(",
")",
";",
"if",
"(",
"from",
"==",
"FRAME_POINTER_REGNUM",
")",
"src",
"=",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"frame_pointer_offset",
";",
"else",
"if",
"(",
"from",
"==",
"ARG_POINTER_REGNUM",
")",
"src",
"=",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"arg_pointer_offset",
";",
"else",
"gcc_unreachable",
"(",
")",
";",
"return",
"src",
"-",
"dest",
";",
"}",
"</s>"
] | [
"Implement",
"INITIAL_ELIMINATION_OFFSET",
".",
"FROM",
"is",
"either",
"the",
"frame",
"pointer",
"or",
"argument",
"pointer",
".",
"TO",
"is",
"either",
"the",
"stack",
"pointer",
"or",
"hard",
"frame",
"pointer",
"."
] | [
"loongarch",
"0"
] | loongarch | loongarch_initial_elimination_offset | loongarch | CPU | GCC | 16,999 | 95 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.