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>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"PassDescription",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"TPC"
] | TPCAddrOpt | getPassName | TPC | Virtual ISA | LLVM | 1,300 | 11 | 1 | [] |
[
"<s>",
"static",
"bool",
"avr_legitimate_combined_insn",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"subrtx_iterator",
"::",
"array_type",
"array",
";",
"FOR_EACH_SUBRTX",
"(",
"iter",
",",
"array",
",",
"PATTERN",
"(",
"insn",
")",
",",
"NONCONST",
")",
"{",
"const_rtx",
"op",
"=",
"*",
"iter",
";",
"if",
"(",
"SUBREG_P",
"(",
"op",
")",
"&&",
"MEM_P",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
"&&",
"(",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"op",
")",
")",
">",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"op",
")",
")",
")",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"PR78883",
":",
"Filter",
"out",
"paradoxical",
"SUBREGs",
"of",
"MEM",
"which",
"are",
"not",
"handled",
"properly",
"by",
"following",
"passes",
".",
"As",
"INSN_SCHEDULING",
"is",
"off",
"and",
"hence",
"general_operand",
"accepts",
"such",
"expressions",
",",
"ditch",
"them",
"now",
"."
] | [
"avr"
] | avr | avr_legitimate_combined_insn | avr | MPU | GCC | 1,301 | 80 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_base_register_rtx_p",
"(",
"rtx",
"x",
",",
"bool",
"strict_p",
")",
"{",
"if",
"(",
"!",
"strict_p",
"&&",
"SUBREG_P",
"(",
"x",
")",
"&&",
"contains_reg_of_mode",
"[",
"GENERAL_REGS",
"]",
"[",
"GET_MODE",
"(",
"SUBREG_REG",
"(",
"x",
")",
")",
"]",
")",
"x",
"=",
"SUBREG_REG",
"(",
"x",
")",
";",
"return",
"(",
"REG_P",
"(",
"x",
")",
"&&",
"aarch64_regno_ok_for_base_p",
"(",
"REGNO",
"(",
"x",
")",
",",
"strict_p",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"X",
"is",
"a",
"valid",
"base",
"register",
"for",
"mode",
"MODE",
".",
"STRICT_P",
"is",
"true",
"if",
"REG_OK_STRICT",
"is",
"in",
"effect",
"."
] | [
"aarch64"
] | aarch641 | aarch64_base_register_rtx_p | aarch64 | CPU | GCC | 1,302 | 61 | 1 | [] |
[
"<s>",
"unsigned",
"LanaiInstrInfo",
"::",
"isLoadFromStackSlotPostFE",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"Lanai",
"::",
"LDW_RI",
")",
"{",
"unsigned",
"Reg",
";",
"if",
"(",
"(",
"Reg",
"=",
"isLoadFromStackSlot",
"(",
"MI",
",",
"FrameIndex",
")",
")",
")",
"return",
"Reg",
";",
"SmallVector",
"<",
"const",
"MachineMemOperand",
"*",
",",
"1",
">",
"Accesses",
";",
"if",
"(",
"hasLoadFromStackSlot",
"(",
"MI",
",",
"Accesses",
")",
")",
"{",
"FrameIndex",
"=",
"cast",
"<",
"FixedStackPseudoSourceValue",
">",
"(",
"Accesses",
".",
"front",
"(",
")",
"->",
"getPseudoValue",
"(",
")",
")",
"->",
"getFrameIndex",
"(",
")",
";",
"return",
"1",
";",
"}",
"}",
"return",
"0",
";",
"}",
"</s>"
] | [
"isLoadFromStackSlotPostFE",
"-",
"Check",
"for",
"post-frame",
"ptr",
"elimination",
"stack",
"locations",
"as",
"well",
"."
] | [
"Lanai",
"Lanai",
"Lanai::LDW_RI",
"1",
"1",
"0"
] | LanaiInstrInfo (2) | isLoadFromStackSlotPostFE | Lanai | CPU | LLVM | 1,303 | 99 | 1 | [] |
[
"<s>",
"rtx",
"legitimize_pe_coff_symbol",
"(",
"rtx",
"addr",
",",
"bool",
"inreg",
")",
"{",
"if",
"(",
"!",
"TARGET_PECOFF",
")",
"return",
"NULL_RTX",
";",
"if",
"(",
"TARGET_DLLIMPORT_DECL_ATTRIBUTES",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"SYMBOL_REF",
"&&",
"SYMBOL_REF_DLLIMPORT_P",
"(",
"addr",
")",
")",
"return",
"legitimize_dllimport_symbol",
"(",
"addr",
",",
"inreg",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"CONST",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"SYMBOL_REF",
"&&",
"SYMBOL_REF_DLLIMPORT_P",
"(",
"XEXP",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"0",
")",
")",
")",
"{",
"rtx",
"t",
"=",
"legitimize_dllimport_symbol",
"(",
"XEXP",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"0",
")",
",",
"inreg",
")",
";",
"return",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"t",
",",
"XEXP",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"1",
")",
")",
";",
"}",
"}",
"if",
"(",
"ix86_cmodel",
"!=",
"CM_LARGE_PIC",
"&&",
"ix86_cmodel",
"!=",
"CM_MEDIUM_PIC",
")",
"return",
"NULL_RTX",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"SYMBOL_REF",
"&&",
"!",
"is_imported_p",
"(",
"addr",
")",
"&&",
"SYMBOL_REF_EXTERNAL_P",
"(",
"addr",
")",
"&&",
"SYMBOL_REF_DECL",
"(",
"addr",
")",
")",
"return",
"legitimize_pe_coff_extern_decl",
"(",
"addr",
",",
"inreg",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"CONST",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"0",
")",
")",
"==",
"SYMBOL_REF",
"&&",
"!",
"is_imported_p",
"(",
"XEXP",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"0",
")",
")",
"&&",
"SYMBOL_REF_EXTERNAL_P",
"(",
"XEXP",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"0",
")",
")",
"&&",
"SYMBOL_REF_DECL",
"(",
"XEXP",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"0",
")",
")",
")",
"{",
"rtx",
"t",
"=",
"legitimize_pe_coff_extern_decl",
"(",
"XEXP",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"0",
")",
",",
"inreg",
")",
";",
"return",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"t",
",",
"XEXP",
"(",
"XEXP",
"(",
"addr",
",",
"0",
")",
",",
"1",
")",
")",
";",
"}",
"return",
"NULL_RTX",
";",
"}",
"</s>"
] | [
"Expand",
"SYMBOL",
"into",
"its",
"corresponding",
"dllimport",
"or",
"refptr",
"symbol",
".",
"WANT_REG",
"is",
"true",
"if",
"we",
"require",
"the",
"result",
"be",
"a",
"register",
"."
] | [
"i386",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1"
] | i386 | legitimize_pe_coff_symbol | i386 | CPU | GCC | 1,304 | 317 | 1 | [] |
[
"<s>",
"void",
"Thumb2InstrInfo",
"::",
"ReplaceTailWithBranchTo",
"(",
"MachineBasicBlock",
"::",
"iterator",
"Tail",
",",
"MachineBasicBlock",
"*",
"NewDest",
")",
"const",
"{",
"MachineBasicBlock",
"*",
"MBB",
"=",
"Tail",
"->",
"getParent",
"(",
")",
";",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MBB",
"->",
"getParent",
"(",
")",
"->",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"!",
"AFI",
"->",
"hasITBlocks",
"(",
")",
"||",
"Tail",
"->",
"isBranch",
"(",
")",
")",
"{",
"TargetInstrInfo",
"::",
"ReplaceTailWithBranchTo",
"(",
"Tail",
",",
"NewDest",
")",
";",
"return",
";",
"}",
"unsigned",
"PredReg",
"=",
"0",
";",
"ARMCC",
"::",
"CondCodes",
"CC",
"=",
"getInstrPredicate",
"(",
"*",
"Tail",
",",
"PredReg",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"Tail",
";",
"if",
"(",
"CC",
"!=",
"ARMCC",
"::",
"AL",
")",
"--",
"MBBI",
";",
"TargetInstrInfo",
"::",
"ReplaceTailWithBranchTo",
"(",
"Tail",
",",
"NewDest",
")",
";",
"if",
"(",
"CC",
"!=",
"ARMCC",
"::",
"AL",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"E",
"=",
"MBB",
"->",
"begin",
"(",
")",
";",
"unsigned",
"Count",
"=",
"4",
";",
"while",
"(",
"Count",
"&&",
"MBBI",
"!=",
"E",
")",
"{",
"if",
"(",
"MBBI",
"->",
"isDebugInstr",
"(",
")",
")",
"{",
"--",
"MBBI",
";",
"continue",
";",
"}",
"if",
"(",
"MBBI",
"->",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"t2IT",
")",
"{",
"unsigned",
"Mask",
"=",
"MBBI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Count",
"==",
"4",
")",
"MBBI",
"->",
"eraseFromParent",
"(",
")",
";",
"else",
"{",
"unsigned",
"MaskOn",
"=",
"1",
"<<",
"Count",
";",
"unsigned",
"MaskOff",
"=",
"~",
"(",
"MaskOn",
"-",
"1",
")",
";",
"MBBI",
"->",
"getOperand",
"(",
"1",
")",
".",
"setImm",
"(",
"(",
"Mask",
"&",
"MaskOff",
")",
"|",
"MaskOn",
")",
";",
"}",
"return",
";",
"}",
"--",
"MBBI",
";",
"--",
"Count",
";",
"}",
"}",
"}",
"</s>"
] | [
"Delete",
"the",
"instruction",
"OldInst",
"and",
"everything",
"after",
"it",
",",
"replacing",
"it",
"with",
"an",
"unconditional",
"branch",
"to",
"NewDest",
"."
] | [
"ARM",
"ARM",
"ARM",
"0",
"ARMCC::CondCodes",
"ARMCC::AL",
"ARMCC::AL",
"4",
"ARM::t2IT",
"1",
"4",
"1",
"1",
"1"
] | Thumb2InstrInfo (2)1 | ReplaceTailWithBranchTo | ARM | CPU | LLVM | 1,305 | 254 | 1 | [] |
[
"<s>",
"DecodeStatus",
"PPCDisassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"MI",
",",
"uint64_t",
"&",
"Size",
",",
"ArrayRef",
"<",
"uint8_t",
">",
"Bytes",
",",
"uint64_t",
"Address",
",",
"raw_ostream",
"&",
"OS",
",",
"raw_ostream",
"&",
"CS",
")",
"const",
"{",
"Size",
"=",
"4",
";",
"if",
"(",
"Bytes",
".",
"size",
"(",
")",
"<",
"4",
")",
"{",
"Size",
"=",
"0",
";",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"}",
"uint32_t",
"Inst",
"=",
"(",
"Bytes",
"[",
"0",
"]",
"<<",
"24",
")",
"|",
"(",
"Bytes",
"[",
"1",
"]",
"<<",
"16",
")",
"|",
"(",
"Bytes",
"[",
"2",
"]",
"<<",
"8",
")",
"|",
"(",
"Bytes",
"[",
"3",
"]",
"<<",
"0",
")",
";",
"if",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
"[",
"PPC",
"::",
"FeatureQPX",
"]",
")",
"{",
"DecodeStatus",
"result",
"=",
"decodeInstruction",
"(",
"DecoderTableQPX32",
",",
"MI",
",",
"Inst",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"if",
"(",
"result",
"!=",
"MCDisassembler",
"::",
"Fail",
")",
"return",
"result",
";",
"MI",
".",
"clear",
"(",
")",
";",
"}",
"return",
"decodeInstruction",
"(",
"DecoderTable32",
",",
"MI",
",",
"Inst",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"PowerPC",
"PPC",
"4",
"4",
"0",
"0",
"24",
"1",
"16",
"2",
"8",
"3",
"0",
"PPC::FeatureQPX"
] | PPCDisassembler28 | getInstruction | PowerPC | CPU | LLVM | 1,306 | 163 | 1 | [] |
[
"<s>",
"bool",
"m68k_tls_reference_p",
"(",
"rtx",
"x",
",",
"bool",
"legitimate_p",
")",
"{",
"if",
"(",
"!",
"TARGET_HAVE_TLS",
")",
"return",
"false",
";",
"if",
"(",
"!",
"legitimate_p",
")",
"{",
"subrtx_var_iterator",
"::",
"array_type",
"array",
";",
"FOR_EACH_SUBRTX_VAR",
"(",
"iter",
",",
"array",
",",
"x",
",",
"ALL",
")",
"{",
"rtx",
"x",
"=",
"*",
"iter",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SYMBOL_REF",
"&&",
"SYMBOL_REF_TLS_MODEL",
"(",
"x",
")",
"!=",
"0",
")",
"return",
"true",
";",
"if",
"(",
"m68k_tls_reference_p",
"(",
"x",
",",
"true",
")",
")",
"iter",
".",
"skip_subrtxes",
"(",
")",
";",
"}",
"return",
"false",
";",
"}",
"else",
"{",
"enum",
"m68k_reloc",
"reloc",
"=",
"RELOC_GOT",
";",
"return",
"(",
"m68k_unwrap_symbol_1",
"(",
"x",
",",
"true",
",",
"&",
"reloc",
")",
"!=",
"x",
"&&",
"TLS_RELOC_P",
"(",
"reloc",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"If",
"!",
"LEGITIMATE_P",
",",
"return",
"true",
"if",
"X",
"is",
"a",
"TLS",
"symbol",
"reference",
",",
"though",
"illegitimate",
"one",
".",
"If",
"LEGITIMATE_P",
",",
"return",
"true",
"if",
"X",
"is",
"a",
"legitimate",
"TLS",
"symbol",
"reference",
"."
] | [
"m68k",
"0"
] | m68k | m68k_tls_reference_p | m68k | MPU | GCC | 1,307 | 115 | 1 | [] |
[
"<s>",
"Value",
"*",
"ARMTargetLowering",
"::",
"getSDagStackGuard",
"(",
"const",
"Module",
"&",
"M",
")",
"const",
"{",
"if",
"(",
"Subtarget",
"->",
"getTargetTriple",
"(",
")",
".",
"isWindowsMSVCEnvironment",
"(",
")",
")",
"return",
"M",
".",
"getGlobalVariable",
"(",
"\"__security_cookie\"",
")",
";",
"return",
"TargetLowering",
"::",
"getSDagStackGuard",
"(",
"M",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"variable",
"that",
"'s",
"previously",
"inserted",
"by",
"insertSSPDeclarations",
",",
"if",
"any",
",",
"otherwise",
"return",
"nullptr",
"."
] | [
"ARM",
"ARM",
"\"__security_cookie\""
] | ARMISelLowering (2)5 | getSDagStackGuard | ARM | CPU | LLVM | 1,308 | 42 | 1 | [] |
[
"<s>",
"bool",
"arm_validize_comparison",
"(",
"rtx",
"*",
"comparison",
",",
"rtx",
"*",
"op1",
",",
"rtx",
"*",
"op2",
")",
"{",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"*",
"comparison",
")",
";",
"int",
"code_int",
";",
"machine_mode",
"mode",
"=",
"(",
"GET_MODE",
"(",
"*",
"op1",
")",
"==",
"VOIDmode",
")",
"?",
"GET_MODE",
"(",
"*",
"op2",
")",
":",
"GET_MODE",
"(",
"*",
"op1",
")",
";",
"gcc_assert",
"(",
"GET_MODE",
"(",
"*",
"op1",
")",
"!=",
"VOIDmode",
"||",
"GET_MODE",
"(",
"*",
"op2",
")",
"!=",
"VOIDmode",
")",
";",
"if",
"(",
"code",
"==",
"UNEQ",
"||",
"code",
"==",
"LTGT",
")",
"return",
"false",
";",
"code_int",
"=",
"(",
"int",
")",
"code",
";",
"arm_canonicalize_comparison",
"(",
"&",
"code_int",
",",
"op1",
",",
"op2",
",",
"0",
")",
";",
"PUT_CODE",
"(",
"*",
"comparison",
",",
"(",
"enum",
"rtx_code",
")",
"code_int",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"SImode",
":",
"if",
"(",
"!",
"arm_add_operand",
"(",
"*",
"op1",
",",
"mode",
")",
")",
"*",
"op1",
"=",
"force_reg",
"(",
"mode",
",",
"*",
"op1",
")",
";",
"if",
"(",
"!",
"arm_add_operand",
"(",
"*",
"op2",
",",
"mode",
")",
")",
"*",
"op2",
"=",
"force_reg",
"(",
"mode",
",",
"*",
"op2",
")",
";",
"return",
"true",
";",
"case",
"DImode",
":",
"if",
"(",
"!",
"cmpdi_operand",
"(",
"*",
"op1",
",",
"mode",
")",
")",
"*",
"op1",
"=",
"force_reg",
"(",
"mode",
",",
"*",
"op1",
")",
";",
"if",
"(",
"!",
"cmpdi_operand",
"(",
"*",
"op2",
",",
"mode",
")",
")",
"*",
"op2",
"=",
"force_reg",
"(",
"mode",
",",
"*",
"op2",
")",
";",
"return",
"true",
";",
"case",
"HFmode",
":",
"if",
"(",
"!",
"TARGET_VFP_FP16INST",
")",
"break",
";",
"mode",
"=",
"SFmode",
";",
"*",
"op1",
"=",
"convert_to_mode",
"(",
"mode",
",",
"*",
"op1",
",",
"1",
")",
";",
"*",
"op2",
"=",
"convert_to_mode",
"(",
"mode",
",",
"*",
"op2",
",",
"1",
")",
";",
"case",
"SFmode",
":",
"case",
"DFmode",
":",
"if",
"(",
"!",
"vfp_compare_operand",
"(",
"*",
"op1",
",",
"mode",
")",
")",
"*",
"op1",
"=",
"force_reg",
"(",
"mode",
",",
"*",
"op1",
")",
";",
"if",
"(",
"!",
"vfp_compare_operand",
"(",
"*",
"op2",
",",
"mode",
")",
")",
"*",
"op2",
"=",
"force_reg",
"(",
"mode",
",",
"*",
"op2",
")",
";",
"return",
"true",
";",
"default",
":",
"break",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"a",
"valid",
"comparison",
"operation",
"and",
"makes",
"the",
"operands",
"in",
"a",
"form",
"that",
"is",
"valid",
"."
] | [
"arm",
"0",
"1",
"1"
] | arm6 | arm_validize_comparison | arm | CPU | GCC | 1,309 | 324 | 1 | [] |
[
"<s>",
"void",
"bfin_expand_epilogue",
"(",
"int",
"need_return",
",",
"int",
"eh_return",
",",
"bool",
"sibcall_p",
")",
"{",
"rtx",
"spreg",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"REG_SP",
")",
";",
"e_funkind",
"fkind",
"=",
"funkind",
"(",
"TREE_TYPE",
"(",
"current_function_decl",
")",
")",
";",
"int",
"e",
"=",
"sibcall_p",
"?",
"-",
"1",
":",
"1",
";",
"tree",
"attrs",
"=",
"TYPE_ATTRIBUTES",
"(",
"TREE_TYPE",
"(",
"current_function_decl",
")",
")",
";",
"bool",
"all",
"=",
"lookup_attribute",
"(",
"\"saveall\"",
",",
"attrs",
")",
"!=",
"NULL_TREE",
";",
"if",
"(",
"fkind",
"!=",
"SUBROUTINE",
")",
"{",
"expand_interrupt_handler_epilogue",
"(",
"spreg",
",",
"fkind",
",",
"all",
")",
";",
"return",
";",
"}",
"do_unlink",
"(",
"spreg",
",",
"get_frame_size",
"(",
")",
",",
"all",
",",
"e",
")",
";",
"expand_epilogue_reg_restore",
"(",
"spreg",
",",
"all",
",",
"false",
")",
";",
"if",
"(",
"!",
"need_return",
")",
"return",
";",
"if",
"(",
"eh_return",
")",
"emit_insn",
"(",
"gen_addsi3",
"(",
"spreg",
",",
"spreg",
",",
"gen_rtx_REG",
"(",
"Pmode",
",",
"REG_P2",
")",
")",
")",
";",
"emit_jump_insn",
"(",
"gen_return_internal",
"(",
"gen_rtx_REG",
"(",
"Pmode",
",",
"REG_RETS",
")",
")",
")",
";",
"}",
"</s>"
] | [
"Generate",
"RTL",
"for",
"the",
"epilogue",
"of",
"the",
"current",
"function",
".",
"NEED_RETURN",
"is",
"zero",
"if",
"this",
"is",
"for",
"a",
"sibcall",
".",
"EH_RETURN",
"is",
"nonzero",
"if",
"we",
"'re",
"expanding",
"an",
"eh_return",
"pattern",
"."
] | [
"bfin",
"1",
"1",
"\"saveall\""
] | bfin | bfin_expand_epilogue | bfin | DSP | GCC | 1,310 | 150 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"AMDGPUPreLegalizerCombiner\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"AMDGPU",
"\"AMDGPUPreLegalizerCombiner\""
] | AMDGPUPreLegalizerCombiner | getPassName | AMDGPU | GPU | LLVM | 1,311 | 11 | 1 | [] |
[
"<s>",
"bool",
"PPCFrameInfo",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
"->",
"hasFnAttr",
"(",
"Attribute",
"::",
"Naked",
")",
")",
"return",
"false",
";",
"return",
"DisableFramePointerElim",
"(",
"MF",
")",
"||",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
"||",
"(",
"GuaranteedTailCallOpt",
"&&",
"MF",
".",
"getInfo",
"<",
"PPCFunctionInfo",
">",
"(",
")",
"->",
"hasFastCall",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"PowerPC",
"PPC",
"PPC"
] | PPCFrameInfo | hasFP | PowerPC | CPU | LLVM | 1,312 | 71 | 1 | [] |
[
"<s>",
"MCSection",
"*",
"SystemZMCAsmInfo",
"::",
"getNonexecutableStackSection",
"(",
"MCContext",
"&",
"Ctx",
")",
"const",
"{",
"return",
"MCSectionELF",
"::",
"Create",
"(",
"\".note.GNU-stack\"",
",",
"MCSectionELF",
"::",
"SHT_PROGBITS",
",",
"0",
",",
"SectionKind",
"::",
"getMetadata",
"(",
")",
",",
"false",
",",
"Ctx",
")",
";",
"}",
"</s>"
] | [
"Targets",
"can",
"implement",
"this",
"method",
"to",
"specify",
"a",
"section",
"to",
"switch",
"to",
"if",
"the",
"translation",
"unit",
"does",
"n't",
"have",
"any",
"trampolines",
"that",
"require",
"an",
"executable",
"stack",
"."
] | [
"SystemZ",
"SystemZ",
"\".note.GNU-stack\"",
"0"
] | SystemZMCAsmInfo27 | getNonexecutableStackSection | SystemZ | CPU | LLVM | 1,313 | 37 | 1 | [] |
[
"<s>",
"bool",
"AArch64InstrInfo",
"::",
"expandPostRAPseudo",
"(",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
")",
"const",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"MBBI",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"AArch64",
"::",
"TLSDESC_BLRx",
":",
"{",
"MachineInstr",
"*",
"NewMI",
"=",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"get",
"(",
"AArch64",
"::",
"TLSDESCCALL",
")",
")",
".",
"addOperand",
"(",
"MI",
".",
"getOperand",
"(",
"1",
")",
")",
";",
"MI",
".",
"setDesc",
"(",
"get",
"(",
"AArch64",
"::",
"BLRx",
")",
")",
";",
"llvm",
"::",
"finalizeBundle",
"(",
"MBB",
",",
"NewMI",
",",
"*",
"++",
"MBBI",
")",
";",
"return",
"true",
";",
"}",
"default",
":",
"return",
"false",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"This",
"function",
"is",
"called",
"for",
"all",
"pseudo",
"instructions",
"that",
"remain",
"after",
"register",
"allocation",
"."
] | [
"AArch64",
"AArch64",
"AArch64::TLSDESC_BLRx",
"AArch64::TLSDESCCALL",
"1",
"AArch64::BLRx"
] | AArch64InstrInfo101 | expandPostRAPseudo | AArch64 | CPU | LLVM | 1,314 | 123 | 1 | [] |
[
"<s>",
"static",
"const",
"char",
"*",
"output_387_ffreep",
"(",
"rtx",
"*",
"operands",
"ATTRIBUTE_UNUSED",
",",
"int",
"opno",
")",
"{",
"if",
"(",
"TARGET_USE_FFREEP",
")",
"return",
"opno",
"?",
"\"ffreep\\t%y1\"",
":",
"\"ffreep\\t%y0\"",
";",
"{",
"static",
"char",
"retval",
"[",
"32",
"]",
";",
"int",
"regno",
"=",
"REGNO",
"(",
"operands",
"[",
"opno",
"]",
")",
";",
"gcc_assert",
"(",
"STACK_REGNO_P",
"(",
"regno",
")",
")",
";",
"regno",
"-=",
"FIRST_STACK_REG",
";",
"snprintf",
"(",
"retval",
",",
"sizeof",
"(",
"retval",
")",
",",
"ASM_SHORT",
"\"0xc%ddf\"",
",",
"regno",
")",
";",
"return",
"retval",
";",
"}",
"return",
"opno",
"?",
"\"fstp\\t%y1\"",
":",
"\"fstp\\t%y0\"",
";",
"}",
"</s>"
] | [
"Output",
"code",
"for",
"x87",
"ffreep",
"insn",
".",
"The",
"OPNO",
"argument",
",",
"which",
"may",
"only",
"have",
"the",
"values",
"zero",
"or",
"one",
",",
"indicates",
"the",
"ffreep",
"insn",
"'s",
"operand",
"from",
"the",
"OPERANDS",
"array",
"."
] | [
"i386",
"\"ffreep\\t%y1\"",
"\"ffreep\\t%y0\"",
"32",
"\"0xc%ddf\"",
"\"fstp\\t%y1\"",
"\"fstp\\t%y0\""
] | i386 | output_387_ffreep | i386 | CPU | GCC | 1,315 | 84 | 1 | [] |
[
"<s>",
"void",
"ix86_expand_sse2_abs",
"(",
"rtx",
"target",
",",
"rtx",
"input",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"target",
")",
";",
"rtx",
"tmp0",
",",
"tmp1",
",",
"x",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"E_V2DImode",
":",
"case",
"E_V4DImode",
":",
"if",
"(",
"TARGET_SSE4_2",
")",
"{",
"tmp0",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"tmp1",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"emit_move_insn",
"(",
"tmp1",
",",
"CONST0_RTX",
"(",
"mode",
")",
")",
";",
"if",
"(",
"mode",
"==",
"E_V2DImode",
")",
"emit_insn",
"(",
"gen_sse4_2_gtv2di3",
"(",
"tmp0",
",",
"tmp1",
",",
"input",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_avx2_gtv4di3",
"(",
"tmp0",
",",
"tmp1",
",",
"input",
")",
")",
";",
"}",
"else",
"{",
"tmp0",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"LSHIFTRT",
",",
"input",
",",
"GEN_INT",
"(",
"GET_MODE_UNIT_BITSIZE",
"(",
"mode",
")",
"-",
"1",
")",
",",
"NULL",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"tmp0",
"=",
"expand_simple_unop",
"(",
"mode",
",",
"NEG",
",",
"tmp0",
",",
"NULL",
",",
"false",
")",
";",
"}",
"tmp1",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"XOR",
",",
"tmp0",
",",
"input",
",",
"NULL",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"x",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"MINUS",
",",
"tmp1",
",",
"tmp0",
",",
"target",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"break",
";",
"case",
"E_V4SImode",
":",
"tmp0",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"ASHIFTRT",
",",
"input",
",",
"GEN_INT",
"(",
"GET_MODE_UNIT_BITSIZE",
"(",
"mode",
")",
"-",
"1",
")",
",",
"NULL",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"tmp1",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"XOR",
",",
"tmp0",
",",
"input",
",",
"NULL",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"x",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"MINUS",
",",
"tmp1",
",",
"tmp0",
",",
"target",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"break",
";",
"case",
"E_V8HImode",
":",
"tmp0",
"=",
"expand_unop",
"(",
"mode",
",",
"neg_optab",
",",
"input",
",",
"NULL_RTX",
",",
"0",
")",
";",
"x",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"SMAX",
",",
"tmp0",
",",
"input",
",",
"target",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"break",
";",
"case",
"E_V16QImode",
":",
"tmp0",
"=",
"expand_unop",
"(",
"mode",
",",
"neg_optab",
",",
"input",
",",
"NULL_RTX",
",",
"0",
")",
";",
"x",
"=",
"expand_simple_binop",
"(",
"V16QImode",
",",
"UMIN",
",",
"tmp0",
",",
"input",
",",
"target",
",",
"0",
",",
"OPTAB_DIRECT",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"if",
"(",
"x",
"!=",
"target",
")",
"emit_move_insn",
"(",
"target",
",",
"x",
")",
";",
"}",
"</s>"
] | [
"Calculate",
"integer",
"abs",
"(",
")",
"using",
"only",
"SSE2",
"instructions",
"."
] | [
"i386",
"1",
"0",
"0",
"0",
"1",
"0",
"0",
"0",
"0",
"0",
"0",
"0"
] | i386-expand | ix86_expand_sse2_abs | i386 | CPU | GCC | 1,316 | 351 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"HexagonTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"(",
"HexagonISD",
"::",
"NodeType",
")",
"Opcode",
")",
"{",
"case",
"HexagonISD",
"::",
"ALLOCA",
":",
"return",
"\"HexagonISD::ALLOCA\"",
";",
"case",
"HexagonISD",
"::",
"ARGEXTEND",
":",
"return",
"\"HexagonISD::ARGEXTEND\"",
";",
"case",
"HexagonISD",
"::",
"AT_GOT",
":",
"return",
"\"HexagonISD::AT_GOT\"",
";",
"case",
"HexagonISD",
"::",
"AT_PCREL",
":",
"return",
"\"HexagonISD::AT_PCREL\"",
";",
"case",
"HexagonISD",
"::",
"BARRIER",
":",
"return",
"\"HexagonISD::BARRIER\"",
";",
"case",
"HexagonISD",
"::",
"BR_JT",
":",
"return",
"\"HexagonISD::BR_JT\"",
";",
"case",
"HexagonISD",
"::",
"CALLR",
":",
"return",
"\"HexagonISD::CALLR\"",
";",
"case",
"HexagonISD",
"::",
"CALLv3nr",
":",
"return",
"\"HexagonISD::CALLv3nr\"",
";",
"case",
"HexagonISD",
"::",
"CALLv3",
":",
"return",
"\"HexagonISD::CALLv3\"",
";",
"case",
"HexagonISD",
"::",
"COMBINE",
":",
"return",
"\"HexagonISD::COMBINE\"",
";",
"case",
"HexagonISD",
"::",
"CONST32_GP",
":",
"return",
"\"HexagonISD::CONST32_GP\"",
";",
"case",
"HexagonISD",
"::",
"CONST32",
":",
"return",
"\"HexagonISD::CONST32\"",
";",
"case",
"HexagonISD",
"::",
"CP",
":",
"return",
"\"HexagonISD::CP\"",
";",
"case",
"HexagonISD",
"::",
"DCFETCH",
":",
"return",
"\"HexagonISD::DCFETCH\"",
";",
"case",
"HexagonISD",
"::",
"EH_RETURN",
":",
"return",
"\"HexagonISD::EH_RETURN\"",
";",
"case",
"HexagonISD",
"::",
"EXTRACTU",
":",
"return",
"\"HexagonISD::EXTRACTU\"",
";",
"case",
"HexagonISD",
"::",
"EXTRACTURP",
":",
"return",
"\"HexagonISD::EXTRACTURP\"",
";",
"case",
"HexagonISD",
"::",
"FCONST32",
":",
"return",
"\"HexagonISD::FCONST32\"",
";",
"case",
"HexagonISD",
"::",
"INSERT",
":",
"return",
"\"HexagonISD::INSERT\"",
";",
"case",
"HexagonISD",
"::",
"INSERTRP",
":",
"return",
"\"HexagonISD::INSERTRP\"",
";",
"case",
"HexagonISD",
"::",
"JT",
":",
"return",
"\"HexagonISD::JT\"",
";",
"case",
"HexagonISD",
"::",
"PACKHL",
":",
"return",
"\"HexagonISD::PACKHL\"",
";",
"case",
"HexagonISD",
"::",
"PIC_ADD",
":",
"return",
"\"HexagonISD::PIC_ADD\"",
";",
"case",
"HexagonISD",
"::",
"POPCOUNT",
":",
"return",
"\"HexagonISD::POPCOUNT\"",
";",
"case",
"HexagonISD",
"::",
"RET_FLAG",
":",
"return",
"\"HexagonISD::RET_FLAG\"",
";",
"case",
"HexagonISD",
"::",
"SHUFFEB",
":",
"return",
"\"HexagonISD::SHUFFEB\"",
";",
"case",
"HexagonISD",
"::",
"SHUFFEH",
":",
"return",
"\"HexagonISD::SHUFFEH\"",
";",
"case",
"HexagonISD",
"::",
"SHUFFOB",
":",
"return",
"\"HexagonISD::SHUFFOB\"",
";",
"case",
"HexagonISD",
"::",
"SHUFFOH",
":",
"return",
"\"HexagonISD::SHUFFOH\"",
";",
"case",
"HexagonISD",
"::",
"TC_RETURN",
":",
"return",
"\"HexagonISD::TC_RETURN\"",
";",
"case",
"HexagonISD",
"::",
"VCMPBEQ",
":",
"return",
"\"HexagonISD::VCMPBEQ\"",
";",
"case",
"HexagonISD",
"::",
"VCMPBGT",
":",
"return",
"\"HexagonISD::VCMPBGT\"",
";",
"case",
"HexagonISD",
"::",
"VCMPBGTU",
":",
"return",
"\"HexagonISD::VCMPBGTU\"",
";",
"case",
"HexagonISD",
"::",
"VCMPHEQ",
":",
"return",
"\"HexagonISD::VCMPHEQ\"",
";",
"case",
"HexagonISD",
"::",
"VCMPHGT",
":",
"return",
"\"HexagonISD::VCMPHGT\"",
";",
"case",
"HexagonISD",
"::",
"VCMPHGTU",
":",
"return",
"\"HexagonISD::VCMPHGTU\"",
";",
"case",
"HexagonISD",
"::",
"VCMPWEQ",
":",
"return",
"\"HexagonISD::VCMPWEQ\"",
";",
"case",
"HexagonISD",
"::",
"VCMPWGT",
":",
"return",
"\"HexagonISD::VCMPWGT\"",
";",
"case",
"HexagonISD",
"::",
"VCMPWGTU",
":",
"return",
"\"HexagonISD::VCMPWGTU\"",
";",
"case",
"HexagonISD",
"::",
"VSHLH",
":",
"return",
"\"HexagonISD::VSHLH\"",
";",
"case",
"HexagonISD",
"::",
"VSHLW",
":",
"return",
"\"HexagonISD::VSHLW\"",
";",
"case",
"HexagonISD",
"::",
"VSPLATB",
":",
"return",
"\"HexagonISD::VSPLTB\"",
";",
"case",
"HexagonISD",
"::",
"VSPLATH",
":",
"return",
"\"HexagonISD::VSPLATH\"",
";",
"case",
"HexagonISD",
"::",
"VSRAH",
":",
"return",
"\"HexagonISD::VSRAH\"",
";",
"case",
"HexagonISD",
"::",
"VSRAW",
":",
"return",
"\"HexagonISD::VSRAW\"",
";",
"case",
"HexagonISD",
"::",
"VSRLH",
":",
"return",
"\"HexagonISD::VSRLH\"",
";",
"case",
"HexagonISD",
"::",
"VSRLW",
":",
"return",
"\"HexagonISD::VSRLW\"",
";",
"case",
"HexagonISD",
"::",
"VSXTBH",
":",
"return",
"\"HexagonISD::VSXTBH\"",
";",
"case",
"HexagonISD",
"::",
"VSXTBW",
":",
"return",
"\"HexagonISD::VSXTBW\"",
";",
"case",
"HexagonISD",
"::",
"OP_END",
":",
"break",
";",
"}",
"return",
"nullptr",
";",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"Hexagon",
"Hexagon",
"HexagonISD::NodeType",
"HexagonISD::ALLOCA",
"\"HexagonISD::ALLOCA\"",
"HexagonISD::ARGEXTEND",
"\"HexagonISD::ARGEXTEND\"",
"HexagonISD::AT_GOT",
"\"HexagonISD::AT_GOT\"",
"HexagonISD::AT_PCREL",
"\"HexagonISD::AT_PCREL\"",
"HexagonISD::BARRIER",
"\"HexagonISD::BARRIER\"",
"HexagonISD::BR_JT",
"\"HexagonISD::BR_JT\"",
"HexagonISD::CALLR",
"\"HexagonISD::CALLR\"",
"HexagonISD::CALLv3nr",
"\"HexagonISD::CALLv3nr\"",
"HexagonISD::CALLv3",
"\"HexagonISD::CALLv3\"",
"HexagonISD::COMBINE",
"\"HexagonISD::COMBINE\"",
"HexagonISD::CONST32_GP",
"\"HexagonISD::CONST32_GP\"",
"HexagonISD::CONST32",
"\"HexagonISD::CONST32\"",
"HexagonISD::CP",
"\"HexagonISD::CP\"",
"HexagonISD::DCFETCH",
"\"HexagonISD::DCFETCH\"",
"HexagonISD::EH_RETURN",
"\"HexagonISD::EH_RETURN\"",
"HexagonISD::EXTRACTU",
"\"HexagonISD::EXTRACTU\"",
"HexagonISD::EXTRACTURP",
"\"HexagonISD::EXTRACTURP\"",
"HexagonISD::FCONST32",
"\"HexagonISD::FCONST32\"",
"HexagonISD::INSERT",
"\"HexagonISD::INSERT\"",
"HexagonISD::INSERTRP",
"\"HexagonISD::INSERTRP\"",
"HexagonISD::JT",
"\"HexagonISD::JT\"",
"HexagonISD::PACKHL",
"\"HexagonISD::PACKHL\"",
"HexagonISD::PIC_ADD",
"\"HexagonISD::PIC_ADD\"",
"HexagonISD::POPCOUNT",
"\"HexagonISD::POPCOUNT\"",
"HexagonISD::RET_FLAG",
"\"HexagonISD::RET_FLAG\"",
"HexagonISD::SHUFFEB",
"\"HexagonISD::SHUFFEB\"",
"HexagonISD::SHUFFEH",
"\"HexagonISD::SHUFFEH\"",
"HexagonISD::SHUFFOB",
"\"HexagonISD::SHUFFOB\"",
"HexagonISD::SHUFFOH",
"\"HexagonISD::SHUFFOH\"",
"HexagonISD::TC_RETURN",
"\"HexagonISD::TC_RETURN\"",
"HexagonISD::VCMPBEQ",
"\"HexagonISD::VCMPBEQ\"",
"HexagonISD::VCMPBGT",
"\"HexagonISD::VCMPBGT\"",
"HexagonISD::VCMPBGTU",
"\"HexagonISD::VCMPBGTU\"",
"HexagonISD::VCMPHEQ",
"\"HexagonISD::VCMPHEQ\"",
"HexagonISD::VCMPHGT",
"\"HexagonISD::VCMPHGT\"",
"HexagonISD::VCMPHGTU",
"\"HexagonISD::VCMPHGTU\"",
"HexagonISD::VCMPWEQ",
"\"HexagonISD::VCMPWEQ\"",
"HexagonISD::VCMPWGT",
"\"HexagonISD::VCMPWGT\"",
"HexagonISD::VCMPWGTU",
"\"HexagonISD::VCMPWGTU\"",
"HexagonISD::VSHLH",
"\"HexagonISD::VSHLH\"",
"HexagonISD::VSHLW",
"\"HexagonISD::VSHLW\"",
"HexagonISD::VSPLATB",
"\"HexagonISD::VSPLTB\"",
"HexagonISD::VSPLATH",
"\"HexagonISD::VSPLATH\"",
"HexagonISD::VSRAH",
"\"HexagonISD::VSRAH\"",
"HexagonISD::VSRAW",
"\"HexagonISD::VSRAW\"",
"HexagonISD::VSRLH",
"\"HexagonISD::VSRLH\"",
"HexagonISD::VSRLW",
"\"HexagonISD::VSRLW\"",
"HexagonISD::VSXTBH",
"\"HexagonISD::VSXTBH\"",
"HexagonISD::VSXTBW",
"\"HexagonISD::VSXTBW\"",
"HexagonISD::OP_END"
] | HexagonISelLowering | getTargetNodeName | Hexagon | DSP | LLVM | 1,317 | 426 | 1 | [] |
[
"<s>",
"const",
"RegisterBankInfo",
"*",
"ARMSubtarget",
"::",
"getRegBankInfo",
"(",
")",
"const",
"{",
"assert",
"(",
"GISel",
"&&",
"\"Access to GlobalISel APIs not set\"",
")",
";",
"return",
"GISel",
"->",
"getRegBankInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"If",
"the",
"information",
"for",
"the",
"register",
"banks",
"is",
"available",
",",
"return",
"it",
"."
] | [
"ARM",
"ARM",
"\"Access to GlobalISel APIs not set\""
] | ARMSubtarget24 | getRegBankInfo | ARM | CPU | LLVM | 1,318 | 25 | 1 | [] |
[
"<s>",
"static",
"int",
"arm_sched_reorder",
"(",
"FILE",
"*",
"file",
",",
"int",
"verbose",
",",
"rtx_insn",
"*",
"*",
"ready",
",",
"int",
"*",
"n_readyp",
",",
"int",
"clock",
")",
"{",
"switch",
"(",
"arm_tune",
")",
"{",
"case",
"TARGET_CPU_cortexa7",
":",
"cortexa7_sched_reorder",
"(",
"file",
",",
"verbose",
",",
"ready",
",",
"n_readyp",
",",
"clock",
")",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"return",
"arm_issue_rate",
"(",
")",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_SCHED_REORDER",
"."
] | [
"arm"
] | arm | arm_sched_reorder | arm | CPU | GCC | 1,319 | 58 | 1 | [] |
[
"<s>",
"static",
"int",
"ix86_mode_exit",
"(",
"int",
"entity",
")",
"{",
"switch",
"(",
"entity",
")",
"{",
"case",
"X86_DIRFLAG",
":",
"return",
"X86_DIRFLAG_ANY",
";",
"case",
"AVX_U128",
":",
"return",
"ix86_avx_u128_mode_exit",
"(",
")",
";",
"case",
"I387_TRUNC",
":",
"case",
"I387_FLOOR",
":",
"case",
"I387_CEIL",
":",
"case",
"I387_MASK_PM",
":",
"return",
"I387_CW_ANY",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"</s>"
] | [
"Return",
"a",
"mode",
"that",
"ENTITY",
"is",
"assumed",
"to",
"be",
"switched",
"to",
"at",
"function",
"exit",
"."
] | [
"i386"
] | i3866 | ix86_mode_exit | i386 | CPU | GCC | 1,320 | 50 | 1 | [] |
[
"<s>",
"int",
"direct_return",
"(",
")",
"{",
"return",
"(",
"!",
"TARGET_ABI_OPEN_VMS",
"&&",
"!",
"TARGET_ABI_UNICOSMK",
"&&",
"reload_completed",
"&&",
"alpha_sa_size",
"(",
")",
"==",
"0",
"&&",
"get_frame_size",
"(",
")",
"==",
"0",
"&&",
"current_function_outgoing_args_size",
"==",
"0",
"&&",
"current_function_pretend_args_size",
"==",
"0",
")",
";",
"}",
"</s>"
] | [
"Return",
"non-zero",
"if",
"this",
"function",
"is",
"known",
"to",
"have",
"a",
"null",
"epilogue",
"."
] | [
"alpha",
"0",
"0",
"0",
"0"
] | alpha2 | direct_return | alpha | MPU | GCC | 1,321 | 37 | 1 | [] |
[
"<s>",
"Register",
"SITargetLowering",
"::",
"getRegisterByName",
"(",
"const",
"char",
"*",
"RegName",
",",
"EVT",
"VT",
",",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"Register",
"Reg",
"=",
"StringSwitch",
"<",
"Register",
">",
"(",
"RegName",
")",
".",
"Case",
"(",
"\"m0\"",
",",
"AMDGPU",
"::",
"M0",
")",
".",
"Case",
"(",
"\"exec\"",
",",
"AMDGPU",
"::",
"EXEC",
")",
".",
"Case",
"(",
"\"exec_lo\"",
",",
"AMDGPU",
"::",
"EXEC_LO",
")",
".",
"Case",
"(",
"\"exec_hi\"",
",",
"AMDGPU",
"::",
"EXEC_HI",
")",
".",
"Case",
"(",
"\"flat_scratch\"",
",",
"AMDGPU",
"::",
"FLAT_SCR",
")",
".",
"Case",
"(",
"\"flat_scratch_lo\"",
",",
"AMDGPU",
"::",
"FLAT_SCR_LO",
")",
".",
"Case",
"(",
"\"flat_scratch_hi\"",
",",
"AMDGPU",
"::",
"FLAT_SCR_HI",
")",
".",
"Default",
"(",
"Register",
"(",
")",
")",
";",
"if",
"(",
"Reg",
"==",
"AMDGPU",
"::",
"NoRegister",
")",
"{",
"report_fatal_error",
"(",
"Twine",
"(",
"\"invalid register name \\\"\"",
"+",
"StringRef",
"(",
"RegName",
")",
"+",
"\"\\\".\"",
")",
")",
";",
"}",
"if",
"(",
"!",
"Subtarget",
"->",
"hasFlatScrRegister",
"(",
")",
"&&",
"Subtarget",
"->",
"getRegisterInfo",
"(",
")",
"->",
"regsOverlap",
"(",
"Reg",
",",
"AMDGPU",
"::",
"FLAT_SCR",
")",
")",
"{",
"report_fatal_error",
"(",
"Twine",
"(",
"\"invalid register \\\"\"",
"+",
"StringRef",
"(",
"RegName",
")",
"+",
"\"\\\" for subtarget.\"",
")",
")",
";",
"}",
"switch",
"(",
"Reg",
")",
"{",
"case",
"AMDGPU",
"::",
"M0",
":",
"case",
"AMDGPU",
"::",
"EXEC_LO",
":",
"case",
"AMDGPU",
"::",
"EXEC_HI",
":",
"case",
"AMDGPU",
"::",
"FLAT_SCR_LO",
":",
"case",
"AMDGPU",
"::",
"FLAT_SCR_HI",
":",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"32",
")",
"return",
"Reg",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"EXEC",
":",
"case",
"AMDGPU",
"::",
"FLAT_SCR",
":",
"if",
"(",
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"64",
")",
"return",
"Reg",
";",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"\"missing register type checking\"",
")",
";",
"}",
"report_fatal_error",
"(",
"Twine",
"(",
"\"invalid type for register \\\"\"",
"+",
"StringRef",
"(",
"RegName",
")",
"+",
"\"\\\".\"",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"register",
"ID",
"of",
"the",
"name",
"passed",
"in",
"."
] | [
"AMDGPU",
"SI",
"\"m0\"",
"AMDGPU::M0",
"\"exec\"",
"AMDGPU::EXEC",
"\"exec_lo\"",
"AMDGPU::EXEC_LO",
"\"exec_hi\"",
"AMDGPU::EXEC_HI",
"\"flat_scratch\"",
"AMDGPU::FLAT_SCR",
"\"flat_scratch_lo\"",
"AMDGPU::FLAT_SCR_LO",
"\"flat_scratch_hi\"",
"AMDGPU::FLAT_SCR_HI",
"AMDGPU::NoRegister",
"\"invalid register name \\\"\"",
"\"\\\".\"",
"AMDGPU::FLAT_SCR",
"\"invalid register \\\"\"",
"\"\\\" for subtarget.\"",
"AMDGPU::M0",
"AMDGPU::EXEC_LO",
"AMDGPU::EXEC_HI",
"AMDGPU::FLAT_SCR_LO",
"AMDGPU::FLAT_SCR_HI",
"32",
"AMDGPU::EXEC",
"AMDGPU::FLAT_SCR",
"64",
"\"missing register type checking\"",
"\"invalid type for register \\\"\"",
"\"\\\".\""
] | SIISelLowering150 | getRegisterByName | AMDGPU | GPU | LLVM | 1,322 | 261 | 1 | [] |
[
"<s>",
"static",
"rtx",
"sparc_function_value_1",
"(",
"const_tree",
"type",
",",
"machine_mode",
"mode",
",",
"bool",
"outgoing",
")",
"{",
"const",
"int",
"regbase",
"=",
"outgoing",
"?",
"SPARC_INCOMING_INT_ARG_FIRST",
":",
"SPARC_OUTGOING_INT_ARG_FIRST",
";",
"enum",
"mode_class",
"mclass",
"=",
"GET_MODE_CLASS",
"(",
"mode",
")",
";",
"int",
"regno",
";",
"if",
"(",
"type",
"&&",
"VECTOR_INTEGER_TYPE_P",
"(",
"type",
")",
"&&",
"mode",
"!=",
"BLKmode",
")",
"mclass",
"=",
"MODE_FLOAT",
";",
"if",
"(",
"TARGET_ARCH64",
"&&",
"type",
")",
"{",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"RECORD_TYPE",
")",
"{",
"const",
"int",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"gcc_assert",
"(",
"size",
"<=",
"32",
")",
";",
"return",
"function_arg_record_value",
"(",
"type",
",",
"mode",
",",
"0",
",",
"true",
",",
"regbase",
")",
";",
"}",
"else",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"UNION_TYPE",
")",
"{",
"const",
"int",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"gcc_assert",
"(",
"size",
"<=",
"32",
")",
";",
"return",
"function_arg_union_value",
"(",
"size",
",",
"mode",
",",
"0",
",",
"regbase",
")",
";",
"}",
"else",
"if",
"(",
"VECTOR_TYPE_P",
"(",
"type",
")",
"&&",
"mode",
"==",
"BLKmode",
")",
"{",
"const",
"int",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"gcc_assert",
"(",
"size",
"<=",
"32",
")",
";",
"return",
"function_arg_vector_value",
"(",
"size",
",",
"0",
",",
"true",
",",
"SPARC_FP_ARG_FIRST",
")",
";",
"}",
"else",
"if",
"(",
"mclass",
"==",
"MODE_FLOAT",
"||",
"mclass",
"==",
"MODE_COMPLEX_FLOAT",
")",
";",
"else",
"if",
"(",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
"{",
"const",
"int",
"size",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"gcc_assert",
"(",
"size",
"<=",
"32",
")",
";",
"mode",
"=",
"int_mode_for_size",
"(",
"size",
"*",
"BITS_PER_UNIT",
",",
"0",
")",
".",
"else_blk",
"(",
")",
";",
"if",
"(",
"mode",
"==",
"BLKmode",
")",
"return",
"function_arg_union_value",
"(",
"size",
",",
"mode",
",",
"0",
",",
"regbase",
")",
";",
"else",
"mclass",
"=",
"MODE_INT",
";",
"}",
"else",
"if",
"(",
"mclass",
"==",
"MODE_INT",
"&&",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<",
"UNITS_PER_WORD",
")",
"mode",
"=",
"word_mode",
";",
"}",
"else",
"if",
"(",
"TARGET_ARCH32",
"&&",
"!",
"(",
"type",
"&&",
"AGGREGATE_TYPE_P",
"(",
"type",
")",
")",
"&&",
"mclass",
"==",
"MODE_INT",
"&&",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<",
"UNITS_PER_WORD",
")",
"mode",
"=",
"word_mode",
";",
"if",
"(",
"(",
"mclass",
"==",
"MODE_FLOAT",
"||",
"mclass",
"==",
"MODE_COMPLEX_FLOAT",
")",
"&&",
"TARGET_FPU",
")",
"regno",
"=",
"SPARC_FP_ARG_FIRST",
";",
"else",
"regno",
"=",
"regbase",
";",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"regno",
")",
";",
"}",
"</s>"
] | [
"Handle",
"TARGET_FUNCTION_VALUE",
",",
"and",
"TARGET_LIBCALL_VALUE",
"target",
"hook",
".",
"For",
"v9",
",",
"function",
"return",
"values",
"are",
"subject",
"to",
"the",
"same",
"rules",
"as",
"arguments",
",",
"except",
"that",
"up",
"to",
"32",
"bytes",
"may",
"be",
"returned",
"in",
"registers",
"."
] | [
"sparc",
"32",
"0",
"32",
"0",
"32",
"0",
"32",
"0",
"0"
] | sparc | sparc_function_value_1 | sparc | CPU | GCC | 1,323 | 340 | 1 | [] |
[
"<s>",
"TargetPassConfig",
"*",
"MipsTargetMachine",
"::",
"createPassConfig",
"(",
"PassManagerBase",
"&",
"PM",
")",
"{",
"return",
"new",
"MipsPassConfig",
"(",
"*",
"this",
",",
"PM",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"pass",
"configuration",
"object",
"to",
"be",
"used",
"by",
"addPassToEmitX",
"methods",
"for",
"generating",
"a",
"pipeline",
"of",
"CodeGen",
"passes",
"."
] | [
"Mips",
"Mips",
"Mips"
] | MipsTargetMachine (2)1 | createPassConfig | Mips | CPU | LLVM | 1,324 | 22 | 1 | [] |
[
"<s>",
"bool",
"R600Packetizer",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"const",
"R600Subtarget",
"&",
"ST",
"=",
"Fn",
".",
"getSubtarget",
"<",
"R600Subtarget",
">",
"(",
")",
";",
"const",
"R600InstrInfo",
"*",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"MachineLoopInfo",
"&",
"MLI",
"=",
"getAnalysis",
"<",
"MachineLoopInfo",
">",
"(",
")",
";",
"R600PacketizerList",
"Packetizer",
"(",
"Fn",
",",
"ST",
",",
"MLI",
")",
";",
"assert",
"(",
"Packetizer",
".",
"getResourceTracker",
"(",
")",
"&&",
"\"Empty DFA table!\"",
")",
";",
"assert",
"(",
"Packetizer",
".",
"getResourceTracker",
"(",
")",
"->",
"getInstrItins",
"(",
")",
")",
";",
"if",
"(",
"Packetizer",
".",
"getResourceTracker",
"(",
")",
"->",
"getInstrItins",
"(",
")",
"->",
"isEmpty",
"(",
")",
")",
"return",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"Fn",
")",
"{",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"llvm",
"::",
"make_early_inc_range",
"(",
"MBB",
")",
")",
"{",
"if",
"(",
"MI",
".",
"isKill",
"(",
")",
"||",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"R600",
"::",
"IMPLICIT_DEF",
"||",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"R600",
"::",
"CF_ALU",
"&&",
"!",
"MI",
".",
"getOperand",
"(",
"8",
")",
".",
"getImm",
"(",
")",
")",
")",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"}",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MBB",
"=",
"Fn",
".",
"begin",
"(",
")",
",",
"MBBe",
"=",
"Fn",
".",
"end",
"(",
")",
";",
"MBB",
"!=",
"MBBe",
";",
"++",
"MBB",
")",
"{",
"unsigned",
"RemainingCount",
"=",
"MBB",
"->",
"size",
"(",
")",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"RegionEnd",
"=",
"MBB",
"->",
"end",
"(",
")",
";",
"RegionEnd",
"!=",
"MBB",
"->",
"begin",
"(",
")",
";",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"RegionEnd",
";",
"for",
"(",
";",
"I",
"!=",
"MBB",
"->",
"begin",
"(",
")",
";",
"--",
"I",
",",
"--",
"RemainingCount",
")",
"{",
"if",
"(",
"TII",
"->",
"isSchedulingBoundary",
"(",
"*",
"std",
"::",
"prev",
"(",
"I",
")",
",",
"&",
"*",
"MBB",
",",
"Fn",
")",
")",
"break",
";",
"}",
"I",
"=",
"MBB",
"->",
"begin",
"(",
")",
";",
"if",
"(",
"I",
"==",
"RegionEnd",
")",
"{",
"RegionEnd",
"=",
"std",
"::",
"prev",
"(",
"RegionEnd",
")",
";",
"--",
"RemainingCount",
";",
"continue",
";",
"}",
"if",
"(",
"I",
"==",
"std",
"::",
"prev",
"(",
"RegionEnd",
")",
")",
"{",
"RegionEnd",
"=",
"std",
"::",
"prev",
"(",
"RegionEnd",
")",
";",
"continue",
";",
"}",
"Packetizer",
".",
"PacketizeMIs",
"(",
"&",
"*",
"MBB",
",",
"&",
"*",
"I",
",",
"RegionEnd",
")",
";",
"RegionEnd",
"=",
"I",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AMDGPU",
"R600",
"R600",
"R600",
"R600",
"R600",
"\"Empty DFA table!\"",
"R600::IMPLICIT_DEF",
"R600::CF_ALU",
"8"
] | R600Packetizer (2)1 | runOnMachineFunction | AMDGPU | GPU | LLVM | 1,325 | 362 | 1 | [] |
[
"<s>",
"static",
"bool",
"s390_fixed_condition_code_regs",
"(",
"unsigned",
"int",
"*",
"p1",
",",
"unsigned",
"int",
"*",
"p2",
")",
"{",
"*",
"p1",
"=",
"CC_REGNUM",
";",
"*",
"p2",
"=",
"INVALID_REGNUM",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Return",
"the",
"fixed",
"registers",
"used",
"for",
"condition",
"codes",
"."
] | [
"s390"
] | s390 | s390_fixed_condition_code_regs | s390 | MPU | GCC | 1,326 | 29 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"THUMB2_SIZE_REDUCE_NAME",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"ARM"
] | Thumb2SizeReduction10 | getPassName | ARM | CPU | LLVM | 1,327 | 11 | 1 | [] |
[
"<s>",
"StringRef",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"X86 cmov Conversion\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"X86",
"\"X86 cmov Conversion\""
] | X86CmovConversion (2) | getPassName | X86 | CPU | LLVM | 1,328 | 11 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"output_move_quad",
"(",
"rtx",
"*",
"operands",
")",
"{",
"if",
"(",
"REG_P",
"(",
"operands",
"[",
"0",
"]",
")",
")",
"{",
"if",
"(",
"MEM_P",
"(",
"operands",
"[",
"1",
"]",
")",
")",
"{",
"switch",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"operands",
"[",
"1",
"]",
",",
"0",
")",
")",
")",
"{",
"case",
"REG",
":",
"output_asm_insn",
"(",
"\"ldmia%?\\t%m1, %M0\"",
",",
"operands",
")",
";",
"break",
";",
"case",
"LABEL_REF",
":",
"case",
"CONST",
":",
"output_asm_insn",
"(",
"\"adr%?\\t%0, %1\"",
",",
"operands",
")",
";",
"output_asm_insn",
"(",
"\"ldmia%?\\t%0, %M0\"",
",",
"operands",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"else",
"{",
"rtx",
"ops",
"[",
"2",
"]",
";",
"int",
"dest",
",",
"src",
",",
"i",
";",
"gcc_assert",
"(",
"REG_P",
"(",
"operands",
"[",
"1",
"]",
")",
")",
";",
"dest",
"=",
"REGNO",
"(",
"operands",
"[",
"0",
"]",
")",
";",
"src",
"=",
"REGNO",
"(",
"operands",
"[",
"1",
"]",
")",
";",
"if",
"(",
"dest",
"<",
"src",
")",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"4",
";",
"i",
"++",
")",
"{",
"ops",
"[",
"0",
"]",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"dest",
"+",
"i",
")",
";",
"ops",
"[",
"1",
"]",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"src",
"+",
"i",
")",
";",
"output_asm_insn",
"(",
"\"mov%?\\t%0, %1\"",
",",
"ops",
")",
";",
"}",
"else",
"for",
"(",
"i",
"=",
"3",
";",
"i",
">=",
"0",
";",
"i",
"--",
")",
"{",
"ops",
"[",
"0",
"]",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"dest",
"+",
"i",
")",
";",
"ops",
"[",
"1",
"]",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"src",
"+",
"i",
")",
";",
"output_asm_insn",
"(",
"\"mov%?\\t%0, %1\"",
",",
"ops",
")",
";",
"}",
"}",
"}",
"else",
"{",
"gcc_assert",
"(",
"MEM_P",
"(",
"operands",
"[",
"0",
"]",
")",
")",
";",
"gcc_assert",
"(",
"REG_P",
"(",
"operands",
"[",
"1",
"]",
")",
")",
";",
"gcc_assert",
"(",
"!",
"reg_overlap_mentioned_p",
"(",
"operands",
"[",
"1",
"]",
",",
"operands",
"[",
"0",
"]",
")",
")",
";",
"switch",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"operands",
"[",
"0",
"]",
",",
"0",
")",
")",
")",
"{",
"case",
"REG",
":",
"output_asm_insn",
"(",
"\"stm%?\\t%m0, %M1\"",
",",
"operands",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}",
"return",
"\"\"",
";",
"}",
"</s>"
] | [
"Output",
"assembler",
"code",
"to",
"perform",
"a",
"quadword",
"move",
"insn",
"with",
"operands",
"OPERANDS",
"."
] | [
"arm",
"0",
"1",
"1",
"0",
"\"ldmia%?\\t%m1, %M0\"",
"\"adr%?\\t%0, %1\"",
"\"ldmia%?\\t%0, %M0\"",
"2",
"1",
"0",
"1",
"0",
"4",
"0",
"1",
"\"mov%?\\t%0, %1\"",
"3",
"0",
"0",
"1",
"\"mov%?\\t%0, %1\"",
"0",
"1",
"1",
"0",
"0",
"0",
"\"stm%?\\t%m0, %M1\"",
"\"\""
] | arm | output_move_quad | arm | CPU | GCC | 1,329 | 326 | 1 | [] |
[
"<s>",
"TargetPassConfig",
"*",
"DigitalTargetMachine",
"::",
"createPassConfig",
"(",
"PassManagerBase",
"&",
"PM",
")",
"{",
"return",
"new",
"DigitalPassConfig",
"(",
"this",
",",
"PM",
")",
";",
"}",
"</s>"
] | [
"Create",
"a",
"pass",
"configuration",
"object",
"to",
"be",
"used",
"by",
"addPassToEmitX",
"methods",
"for",
"generating",
"a",
"pipeline",
"of",
"CodeGen",
"passes",
"."
] | [
"Digital"
] | DigitalTargetMachine | createPassConfig | Digital | CPU | LLVM | 1,330 | 21 | 1 | [] |
[
"<s>",
"static",
"bool",
"check_liw_constraints",
"(",
"struct",
"liw_data",
"*",
"pliw1",
",",
"struct",
"liw_data",
"*",
"pliw2",
")",
"{",
"if",
"(",
"pliw2",
"->",
"slot",
"==",
"pliw1",
"->",
"slot",
"&&",
"pliw1",
"->",
"slot",
"!=",
"LIW_EITHER",
")",
"return",
"false",
";",
"if",
"(",
"pliw1",
"->",
"op",
"==",
"LIW_OP_CMP",
")",
"{",
"gcc_assert",
"(",
"pliw1",
"->",
"op",
"!=",
"pliw2",
"->",
"op",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"pliw2",
"->",
"op",
"==",
"LIW_OP_CMP",
")",
"{",
"if",
"(",
"REGNO",
"(",
"pliw2",
"->",
"dest",
")",
"==",
"REGNO",
"(",
"pliw1",
"->",
"dest",
")",
")",
"return",
"false",
";",
"if",
"(",
"REG_P",
"(",
"pliw2",
"->",
"src",
")",
")",
"return",
"REGNO",
"(",
"pliw2",
"->",
"src",
")",
"!=",
"REGNO",
"(",
"pliw1",
"->",
"dest",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"REGNO",
"(",
"pliw2",
"->",
"dest",
")",
"==",
"REGNO",
"(",
"pliw1",
"->",
"dest",
")",
")",
"return",
"false",
";",
"if",
"(",
"REG_P",
"(",
"pliw2",
"->",
"src",
")",
"&&",
"REGNO",
"(",
"pliw2",
"->",
"src",
")",
"==",
"REGNO",
"(",
"pliw1",
"->",
"dest",
")",
")",
"{",
"if",
"(",
"pliw1",
"->",
"op",
"==",
"LIW_OP_MOV",
"&&",
"REG_P",
"(",
"pliw1",
"->",
"src",
")",
")",
"{",
"if",
"(",
"!",
"REG_P",
"(",
"pliw1",
"->",
"src",
")",
"&&",
"(",
"pliw2",
"->",
"op",
"==",
"LIW_OP_AND",
"||",
"pliw2",
"->",
"op",
"==",
"LIW_OP_OR",
"||",
"pliw2",
"->",
"op",
"==",
"LIW_OP_XOR",
")",
")",
"return",
"false",
";",
"pliw2",
"->",
"src",
"=",
"pliw1",
"->",
"src",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Make",
"sure",
"that",
"it",
"is",
"OK",
"to",
"execute",
"LIW1",
"and",
"LIW2",
"in",
"parallel",
".",
"GCC",
"generated",
"the",
"instructions",
"with",
"the",
"assumption",
"that",
"LIW1",
"would",
"be",
"executed",
"before",
"LIW2",
"so",
"we",
"must",
"check",
"for",
"overlaps",
"between",
"their",
"sources",
"and",
"destinations",
"."
] | [
"mn10300"
] | mn10300 | check_liw_constraints | mn10300 | MPU | GCC | 1,331 | 226 | 1 | [] |
[
"<s>",
"const",
"MCExpr",
"*",
"X86_64MachoTargetObjectFile",
"::",
"getTTypeGlobalReference",
"(",
"const",
"GlobalValue",
"*",
"GV",
",",
"unsigned",
"Encoding",
",",
"Mangler",
"&",
"Mang",
",",
"const",
"TargetMachine",
"&",
"TM",
",",
"MachineModuleInfo",
"*",
"MMI",
",",
"MCStreamer",
"&",
"Streamer",
")",
"const",
"{",
"if",
"(",
"(",
"Encoding",
"&",
"DW_EH_PE_indirect",
")",
"&&",
"(",
"Encoding",
"&",
"DW_EH_PE_pcrel",
")",
")",
"{",
"const",
"MCSymbol",
"*",
"Sym",
"=",
"TM",
".",
"getSymbol",
"(",
"GV",
",",
"Mang",
")",
";",
"const",
"MCExpr",
"*",
"Res",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"Sym",
",",
"MCSymbolRefExpr",
"::",
"VK_GOTPCREL",
",",
"getContext",
"(",
")",
")",
";",
"const",
"MCExpr",
"*",
"Four",
"=",
"MCConstantExpr",
"::",
"create",
"(",
"4",
",",
"getContext",
"(",
")",
")",
";",
"return",
"MCBinaryExpr",
"::",
"createAdd",
"(",
"Res",
",",
"Four",
",",
"getContext",
"(",
")",
")",
";",
"}",
"return",
"TargetLoweringObjectFileMachO",
"::",
"getTTypeGlobalReference",
"(",
"GV",
",",
"Encoding",
",",
"Mang",
",",
"TM",
",",
"MMI",
",",
"Streamer",
")",
";",
"}",
"</s>"
] | [
"The",
"mach-o",
"version",
"of",
"this",
"method",
"defaults",
"to",
"returning",
"a",
"stub",
"reference",
"."
] | [
"X86",
"X86",
"4"
] | X86TargetObjectFile2 | getTTypeGlobalReference | X86 | CPU | LLVM | 1,332 | 133 | 1 | [] |
[
"<s>",
"void",
"AMDGPURegBankCombiner",
"::",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"{",
"AU",
".",
"addRequired",
"<",
"TargetPassConfig",
">",
"(",
")",
";",
"AU",
".",
"setPreservesCFG",
"(",
")",
";",
"getSelectionDAGFallbackAnalysisUsage",
"(",
"AU",
")",
";",
"AU",
".",
"addRequired",
"<",
"GISelKnownBitsAnalysis",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"GISelKnownBitsAnalysis",
">",
"(",
")",
";",
"if",
"(",
"!",
"IsOptNone",
")",
"{",
"AU",
".",
"addRequired",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"AU",
".",
"addPreserved",
"<",
"MachineDominatorTree",
">",
"(",
")",
";",
"}",
"MachineFunctionPass",
"::",
"getAnalysisUsage",
"(",
"AU",
")",
";",
"}",
"</s>"
] | [
"getAnalysisUsage",
"-",
"Subclasses",
"that",
"override",
"getAnalysisUsage",
"must",
"call",
"this",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPURegBankCombiner | getAnalysisUsage | AMDGPU | GPU | LLVM | 1,333 | 82 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"F2003fRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"return",
"CSR_NoRegs_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"F2003f",
"F2003f"
] | F2003fRegisterInfo | getCalleeSavedRegs | F2003f | CPU | LLVM | 1,334 | 18 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetMachine",
"::",
"parseMachineFunctionInfo",
"(",
"const",
"yaml",
"::",
"MachineFunctionInfo",
"&",
"MFI",
",",
"PerFunctionMIParsingState",
"&",
"PFS",
",",
"SMDiagnostic",
"&",
"Error",
",",
"SMRange",
"&",
"SourceRange",
")",
"const",
"{",
"const",
"auto",
"&",
"YamlMFI",
"=",
"static_cast",
"<",
"const",
"yaml",
"::",
"AArch64FunctionInfo",
"&",
">",
"(",
"MFI",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"PFS",
".",
"MF",
";",
"MF",
".",
"getInfo",
"<",
"AArch64FunctionInfo",
">",
"(",
")",
"->",
"initializeBaseYamlFields",
"(",
"YamlMFI",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Parse",
"out",
"the",
"target",
"'s",
"MachineFunctionInfo",
"from",
"the",
"YAML",
"reprsentation",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64"
] | AArch64TargetMachine35 | parseMachineFunctionInfo | AArch64 | CPU | LLVM | 1,335 | 69 | 1 | [] |
[
"<s>",
"bool",
"PPCSubtarget",
"::",
"isGVIndirectSymbol",
"(",
"const",
"GlobalValue",
"*",
"GV",
")",
"const",
"{",
"if",
"(",
"TM",
".",
"getCodeModel",
"(",
")",
"==",
"CodeModel",
"::",
"Large",
")",
"return",
"true",
";",
"if",
"(",
"TM",
".",
"shouldAssumeDSOLocal",
"(",
"*",
"GV",
"->",
"getParent",
"(",
")",
",",
"GV",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"True",
"if",
"the",
"GV",
"will",
"be",
"accessed",
"via",
"an",
"indirect",
"symbol",
"."
] | [
"PowerPC",
"PPC"
] | PPCSubtarget10 | isGVIndirectSymbol | PowerPC | CPU | LLVM | 1,336 | 50 | 1 | [] |
[
"<s>",
"static",
"tree",
"def_builtin",
"(",
"const",
"char",
"*",
"name",
",",
"enum",
"insn_code",
"icode",
",",
"enum",
"sparc_builtins",
"code",
",",
"tree",
"type",
")",
"{",
"tree",
"t",
"=",
"add_builtin_function",
"(",
"name",
",",
"type",
",",
"code",
",",
"BUILT_IN_MD",
",",
"NULL",
",",
"NULL_TREE",
")",
";",
"if",
"(",
"t",
")",
"{",
"sparc_builtins",
"[",
"code",
"]",
"=",
"t",
";",
"sparc_builtins_icode",
"[",
"code",
"]",
"=",
"icode",
";",
"}",
"return",
"t",
";",
"}",
"</s>"
] | [
"Add",
"a",
"SPARC",
"builtin",
"function",
"with",
"NAME",
",",
"ICODE",
",",
"CODE",
"and",
"TYPE",
".",
"Return",
"the",
"function",
"decl",
"or",
"NULL_TREE",
"if",
"the",
"builtin",
"was",
"not",
"added",
"."
] | [
"sparc"
] | sparc | def_builtin | sparc | CPU | GCC | 1,337 | 63 | 1 | [] |
[
"<s>",
"bool",
"ix86_expand_fp_vec_cmp",
"(",
"rtx",
"operands",
"[",
"]",
")",
"{",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"operands",
"[",
"1",
"]",
")",
";",
"rtx",
"cmp",
";",
"code",
"=",
"ix86_prepare_sse_fp_compare_args",
"(",
"operands",
"[",
"0",
"]",
",",
"code",
",",
"&",
"operands",
"[",
"2",
"]",
",",
"&",
"operands",
"[",
"3",
"]",
")",
";",
"if",
"(",
"code",
"==",
"UNKNOWN",
")",
"{",
"rtx",
"temp",
";",
"switch",
"(",
"GET_CODE",
"(",
"operands",
"[",
"1",
"]",
")",
")",
"{",
"case",
"LTGT",
":",
"temp",
"=",
"ix86_expand_sse_cmp",
"(",
"operands",
"[",
"0",
"]",
",",
"ORDERED",
",",
"operands",
"[",
"2",
"]",
",",
"operands",
"[",
"3",
"]",
",",
"NULL",
",",
"NULL",
")",
";",
"cmp",
"=",
"ix86_expand_sse_cmp",
"(",
"operands",
"[",
"0",
"]",
",",
"NE",
",",
"operands",
"[",
"2",
"]",
",",
"operands",
"[",
"3",
"]",
",",
"NULL",
",",
"NULL",
")",
";",
"code",
"=",
"AND",
";",
"break",
";",
"case",
"UNEQ",
":",
"temp",
"=",
"ix86_expand_sse_cmp",
"(",
"operands",
"[",
"0",
"]",
",",
"UNORDERED",
",",
"operands",
"[",
"2",
"]",
",",
"operands",
"[",
"3",
"]",
",",
"NULL",
",",
"NULL",
")",
";",
"cmp",
"=",
"ix86_expand_sse_cmp",
"(",
"operands",
"[",
"0",
"]",
",",
"EQ",
",",
"operands",
"[",
"2",
"]",
",",
"operands",
"[",
"3",
"]",
",",
"NULL",
",",
"NULL",
")",
";",
"code",
"=",
"IOR",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"cmp",
"=",
"expand_simple_binop",
"(",
"GET_MODE",
"(",
"cmp",
")",
",",
"code",
",",
"temp",
",",
"cmp",
",",
"cmp",
",",
"1",
",",
"OPTAB_DIRECT",
")",
";",
"}",
"else",
"cmp",
"=",
"ix86_expand_sse_cmp",
"(",
"operands",
"[",
"0",
"]",
",",
"code",
",",
"operands",
"[",
"2",
"]",
",",
"operands",
"[",
"3",
"]",
",",
"NULL",
",",
"NULL",
")",
";",
"if",
"(",
"operands",
"[",
"0",
"]",
"!=",
"cmp",
")",
"emit_move_insn",
"(",
"operands",
"[",
"0",
"]",
",",
"cmp",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Expand",
"fp",
"vector",
"comparison",
"."
] | [
"i386",
"1",
"0",
"2",
"3",
"1",
"0",
"2",
"3",
"0",
"2",
"3",
"0",
"2",
"3",
"0",
"2",
"3",
"1",
"0",
"2",
"3",
"0",
"0"
] | i386-expand | ix86_expand_fp_vec_cmp | i386 | CPU | GCC | 1,338 | 271 | 1 | [] |
[
"<s>",
"SystemZSubtarget",
"&",
"SystemZSubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
")",
"{",
"StringRef",
"CPUName",
"=",
"CPU",
";",
"if",
"(",
"CPUName",
".",
"empty",
"(",
")",
")",
"CPUName",
"=",
"\"generic\"",
";",
"ParseSubtargetFeatures",
"(",
"CPUName",
",",
"FS",
")",
";",
"if",
"(",
"HasSoftFloat",
")",
"HasVector",
"=",
"false",
";",
"if",
"(",
"!",
"HasVector",
")",
"{",
"HasVectorEnhancements1",
"=",
"false",
";",
"HasVectorEnhancements2",
"=",
"false",
";",
"HasVectorPackedDecimal",
"=",
"false",
";",
"HasVectorPackedDecimalEnhancement",
"=",
"false",
";",
"}",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"\"generic\""
] | SystemZSubtarget17 | initializeSubtargetDependencies | SystemZ | CPU | LLVM | 1,339 | 73 | 1 | [] |
[
"<s>",
"bool",
"AArch64RegisterInfo",
"::",
"isConstantPhysReg",
"(",
"unsigned",
"PhysReg",
")",
"const",
"{",
"return",
"PhysReg",
"==",
"AArch64",
"::",
"WZR",
"||",
"PhysReg",
"==",
"AArch64",
"::",
"XZR",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"PhysReg",
"is",
"unallocatable",
"and",
"constant",
"throughout",
"the",
"function",
"."
] | [
"AArch64",
"AArch64",
"AArch64::WZR",
"AArch64::XZR"
] | AArch64RegisterInfo | isConstantPhysReg | AArch64 | CPU | LLVM | 1,340 | 24 | 1 | [] |
[
"<s>",
"std",
"::",
"string",
"NVPTXAsmPrinter",
"::",
"getSymbolName",
"(",
"const",
"GlobalValue",
"*",
"GV",
")",
"const",
"{",
"MCSymbol",
"*",
"Sym",
"=",
"getSymbol",
"(",
"GV",
")",
";",
"std",
"::",
"string",
"OriginalName",
";",
"raw_string_ostream",
"OriginalNameStream",
"(",
"OriginalName",
")",
";",
"Sym",
"->",
"print",
"(",
"OriginalNameStream",
")",
";",
"OriginalNameStream",
".",
"flush",
"(",
")",
";",
"std",
"::",
"string",
"CleanName",
";",
"raw_string_ostream",
"CleanNameStream",
"(",
"CleanName",
")",
";",
"for",
"(",
"unsigned",
"I",
"=",
"0",
",",
"E",
"=",
"OriginalName",
".",
"size",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"char",
"C",
"=",
"OriginalName",
"[",
"I",
"]",
";",
"if",
"(",
"C",
"==",
"'.'",
")",
"{",
"CleanNameStream",
"<<",
"\"_$_\"",
";",
"}",
"else",
"if",
"(",
"C",
"==",
"'@'",
")",
"{",
"CleanNameStream",
"<<",
"\"_%_\"",
";",
"}",
"else",
"{",
"CleanNameStream",
"<<",
"C",
";",
"}",
"}",
"return",
"CleanNameStream",
".",
"str",
"(",
")",
";",
"}",
"</s>"
] | [
"Get",
"the",
"name",
"of",
"the",
"symbol",
"at",
"the",
"specified",
"index",
"."
] | [
"NVPTX",
"NVPTX",
"0",
"\"_$_\"",
"\"_%_\""
] | NVPTXAsmPrinter24 | getSymbolName | NVPTX | GPU | LLVM | 1,341 | 130 | 1 | [] |
[
"<s>",
"unsigned",
"MipsAsmParser",
"::",
"checkEarlyTargetMatchPredicate",
"(",
"MCInst",
"&",
"Inst",
",",
"const",
"OperandVector",
"&",
"Operands",
")",
"{",
"switch",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"Match_Success",
";",
"case",
"Mips",
"::",
"DATI",
":",
"case",
"Mips",
"::",
"DAHI",
":",
"case",
"Mips",
"::",
"DATI_MM64R6",
":",
"case",
"Mips",
"::",
"DAHI_MM64R6",
":",
"if",
"(",
"static_cast",
"<",
"MipsOperand",
"&",
">",
"(",
"*",
"Operands",
"[",
"1",
"]",
")",
".",
"isValidForTie",
"(",
"static_cast",
"<",
"MipsOperand",
"&",
">",
"(",
"*",
"Operands",
"[",
"2",
"]",
")",
")",
")",
"return",
"Match_Success",
";",
"return",
"Match_RequiresSameSrcAndDst",
";",
"}",
"}",
"</s>"
] | [
"Validate",
"the",
"instruction",
"match",
"against",
"any",
"complex",
"target",
"predicates",
"before",
"rendering",
"any",
"operands",
"to",
"it",
"."
] | [
"Mips",
"Mips",
"Mips::DATI",
"Mips::DAHI",
"Mips::DATI_MM64R6",
"Mips::DAHI_MM64R6",
"Mips",
"1",
"Mips",
"2"
] | MipsAsmParser104 | checkEarlyTargetMatchPredicate | Mips | CPU | LLVM | 1,342 | 88 | 1 | [] |
[
"<s>",
"static",
"rtx",
"s390_emit_compare_and_swap",
"(",
"enum",
"rtx_code",
"code",
",",
"rtx",
"old",
",",
"rtx",
"mem",
",",
"rtx",
"cmp",
",",
"rtx",
"new_rtx",
",",
"machine_mode",
"ccmode",
")",
"{",
"rtx",
"cc",
";",
"cc",
"=",
"gen_rtx_REG",
"(",
"ccmode",
",",
"CC_REGNUM",
")",
";",
"switch",
"(",
"GET_MODE",
"(",
"mem",
")",
")",
"{",
"case",
"E_SImode",
":",
"emit_insn",
"(",
"gen_atomic_compare_and_swapsi_internal",
"(",
"old",
",",
"mem",
",",
"cmp",
",",
"new_rtx",
",",
"cc",
")",
")",
";",
"break",
";",
"case",
"E_DImode",
":",
"emit_insn",
"(",
"gen_atomic_compare_and_swapdi_internal",
"(",
"old",
",",
"mem",
",",
"cmp",
",",
"new_rtx",
",",
"cc",
")",
")",
";",
"break",
";",
"case",
"E_TImode",
":",
"emit_insn",
"(",
"gen_atomic_compare_and_swapti_internal",
"(",
"old",
",",
"mem",
",",
"cmp",
",",
"new_rtx",
",",
"cc",
")",
")",
";",
"break",
";",
"case",
"E_QImode",
":",
"case",
"E_HImode",
":",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"s390_emit_compare",
"(",
"code",
",",
"cc",
",",
"const0_rtx",
")",
";",
"}",
"</s>"
] | [
"Emit",
"a",
"SImode",
"compare",
"and",
"swap",
"instruction",
"setting",
"MEM",
"to",
"NEW_RTX",
"if",
"OLD",
"matches",
"CMP",
".",
"Return",
"the",
"correct",
"condition",
"RTL",
"to",
"be",
"placed",
"in",
"the",
"IF_THEN_ELSE",
"of",
"the",
"conditional",
"branch",
"testing",
"the",
"result",
"."
] | [
"s390"
] | s3907 | s390_emit_compare_and_swap | s390 | MPU | GCC | 1,343 | 131 | 1 | [] |
[
"<s>",
"bool",
"BPFInstrInfo",
"::",
"analyzeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"&",
"TBB",
",",
"MachineBasicBlock",
"*",
"&",
"FBB",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
",",
"bool",
"AllowModify",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"while",
"(",
"I",
"!=",
"MBB",
".",
"begin",
"(",
")",
")",
"{",
"--",
"I",
";",
"if",
"(",
"I",
"->",
"isDebugInstr",
"(",
")",
")",
"continue",
";",
"if",
"(",
"!",
"isUnpredicatedTerminator",
"(",
"*",
"I",
")",
")",
"break",
";",
"if",
"(",
"!",
"I",
"->",
"isBranch",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"==",
"BPF",
"::",
"JMP",
")",
"{",
"if",
"(",
"!",
"AllowModify",
")",
"{",
"TBB",
"=",
"I",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"continue",
";",
"}",
"while",
"(",
"std",
"::",
"next",
"(",
"I",
")",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"std",
"::",
"next",
"(",
"I",
")",
"->",
"eraseFromParent",
"(",
")",
";",
"Cond",
".",
"clear",
"(",
")",
";",
"FBB",
"=",
"nullptr",
";",
"if",
"(",
"MBB",
".",
"isLayoutSuccessor",
"(",
"I",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
")",
")",
"{",
"TBB",
"=",
"nullptr",
";",
"I",
"->",
"eraseFromParent",
"(",
")",
";",
"I",
"=",
"MBB",
".",
"end",
"(",
")",
";",
"continue",
";",
"}",
"TBB",
"=",
"I",
"->",
"getOperand",
"(",
"0",
")",
".",
"getMBB",
"(",
")",
";",
"continue",
";",
"}",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"analyzeBranch",
"-",
"Analyze",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"MBB",
",",
"returning",
"true",
"if",
"it",
"can",
"not",
"be",
"understood",
"(",
"e.g",
"."
] | [
"BPF",
"BPF",
"BPF::JMP",
"0",
"0",
"0"
] | BPFInstrInfo12 | analyzeBranch | BPF | Virtual ISA | LLVM | 1,344 | 224 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"ARM PIC Global Base Reg Initialization\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"ARM",
"\"ARM PIC Global Base Reg Initialization\""
] | ARMInstrInfo | getPassName | ARM | CPU | LLVM | 1,345 | 13 | 1 | [] |
[
"<s>",
"static",
"bool",
"arm_sets_movw_movt_fusible_p",
"(",
"rtx",
"prev_set",
",",
"rtx",
"curr_set",
")",
"{",
"rtx",
"set_dest",
"=",
"SET_DEST",
"(",
"curr_set",
")",
";",
"if",
"(",
"GET_MODE",
"(",
"set_dest",
")",
"!=",
"SImode",
")",
"return",
"false",
";",
"if",
"(",
"GET_CODE",
"(",
"set_dest",
")",
"==",
"ZERO_EXTRACT",
")",
"{",
"if",
"(",
"CONST_INT_P",
"(",
"SET_SRC",
"(",
"curr_set",
")",
")",
"&&",
"CONST_INT_P",
"(",
"SET_SRC",
"(",
"prev_set",
")",
")",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"set_dest",
",",
"0",
")",
")",
"&&",
"REG_P",
"(",
"SET_DEST",
"(",
"prev_set",
")",
")",
"&&",
"REGNO",
"(",
"XEXP",
"(",
"set_dest",
",",
"0",
")",
")",
"==",
"REGNO",
"(",
"SET_DEST",
"(",
"prev_set",
")",
")",
")",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"SET_SRC",
"(",
"curr_set",
")",
")",
"==",
"LO_SUM",
"&&",
"REG_P",
"(",
"SET_DEST",
"(",
"curr_set",
")",
")",
"&&",
"REG_P",
"(",
"SET_DEST",
"(",
"prev_set",
")",
")",
"&&",
"GET_CODE",
"(",
"SET_SRC",
"(",
"prev_set",
")",
")",
"==",
"HIGH",
"&&",
"REGNO",
"(",
"SET_DEST",
"(",
"curr_set",
")",
")",
"==",
"REGNO",
"(",
"SET_DEST",
"(",
"prev_set",
")",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"two",
"back-to-back",
"sets",
"PREV_SET",
",",
"CURR_SET",
"are",
"suitable",
"for",
"MOVW",
"/",
"MOVT",
"macro",
"fusion",
"."
] | [
"arm",
"0",
"0"
] | arm | arm_sets_movw_movt_fusible_p | arm | CPU | GCC | 1,346 | 161 | 1 | [] |
[
"<s>",
"unsigned",
"SIInstrInfo",
"::",
"getAddressSpaceForPseudoSourceKind",
"(",
"unsigned",
"Kind",
")",
"const",
"{",
"switch",
"(",
"Kind",
")",
"{",
"case",
"PseudoSourceValue",
"::",
"Stack",
":",
"case",
"PseudoSourceValue",
"::",
"FixedStack",
":",
"return",
"AMDGPUAS",
"::",
"PRIVATE_ADDRESS",
";",
"case",
"PseudoSourceValue",
"::",
"ConstantPool",
":",
"case",
"PseudoSourceValue",
"::",
"GOT",
":",
"case",
"PseudoSourceValue",
"::",
"JumpTable",
":",
"case",
"PseudoSourceValue",
"::",
"GlobalValueCallEntry",
":",
"case",
"PseudoSourceValue",
"::",
"ExternalSymbolCallEntry",
":",
"case",
"PseudoSourceValue",
"::",
"TargetCustom",
":",
"return",
"AMDGPUAS",
"::",
"CONSTANT_ADDRESS",
";",
"case",
"PseudoSourceValue",
"::",
"CapTable",
":",
"return",
"AMDGPUAS",
"::",
"CONSTANT_ADDRESS",
";",
"}",
"return",
"AMDGPUAS",
"::",
"FLAT_ADDRESS",
";",
"}",
"</s>"
] | [
"getAddressSpaceForPseudoSourceKind",
"-",
"Given",
"the",
"kind",
"of",
"memory",
"(",
"e.g",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU",
"AMDGPU",
"AMDGPU",
"AMDGPU"
] | SIInstrInfo70 | getAddressSpaceForPseudoSourceKind | AMDGPU | GPU | LLVM | 1,347 | 82 | 1 | [] |
[
"<s>",
"static",
"bool",
"is_fmul_fmac_insn",
"(",
"rtx_insn",
"*",
"insn",
",",
"bool",
"fmul_ok",
")",
"{",
"enum",
"attr_type",
"t",
";",
"if",
"(",
"!",
"NONDEBUG_INSN_P",
"(",
"insn",
")",
")",
"return",
"false",
";",
"if",
"(",
"recog_memoized",
"(",
"insn",
")",
"<",
"0",
")",
"return",
"false",
";",
"t",
"=",
"get_attr_type",
"(",
"insn",
")",
";",
"return",
"is_fmac_op",
"(",
"t",
")",
"||",
"(",
"fmul_ok",
"&&",
"is_fmul_op",
"(",
"t",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"whether",
"INSN",
"is",
"an",
"FMUL",
"(",
"if",
"FMUL_OK",
"is",
"true",
")",
"or",
"FMADD/FMSUB",
"instruction",
"."
] | [
"aarch64",
"0"
] | cortex-a57-fma-steering | is_fmul_fmac_insn | aarch64 | CPU | GCC | 1,348 | 62 | 1 | [] |
[
"<s>",
"void",
"fma_node",
"::",
"add_child",
"(",
"fma_node",
"*",
"child",
")",
"{",
"this",
"->",
"m_children",
"->",
"push_back",
"(",
"child",
")",
";",
"}",
"</s>"
] | [
"Add",
"a",
"child",
"to",
"this",
"node",
"in",
"the",
"list",
"of",
"children",
"."
] | [
"aarch64"
] | cortex-a57-fma-steering | add_child | aarch64 | CPU | GCC | 1,349 | 20 | 1 | [] |
[
"<s>",
"static",
"int",
"classify_argument",
"(",
"machine_mode",
"mode",
",",
"const_tree",
"type",
",",
"enum",
"x86_64_reg_class",
"classes",
"[",
"MAX_CLASSES",
"]",
",",
"int",
"bit_offset",
")",
"{",
"int",
"zero_width_bitfields",
"=",
"0",
";",
"static",
"bool",
"warned",
"=",
"false",
";",
"int",
"n",
"=",
"classify_argument",
"(",
"mode",
",",
"type",
",",
"classes",
",",
"bit_offset",
",",
"zero_width_bitfields",
")",
";",
"if",
"(",
"!",
"zero_width_bitfields",
"||",
"warned",
"||",
"!",
"warn_psabi",
")",
"return",
"n",
";",
"enum",
"x86_64_reg_class",
"alt_classes",
"[",
"MAX_CLASSES",
"]",
";",
"zero_width_bitfields",
"=",
"2",
";",
"if",
"(",
"classify_argument",
"(",
"mode",
",",
"type",
",",
"alt_classes",
",",
"bit_offset",
",",
"zero_width_bitfields",
")",
"!=",
"n",
")",
"zero_width_bitfields",
"=",
"3",
";",
"else",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
")",
"if",
"(",
"classes",
"[",
"i",
"]",
"!=",
"alt_classes",
"[",
"i",
"]",
")",
"{",
"zero_width_bitfields",
"=",
"3",
";",
"break",
";",
"}",
"if",
"(",
"zero_width_bitfields",
"==",
"3",
")",
"{",
"warned",
"=",
"true",
";",
"const",
"char",
"*",
"url",
"=",
"CHANGES_ROOT_URL",
"\"gcc-12/changes.html#zero_width_bitfields\"",
";",
"inform",
"(",
"input_location",
",",
"\"the ABI of passing C structures with zero-width bit-fields\"",
"\" has changed in GCC %{12.1%}\"",
",",
"url",
")",
";",
"}",
"return",
"n",
";",
"}",
"</s>"
] | [
"Classify",
"the",
"argument",
"of",
"type",
"TYPE",
"and",
"mode",
"MODE",
".",
"CLASSES",
"will",
"be",
"filled",
"by",
"the",
"register",
"class",
"used",
"to",
"pass",
"each",
"word",
"of",
"the",
"operand",
".",
"The",
"number",
"of",
"words",
"is",
"returned",
".",
"In",
"case",
"the",
"parameter",
"should",
"be",
"passed",
"in",
"memory",
",",
"0",
"is",
"returned",
".",
"As",
"a",
"special",
"case",
"for",
"zero",
"sized",
"containers",
",",
"classes",
"[",
"0",
"]",
"will",
"be",
"NO_CLASS",
"and",
"1",
"is",
"returned",
".",
"BIT_OFFSET",
"is",
"used",
"internally",
"for",
"handling",
"records",
"and",
"specifies",
"offset",
"of",
"the",
"offset",
"in",
"bits",
"modulo",
"256",
"to",
"avoid",
"overflow",
"cases",
".",
"See",
"the",
"x86-64",
"PS",
"ABI",
"for",
"details",
"."
] | [
"i386",
"0",
"2",
"3",
"0",
"3",
"3",
"\"gcc-12/changes.html#zero_width_bitfields\"",
"\"the ABI of passing C structures with zero-width bit-fields\"",
"\" has changed in GCC %{12.1%}\""
] | i386 | classify_argument | i386 | CPU | GCC | 1,350 | 162 | 1 | [] |
[
"<s>",
"Register",
"TPCTargetLowering",
"::",
"getRegisterByName",
"(",
"const",
"char",
"*",
"RegName",
",",
"LLT",
"VT",
",",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"unsigned",
"Reg",
"=",
"StringSwitch",
"<",
"unsigned",
">",
"(",
"RegName",
")",
".",
"Case",
"(",
"\"sp0\"",
",",
"TPC",
"::",
"SP0",
")",
".",
"Case",
"(",
"\"vp0\"",
",",
"TPC",
"::",
"VP0",
")",
".",
"Case",
"(",
"\"lfsr\"",
",",
"TPC",
"::",
"LFSR",
")",
".",
"Case",
"(",
"\"lfsr_no_change\"",
",",
"TPC",
"::",
"LFSR_NO_CHANGE",
")",
".",
"Case",
"(",
"\"s_lfsr\"",
",",
"TPC",
"::",
"S_LFSR",
")",
".",
"Case",
"(",
"\"s_lfsr_no_change\"",
",",
"TPC",
"::",
"S_LFSR_NO_CHANGE",
")",
".",
"Case",
"(",
"\"v_lane_id_32\"",
",",
"TPC",
"::",
"V_LANE_ID_32",
")",
".",
"Case",
"(",
"\"v_lane_id_16\"",
",",
"TPC",
"::",
"V_LANE_ID_16",
")",
".",
"Case",
"(",
"\"v_lane_id_8\"",
",",
"TPC",
"::",
"V_LANE_ID_8",
")",
".",
"Case",
"(",
"\"i2\"",
",",
"TPC",
"::",
"I2",
")",
".",
"Default",
"(",
"0",
")",
";",
"if",
"(",
"Reg",
")",
"return",
"Reg",
";",
"report_fatal_error",
"(",
"\"Invalid register name global variable\"",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"register",
"ID",
"of",
"the",
"name",
"passed",
"in",
"."
] | [
"TPC",
"TPC",
"\"sp0\"",
"TPC::SP0",
"\"vp0\"",
"TPC::VP0",
"\"lfsr\"",
"TPC::LFSR",
"\"lfsr_no_change\"",
"TPC::LFSR_NO_CHANGE",
"\"s_lfsr\"",
"TPC::S_LFSR",
"\"s_lfsr_no_change\"",
"TPC::S_LFSR_NO_CHANGE",
"\"v_lane_id_32\"",
"TPC::V_LANE_ID_32",
"\"v_lane_id_16\"",
"TPC::V_LANE_ID_16",
"\"v_lane_id_8\"",
"TPC::V_LANE_ID_8",
"\"i2\"",
"TPC::I2",
"0",
"\"Invalid register name global variable\""
] | TPCISelLowering | getRegisterByName | TPC | Virtual ISA | LLVM | 1,351 | 139 | 1 | [] |
[
"<s>",
"void",
"AMDGPUMCInstLower",
"::",
"lower",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"MCInst",
"&",
"OutMI",
")",
"const",
"{",
"int",
"MCOpcode",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
"->",
"pseudoToMCOpcode",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"MCOpcode",
"==",
"-",
"1",
")",
"{",
"LLVMContext",
"&",
"C",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getFunction",
"(",
")",
"->",
"getContext",
"(",
")",
";",
"C",
".",
"emitError",
"(",
"\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"",
"\"a target-specific version: \"",
"+",
"Twine",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
";",
"}",
"OutMI",
".",
"setOpcode",
"(",
"MCOpcode",
")",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"MI",
"->",
"explicit_operands",
"(",
")",
")",
"{",
"MCOperand",
"MCOp",
";",
"switch",
"(",
"MO",
".",
"getType",
"(",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"unknown operand type\"",
")",
";",
"case",
"MachineOperand",
"::",
"MO_Immediate",
":",
"MCOp",
"=",
"MCOperand",
"::",
"CreateImm",
"(",
"MO",
".",
"getImm",
"(",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_Register",
":",
"MCOp",
"=",
"MCOperand",
"::",
"CreateReg",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_MachineBasicBlock",
":",
"MCOp",
"=",
"MCOperand",
"::",
"CreateExpr",
"(",
"MCSymbolRefExpr",
"::",
"Create",
"(",
"MO",
".",
"getMBB",
"(",
")",
"->",
"getSymbol",
"(",
")",
",",
"Ctx",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_GlobalAddress",
":",
"{",
"const",
"GlobalValue",
"*",
"GV",
"=",
"MO",
".",
"getGlobal",
"(",
")",
";",
"MCSymbol",
"*",
"Sym",
"=",
"Ctx",
".",
"GetOrCreateSymbol",
"(",
"StringRef",
"(",
"GV",
"->",
"getName",
"(",
")",
")",
")",
";",
"MCOp",
"=",
"MCOperand",
"::",
"CreateExpr",
"(",
"MCSymbolRefExpr",
"::",
"Create",
"(",
"Sym",
",",
"Ctx",
")",
")",
";",
"break",
";",
"}",
"case",
"MachineOperand",
"::",
"MO_TargetIndex",
":",
"{",
"assert",
"(",
"MO",
".",
"getIndex",
"(",
")",
"==",
"AMDGPU",
"::",
"TI_CONSTDATA_START",
")",
";",
"MCSymbol",
"*",
"Sym",
"=",
"Ctx",
".",
"GetOrCreateSymbol",
"(",
"StringRef",
"(",
"END_OF_TEXT_LABEL_NAME",
")",
")",
";",
"const",
"MCSymbolRefExpr",
"*",
"Expr",
"=",
"MCSymbolRefExpr",
"::",
"Create",
"(",
"Sym",
",",
"Ctx",
")",
";",
"MCOp",
"=",
"MCOperand",
"::",
"CreateExpr",
"(",
"Expr",
")",
";",
"break",
";",
"}",
"}",
"OutMI",
".",
"addOperand",
"(",
"MCOp",
")",
";",
"}",
"}",
"</s>"
] | [
"The",
"instruction",
"is",
"lowered",
"."
] | [
"R600",
"1",
"\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"",
"\"a target-specific version: \"",
"\"unknown operand type\""
] | AMDGPUMCInstLower39 | lower | R600 | GPU | LLVM | 1,352 | 316 | 1 | [] |
[
"<s>",
"void",
"AArch64CallLowering",
"::",
"splitToValueTypes",
"(",
"const",
"ArgInfo",
"&",
"OrigArg",
",",
"SmallVectorImpl",
"<",
"ArgInfo",
">",
"&",
"SplitArgs",
",",
"const",
"DataLayout",
"&",
"DL",
",",
"MachineRegisterInfo",
"&",
"MRI",
",",
"SplitArgTy",
"PerformArgSplit",
")",
"const",
"{",
"const",
"AArch64TargetLowering",
"&",
"TLI",
"=",
"*",
"getTLI",
"<",
"AArch64TargetLowering",
">",
"(",
")",
";",
"LLVMContext",
"&",
"Ctx",
"=",
"OrigArg",
".",
"Ty",
"->",
"getContext",
"(",
")",
";",
"SmallVector",
"<",
"EVT",
",",
"4",
">",
"SplitVTs",
";",
"SmallVector",
"<",
"uint64_t",
",",
"4",
">",
"Offsets",
";",
"ComputeValueVTs",
"(",
"TLI",
",",
"DL",
",",
"OrigArg",
".",
"Ty",
",",
"SplitVTs",
",",
"&",
"Offsets",
",",
"0",
")",
";",
"if",
"(",
"SplitVTs",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"SplitArgs",
".",
"emplace_back",
"(",
"OrigArg",
".",
"Reg",
",",
"SplitVTs",
"[",
"0",
"]",
".",
"getTypeForEVT",
"(",
"Ctx",
")",
",",
"OrigArg",
".",
"Flags",
")",
";",
"return",
";",
"}",
"unsigned",
"FirstRegIdx",
"=",
"SplitArgs",
".",
"size",
"(",
")",
";",
"for",
"(",
"auto",
"SplitVT",
":",
"SplitVTs",
")",
"{",
"Type",
"*",
"SplitTy",
"=",
"SplitVT",
".",
"getTypeForEVT",
"(",
"Ctx",
")",
";",
"SplitArgs",
".",
"push_back",
"(",
"ArgInfo",
"{",
"MRI",
".",
"createGenericVirtualRegister",
"(",
"LLT",
"{",
"*",
"SplitTy",
",",
"DL",
"}",
")",
",",
"SplitTy",
",",
"OrigArg",
".",
"Flags",
"}",
")",
";",
"}",
"SmallVector",
"<",
"uint64_t",
",",
"4",
">",
"BitOffsets",
";",
"for",
"(",
"auto",
"Offset",
":",
"Offsets",
")",
"BitOffsets",
".",
"push_back",
"(",
"Offset",
"*",
"8",
")",
";",
"SmallVector",
"<",
"unsigned",
",",
"8",
">",
"SplitRegs",
";",
"for",
"(",
"auto",
"I",
"=",
"&",
"SplitArgs",
"[",
"FirstRegIdx",
"]",
";",
"I",
"!=",
"SplitArgs",
".",
"end",
"(",
")",
";",
"++",
"I",
")",
"SplitRegs",
".",
"push_back",
"(",
"I",
"->",
"Reg",
")",
";",
"PerformArgSplit",
"(",
"SplitRegs",
",",
"BitOffsets",
")",
";",
"}",
"</s>"
] | [
"Break",
"OrigArgInfo",
"into",
"one",
"or",
"more",
"pieces",
"the",
"calling",
"convention",
"can",
"process",
",",
"returned",
"in",
"SplitArgs",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"4",
"4",
"0",
"1",
"0",
"4",
"8",
"8"
] | AArch64CallLowering22 | splitToValueTypes | AArch64 | CPU | LLVM | 1,353 | 254 | 1 | [] |
[
"<s>",
"void",
"NVPTXTargetStreamer",
"::",
"outputDwarfFileDirectives",
"(",
")",
"{",
"for",
"(",
"const",
"std",
"::",
"string",
"&",
"S",
":",
"DwarfFiles",
")",
"getStreamer",
"(",
")",
".",
"EmitRawText",
"(",
"S",
".",
"data",
"(",
")",
")",
";",
"DwarfFiles",
".",
"clear",
"(",
")",
";",
"}",
"</s>"
] | [
"Outputs",
"the",
"list",
"of",
"the",
"DWARF",
"'.file",
"'",
"directives",
"to",
"the",
"streamer",
"."
] | [
"NVPTX",
"NVPTX"
] | NVPTXTargetStreamer (2) | outputDwarfFileDirectives | NVPTX | GPU | LLVM | 1,354 | 38 | 1 | [] |
[
"<s>",
"bool",
"PPCFrameLowering",
"::",
"spillCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"!",
"Subtarget",
".",
"isSVR4ABI",
"(",
")",
")",
"return",
"false",
";",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"PPCInstrInfo",
"&",
"TII",
"=",
"*",
"static_cast",
"<",
"const",
"PPCInstrInfo",
"*",
">",
"(",
"MF",
"->",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"DebugLoc",
"DL",
";",
"bool",
"CRSpilled",
"=",
"false",
";",
"MachineInstrBuilder",
"CRMIB",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"]",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"Reg",
"==",
"PPC",
"::",
"VRSAVE",
"&&",
"!",
"Subtarget",
".",
"isDarwinABI",
"(",
")",
")",
"continue",
";",
"bool",
"IsCRField",
"=",
"PPC",
"::",
"CR2",
"<=",
"Reg",
"&&",
"Reg",
"<=",
"PPC",
"::",
"CR4",
";",
"MBB",
".",
"addLiveIn",
"(",
"Reg",
")",
";",
"if",
"(",
"CRSpilled",
"&&",
"IsCRField",
")",
"{",
"CRMIB",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"ImplicitKill",
")",
";",
"continue",
";",
"}",
"if",
"(",
"IsCRField",
")",
"{",
"PPCFunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
"->",
"getInfo",
"<",
"PPCFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"Subtarget",
".",
"isPPC64",
"(",
")",
")",
"{",
"FuncInfo",
"->",
"addMustSaveCR",
"(",
"Reg",
")",
";",
"}",
"else",
"{",
"CRSpilled",
"=",
"true",
";",
"FuncInfo",
"->",
"setSpillsCR",
"(",
")",
";",
"CRMIB",
"=",
"BuildMI",
"(",
"*",
"MF",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"PPC",
"::",
"MFCR",
")",
",",
"PPC",
"::",
"R12",
")",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"ImplicitKill",
")",
";",
"MBB",
".",
"insert",
"(",
"MI",
",",
"CRMIB",
")",
";",
"MBB",
".",
"insert",
"(",
"MI",
",",
"addFrameReference",
"(",
"BuildMI",
"(",
"*",
"MF",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"PPC",
"::",
"STW",
")",
")",
".",
"addReg",
"(",
"PPC",
"::",
"R12",
",",
"getKillRegState",
"(",
"true",
")",
")",
",",
"CSI",
"[",
"i",
"]",
".",
"getFrameIdx",
"(",
")",
")",
")",
";",
"}",
"}",
"else",
"{",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TRI",
"->",
"getMinimalPhysRegClass",
"(",
"Reg",
")",
";",
"TII",
".",
"storeRegToStackSlot",
"(",
"MBB",
",",
"MI",
",",
"Reg",
",",
"true",
",",
"CSI",
"[",
"i",
"]",
".",
"getFrameIdx",
"(",
")",
",",
"RC",
",",
"TRI",
")",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"spillCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"spill",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"store",
"instructions",
"via",
"storeRegToStackSlot",
"(",
")",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC",
"0",
"PPC::VRSAVE",
"PPC::CR2",
"PPC::CR4",
"PPC",
"PPC",
"PPC",
"PPC::MFCR",
"PPC::R12",
"PPC::STW",
"PPC::R12"
] | PPCFrameLowering79 | spillCalleeSavedRegisters | PowerPC | CPU | LLVM | 1,355 | 367 | 1 | [] |
[
"<s>",
"static",
"bool",
"ix86_can_change_mode_class",
"(",
"machine_mode",
"from",
",",
"machine_mode",
"to",
",",
"reg_class_t",
"regclass",
")",
"{",
"if",
"(",
"from",
"==",
"to",
")",
"return",
"true",
";",
"if",
"(",
"MAYBE_FLOAT_CLASS_P",
"(",
"regclass",
")",
")",
"return",
"false",
";",
"if",
"(",
"MAYBE_SSE_CLASS_P",
"(",
"regclass",
")",
"||",
"MAYBE_MMX_CLASS_P",
"(",
"regclass",
")",
")",
"{",
"int",
"mov_size",
"=",
"MAYBE_SSE_CLASS_P",
"(",
"regclass",
")",
"&&",
"TARGET_SSE2",
"?",
"2",
":",
"4",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"from",
")",
"<",
"mov_size",
"||",
"GET_MODE_SIZE",
"(",
"to",
")",
"<",
"mov_size",
")",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_CAN_CHANGE_MODE_CLASS",
"."
] | [
"i386",
"2",
"4"
] | i3861 | ix86_can_change_mode_class | i386 | CPU | GCC | 1,356 | 84 | 1 | [] |
[
"<s>",
"MVT",
"getPointerTy",
"(",
"const",
"DataLayout",
"&",
"DL",
",",
"uint32_t",
"AS",
"=",
"0",
")",
"const",
"override",
"{",
"if",
"(",
"AS",
"==",
"WasmAddressSpace",
"::",
"EXTERNREF",
")",
"return",
"MVT",
"::",
"externref",
";",
"if",
"(",
"AS",
"==",
"WasmAddressSpace",
"::",
"FUNCREF",
")",
"return",
"MVT",
"::",
"funcref",
";",
"return",
"TargetLowering",
"::",
"getPointerTy",
"(",
"DL",
",",
"AS",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"pointer",
"type",
"for",
"the",
"given",
"address",
"space",
",",
"defaults",
"to",
"the",
"pointer",
"type",
"from",
"the",
"data",
"layout",
"."
] | [
"WebAssembly",
"0",
"WasmAddressSpace::EXTERNREF",
"MVT::externref",
"WasmAddressSpace::FUNCREF",
"MVT::funcref"
] | WebAssemblyISelLowering16 | getPointerTy | WebAssembly | Virtual ISA | LLVM | 1,357 | 53 | 1 | [] |
[
"<s>",
"MVT",
"ARM64TargetLowering",
"::",
"getScalarShiftAmountTy",
"(",
"EVT",
"LHSTy",
")",
"const",
"{",
"return",
"MVT",
"::",
"i64",
";",
"}",
"</s>"
] | [
"Return",
"the",
"type",
"to",
"use",
"for",
"a",
"scalar",
"shift",
"opcode",
",",
"given",
"the",
"shifted",
"amount",
"type",
"."
] | [
"ARM64",
"ARM64",
"MVT::i64"
] | ARM64ISelLowering | getScalarShiftAmountTy | ARM64 | CPU | LLVM | 1,358 | 16 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"isLegalAddressingMode",
"(",
"const",
"AddrMode",
"&",
"AM",
",",
"const",
"Type",
"*",
"Ty",
")",
"const",
"{",
"MVT",
"VT",
"=",
"getValueType",
"(",
"Ty",
",",
"true",
")",
";",
"if",
"(",
"!",
"isLegalAddressImmediate",
"(",
"AM",
".",
"BaseOffs",
",",
"VT",
",",
"Subtarget",
")",
")",
"return",
"false",
";",
"if",
"(",
"AM",
".",
"BaseGV",
")",
"return",
"false",
";",
"switch",
"(",
"AM",
".",
"Scale",
")",
"{",
"case",
"0",
":",
"break",
";",
"case",
"1",
":",
"if",
"(",
"Subtarget",
"->",
"isThumb",
"(",
")",
")",
"return",
"false",
";",
"default",
":",
"if",
"(",
"AM",
".",
"BaseOffs",
")",
"return",
"false",
";",
"if",
"(",
"!",
"VT",
".",
"isSimple",
"(",
")",
")",
"return",
"false",
";",
"int",
"Scale",
"=",
"AM",
".",
"Scale",
";",
"switch",
"(",
"VT",
".",
"getSimpleVT",
"(",
")",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"MVT",
"::",
"i1",
":",
"case",
"MVT",
"::",
"i8",
":",
"case",
"MVT",
"::",
"i32",
":",
"case",
"MVT",
"::",
"i64",
":",
"if",
"(",
"Scale",
"<",
"0",
")",
"Scale",
"=",
"-",
"Scale",
";",
"if",
"(",
"Scale",
"==",
"1",
")",
"return",
"true",
";",
"return",
"isPowerOf2_32",
"(",
"Scale",
"&",
"~",
"1",
")",
";",
"case",
"MVT",
"::",
"i16",
":",
"if",
"(",
"(",
"(",
"unsigned",
")",
"AM",
".",
"HasBaseReg",
"+",
"Scale",
")",
"<=",
"2",
")",
"return",
"true",
";",
"return",
"false",
";",
"case",
"MVT",
"::",
"isVoid",
":",
"if",
"(",
"AM",
".",
"Scale",
"&",
"1",
")",
"return",
"false",
";",
"return",
"isPowerOf2_32",
"(",
"AM",
".",
"Scale",
")",
";",
"}",
"break",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"isLegalAddressingMode",
"-",
"Return",
"true",
"if",
"the",
"addressing",
"mode",
"represented",
"by",
"AM",
"is",
"legal",
"for",
"this",
"target",
",",
"for",
"a",
"load/store",
"of",
"the",
"specified",
"type",
"."
] | [
"ARM",
"ARM",
"0",
"1",
"MVT::i1",
"MVT::i8",
"MVT::i32",
"MVT::i64",
"0",
"1",
"1",
"MVT::i16",
"2",
"MVT::isVoid",
"1"
] | ARMISelLowering57 | isLegalAddressingMode | ARM | CPU | LLVM | 1,359 | 230 | 1 | [] |
[
"<s>",
"bool",
"PPCRegisterInfo",
"::",
"requiresFrameIndexScavenging",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"PPCSubtarget",
"&",
"Subtarget",
"=",
"MF",
".",
"getSubtarget",
"<",
"PPCSubtarget",
">",
"(",
")",
";",
"const",
"PPCInstrInfo",
"*",
"InstrInfo",
"=",
"Subtarget",
".",
"getInstrInfo",
"(",
")",
";",
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"Info",
"=",
"MFI",
".",
"getCalleeSavedInfo",
"(",
")",
";",
"if",
"(",
"!",
"MFI",
".",
"isCalleeSavedInfoValid",
"(",
")",
")",
"return",
"true",
";",
"unsigned",
"FrameSize",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"if",
"(",
"FrameSize",
"&",
"~",
"0x7FFF",
")",
"return",
"true",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"Info",
".",
"size",
"(",
")",
";",
"i",
"++",
")",
"{",
"int",
"FrIdx",
"=",
"Info",
"[",
"i",
"]",
".",
"getFrameIdx",
"(",
")",
";",
"unsigned",
"Reg",
"=",
"Info",
"[",
"i",
"]",
".",
"getReg",
"(",
")",
";",
"unsigned",
"Opcode",
"=",
"InstrInfo",
"->",
"getStoreOpcodeForSpill",
"(",
"Reg",
")",
";",
"if",
"(",
"!",
"MFI",
".",
"isFixedObjectIndex",
"(",
"FrIdx",
")",
")",
"{",
"if",
"(",
"offsetMinAlignForOpcode",
"(",
"Opcode",
")",
">",
"1",
")",
"return",
"true",
";",
"}",
"if",
"(",
"InstrInfo",
"->",
"isXFormMemOp",
"(",
"Opcode",
")",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"requires",
"post",
"PEI",
"scavenging",
"of",
"registers",
"for",
"materializing",
"frame",
"index",
"constants",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC",
"PPC",
"0x7FFF",
"0",
"1"
] | PPCRegisterInfo10 | requiresFrameIndexScavenging | PowerPC | CPU | LLVM | 1,360 | 189 | 1 | [] |
[
"<s>",
"unsigned",
"TOYInstrInfo",
"::",
"removeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"int",
"*",
"BytesRemoved",
")",
"const",
"{",
"assert",
"(",
"0",
"&&",
"\"Unimplemented\"",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Remove",
"the",
"branching",
"code",
"at",
"the",
"end",
"of",
"the",
"specific",
"MBB",
"."
] | [
"TOY",
"TOY",
"0",
"\"Unimplemented\"",
"0"
] | TOYInstrInfo1 | removeBranch | TOY | CPU | LLVM | 1,361 | 26 | 1 | [] |
[
"<s>",
"std",
"::",
"string",
"AMDGPUIntrinsicInfo",
"::",
"getName",
"(",
"unsigned",
"IntrID",
",",
"Type",
"*",
"*",
"Tys",
",",
"unsigned",
"numTys",
")",
"const",
"{",
"if",
"(",
"IntrID",
"<",
"Intrinsic",
"::",
"num_intrinsics",
")",
"{",
"return",
"nullptr",
";",
"}",
"assert",
"(",
"IntrID",
"<",
"AMDGPUIntrinsic",
"::",
"num_AMDGPU_intrinsics",
"&&",
"\"Invalid intrinsic ID\"",
")",
";",
"std",
"::",
"string",
"Result",
"(",
"IntrinsicNameTable",
"[",
"IntrID",
"-",
"Intrinsic",
"::",
"num_intrinsics",
"]",
")",
";",
"return",
"Result",
";",
"}",
"</s>"
] | [
"Return",
"a",
"string",
"with",
"the",
"name",
"of",
"the",
"plan",
"and",
"the",
"applicable",
"VFs",
"and",
"UFs",
"."
] | [
"AMDGPU",
"AMDGPU",
"Intrinsic::num_intrinsics",
"AMDGPUIntrinsic::num_AMDGPU_intrinsics",
"\"Invalid intrinsic ID\"",
"Intrinsic::num_intrinsics"
] | AMDGPUIntrinsicInfo1 | getName | AMDGPU | GPU | LLVM | 1,362 | 63 | 1 | [] |
[
"<s>",
"void",
"X86AvoidSFBPass",
"::",
"buildCopy",
"(",
"MachineInstr",
"*",
"LoadInst",
",",
"unsigned",
"NLoadOpcode",
",",
"int64_t",
"LoadDisp",
",",
"MachineInstr",
"*",
"StoreInst",
",",
"unsigned",
"NStoreOpcode",
",",
"int64_t",
"StoreDisp",
",",
"unsigned",
"Size",
",",
"int64_t",
"LMMOffset",
",",
"int64_t",
"SMMOffset",
")",
"{",
"MachineOperand",
"&",
"LoadBase",
"=",
"getBaseOperand",
"(",
"LoadInst",
")",
";",
"MachineOperand",
"&",
"StoreBase",
"=",
"getBaseOperand",
"(",
"StoreInst",
")",
";",
"MachineBasicBlock",
"*",
"MBB",
"=",
"LoadInst",
"->",
"getParent",
"(",
")",
";",
"MachineMemOperand",
"*",
"LMMO",
"=",
"*",
"LoadInst",
"->",
"memoperands_begin",
"(",
")",
";",
"MachineMemOperand",
"*",
"SMMO",
"=",
"*",
"StoreInst",
"->",
"memoperands_begin",
"(",
")",
";",
"unsigned",
"Reg1",
"=",
"MRI",
"->",
"createVirtualRegister",
"(",
"TII",
"->",
"getRegClass",
"(",
"TII",
"->",
"get",
"(",
"NLoadOpcode",
")",
",",
"0",
",",
"TRI",
",",
"*",
"(",
"MBB",
"->",
"getParent",
"(",
")",
")",
")",
")",
";",
"MachineInstr",
"*",
"NewLoad",
"=",
"BuildMI",
"(",
"*",
"MBB",
",",
"LoadInst",
",",
"LoadInst",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"NLoadOpcode",
")",
",",
"Reg1",
")",
".",
"add",
"(",
"LoadBase",
")",
".",
"addImm",
"(",
"1",
")",
".",
"addReg",
"(",
"X86",
"::",
"NoRegister",
")",
".",
"addImm",
"(",
"LoadDisp",
")",
".",
"addReg",
"(",
"X86",
"::",
"NoRegister",
")",
".",
"addMemOperand",
"(",
"MBB",
"->",
"getParent",
"(",
")",
"->",
"getMachineMemOperand",
"(",
"LMMO",
",",
"LMMOffset",
",",
"Size",
")",
")",
";",
"if",
"(",
"LoadBase",
".",
"isReg",
"(",
")",
")",
"getBaseOperand",
"(",
"NewLoad",
")",
".",
"setIsKill",
"(",
"false",
")",
";",
"LLVM_DEBUG",
"(",
"NewLoad",
"->",
"dump",
"(",
")",
")",
";",
"MachineInstr",
"*",
"StInst",
"=",
"StoreInst",
";",
"auto",
"PrevInstrIt",
"=",
"skipDebugInstructionsBackward",
"(",
"std",
"::",
"prev",
"(",
"MachineBasicBlock",
"::",
"instr_iterator",
"(",
"StoreInst",
")",
")",
",",
"MBB",
"->",
"instr_begin",
"(",
")",
")",
";",
"if",
"(",
"PrevInstrIt",
".",
"getNodePtr",
"(",
")",
"==",
"LoadInst",
")",
"StInst",
"=",
"LoadInst",
";",
"MachineInstr",
"*",
"NewStore",
"=",
"BuildMI",
"(",
"*",
"MBB",
",",
"StInst",
",",
"StInst",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"NStoreOpcode",
")",
")",
".",
"add",
"(",
"StoreBase",
")",
".",
"addImm",
"(",
"1",
")",
".",
"addReg",
"(",
"X86",
"::",
"NoRegister",
")",
".",
"addImm",
"(",
"StoreDisp",
")",
".",
"addReg",
"(",
"X86",
"::",
"NoRegister",
")",
".",
"addReg",
"(",
"Reg1",
")",
".",
"addMemOperand",
"(",
"MBB",
"->",
"getParent",
"(",
")",
"->",
"getMachineMemOperand",
"(",
"SMMO",
",",
"SMMOffset",
",",
"Size",
")",
")",
";",
"if",
"(",
"StoreBase",
".",
"isReg",
"(",
")",
")",
"getBaseOperand",
"(",
"NewStore",
")",
".",
"setIsKill",
"(",
"false",
")",
";",
"MachineOperand",
"&",
"StoreSrcVReg",
"=",
"StoreInst",
"->",
"getOperand",
"(",
"X86",
"::",
"AddrNumOperands",
")",
";",
"assert",
"(",
"StoreSrcVReg",
".",
"isReg",
"(",
")",
"&&",
"\"Expected virtual register\"",
")",
";",
"NewStore",
"->",
"getOperand",
"(",
"X86",
"::",
"AddrNumOperands",
")",
".",
"setIsKill",
"(",
"StoreSrcVReg",
".",
"isKill",
"(",
")",
")",
";",
"LLVM_DEBUG",
"(",
"NewStore",
"->",
"dump",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Build",
"and",
"insert",
"Res",
"=",
"COPY",
"Op",
"."
] | [
"X86",
"X86",
"0",
"1",
"X86::NoRegister",
"X86::NoRegister",
"1",
"X86::NoRegister",
"X86::NoRegister",
"X86::AddrNumOperands",
"\"Expected virtual register\"",
"X86::AddrNumOperands"
] | X86AvoidStoreForwardingBlocks11 | buildCopy | X86 | CPU | LLVM | 1,363 | 410 | 1 | [] |
[
"<s>",
"void",
"rs6000_cost_data",
"::",
"density_test",
"(",
"loop_vec_info",
"loop_vinfo",
")",
"{",
"if",
"(",
"m_costing_for_scalar",
")",
"return",
";",
"struct",
"loop",
"*",
"loop",
"=",
"LOOP_VINFO_LOOP",
"(",
"loop_vinfo",
")",
";",
"basic_block",
"*",
"bbs",
"=",
"get_loop_body",
"(",
"loop",
")",
";",
"int",
"nbbs",
"=",
"loop",
"->",
"num_nodes",
";",
"int",
"vec_cost",
"=",
"m_costs",
"[",
"vect_body",
"]",
",",
"not_vec_cost",
"=",
"0",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"nbbs",
";",
"i",
"++",
")",
"{",
"basic_block",
"bb",
"=",
"bbs",
"[",
"i",
"]",
";",
"gimple_stmt_iterator",
"gsi",
";",
"for",
"(",
"gsi",
"=",
"gsi_start_bb",
"(",
"bb",
")",
";",
"!",
"gsi_end_p",
"(",
"gsi",
")",
";",
"gsi_next",
"(",
"&",
"gsi",
")",
")",
"{",
"gimple",
"*",
"stmt",
"=",
"gsi_stmt",
"(",
"gsi",
")",
";",
"if",
"(",
"is_gimple_debug",
"(",
"stmt",
")",
")",
"continue",
";",
"stmt_vec_info",
"stmt_info",
"=",
"loop_vinfo",
"->",
"lookup_stmt",
"(",
"stmt",
")",
";",
"if",
"(",
"!",
"STMT_VINFO_RELEVANT_P",
"(",
"stmt_info",
")",
"&&",
"!",
"STMT_VINFO_IN_PATTERN_P",
"(",
"stmt_info",
")",
")",
"not_vec_cost",
"++",
";",
"}",
"}",
"free",
"(",
"bbs",
")",
";",
"int",
"density_pct",
"=",
"(",
"vec_cost",
"*",
"100",
")",
"/",
"(",
"vec_cost",
"+",
"not_vec_cost",
")",
";",
"if",
"(",
"density_pct",
">",
"rs6000_density_pct_threshold",
"&&",
"vec_cost",
"+",
"not_vec_cost",
">",
"rs6000_density_size_threshold",
")",
"{",
"m_costs",
"[",
"vect_body",
"]",
"=",
"vec_cost",
"*",
"(",
"100",
"+",
"rs6000_density_penalty",
")",
"/",
"100",
";",
"if",
"(",
"dump_enabled_p",
"(",
")",
")",
"dump_printf_loc",
"(",
"MSG_NOTE",
",",
"vect_location",
",",
"\"density %d%%, cost %d exceeds threshold, penalizing \"",
"\"loop body cost by %u%%\\n\"",
",",
"density_pct",
",",
"vec_cost",
"+",
"not_vec_cost",
",",
"rs6000_density_penalty",
")",
";",
"}",
"if",
"(",
"m_extra_ctor_cost",
">",
"0",
")",
"{",
"gcc_assert",
"(",
"m_nloads",
"<=",
"m_nstmts",
")",
";",
"unsigned",
"int",
"load_pct",
"=",
"(",
"m_nloads",
"*",
"100",
")",
"/",
"m_nstmts",
";",
"if",
"(",
"m_nloads",
">",
"(",
"unsigned",
"int",
")",
"rs6000_density_load_num_threshold",
"&&",
"load_pct",
">",
"(",
"unsigned",
"int",
")",
"rs6000_density_load_pct_threshold",
")",
"{",
"m_costs",
"[",
"vect_body",
"]",
"+=",
"m_extra_ctor_cost",
";",
"if",
"(",
"dump_enabled_p",
"(",
")",
")",
"dump_printf_loc",
"(",
"MSG_NOTE",
",",
"vect_location",
",",
"\"Found %u loads and \"",
"\"load pct. %u%% exceed \"",
"\"the threshold, \"",
"\"penalizing loop body \"",
"\"cost by extra cost %u \"",
"\"for ctor.\\n\"",
",",
"m_nloads",
",",
"load_pct",
",",
"m_extra_ctor_cost",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Test",
"for",
"likely",
"overcommitment",
"of",
"vector",
"hardware",
"resources",
".",
"If",
"a",
"loop",
"iteration",
"is",
"relatively",
"large",
",",
"and",
"too",
"large",
"a",
"percentage",
"of",
"instructions",
"in",
"the",
"loop",
"are",
"vectorized",
",",
"the",
"cost",
"model",
"may",
"not",
"adequately",
"reflect",
"delays",
"from",
"unavailable",
"vector",
"resources",
".",
"Penalize",
"the",
"loop",
"body",
"cost",
"for",
"this",
"case",
"."
] | [
"rs6000",
"0",
"0",
"100",
"100",
"100",
"\"density %d%%, cost %d exceeds threshold, penalizing \"",
"\"loop body cost by %u%%\\n\"",
"0",
"100",
"\"Found %u loads and \"",
"\"load pct. %u%% exceed \"",
"\"the threshold, \"",
"\"penalizing loop body \"",
"\"cost by extra cost %u \"",
"\"for ctor.\\n\""
] | rs6000 | density_test | rs6000 | CPU | GCC | 1,364 | 302 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"VideocoreDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"N",
")",
"{",
"if",
"(",
"N",
"->",
"isMachineOpcode",
"(",
")",
")",
"return",
"NULL",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"}",
"return",
"SelectCode",
"(",
"N",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"Videocore",
"Videocore"
] | VideocoreISelDAGToDAG | Select | Videocore | DSP | LLVM | 1,365 | 43 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"CSKYRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"const",
"CSKYSubtarget",
"&",
"STI",
"=",
"MF",
"->",
"getSubtarget",
"<",
"CSKYSubtarget",
">",
"(",
")",
";",
"if",
"(",
"MF",
"->",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"\"interrupt\"",
")",
")",
"{",
"return",
"CSR_GPR_ISR_SaveList",
";",
"}",
"return",
"CSR_I32_SaveList",
";",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"CSKY",
"CSKY",
"CSKY",
"CSKY",
"\"interrupt\""
] | CSKYRegisterInfo | getCalleeSavedRegs | CSKY | CPU | LLVM | 1,366 | 50 | 1 | [] |
[
"<s>",
"int",
"sh_cfun_attr_renesas_p",
"(",
"void",
")",
"{",
"return",
"sh_attr_renesas_p",
"(",
"current_function_decl",
")",
";",
"}",
"</s>"
] | [
"True",
"if",
"__attribute__",
"(",
"(",
"renesas",
")",
")",
"or",
"-mrenesas",
",",
"for",
"the",
"current",
"function",
"."
] | [
"sh"
] | sh3 | sh_cfun_attr_renesas_p | sh | CPU | GCC | 1,367 | 13 | 1 | [] |
[
"<s>",
"bool",
"ARMLoadStoreOpt",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"const",
"TargetMachine",
"&",
"TM",
"=",
"Fn",
".",
"getTarget",
"(",
")",
";",
"AFI",
"=",
"Fn",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"TII",
"=",
"TM",
".",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"TM",
".",
"getRegisterInfo",
"(",
")",
";",
"RS",
"=",
"new",
"RegScavenger",
"(",
")",
";",
"isThumb2",
"=",
"AFI",
"->",
"isThumb2Function",
"(",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MFI",
"=",
"Fn",
".",
"begin",
"(",
")",
",",
"E",
"=",
"Fn",
".",
"end",
"(",
")",
";",
"MFI",
"!=",
"E",
";",
"++",
"MFI",
")",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MFI",
";",
"Modified",
"|=",
"LoadStoreMultipleOpti",
"(",
"MBB",
")",
";",
"if",
"(",
"TM",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
".",
"hasV5TOps",
"(",
")",
")",
"Modified",
"|=",
"MergeReturnIntoLDM",
"(",
"MBB",
")",
";",
"}",
"delete",
"RS",
";",
"return",
"Modified",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM"
] | ARMLoadStoreOptimizer4 | runOnMachineFunction | ARM | CPU | LLVM | 1,368 | 141 | 1 | [] |
[
"<s>",
"bool",
"ARMBaseRegisterInfo",
"::",
"requiresRegisterScavenging",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"the",
"target",
"requires",
"(",
"and",
"can",
"make",
"use",
"of",
")",
"the",
"register",
"scavenger",
"."
] | [
"ARM",
"ARM"
] | ARMBaseRegisterInfo | requiresRegisterScavenging | ARM | CPU | LLVM | 1,369 | 16 | 1 | [] |
[
"<s>",
"static",
"HOST_WIDE_INT",
"lm32_compute_frame_size",
"(",
"int",
"size",
")",
"{",
"int",
"regno",
";",
"HOST_WIDE_INT",
"total_size",
",",
"locals_size",
",",
"args_size",
",",
"pretend_size",
",",
"callee_size",
";",
"unsigned",
"int",
"reg_save_mask",
";",
"locals_size",
"=",
"size",
";",
"args_size",
"=",
"crtl",
"->",
"outgoing_args_size",
";",
"pretend_size",
"=",
"crtl",
"->",
"args",
".",
"pretend_args_size",
";",
"callee_size",
"=",
"0",
";",
"reg_save_mask",
"=",
"0",
";",
"for",
"(",
"regno",
"=",
"1",
";",
"regno",
"<",
"SP_REGNUM",
";",
"regno",
"++",
")",
"{",
"if",
"(",
"df_regs_ever_live_p",
"(",
"regno",
")",
"&&",
"!",
"call_used_regs",
"[",
"regno",
"]",
")",
"{",
"reg_save_mask",
"|=",
"1",
"<<",
"regno",
";",
"callee_size",
"+=",
"UNITS_PER_WORD",
";",
"}",
"}",
"if",
"(",
"df_regs_ever_live_p",
"(",
"RA_REGNUM",
")",
"||",
"!",
"crtl",
"->",
"is_leaf",
"||",
"!",
"optimize",
")",
"{",
"reg_save_mask",
"|=",
"1",
"<<",
"RA_REGNUM",
";",
"callee_size",
"+=",
"UNITS_PER_WORD",
";",
"}",
"if",
"(",
"!",
"(",
"reg_save_mask",
"&",
"(",
"1",
"<<",
"FP_REGNUM",
")",
")",
"&&",
"frame_pointer_needed",
")",
"{",
"reg_save_mask",
"|=",
"1",
"<<",
"FP_REGNUM",
";",
"callee_size",
"+=",
"UNITS_PER_WORD",
";",
"}",
"total_size",
"=",
"pretend_size",
"+",
"args_size",
"+",
"locals_size",
"+",
"callee_size",
";",
"total_size",
"=",
"(",
"total_size",
"+",
"3",
")",
"&",
"~",
"3",
";",
"current_frame_info",
".",
"total_size",
"=",
"total_size",
";",
"current_frame_info",
".",
"callee_size",
"=",
"callee_size",
";",
"current_frame_info",
".",
"pretend_size",
"=",
"pretend_size",
";",
"current_frame_info",
".",
"locals_size",
"=",
"locals_size",
";",
"current_frame_info",
".",
"args_size",
"=",
"args_size",
";",
"current_frame_info",
".",
"reg_save_mask",
"=",
"reg_save_mask",
";",
"return",
"total_size",
";",
"}",
"</s>"
] | [
"Return",
"the",
"bytes",
"needed",
"to",
"compute",
"the",
"frame",
"pointer",
"from",
"the",
"current",
"stack",
"pointer",
"."
] | [
"lm32",
"0",
"0",
"1",
"1",
"1",
"1",
"1",
"3",
"3"
] | lm322 | lm32_compute_frame_size | lm32 | MPU | GCC | 1,370 | 207 | 1 | [] |
[
"<s>",
"GCNRegPressure",
"getRegPressure",
"(",
"const",
"MachineRegisterInfo",
"&",
"MRI",
",",
"Range",
"&&",
"LiveRegs",
")",
"{",
"GCNRegPressure",
"Res",
";",
"for",
"(",
"const",
"auto",
"&",
"RM",
":",
"LiveRegs",
")",
"Res",
".",
"inc",
"(",
"RM",
".",
"first",
",",
"LaneBitmask",
"::",
"getNone",
"(",
")",
",",
"RM",
".",
"second",
",",
"MRI",
")",
";",
"return",
"Res",
";",
"}",
"</s>"
] | [
"Get",
"register",
"pressure",
"for",
"the",
"entire",
"scheduling",
"region",
"before",
"scheduling",
"."
] | [
"AMDGPU"
] | GCNRegPressure | getRegPressure | AMDGPU | GPU | LLVM | 1,371 | 50 | 1 | [] |
[
"<s>",
"SUnit",
"*",
"R600SchedStrategy",
"::",
"pickNode",
"(",
"bool",
"&",
"IsTopNode",
")",
"{",
"SUnit",
"*",
"SU",
"=",
"nullptr",
";",
"NextInstKind",
"=",
"IDOther",
";",
"IsTopNode",
"=",
"false",
";",
"bool",
"AllowSwitchToAlu",
"=",
"(",
"CurEmitted",
">=",
"InstKindLimit",
"[",
"CurInstKind",
"]",
")",
"||",
"(",
"Available",
"[",
"CurInstKind",
"]",
".",
"empty",
"(",
")",
")",
";",
"bool",
"AllowSwitchFromAlu",
"=",
"(",
"CurEmitted",
">=",
"InstKindLimit",
"[",
"CurInstKind",
"]",
")",
"&&",
"(",
"!",
"Available",
"[",
"IDFetch",
"]",
".",
"empty",
"(",
")",
"||",
"!",
"Available",
"[",
"IDOther",
"]",
".",
"empty",
"(",
")",
")",
";",
"if",
"(",
"CurInstKind",
"==",
"IDAlu",
"&&",
"!",
"Available",
"[",
"IDFetch",
"]",
".",
"empty",
"(",
")",
")",
"{",
"float",
"ALUFetchRationEstimate",
"=",
"(",
"AluInstCount",
"+",
"AvailablesAluCount",
"(",
")",
"+",
"Pending",
"[",
"IDAlu",
"]",
".",
"size",
"(",
")",
")",
"/",
"(",
"FetchInstCount",
"+",
"Available",
"[",
"IDFetch",
"]",
".",
"size",
"(",
")",
")",
";",
"if",
"(",
"ALUFetchRationEstimate",
"==",
"0",
")",
"{",
"AllowSwitchFromAlu",
"=",
"true",
";",
"}",
"else",
"{",
"unsigned",
"NeededWF",
"=",
"62.5f",
"/",
"ALUFetchRationEstimate",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"NeededWF",
"<<",
"\" approx. Wavefronts Required\\n\"",
")",
";",
"unsigned",
"NearRegisterRequirement",
"=",
"2",
"*",
"Available",
"[",
"IDFetch",
"]",
".",
"size",
"(",
")",
";",
"if",
"(",
"NeededWF",
">",
"getWFCountLimitedByGPR",
"(",
"NearRegisterRequirement",
")",
")",
"AllowSwitchFromAlu",
"=",
"true",
";",
"}",
"}",
"if",
"(",
"!",
"SU",
"&&",
"(",
"(",
"AllowSwitchToAlu",
"&&",
"CurInstKind",
"!=",
"IDAlu",
")",
"||",
"(",
"!",
"AllowSwitchFromAlu",
"&&",
"CurInstKind",
"==",
"IDAlu",
")",
")",
")",
"{",
"SU",
"=",
"pickAlu",
"(",
")",
";",
"if",
"(",
"!",
"SU",
"&&",
"!",
"PhysicalRegCopy",
".",
"empty",
"(",
")",
")",
"{",
"SU",
"=",
"PhysicalRegCopy",
".",
"front",
"(",
")",
";",
"PhysicalRegCopy",
".",
"erase",
"(",
"PhysicalRegCopy",
".",
"begin",
"(",
")",
")",
";",
"}",
"if",
"(",
"SU",
")",
"{",
"if",
"(",
"CurEmitted",
">=",
"InstKindLimit",
"[",
"IDAlu",
"]",
")",
"CurEmitted",
"=",
"0",
";",
"NextInstKind",
"=",
"IDAlu",
";",
"}",
"}",
"if",
"(",
"!",
"SU",
")",
"{",
"SU",
"=",
"pickOther",
"(",
"IDFetch",
")",
";",
"if",
"(",
"SU",
")",
"NextInstKind",
"=",
"IDFetch",
";",
"}",
"if",
"(",
"!",
"SU",
")",
"{",
"SU",
"=",
"pickOther",
"(",
"IDOther",
")",
";",
"if",
"(",
"SU",
")",
"NextInstKind",
"=",
"IDOther",
";",
"}",
"LLVM_DEBUG",
"(",
"if",
"(",
"SU",
")",
"{",
"dbgs",
"(",
")",
"<<",
"\" ** Pick node **\\n\"",
";",
"SU",
"->",
"dump",
"(",
"DAG",
")",
";",
"}",
"else",
"{",
"dbgs",
"(",
")",
"<<",
"\"NO NODE \\n\"",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"DAG",
"->",
"SUnits",
".",
"size",
"(",
")",
";",
"i",
"++",
")",
"{",
"const",
"SUnit",
"&",
"S",
"=",
"DAG",
"->",
"SUnits",
"[",
"i",
"]",
";",
"if",
"(",
"!",
"S",
".",
"isScheduled",
")",
"S",
".",
"dump",
"(",
"DAG",
")",
";",
"}",
"}",
"</s>"
] | [
"Pick",
"the",
"next",
"node",
"to",
"schedule",
",",
"or",
"return",
"NULL",
"."
] | [
"AMDGPU",
"R600",
"0",
"62.5f",
"\" approx. Wavefronts Required\\n\"",
"2",
"0",
"\" ** Pick node **\\n\"",
"\"NO NODE \\n\"",
"0"
] | R600MachineScheduler11 | pickNode | AMDGPU | GPU | LLVM | 1,372 | 403 | 1 | [] |
[
"<s>",
"const",
"BPFRegisterInfo",
"&",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"RI",
";",
"}",
"</s>"
] | [
"getRegisterInfo",
"-",
"TargetInstrInfo",
"is",
"a",
"superset",
"of",
"MRegister",
"info",
"."
] | [
"BPF",
"BPF"
] | BPFInstrInfo | getRegisterInfo | BPF | Virtual ISA | LLVM | 1,373 | 12 | 1 | [] |
[
"<s>",
"bool",
"isBranchTarget",
"(",
")",
"const",
"{",
"if",
"(",
"!",
"isImm",
"(",
")",
")",
"return",
"false",
";",
"const",
"MCConstantExpr",
"*",
"MCE",
"=",
"dyn_cast",
"<",
"MCConstantExpr",
">",
"(",
"getImm",
"(",
")",
")",
";",
"if",
"(",
"!",
"MCE",
")",
"return",
"true",
";",
"int64_t",
"Val",
"=",
"MCE",
"->",
"getValue",
"(",
")",
";",
"if",
"(",
"Val",
"&",
"0x3",
")",
"return",
"false",
";",
"assert",
"(",
"N",
">",
"0",
"&&",
"\"Branch target immediate cannot be 0 bits!\"",
")",
";",
"return",
"(",
"Val",
">=",
"-",
"(",
"(",
"1",
"<<",
"(",
"N",
"-",
"1",
")",
")",
"<<",
"2",
")",
"&&",
"Val",
"<=",
"(",
"(",
"(",
"1",
"<<",
"(",
"N",
"-",
"1",
")",
")",
"-",
"1",
")",
"<<",
"2",
")",
")",
";",
"}",
"</s>"
] | [
"Set",
"if",
"this",
"operand",
"is",
"a",
"branch",
"target",
"."
] | [
"AArch64",
"0x3",
"0",
"\"Branch target immediate cannot be 0 bits!\"",
"1",
"1",
"2",
"1",
"1",
"1",
"2"
] | AArch64AsmParser (2)2 | isBranchTarget | AArch64 | CPU | LLVM | 1,374 | 107 | 1 | [] |
[
"<s>",
"static",
"bool",
"mn10300_legitimate_constant_p",
"(",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
",",
"rtx",
"x",
")",
"{",
"switch",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"{",
"case",
"CONST",
":",
"x",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
")",
"{",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"XEXP",
"(",
"x",
",",
"1",
")",
")",
")",
"return",
"false",
";",
"x",
"=",
"XEXP",
"(",
"x",
",",
"0",
")",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"UNSPEC",
")",
"{",
"switch",
"(",
"XINT",
"(",
"x",
",",
"1",
")",
")",
"{",
"case",
"UNSPEC_PIC",
":",
"case",
"UNSPEC_GOT",
":",
"case",
"UNSPEC_GOTOFF",
":",
"case",
"UNSPEC_PLT",
":",
"return",
"true",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"if",
"(",
"!",
"mn10300_symbolic_operand",
"(",
"x",
",",
"Pmode",
")",
")",
"return",
"false",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_LEGITIMATE_CONSTANT_P",
".",
"Returns",
"TRUE",
"if",
"X",
"is",
"a",
"valid",
"constant",
".",
"Note",
"that",
"some",
"``",
"constants",
"''",
"are",
"n't",
"valid",
",",
"such",
"as",
"TLS",
"symbols",
"and",
"unconverted",
"GOT-based",
"references",
",",
"so",
"we",
"eliminate",
"those",
"here",
"."
] | [
"mn10300",
"0",
"1",
"0",
"1"
] | mn10300 | mn10300_legitimate_constant_p | mn10300 | MPU | GCC | 1,375 | 134 | 1 | [] |
[
"<s>",
"static",
"void",
"nds32_setup_incoming_varargs",
"(",
"cumulative_args_t",
"ca",
",",
"const",
"function_arg_info",
"&",
"arg",
",",
"int",
"*",
"pretend_args_size",
",",
"int",
"second_time",
"ATTRIBUTE_UNUSED",
")",
"{",
"unsigned",
"int",
"total_args_regs",
";",
"unsigned",
"int",
"num_of_used_regs",
";",
"unsigned",
"int",
"remaining_reg_count",
";",
"CUMULATIVE_ARGS",
"*",
"cum",
";",
"if",
"(",
"TARGET_HARD_FLOAT",
")",
"return",
";",
"cum",
"=",
"get_cumulative_args",
"(",
"ca",
")",
";",
"total_args_regs",
"=",
"NDS32_MAX_GPR_REGS_FOR_ARGS",
"+",
"NDS32_GPR_ARG_FIRST_REGNUM",
";",
"num_of_used_regs",
"=",
"NDS32_AVAILABLE_REGNUM_FOR_GPR_ARG",
"(",
"cum",
"->",
"gpr_offset",
",",
"arg",
".",
"mode",
",",
"arg",
".",
"type",
")",
"+",
"NDS32_NEED_N_REGS_FOR_ARG",
"(",
"arg",
".",
"mode",
",",
"arg",
".",
"type",
")",
";",
"remaining_reg_count",
"=",
"total_args_regs",
"-",
"num_of_used_regs",
";",
"*",
"pretend_args_size",
"=",
"remaining_reg_count",
"*",
"UNITS_PER_WORD",
";",
"return",
";",
"}",
"</s>"
] | [
"Implementing",
"the",
"Varargs",
"Macros",
"."
] | [
"nds32"
] | nds32 | nds32_setup_incoming_varargs | nds32 | CPU | GCC | 1,376 | 100 | 1 | [] |
[
"<s>",
"TargetLoweringObjectFile",
"*",
"getObjFileLowering",
"(",
")",
"const",
"override",
"{",
"return",
"TLOF",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"information",
"about",
"object",
"file",
"lowering",
"."
] | [
"TGSI"
] | TGSITargetMachine | getObjFileLowering | TGSI | Virtual ISA | LLVM | 1,377 | 16 | 1 | [] |
[
"<s>",
"void",
"R600InstrInfo",
"::",
"reserveIndirectRegisters",
"(",
"BitVector",
"&",
"Reserved",
",",
"const",
"MachineFunction",
"&",
"MF",
",",
"const",
"R600RegisterInfo",
"&",
"TRI",
")",
"const",
"{",
"const",
"R600Subtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"R600Subtarget",
">",
"(",
")",
";",
"const",
"R600FrameLowering",
"*",
"TFL",
"=",
"ST",
".",
"getFrameLowering",
"(",
")",
";",
"unsigned",
"StackWidth",
"=",
"TFL",
"->",
"getStackWidth",
"(",
"MF",
")",
";",
"int",
"End",
"=",
"getIndirectIndexEnd",
"(",
"MF",
")",
";",
"if",
"(",
"End",
"==",
"-",
"1",
")",
"return",
";",
"for",
"(",
"int",
"Index",
"=",
"getIndirectIndexBegin",
"(",
"MF",
")",
";",
"Index",
"<=",
"End",
";",
"++",
"Index",
")",
"{",
"for",
"(",
"unsigned",
"Chan",
"=",
"0",
";",
"Chan",
"<",
"StackWidth",
";",
"++",
"Chan",
")",
"{",
"unsigned",
"Reg",
"=",
"AMDGPU",
"::",
"R600_TReg32RegClass",
".",
"getRegister",
"(",
"(",
"4",
"*",
"Index",
")",
"+",
"Chan",
")",
";",
"TRI",
".",
"reserveRegisterTuples",
"(",
"Reserved",
",",
"Reg",
")",
";",
"}",
"}",
"}",
"</s>"
] | [
"Reserve",
"the",
"registers",
"that",
"may",
"be",
"accessed",
"using",
"indirect",
"addressing",
"."
] | [
"AMDGPU",
"R600",
"R600",
"R600",
"R600",
"R600",
"1",
"0",
"AMDGPU::R600_TReg32RegClass",
"4"
] | R600InstrInfo21 | reserveIndirectRegisters | AMDGPU | GPU | LLVM | 1,378 | 136 | 1 | [] |
[
"<s>",
"bool",
"ARMCallLowering",
"::",
"lowerFormalArguments",
"(",
"MachineIRBuilder",
"&",
"MIRBuilder",
",",
"const",
"Function",
"&",
"F",
",",
"ArrayRef",
"<",
"unsigned",
">",
"VRegs",
")",
"const",
"{",
"if",
"(",
"F",
".",
"arg_empty",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"F",
".",
"isVarArg",
"(",
")",
")",
"return",
"false",
";",
"auto",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"auto",
"&",
"MBB",
"=",
"MIRBuilder",
".",
"getMBB",
"(",
")",
";",
"auto",
"DL",
"=",
"MF",
".",
"getDataLayout",
"(",
")",
";",
"auto",
"&",
"TLI",
"=",
"*",
"getTLI",
"<",
"ARMTargetLowering",
">",
"(",
")",
";",
"auto",
"Subtarget",
"=",
"TLI",
".",
"getSubtarget",
"(",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isThumb",
"(",
")",
")",
"return",
"false",
";",
"for",
"(",
"auto",
"&",
"Arg",
":",
"F",
".",
"args",
"(",
")",
")",
"if",
"(",
"!",
"isSupportedType",
"(",
"DL",
",",
"TLI",
",",
"Arg",
".",
"getType",
"(",
")",
")",
")",
"return",
"false",
";",
"CCAssignFn",
"*",
"AssignFn",
"=",
"TLI",
".",
"CCAssignFnForCall",
"(",
"F",
".",
"getCallingConv",
"(",
")",
",",
"F",
".",
"isVarArg",
"(",
")",
")",
";",
"FormalArgHandler",
"ArgHandler",
"(",
"MIRBuilder",
",",
"MIRBuilder",
".",
"getMF",
"(",
")",
".",
"getRegInfo",
"(",
")",
",",
"AssignFn",
")",
";",
"SmallVector",
"<",
"ArgInfo",
",",
"8",
">",
"ArgInfos",
";",
"SmallVector",
"<",
"unsigned",
",",
"4",
">",
"SplitRegs",
";",
"unsigned",
"Idx",
"=",
"0",
";",
"for",
"(",
"auto",
"&",
"Arg",
":",
"F",
".",
"args",
"(",
")",
")",
"{",
"ArgInfo",
"AInfo",
"(",
"VRegs",
"[",
"Idx",
"]",
",",
"Arg",
".",
"getType",
"(",
")",
")",
";",
"setArgFlags",
"(",
"AInfo",
",",
"Idx",
"+",
"AttributeList",
"::",
"FirstArgIndex",
",",
"DL",
",",
"F",
")",
";",
"SplitRegs",
".",
"clear",
"(",
")",
";",
"splitToValueTypes",
"(",
"AInfo",
",",
"ArgInfos",
",",
"MF",
",",
"[",
"&",
"]",
"(",
"unsigned",
"Reg",
",",
"uint64_t",
"Offset",
")",
"{",
"SplitRegs",
".",
"push_back",
"(",
"Reg",
")",
";",
"}",
")",
";",
"if",
"(",
"!",
"SplitRegs",
".",
"empty",
"(",
")",
")",
"MIRBuilder",
".",
"buildMerge",
"(",
"VRegs",
"[",
"Idx",
"]",
",",
"SplitRegs",
")",
";",
"Idx",
"++",
";",
"}",
"if",
"(",
"!",
"MBB",
".",
"empty",
"(",
")",
")",
"MIRBuilder",
".",
"setInstr",
"(",
"*",
"MBB",
".",
"begin",
"(",
")",
")",
";",
"return",
"handleAssignments",
"(",
"MIRBuilder",
",",
"ArgInfos",
",",
"ArgHandler",
")",
";",
"}",
"</s>"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"VRegs",
",",
"for",
"GlobalISel",
"."
] | [
"ARM",
"ARM",
"ARM",
"8",
"4",
"0"
] | ARMCallLowering36 | lowerFormalArguments | ARM | CPU | LLVM | 1,379 | 331 | 1 | [] |
[
"<s>",
"unsigned",
"int",
"execute",
"(",
"function",
"*",
")",
"final",
"override",
"{",
"return",
"remove_partial_avx_dependency",
"(",
")",
";",
"}",
"</s>"
] | [
"Main",
"entry",
"point",
"for",
"this",
"pass",
"."
] | [
"i386"
] | i386-features1 | execute | i386 | CPU | GCC | 1,380 | 16 | 1 | [] |
[
"<s>",
"const",
"TriCoreSubtarget",
"*",
"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",
"."
] | [
"TriCore",
"TriCore"
] | TriCoreTargetMachine | getSubtargetImpl | TriCore | MPU | LLVM | 1,381 | 17 | 1 | [] |
[
"<s>",
"SMLoc",
"getEndLoc",
"(",
")",
"const",
"override",
"{",
"return",
"EndLoc",
";",
"}",
"</s>"
] | [
"getEndLoc",
"-",
"Get",
"the",
"location",
"of",
"the",
"last",
"token",
"of",
"this",
"operand",
"."
] | [
"PowerPC"
] | PPCAsmParser (2)1 | getEndLoc | PowerPC | CPU | LLVM | 1,382 | 11 | 1 | [] |
[
"<s>",
"void",
"X86InstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"DestReg",
",",
"int",
"FrameIdx",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"const",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"unsigned",
"Alignment",
"=",
"std",
"::",
"max",
"<",
"uint32_t",
">",
"(",
"TRI",
"->",
"getSpillSize",
"(",
"*",
"RC",
")",
",",
"16",
")",
";",
"bool",
"isAligned",
"=",
"(",
"Subtarget",
".",
"getFrameLowering",
"(",
")",
"->",
"getStackAlignment",
"(",
")",
">=",
"Alignment",
")",
"||",
"RI",
".",
"canRealignStack",
"(",
"MF",
")",
";",
"unsigned",
"Opc",
"=",
"getLoadRegOpcode",
"(",
"DestReg",
",",
"RC",
",",
"isAligned",
",",
"Subtarget",
")",
";",
"DebugLoc",
"DL",
"=",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
";",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opc",
")",
",",
"DestReg",
")",
",",
"FrameIdx",
")",
";",
"}",
"</s>"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"X86",
"X86",
"16"
] | X86InstrInfo | loadRegFromStackSlot | X86 | CPU | LLVM | 1,383 | 135 | 1 | [] |
[
"<s>",
"void",
"handle_pragma_vector",
"(",
")",
"{",
"if",
"(",
"function_table",
")",
"{",
"error",
"(",
"\"duplicate definition of %qs\"",
",",
"\"riscv_vector.h\"",
")",
";",
"return",
";",
"}",
"rvv_switcher",
"rvv",
";",
"for",
"(",
"unsigned",
"int",
"type_i",
"=",
"0",
";",
"type_i",
"<",
"NUM_VECTOR_TYPES",
";",
"++",
"type_i",
")",
"register_vector_type",
"(",
"(",
"enum",
"vector_type_index",
")",
"type_i",
")",
";",
"function_table",
"=",
"new",
"hash_table",
"<",
"registered_function_hasher",
">",
"(",
"1023",
")",
";",
"function_builder",
"builder",
";",
"for",
"(",
"unsigned",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"function_groups",
")",
";",
"++",
"i",
")",
"builder",
".",
"register_function_group",
"(",
"function_groups",
"[",
"i",
"]",
")",
";",
"}",
"</s>"
] | [
"Implement",
"#",
"pragma",
"riscv",
"intrinsic",
"vector",
"."
] | [
"riscv",
"\"duplicate definition of %qs\"",
"\"riscv_vector.h\"",
"0",
"1023",
"0"
] | riscv-vector-builtins | handle_pragma_vector | riscv | CPU | GCC | 1,384 | 90 | 1 | [] |
[
"<s>",
"int",
"cris_delay_slots_for_epilogue",
"(",
")",
"{",
"if",
"(",
"regs_ever_live",
"[",
"CRIS_SRP_REGNUM",
"]",
"||",
"cfun",
"->",
"machine",
"->",
"needs_return_address_on_stack",
"!=",
"0",
")",
"return",
"0",
";",
"cris_target_asm_function_epilogue",
"(",
"NULL",
",",
"get_frame_size",
"(",
")",
")",
";",
"if",
"(",
"*",
"save_last",
")",
"return",
"1",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"the",
"number",
"of",
"delay-slots",
"in",
"the",
"epilogue",
":",
"return",
"1",
"if",
"it",
"contains",
"``",
"ret",
"''",
",",
"else",
"0",
"."
] | [
"cris",
"0",
"0",
"1",
"0"
] | cris2 | cris_delay_slots_for_epilogue | cris | MPU | GCC | 1,385 | 44 | 1 | [] |
[
"<s>",
"void",
"KudeyarAsmPrinter",
"::",
"emitFrameDirective",
"(",
")",
"{",
"const",
"TargetRegisterInfo",
"&",
"RI",
"=",
"*",
"TM",
".",
"getRegisterInfo",
"(",
")",
";",
"unsigned",
"stackReg",
"=",
"RI",
".",
"getFrameRegister",
"(",
"*",
"MF",
")",
";",
"unsigned",
"returnReg",
"=",
"RI",
".",
"getRARegister",
"(",
")",
";",
"unsigned",
"stackSize",
"=",
"MF",
"->",
"getFrameInfo",
"(",
")",
"->",
"getStackSize",
"(",
")",
";",
"if",
"(",
"OutStreamer",
".",
"hasRawTextSupport",
"(",
")",
")",
"OutStreamer",
".",
"EmitRawText",
"(",
"\"\\t.frame\\t$\"",
"+",
"StringRef",
"(",
"KudeyarInstPrinter",
"::",
"getRegisterName",
"(",
"stackReg",
")",
")",
".",
"lower",
"(",
")",
"+",
"\",\"",
"+",
"Twine",
"(",
"stackSize",
")",
")",
";",
"}",
"</s>"
] | [
"Frame",
"Directive",
"."
] | [
"Kudeyar",
"Kudeyar",
"\"\\t.frame\\t$\"",
"Kudeyar",
"\",\""
] | KudeyarAsmPrinter | emitFrameDirective | Kudeyar | CPU | LLVM | 1,386 | 89 | 1 | [] |
[
"<s>",
"void",
"nios2_adjust_call_address",
"(",
"rtx",
"*",
"call_op",
",",
"rtx",
"reg",
")",
"{",
"if",
"(",
"MEM_P",
"(",
"*",
"call_op",
")",
")",
"call_op",
"=",
"&",
"XEXP",
"(",
"*",
"call_op",
",",
"0",
")",
";",
"rtx",
"addr",
"=",
"*",
"call_op",
";",
"if",
"(",
"flag_pic",
"&&",
"CONSTANT_P",
"(",
"addr",
")",
")",
"{",
"rtx",
"tmp",
"=",
"reg",
"?",
"reg",
":",
"NULL_RTX",
";",
"if",
"(",
"!",
"reg",
")",
"reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"addr",
"=",
"nios2_load_pic_address",
"(",
"addr",
",",
"UNSPEC_PIC_CALL_SYM",
",",
"tmp",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"reg",
",",
"addr",
")",
")",
";",
"*",
"call_op",
"=",
"reg",
";",
"}",
"}",
"</s>"
] | [
"The",
"function",
"with",
"address",
"*",
"ADDR",
"is",
"being",
"called",
".",
"If",
"the",
"address",
"needs",
"to",
"be",
"loaded",
"from",
"the",
"GOT",
",",
"emit",
"the",
"instruction",
"to",
"do",
"so",
"and",
"update",
"*",
"ADDR",
"to",
"point",
"to",
"the",
"rtx",
"for",
"the",
"loaded",
"value",
".",
"If",
"REG",
"!",
"=",
"NULL_RTX",
",",
"it",
"is",
"used",
"as",
"the",
"target/scratch",
"register",
"in",
"the",
"GOT",
"address",
"calculation",
"."
] | [
"nios2",
"0"
] | nios22 | nios2_adjust_call_address | nios2 | MPU | GCC | 1,387 | 97 | 1 | [] |
[
"<s>",
"Value",
"*",
"RISCVTargetLowering",
"::",
"emitMaskedAtomicRMWIntrinsic",
"(",
"IRBuilder",
"<",
">",
"&",
"Builder",
",",
"AtomicRMWInst",
"*",
"AI",
",",
"Value",
"*",
"AlignedAddr",
",",
"Value",
"*",
"Incr",
",",
"Value",
"*",
"Mask",
",",
"Value",
"*",
"ShiftAmt",
",",
"AtomicOrdering",
"Ord",
")",
"const",
"{",
"Value",
"*",
"Ordering",
"=",
"Builder",
".",
"getInt32",
"(",
"static_cast",
"<",
"uint32_t",
">",
"(",
"AI",
"->",
"getOrdering",
"(",
")",
")",
")",
";",
"Type",
"*",
"Tys",
"[",
"]",
"=",
"{",
"AlignedAddr",
"->",
"getType",
"(",
")",
"}",
";",
"Function",
"*",
"LrwOpScwLoop",
"=",
"Intrinsic",
"::",
"getDeclaration",
"(",
"AI",
"->",
"getModule",
"(",
")",
",",
"getIntrinsicForMaskedAtomicRMWBinOp32",
"(",
"AI",
"->",
"getOperation",
"(",
")",
")",
",",
"Tys",
")",
";",
"if",
"(",
"AI",
"->",
"getOperation",
"(",
")",
"==",
"AtomicRMWInst",
"::",
"Min",
"||",
"AI",
"->",
"getOperation",
"(",
")",
"==",
"AtomicRMWInst",
"::",
"Max",
")",
"{",
"const",
"DataLayout",
"&",
"DL",
"=",
"AI",
"->",
"getModule",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"unsigned",
"ValWidth",
"=",
"DL",
".",
"getTypeStoreSizeInBits",
"(",
"AI",
"->",
"getValOperand",
"(",
")",
"->",
"getType",
"(",
")",
")",
";",
"Value",
"*",
"SextShamt",
"=",
"Builder",
".",
"CreateSub",
"(",
"Builder",
".",
"getInt32",
"(",
"Subtarget",
".",
"getXLen",
"(",
")",
"-",
"ValWidth",
")",
",",
"ShiftAmt",
")",
";",
"return",
"Builder",
".",
"CreateCall",
"(",
"LrwOpScwLoop",
",",
"{",
"AlignedAddr",
",",
"Incr",
",",
"Mask",
",",
"SextShamt",
",",
"Ordering",
"}",
")",
";",
"}",
"return",
"Builder",
".",
"CreateCall",
"(",
"LrwOpScwLoop",
",",
"{",
"AlignedAddr",
",",
"Incr",
",",
"Mask",
",",
"Ordering",
"}",
")",
";",
"}",
"</s>"
] | [
"Perform",
"a",
"masked",
"atomicrmw",
"using",
"a",
"target-specific",
"intrinsic",
"."
] | [
"RISCV",
"RISCV",
"Intrinsic::getDeclaration"
] | RISCVISelLowering25 | emitMaskedAtomicRMWIntrinsic | RISCV | CPU | LLVM | 1,388 | 218 | 1 | [] |
[
"<s>",
"TargetLoweringBase",
"::",
"LegalizeTypeAction",
"getPreferredVectorAction",
"(",
"EVT",
"VT",
")",
"const",
"override",
"{",
"if",
"(",
"VT",
".",
"getVectorElementType",
"(",
")",
".",
"getSizeInBits",
"(",
")",
"%",
"8",
"==",
"0",
")",
"return",
"TypeWidenVector",
";",
"return",
"TargetLoweringBase",
"::",
"getPreferredVectorAction",
"(",
"VT",
")",
";",
"}",
"</s>"
] | [
"Customize",
"the",
"preferred",
"legalization",
"strategy",
"for",
"certain",
"types",
"."
] | [
"PowerPC",
"8",
"0"
] | PPCISelLowering107 | getPreferredVectorAction | PowerPC | CPU | LLVM | 1,389 | 39 | 1 | [] |
[
"<s>",
"bool",
"AArch64TargetLowering",
"::",
"shouldProduceAndByConstByHoistingConstFromShiftsLHSOfAnd",
"(",
"SDValue",
"X",
",",
"ConstantSDNode",
"*",
"XC",
",",
"ConstantSDNode",
"*",
"CC",
",",
"SDValue",
"Y",
",",
"unsigned",
"OldShiftOpcode",
",",
"unsigned",
"NewShiftOpcode",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"if",
"(",
"!",
"TargetLowering",
"::",
"shouldProduceAndByConstByHoistingConstFromShiftsLHSOfAnd",
"(",
"X",
",",
"XC",
",",
"CC",
",",
"Y",
",",
"OldShiftOpcode",
",",
"NewShiftOpcode",
",",
"DAG",
")",
")",
"return",
"false",
";",
"return",
"X",
".",
"getValueType",
"(",
")",
".",
"isScalarInteger",
"(",
")",
"||",
"NewShiftOpcode",
"==",
"ISD",
"::",
"SHL",
";",
"}",
"</s>"
] | [
"Given",
"the",
"pattern",
"(",
"X",
"&",
"(",
"C",
"l",
">",
">",
"/",
"<",
"<",
"Y",
")",
")",
"==/",
"!",
"=",
"0",
"return",
"true",
"if",
"it",
"should",
"be",
"transformed",
"into",
":",
"(",
"(",
"X",
"<",
"<",
"/l",
">",
">",
"Y",
")",
"&",
"C",
")",
"==/",
"!",
"=",
"0",
"WARNING",
":",
"if",
"'",
"X",
"'",
"is",
"a",
"constant",
",",
"the",
"fold",
"may",
"deadlock",
"!",
"FIXME",
":",
"we",
"could",
"avoid",
"passing",
"XC",
",",
"but",
"we",
"ca",
"n't",
"use",
"isConstOrConstSplat",
"(",
")",
"here",
"because",
"it",
"can",
"end",
"up",
"being",
"not",
"linked",
"in",
"."
] | [
"AArch64",
"AArch64",
"ISD::SHL"
] | AArch64ISelLowering (2)2 | shouldProduceAndByConstByHoistingConstFromShiftsLHSOfAnd | AArch64 | CPU | LLVM | 1,390 | 74 | 1 | [] |
[
"<s>",
"void",
"convert_float128_to_int",
"(",
"rtx",
"*",
"operands",
",",
"enum",
"rtx_code",
"code",
")",
"{",
"rtx",
"dest",
"=",
"operands",
"[",
"0",
"]",
";",
"rtx",
"src",
"=",
"operands",
"[",
"1",
"]",
";",
"rtx",
"tmp",
"=",
"operands",
"[",
"2",
"]",
";",
"rtx",
"cvt",
";",
"rtvec",
"cvt_vec",
";",
"rtx",
"cvt_unspec",
";",
"rtvec",
"move_vec",
";",
"rtx",
"move_unspec",
";",
"if",
"(",
"GET_CODE",
"(",
"tmp",
")",
"==",
"SCRATCH",
")",
"tmp",
"=",
"gen_reg_rtx",
"(",
"V2DImode",
")",
";",
"if",
"(",
"MEM_P",
"(",
"dest",
")",
")",
"dest",
"=",
"rs6000_address_for_fpconvert",
"(",
"dest",
")",
";",
"cvt",
"=",
"gen_rtx_fmt_e",
"(",
"code",
",",
"GET_MODE",
"(",
"dest",
")",
",",
"src",
")",
";",
"cvt_vec",
"=",
"gen_rtvec",
"(",
"1",
",",
"cvt",
")",
";",
"cvt_unspec",
"=",
"gen_rtx_UNSPEC",
"(",
"V2DImode",
",",
"cvt_vec",
",",
"UNSPEC_IEEE128_CONVERT",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"tmp",
",",
"cvt_unspec",
")",
")",
";",
"move_vec",
"=",
"gen_rtvec",
"(",
"1",
",",
"tmp",
")",
";",
"move_unspec",
"=",
"gen_rtx_UNSPEC",
"(",
"GET_MODE",
"(",
"dest",
")",
",",
"move_vec",
",",
"UNSPEC_IEEE128_MOVE",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"dest",
",",
"move_unspec",
")",
")",
";",
"}",
"</s>"
] | [
"Split",
"a",
"conversion",
"from",
"__float128",
"to",
"an",
"integer",
"type",
"into",
"separate",
"insns",
".",
"OPERANDS",
"points",
"to",
"the",
"destination",
",",
"source",
",",
"and",
"V2DI",
"temporary",
"register",
".",
"CODE",
"is",
"either",
"FIX",
"or",
"UNSIGNED_FIX",
"."
] | [
"rs6000",
"0",
"1",
"2",
"1",
"1"
] | rs60005 | convert_float128_to_int | rs6000 | CPU | GCC | 1,391 | 159 | 1 | [] |
[
"<s>",
"static",
"bool",
"arm_valid_target_attribute_p",
"(",
"tree",
"fndecl",
",",
"tree",
"ARG_UNUSED",
"(",
"name",
")",
",",
"tree",
"args",
",",
"int",
"ARG_UNUSED",
"(",
"flags",
")",
")",
"{",
"bool",
"ret",
"=",
"true",
";",
"struct",
"gcc_options",
"func_options",
",",
"func_options_set",
";",
"tree",
"cur_tree",
",",
"new_optimize",
";",
"gcc_assert",
"(",
"(",
"fndecl",
"!=",
"NULL_TREE",
")",
"&&",
"(",
"args",
"!=",
"NULL_TREE",
")",
")",
";",
"tree",
"func_optimize",
"=",
"DECL_FUNCTION_SPECIFIC_OPTIMIZATION",
"(",
"fndecl",
")",
";",
"if",
"(",
"!",
"func_optimize",
")",
"func_optimize",
"=",
"optimization_default_node",
";",
"memset",
"(",
"&",
"func_options",
",",
"0",
",",
"sizeof",
"(",
"func_options",
")",
")",
";",
"init_options_struct",
"(",
"&",
"func_options",
",",
"NULL",
")",
";",
"lang_hooks",
".",
"init_options_struct",
"(",
"&",
"func_options",
")",
";",
"memset",
"(",
"&",
"func_options_set",
",",
"0",
",",
"sizeof",
"(",
"func_options_set",
")",
")",
";",
"cl_optimization_restore",
"(",
"&",
"func_options",
",",
"&",
"func_options_set",
",",
"TREE_OPTIMIZATION",
"(",
"func_optimize",
")",
")",
";",
"cl_target_option_restore",
"(",
"&",
"func_options",
",",
"&",
"func_options_set",
",",
"TREE_TARGET_OPTION",
"(",
"target_option_default_node",
")",
")",
";",
"cur_tree",
"=",
"arm_valid_target_attribute_tree",
"(",
"args",
",",
"&",
"func_options",
",",
"&",
"func_options_set",
")",
";",
"if",
"(",
"cur_tree",
"==",
"NULL_TREE",
")",
"ret",
"=",
"false",
";",
"new_optimize",
"=",
"build_optimization_node",
"(",
"&",
"func_options",
",",
"&",
"func_options_set",
")",
";",
"DECL_FUNCTION_SPECIFIC_TARGET",
"(",
"fndecl",
")",
"=",
"cur_tree",
";",
"DECL_FUNCTION_SPECIFIC_OPTIMIZATION",
"(",
"fndecl",
")",
"=",
"new_optimize",
";",
"return",
"ret",
";",
"}",
"</s>"
] | [
"Hook",
"to",
"validate",
"attribute",
"(",
"(",
"target",
"(",
"``",
"string",
"''",
")",
")",
")",
"."
] | [
"arm",
"0",
"0"
] | arm | arm_valid_target_attribute_p | arm | CPU | GCC | 1,392 | 193 | 1 | [] |
[
"<s>",
"static",
"void",
"nios2_handle_custom_fpu_insn_option",
"(",
"int",
"fpu_insn_index",
")",
"{",
"int",
"param",
"=",
"N2FPU_N",
"(",
"fpu_insn_index",
")",
";",
"if",
"(",
"0",
"<=",
"param",
"&&",
"param",
"<=",
"255",
")",
"nios2_register_custom_code",
"(",
"param",
",",
"CCS_FPU",
",",
"fpu_insn_index",
")",
";",
"else",
"if",
"(",
"param",
"!=",
"-",
"1",
")",
"error",
"(",
"\"switch %<-mcustom-%s%> value %d must be between 0 and 255\"",
",",
"N2FPU_NAME",
"(",
"fpu_insn_index",
")",
",",
"param",
")",
";",
"}",
"</s>"
] | [
"Check",
"individual",
"FPU",
"insn",
"options",
",",
"and",
"register",
"custom",
"code",
"."
] | [
"nios2",
"0",
"255",
"1",
"\"switch %<-mcustom-%s%> value %d must be between 0 and 255\""
] | nios22 | nios2_handle_custom_fpu_insn_option | nios2 | MPU | GCC | 1,393 | 56 | 1 | [] |
[
"<s>",
"static",
"void",
"rs6000_elf_select_rtx_section",
"(",
"enum",
"machine_mode",
"mode",
",",
"rtx",
"x",
",",
"unsigned",
"HOST_WIDE_INT",
"align",
")",
"{",
"if",
"(",
"ASM_OUTPUT_SPECIAL_POOL_ENTRY_P",
"(",
"x",
",",
"mode",
")",
")",
"toc_section",
"(",
")",
";",
"else",
"default_elf_select_rtx_section",
"(",
"mode",
",",
"x",
",",
"align",
")",
";",
"}",
"</s>"
] | [
"A",
"C",
"statement",
"or",
"statements",
"to",
"switch",
"to",
"the",
"appropriate",
"section",
"for",
"output",
"of",
"RTX",
"in",
"mode",
"MODE",
".",
"You",
"can",
"assume",
"that",
"RTX",
"is",
"some",
"kind",
"of",
"constant",
"in",
"RTL",
".",
"The",
"argument",
"MODE",
"is",
"redundant",
"except",
"in",
"the",
"case",
"of",
"a",
"`",
"const_int",
"'",
"rtx",
".",
"Select",
"the",
"section",
"by",
"calling",
"`",
"text_section",
"'",
"or",
"one",
"of",
"the",
"alternatives",
"for",
"other",
"sections",
".",
"Do",
"not",
"define",
"this",
"macro",
"if",
"you",
"put",
"all",
"constants",
"in",
"the",
"read-only",
"data",
"section",
"."
] | [
"rs6000"
] | rs60003 | rs6000_elf_select_rtx_section | rs6000 | CPU | GCC | 1,394 | 40 | 1 | [] |
[
"<s>",
"const",
"MCExpr",
"*",
"WebAssemblyAsmPrinter",
"::",
"lowerConstant",
"(",
"const",
"Constant",
"*",
"CV",
")",
"{",
"if",
"(",
"const",
"GlobalValue",
"*",
"GV",
"=",
"dyn_cast",
"<",
"GlobalValue",
">",
"(",
"CV",
")",
")",
"if",
"(",
"GV",
"->",
"getValueType",
"(",
")",
"->",
"isFunctionTy",
"(",
")",
")",
"{",
"MCSymbol",
"*",
"Sym",
"=",
"getSymbol",
"(",
"GV",
")",
";",
"if",
"(",
"!",
"isa",
"<",
"MCSymbolELF",
">",
"(",
"Sym",
")",
")",
"cast",
"<",
"MCSymbolWasm",
">",
"(",
"Sym",
")",
"->",
"setIsFunction",
"(",
"true",
")",
";",
"return",
"MCSymbolRefExpr",
"::",
"create",
"(",
"Sym",
",",
"MCSymbolRefExpr",
"::",
"VK_WebAssembly_FUNCTION",
",",
"OutContext",
")",
";",
"}",
"return",
"AsmPrinter",
"::",
"lowerConstant",
"(",
"CV",
")",
";",
"}",
"</s>"
] | [
"Lower",
"the",
"specified",
"LLVM",
"Constant",
"to",
"an",
"MCExpr",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly"
] | WebAssemblyAsmPrinter9 | lowerConstant | WebAssembly | Virtual ISA | LLVM | 1,395 | 98 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"SparcDAGToDAGISel",
"::",
"getGlobalBaseReg",
"(",
")",
"{",
"unsigned",
"GlobalBaseReg",
"=",
"Subtarget",
"->",
"getInstrInfo",
"(",
")",
"->",
"getGlobalBaseReg",
"(",
"MF",
")",
";",
"return",
"CurDAG",
"->",
"getRegister",
"(",
"GlobalBaseReg",
",",
"TLI",
"->",
"getPointerTy",
"(",
"CurDAG",
"->",
"getDataLayout",
"(",
")",
")",
")",
".",
"getNode",
"(",
")",
";",
"}",
"</s>"
] | [
"getGlobalBaseReg",
"-",
"Return",
"a",
"virtual",
"register",
"initialized",
"with",
"the",
"the",
"global",
"base",
"register",
"value",
"."
] | [
"Sparc",
"Sparc"
] | SparcISelDAGToDAG (2) | getGlobalBaseReg | Sparc | CPU | LLVM | 1,396 | 46 | 1 | [] |
[
"<s>",
"static",
"void",
"mmix_reorg",
"(",
"void",
")",
"{",
"int",
"regno",
";",
"for",
"(",
"regno",
"=",
"MMIX_LAST_STACK_REGISTER_REGNUM",
";",
"regno",
">=",
"0",
";",
"regno",
"--",
")",
"if",
"(",
"(",
"df_regs_ever_live_p",
"(",
"regno",
")",
"&&",
"!",
"call_used_or_fixed_reg_p",
"(",
"regno",
")",
")",
"||",
"(",
"regno",
"==",
"MMIX_FRAME_POINTER_REGNUM",
"&&",
"frame_pointer_needed",
")",
")",
"break",
";",
"if",
"(",
"!",
"TARGET_ABI_GNU",
"&&",
"regno",
"<",
"crtl",
"->",
"args",
".",
"info",
".",
"regs",
"-",
"1",
")",
"{",
"regno",
"=",
"crtl",
"->",
"args",
".",
"info",
".",
"regs",
"-",
"1",
";",
"if",
"(",
"regno",
">",
"MMIX_RETURN_VALUE_REGNUM",
"-",
"1",
")",
"regno",
"=",
"MMIX_RETURN_VALUE_REGNUM",
"-",
"1",
";",
"}",
"cfun",
"->",
"machine",
"->",
"highest_saved_stack_register",
"=",
"regno",
";",
"}",
"</s>"
] | [
"Implement",
"TARGET_MACHINE_DEPENDENT_REORG",
".",
"No",
"actual",
"rearrangements",
"done",
"here",
";",
"just",
"virtually",
"by",
"calculating",
"the",
"highest",
"saved",
"stack",
"register",
"number",
"used",
"to",
"modify",
"the",
"register",
"numbers",
"at",
"output",
"time",
"."
] | [
"mmix",
"0",
"1",
"1",
"1",
"1"
] | mmix | mmix_reorg | mmix | CPU | GCC | 1,397 | 102 | 1 | [] |
[
"<s>",
"bool",
"HSAILInstrInfo",
"::",
"shouldScheduleLoadsNear",
"(",
"SDNode",
"*",
"Node1",
",",
"SDNode",
"*",
"Node2",
",",
"int64_t",
"Offset1",
",",
"int64_t",
"Offset2",
",",
"unsigned",
"NumLoads",
")",
"const",
"{",
"if",
"(",
"!",
"Node1",
"->",
"isMachineOpcode",
"(",
")",
")",
"return",
"false",
";",
"MachineSDNode",
"*",
"mnode1",
"=",
"cast",
"<",
"MachineSDNode",
">",
"(",
"Node1",
")",
";",
"if",
"(",
"Offset2",
"-",
"Offset1",
"<=",
"4",
"*",
"(",
"int64_t",
")",
"(",
"*",
"mnode1",
"->",
"memoperands_begin",
"(",
")",
")",
"->",
"getSize",
"(",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"shouldScheduleLoadsNear",
"-",
"This",
"is",
"a",
"used",
"by",
"the",
"pre-regalloc",
"scheduler",
"to",
"determine",
"(",
"in",
"conjunction",
"with",
"areLoadsFromSameBasePtr",
")",
"if",
"two",
"loads",
"should",
"be",
"scheduled",
"togther",
"."
] | [
"HSAIL",
"HSAIL",
"4"
] | HSAILInstrInfo | shouldScheduleLoadsNear | HSAIL | Virtual ISA | LLVM | 1,398 | 79 | 1 | [] |
[
"<s>",
"void",
"SystemZFrameLowering",
"::",
"processFunctionBeforeFrameFinalized",
"(",
"MachineFunction",
"&",
"MF",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"MachineFrameInfo",
"&",
"MFFrame",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"bool",
"BackChain",
"=",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"\"backchain\"",
")",
";",
"if",
"(",
"!",
"usePackedStack",
"(",
"MF",
")",
"||",
"BackChain",
")",
"getOrCreateFramePointerSaveIndex",
"(",
"MF",
")",
";",
"uint64_t",
"StackSize",
"=",
"(",
"MFFrame",
".",
"estimateStackSize",
"(",
"MF",
")",
"+",
"SystemZMC",
"::",
"CallFrameSize",
")",
";",
"int64_t",
"MaxArgOffset",
"=",
"0",
";",
"for",
"(",
"int",
"I",
"=",
"MFFrame",
".",
"getObjectIndexBegin",
"(",
")",
";",
"I",
"!=",
"0",
";",
"++",
"I",
")",
"if",
"(",
"MFFrame",
".",
"getObjectOffset",
"(",
"I",
")",
">=",
"0",
")",
"{",
"int64_t",
"ArgOffset",
"=",
"MFFrame",
".",
"getObjectOffset",
"(",
"I",
")",
"+",
"MFFrame",
".",
"getObjectSize",
"(",
"I",
")",
";",
"MaxArgOffset",
"=",
"std",
"::",
"max",
"(",
"MaxArgOffset",
",",
"ArgOffset",
")",
";",
"}",
"uint64_t",
"MaxReach",
"=",
"StackSize",
"+",
"MaxArgOffset",
";",
"if",
"(",
"!",
"isUInt",
"<",
"12",
">",
"(",
"MaxReach",
")",
")",
"{",
"RS",
"->",
"addScavengingFrameIndex",
"(",
"MFFrame",
".",
"CreateStackObject",
"(",
"8",
",",
"8",
",",
"false",
")",
")",
";",
"RS",
"->",
"addScavengingFrameIndex",
"(",
"MFFrame",
".",
"CreateStackObject",
"(",
"8",
",",
"8",
",",
"false",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"processFunctionBeforeFrameFinalized",
"-",
"This",
"method",
"is",
"called",
"immediately",
"before",
"the",
"specified",
"function",
"'s",
"frame",
"layout",
"(",
"MF.getFrameInfo",
"(",
")",
")",
"is",
"finalized",
"."
] | [
"SystemZ",
"SystemZ",
"\"backchain\"",
"SystemZMC::CallFrameSize",
"0",
"0",
"0",
"12",
"8",
"8",
"8",
"8"
] | SystemZFrameLowering1 | processFunctionBeforeFrameFinalized | SystemZ | CPU | LLVM | 1,399 | 187 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.