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>",
"bool",
"TMS320C64XAsmPrinter",
"::",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"outputStream",
")",
"{",
"llvm_unreachable_internal",
"(",
"\"Unimplemented function PrintAsmOperand\"",
")",
";",
"}",
"</s>"
] | [
"PrintAsmOperand",
"-",
"Print",
"out",
"an",
"operand",
"for",
"an",
"inline",
"asm",
"expression",
"."
] | [
"TMS320C64X",
"TMS320C64X",
"\"Unimplemented function PrintAsmOperand\""
] | TMS320C64XAsmPrinter | PrintAsmOperand | TMS320C64X | VLIW | LLVM | 4,800 | 32 | 1 | [] |
[
"<s>",
"static",
"rtx",
"rs6000_mask_atomic_subword",
"(",
"rtx",
"oldval",
",",
"rtx",
"newval",
",",
"rtx",
"mask",
")",
"{",
"rtx",
"x",
";",
"x",
"=",
"gen_reg_rtx",
"(",
"SImode",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"x",
",",
"gen_rtx_AND",
"(",
"SImode",
",",
"gen_rtx_NOT",
"(",
"SImode",
",",
"mask",
")",
",",
"oldval",
")",
")",
")",
";",
"x",
"=",
"expand_simple_binop",
"(",
"SImode",
",",
"IOR",
",",
"newval",
",",
"x",
",",
"x",
",",
"1",
",",
"OPTAB_LIB_WIDEN",
")",
";",
"return",
"x",
";",
"}",
"</s>"
] | [
"A",
"subroutine",
"of",
"the",
"various",
"atomic",
"expanders",
".",
"For",
"sub-word",
"operands",
",",
"combine",
"OLDVAL",
"and",
"NEWVAL",
"via",
"MASK",
".",
"Returns",
"a",
"new",
"pseduo",
"."
] | [
"rs6000",
"1"
] | rs6000 | rs6000_mask_atomic_subword | rs6000 | CPU | GCC | 4,801 | 69 | 1 | [] |
[
"<s>",
"bool",
"HexagonGenInsert",
"::",
"removeDeadCode",
"(",
"MachineDomTreeNode",
"*",
"N",
")",
"{",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"auto",
"*",
"DTN",
":",
"children",
"<",
"MachineDomTreeNode",
"*",
">",
"(",
"N",
")",
")",
"Changed",
"|=",
"removeDeadCode",
"(",
"DTN",
")",
";",
"MachineBasicBlock",
"*",
"B",
"=",
"N",
"->",
"getBlock",
"(",
")",
";",
"std",
"::",
"vector",
"<",
"MachineInstr",
"*",
">",
"Instrs",
";",
"for",
"(",
"auto",
"I",
"=",
"B",
"->",
"rbegin",
"(",
")",
",",
"E",
"=",
"B",
"->",
"rend",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"Instrs",
".",
"push_back",
"(",
"&",
"*",
"I",
")",
";",
"for",
"(",
"MachineInstr",
"*",
"MI",
":",
"Instrs",
")",
"{",
"unsigned",
"Opc",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"Opc",
"==",
"TargetOpcode",
"::",
"LIFETIME_START",
"||",
"Opc",
"==",
"TargetOpcode",
"::",
"LIFETIME_END",
")",
"continue",
";",
"bool",
"Store",
"=",
"false",
";",
"if",
"(",
"MI",
"->",
"isInlineAsm",
"(",
")",
"||",
"!",
"MI",
"->",
"isSafeToMove",
"(",
"nullptr",
",",
"Store",
")",
")",
"continue",
";",
"bool",
"AllDead",
"=",
"true",
";",
"SmallVector",
"<",
"unsigned",
",",
"2",
">",
"Regs",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"MI",
"->",
"operands",
"(",
")",
")",
"{",
"if",
"(",
"!",
"MO",
".",
"isReg",
"(",
")",
"||",
"!",
"MO",
".",
"isDef",
"(",
")",
")",
"continue",
";",
"Register",
"R",
"=",
"MO",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"!",
"R",
".",
"isVirtual",
"(",
")",
"||",
"!",
"MRI",
"->",
"use_nodbg_empty",
"(",
"R",
")",
")",
"{",
"AllDead",
"=",
"false",
";",
"break",
";",
"}",
"Regs",
".",
"push_back",
"(",
"R",
")",
";",
"}",
"if",
"(",
"!",
"AllDead",
")",
"continue",
";",
"B",
"->",
"erase",
"(",
"MI",
")",
";",
"for",
"(",
"unsigned",
"I",
"=",
"0",
",",
"N",
"=",
"Regs",
".",
"size",
"(",
")",
";",
"I",
"!=",
"N",
";",
"++",
"I",
")",
"MRI",
"->",
"markUsesInDebugValueAsUndef",
"(",
"Regs",
"[",
"I",
"]",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"Remove",
"all",
"dead",
"instructions",
"between",
"the",
"I",
"and",
"E",
"."
] | [
"Hexagon",
"Hexagon",
"2",
"0"
] | HexagonGenInsert10 | removeDeadCode | Hexagon | DSP | LLVM | 4,802 | 292 | 1 | [] |
[
"<s>",
"const",
"MCInstrDesc",
"&",
"getMCOpcodeFromPseudo",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"return",
"get",
"(",
"pseudoToMCOpcode",
"(",
"Opcode",
")",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"descriptor",
"of",
"the",
"target-specific",
"machine",
"instruction",
"that",
"corresponds",
"to",
"the",
"specified",
"pseudo",
"or",
"native",
"opcode",
"."
] | [
"R600"
] | AMDGPUInstrInfo10 | getMCOpcodeFromPseudo | R600 | GPU | LLVM | 4,803 | 20 | 1 | [] |
[
"<s>",
"int",
"SystemZTTIImpl",
"::",
"getIntImmCost",
"(",
"Intrinsic",
"::",
"ID",
"IID",
",",
"unsigned",
"Idx",
",",
"const",
"APInt",
"&",
"Imm",
",",
"Type",
"*",
"Ty",
")",
"{",
"assert",
"(",
"Ty",
"->",
"isIntegerTy",
"(",
")",
")",
";",
"unsigned",
"BitSize",
"=",
"Ty",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"if",
"(",
"BitSize",
"==",
"0",
")",
"return",
"TTI",
"::",
"TCC_Free",
";",
"if",
"(",
"BitSize",
">",
"64",
")",
"return",
"TTI",
"::",
"TCC_Free",
";",
"switch",
"(",
"IID",
")",
"{",
"default",
":",
"return",
"TTI",
"::",
"TCC_Free",
";",
"case",
"Intrinsic",
"::",
"sadd_with_overflow",
":",
"case",
"Intrinsic",
"::",
"uadd_with_overflow",
":",
"case",
"Intrinsic",
"::",
"ssub_with_overflow",
":",
"case",
"Intrinsic",
"::",
"usub_with_overflow",
":",
"if",
"(",
"Idx",
"==",
"1",
"&&",
"Imm",
".",
"getBitWidth",
"(",
")",
"<=",
"64",
")",
"{",
"if",
"(",
"isUInt",
"<",
"32",
">",
"(",
"Imm",
".",
"getZExtValue",
"(",
")",
")",
")",
"return",
"TTI",
"::",
"TCC_Free",
";",
"if",
"(",
"isUInt",
"<",
"32",
">",
"(",
"-",
"Imm",
".",
"getSExtValue",
"(",
")",
")",
")",
"return",
"TTI",
"::",
"TCC_Free",
";",
"}",
"break",
";",
"case",
"Intrinsic",
"::",
"smul_with_overflow",
":",
"case",
"Intrinsic",
"::",
"umul_with_overflow",
":",
"if",
"(",
"Idx",
"==",
"1",
"&&",
"Imm",
".",
"getBitWidth",
"(",
")",
"<=",
"64",
")",
"{",
"if",
"(",
"isInt",
"<",
"32",
">",
"(",
"Imm",
".",
"getSExtValue",
"(",
")",
")",
")",
"return",
"TTI",
"::",
"TCC_Free",
";",
"}",
"break",
";",
"case",
"Intrinsic",
"::",
"experimental_stackmap",
":",
"if",
"(",
"(",
"Idx",
"<",
"2",
")",
"||",
"(",
"Imm",
".",
"getBitWidth",
"(",
")",
"<=",
"64",
"&&",
"isInt",
"<",
"64",
">",
"(",
"Imm",
".",
"getSExtValue",
"(",
")",
")",
")",
")",
"return",
"TTI",
"::",
"TCC_Free",
";",
"break",
";",
"case",
"Intrinsic",
"::",
"experimental_patchpoint_void",
":",
"case",
"Intrinsic",
"::",
"experimental_patchpoint_i64",
":",
"if",
"(",
"(",
"Idx",
"<",
"4",
")",
"||",
"(",
"Imm",
".",
"getBitWidth",
"(",
")",
"<=",
"64",
"&&",
"isInt",
"<",
"64",
">",
"(",
"Imm",
".",
"getSExtValue",
"(",
")",
")",
")",
")",
"return",
"TTI",
"::",
"TCC_Free",
";",
"break",
";",
"}",
"return",
"SystemZTTIImpl",
"::",
"getIntImmCost",
"(",
"Imm",
",",
"Ty",
")",
";",
"}",
"</s>"
] | [
"Calculate",
"the",
"cost",
"of",
"materializing",
"a",
"64-bit",
"value",
"."
] | [
"SystemZ",
"SystemZ",
"Intrinsic::ID",
"0",
"64",
"Intrinsic::sadd_with_overflow",
"Intrinsic::uadd_with_overflow",
"Intrinsic::ssub_with_overflow",
"Intrinsic::usub_with_overflow",
"1",
"64",
"32",
"32",
"Intrinsic::smul_with_overflow",
"Intrinsic::umul_with_overflow",
"1",
"64",
"32",
"Intrinsic::experimental_stackmap",
"2",
"64",
"64",
"Intrinsic::experimental_patchpoint_void",
"Intrinsic::experimental_patchpoint_i64",
"4",
"64",
"64",
"SystemZ"
] | SystemZTargetTransformInfo (2) | getIntImmCost | SystemZ | CPU | LLVM | 4,804 | 300 | 1 | [] |
[
"<s>",
"ArrayRef",
"<",
"std",
"::",
"pair",
"<",
"int",
",",
"const",
"char",
"*",
">>",
"MOSInstrInfo",
"::",
"getSerializableTargetIndices",
"(",
")",
"const",
"{",
"static",
"const",
"std",
"::",
"pair",
"<",
"int",
",",
"const",
"char",
"*",
">",
"Flags",
"[",
"]",
"=",
"{",
"{",
"MOS",
"::",
"TI_STATIC_STACK",
",",
"\"mos-static-stack\"",
"}",
"}",
";",
"return",
"Flags",
";",
"}",
"</s>"
] | [
"Return",
"an",
"array",
"that",
"contains",
"the",
"ids",
"of",
"the",
"target",
"indices",
"(",
"used",
"for",
"the",
"TargetIndex",
"machine",
"operand",
")",
"and",
"their",
"names",
"."
] | [
"MOS",
"MOS",
"MOS::TI_STATIC_STACK",
"\"mos-static-stack\""
] | MOSInstrInfo | getSerializableTargetIndices | MOS | MPU | LLVM | 4,805 | 49 | 1 | [] |
[
"<s>",
"static",
"bool",
"expand_vec_perm_vpermi2_vpshub2",
"(",
"struct",
"expand_vec_perm_d",
"*",
"d",
")",
"{",
"if",
"(",
"!",
"TARGET_AVX512BW",
"||",
"!",
"(",
"d",
"->",
"vmode",
"==",
"V64QImode",
")",
")",
"return",
"false",
";",
"if",
"(",
"d",
"->",
"testing_p",
")",
"return",
"true",
";",
"struct",
"expand_vec_perm_d",
"ds",
"[",
"2",
"]",
";",
"rtx",
"rperm",
"[",
"128",
"]",
",",
"vperm",
",",
"target0",
",",
"target1",
";",
"unsigned",
"int",
"i",
",",
"nelt",
";",
"machine_mode",
"vmode",
";",
"nelt",
"=",
"d",
"->",
"nelt",
";",
"vmode",
"=",
"V64QImode",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"2",
";",
"i",
"++",
")",
"{",
"ds",
"[",
"i",
"]",
"=",
"*",
"d",
";",
"ds",
"[",
"i",
"]",
".",
"vmode",
"=",
"V32HImode",
";",
"ds",
"[",
"i",
"]",
".",
"nelt",
"=",
"32",
";",
"ds",
"[",
"i",
"]",
".",
"target",
"=",
"gen_reg_rtx",
"(",
"V32HImode",
")",
";",
"ds",
"[",
"i",
"]",
".",
"op0",
"=",
"gen_lowpart",
"(",
"V32HImode",
",",
"d",
"->",
"op0",
")",
";",
"ds",
"[",
"i",
"]",
".",
"op1",
"=",
"gen_lowpart",
"(",
"V32HImode",
",",
"d",
"->",
"op1",
")",
";",
"}",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"nelt",
";",
"i",
"++",
")",
"{",
"ds",
"[",
"i",
"&",
"1",
"]",
".",
"perm",
"[",
"i",
"/",
"2",
"]",
"=",
"d",
"->",
"perm",
"[",
"i",
"]",
"/",
"2",
";",
"if",
"(",
"i",
"&",
"1",
")",
"{",
"rperm",
"[",
"i",
"]",
"=",
"constm1_rtx",
";",
"rperm",
"[",
"i",
"+",
"64",
"]",
"=",
"GEN_INT",
"(",
"(",
"i",
"&",
"14",
")",
"+",
"(",
"d",
"->",
"perm",
"[",
"i",
"]",
"&",
"1",
")",
")",
";",
"}",
"else",
"{",
"rperm",
"[",
"i",
"]",
"=",
"GEN_INT",
"(",
"(",
"i",
"&",
"14",
")",
"+",
"(",
"d",
"->",
"perm",
"[",
"i",
"]",
"&",
"1",
")",
")",
";",
"rperm",
"[",
"i",
"+",
"64",
"]",
"=",
"constm1_rtx",
";",
"}",
"}",
"bool",
"ok",
"=",
"expand_vec_perm_1",
"(",
"&",
"ds",
"[",
"0",
"]",
")",
";",
"gcc_assert",
"(",
"ok",
")",
";",
"ds",
"[",
"0",
"]",
".",
"target",
"=",
"gen_lowpart",
"(",
"V64QImode",
",",
"ds",
"[",
"0",
"]",
".",
"target",
")",
";",
"ok",
"=",
"expand_vec_perm_1",
"(",
"&",
"ds",
"[",
"1",
"]",
")",
";",
"gcc_assert",
"(",
"ok",
")",
";",
"ds",
"[",
"1",
"]",
".",
"target",
"=",
"gen_lowpart",
"(",
"V64QImode",
",",
"ds",
"[",
"1",
"]",
".",
"target",
")",
";",
"vperm",
"=",
"gen_rtx_CONST_VECTOR",
"(",
"V64QImode",
",",
"gen_rtvec_v",
"(",
"64",
",",
"rperm",
")",
")",
";",
"vperm",
"=",
"force_reg",
"(",
"vmode",
",",
"vperm",
")",
";",
"target0",
"=",
"gen_reg_rtx",
"(",
"V64QImode",
")",
";",
"emit_insn",
"(",
"gen_avx512bw_pshufbv64qi3",
"(",
"target0",
",",
"ds",
"[",
"0",
"]",
".",
"target",
",",
"vperm",
")",
")",
";",
"vperm",
"=",
"gen_rtx_CONST_VECTOR",
"(",
"V64QImode",
",",
"gen_rtvec_v",
"(",
"64",
",",
"rperm",
"+",
"64",
")",
")",
";",
"vperm",
"=",
"force_reg",
"(",
"vmode",
",",
"vperm",
")",
";",
"target1",
"=",
"gen_reg_rtx",
"(",
"V64QImode",
")",
";",
"emit_insn",
"(",
"gen_avx512bw_pshufbv64qi3",
"(",
"target1",
",",
"ds",
"[",
"1",
"]",
".",
"target",
",",
"vperm",
")",
")",
";",
"emit_insn",
"(",
"gen_iorv64qi3",
"(",
"d",
"->",
"target",
",",
"target0",
",",
"target1",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Implement",
"arbitrary",
"permutations",
"of",
"two",
"V64QImode",
"operands",
"will",
"2",
"vpermi2w",
",",
"2",
"vpshufb",
"and",
"one",
"vpor",
"instruction",
"."
] | [
"i386",
"2",
"128",
"0",
"2",
"32",
"0",
"1",
"2",
"2",
"1",
"64",
"14",
"1",
"14",
"1",
"64",
"0",
"0",
"0",
"1",
"1",
"1",
"64",
"0",
"64",
"64",
"1"
] | i3864 | expand_vec_perm_vpermi2_vpshub2 | i386 | CPU | GCC | 4,806 | 461 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"long",
"arm_compute_save_core_reg_mask",
"(",
"void",
")",
"{",
"unsigned",
"int",
"save_reg_mask",
"=",
"0",
";",
"unsigned",
"long",
"func_type",
"=",
"arm_current_func_type",
"(",
")",
";",
"unsigned",
"int",
"reg",
";",
"if",
"(",
"IS_NAKED",
"(",
"func_type",
")",
")",
"return",
"0",
";",
"if",
"(",
"TARGET_APCS_FRAME",
"&&",
"frame_pointer_needed",
"&&",
"TARGET_ARM",
")",
"save_reg_mask",
"|=",
"(",
"1",
"<<",
"ARM_HARD_FRAME_POINTER_REGNUM",
")",
"|",
"(",
"1",
"<<",
"IP_REGNUM",
")",
"|",
"(",
"1",
"<<",
"LR_REGNUM",
")",
"|",
"(",
"1",
"<<",
"PC_REGNUM",
")",
";",
"save_reg_mask",
"|=",
"arm_compute_save_reg0_reg12_mask",
"(",
")",
";",
"if",
"(",
"df_regs_ever_live_p",
"(",
"LR_REGNUM",
")",
"||",
"(",
"save_reg_mask",
"&&",
"optimize_size",
"&&",
"ARM_FUNC_TYPE",
"(",
"func_type",
")",
"==",
"ARM_FT_NORMAL",
"&&",
"!",
"crtl",
"->",
"tail_call_emit",
"&&",
"!",
"crtl",
"->",
"calls_eh_return",
")",
")",
"save_reg_mask",
"|=",
"1",
"<<",
"LR_REGNUM",
";",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"lr_save_eliminated",
")",
"save_reg_mask",
"&=",
"~",
"(",
"1",
"<<",
"LR_REGNUM",
")",
";",
"if",
"(",
"TARGET_REALLY_IWMMXT",
"&&",
"(",
"(",
"bit_count",
"(",
"save_reg_mask",
")",
"+",
"ARM_NUM_INTS",
"(",
"crtl",
"->",
"args",
".",
"pretend_args_size",
"+",
"arm_compute_static_chain_stack_bytes",
"(",
")",
")",
")",
"%",
"2",
")",
"!=",
"0",
")",
"{",
"for",
"(",
"reg",
"=",
"4",
";",
"reg",
"<=",
"12",
";",
"reg",
"++",
")",
"if",
"(",
"(",
"save_reg_mask",
"&",
"(",
"1",
"<<",
"reg",
")",
")",
"==",
"0",
")",
"break",
";",
"if",
"(",
"reg",
"<=",
"12",
")",
"save_reg_mask",
"|=",
"(",
"1",
"<<",
"reg",
")",
";",
"else",
"{",
"cfun",
"->",
"machine",
"->",
"sibcall_blocked",
"=",
"1",
";",
"save_reg_mask",
"|=",
"(",
"1",
"<<",
"3",
")",
";",
"}",
"}",
"if",
"(",
"TARGET_THUMB2",
"&&",
"IS_NESTED",
"(",
"func_type",
")",
"&&",
"flag_pic",
"&&",
"(",
"save_reg_mask",
"&",
"THUMB2_WORK_REGS",
")",
"==",
"0",
")",
"{",
"reg",
"=",
"thumb_find_work_register",
"(",
"1",
"<<",
"4",
")",
";",
"if",
"(",
"!",
"call_used_or_fixed_reg_p",
"(",
"reg",
")",
")",
"save_reg_mask",
"|=",
"(",
"1",
"<<",
"reg",
")",
";",
"}",
"return",
"save_reg_mask",
";",
"}",
"</s>"
] | [
"Compute",
"a",
"bit",
"mask",
"of",
"which",
"core",
"registers",
"need",
"to",
"be",
"saved",
"on",
"the",
"stack",
"for",
"the",
"current",
"function",
".",
"This",
"is",
"used",
"by",
"arm_compute_frame_layout",
",",
"which",
"may",
"add",
"extra",
"registers",
"."
] | [
"arm",
"0",
"0",
"1",
"1",
"1",
"1",
"1",
"1",
"2",
"0",
"4",
"12",
"1",
"0",
"12",
"1",
"1",
"1",
"3",
"0",
"1",
"4",
"1"
] | arm | arm_compute_save_core_reg_mask | arm | CPU | GCC | 4,807 | 273 | 1 | [] |
[
"<s>",
"SDNode",
"*",
"SparcDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"N",
")",
"{",
"DebugLoc",
"dl",
"=",
"N",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"N",
"->",
"isMachineOpcode",
"(",
")",
")",
"return",
"NULL",
";",
"switch",
"(",
"N",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"SPISD",
"::",
"GLOBAL_BASE_REG",
":",
"return",
"getGlobalBaseReg",
"(",
")",
";",
"case",
"ISD",
"::",
"SDIV",
":",
"case",
"ISD",
"::",
"UDIV",
":",
"{",
"SDValue",
"DivLHS",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"DivRHS",
"=",
"N",
"->",
"getOperand",
"(",
"1",
")",
";",
"SDValue",
"TopPart",
";",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SDIV",
")",
"{",
"TopPart",
"=",
"SDValue",
"(",
"CurDAG",
"->",
"getMachineNode",
"(",
"SP",
"::",
"SRAri",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"DivLHS",
",",
"CurDAG",
"->",
"getTargetConstant",
"(",
"31",
",",
"MVT",
"::",
"i32",
")",
")",
",",
"0",
")",
";",
"}",
"else",
"{",
"TopPart",
"=",
"CurDAG",
"->",
"getRegister",
"(",
"SP",
"::",
"G0",
",",
"MVT",
"::",
"i32",
")",
";",
"}",
"TopPart",
"=",
"SDValue",
"(",
"CurDAG",
"->",
"getMachineNode",
"(",
"SP",
"::",
"WRYrr",
",",
"dl",
",",
"MVT",
"::",
"Flag",
",",
"TopPart",
",",
"CurDAG",
"->",
"getRegister",
"(",
"SP",
"::",
"G0",
",",
"MVT",
"::",
"i32",
")",
")",
",",
"0",
")",
";",
"unsigned",
"Opcode",
"=",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SDIV",
"?",
"SP",
"::",
"SDIVrr",
":",
"SP",
"::",
"UDIVrr",
";",
"return",
"CurDAG",
"->",
"SelectNodeTo",
"(",
"N",
",",
"Opcode",
",",
"MVT",
"::",
"i32",
",",
"DivLHS",
",",
"DivRHS",
",",
"TopPart",
")",
";",
"}",
"case",
"ISD",
"::",
"MULHU",
":",
"case",
"ISD",
"::",
"MULHS",
":",
"{",
"SDValue",
"MulLHS",
"=",
"N",
"->",
"getOperand",
"(",
"0",
")",
";",
"SDValue",
"MulRHS",
"=",
"N",
"->",
"getOperand",
"(",
"1",
")",
";",
"unsigned",
"Opcode",
"=",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"MULHU",
"?",
"SP",
"::",
"UMULrr",
":",
"SP",
"::",
"SMULrr",
";",
"SDNode",
"*",
"Mul",
"=",
"CurDAG",
"->",
"getMachineNode",
"(",
"Opcode",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"MVT",
"::",
"Flag",
",",
"MulLHS",
",",
"MulRHS",
")",
";",
"return",
"CurDAG",
"->",
"SelectNodeTo",
"(",
"N",
",",
"SP",
"::",
"RDY",
",",
"MVT",
"::",
"i32",
",",
"SDValue",
"(",
"Mul",
",",
"1",
")",
")",
";",
"return",
"NULL",
";",
"}",
"}",
"return",
"SelectCode",
"(",
"N",
")",
";",
"}",
"</s>"
] | [
"Main",
"hook",
"for",
"targets",
"to",
"transform",
"nodes",
"into",
"machine",
"nodes",
"."
] | [
"Sparc",
"Sparc",
"SPISD::GLOBAL_BASE_REG",
"ISD::SDIV",
"ISD::UDIV",
"0",
"1",
"ISD::SDIV",
"SP::SRAri",
"MVT::i32",
"31",
"MVT::i32",
"0",
"SP::G0",
"MVT::i32",
"SP::WRYrr",
"MVT::Flag",
"SP::G0",
"MVT::i32",
"0",
"ISD::SDIV",
"SP::SDIVrr",
"SP::UDIVrr",
"MVT::i32",
"ISD::MULHU",
"ISD::MULHS",
"0",
"1",
"ISD::MULHU",
"SP::UMULrr",
"SP::SMULrr",
"MVT::i32",
"MVT::Flag",
"SP::RDY",
"MVT::i32",
"1"
] | SparcISelDAGToDAG15 | Select | Sparc | CPU | LLVM | 4,808 | 346 | 1 | [] |
[
"<s>",
"static",
"int",
"rs6000_issue_rate",
"(",
"void",
")",
"{",
"if",
"(",
"!",
"reload_completed",
")",
"return",
"1",
";",
"switch",
"(",
"rs6000_cpu_attr",
")",
"{",
"case",
"CPU_RIOS1",
":",
"case",
"CPU_RS64A",
":",
"case",
"CPU_PPC601",
":",
"case",
"CPU_PPC7450",
":",
"return",
"3",
";",
"case",
"CPU_PPC440",
":",
"case",
"CPU_PPC603",
":",
"case",
"CPU_PPC750",
":",
"case",
"CPU_PPC7400",
":",
"case",
"CPU_PPC8540",
":",
"return",
"2",
";",
"case",
"CPU_RIOS2",
":",
"case",
"CPU_PPC604",
":",
"case",
"CPU_PPC604E",
":",
"case",
"CPU_PPC620",
":",
"case",
"CPU_PPC630",
":",
"return",
"4",
";",
"case",
"CPU_POWER4",
":",
"case",
"CPU_POWER5",
":",
"return",
"5",
";",
"default",
":",
"return",
"1",
";",
"}",
"}",
"</s>"
] | [
"Return",
"how",
"many",
"instructions",
"the",
"machine",
"can",
"issue",
"per",
"cycle",
"."
] | [
"rs6000",
"1",
"3",
"2",
"4",
"5",
"1"
] | rs60003 | rs6000_issue_rate | rs6000 | CPU | GCC | 4,809 | 87 | 1 | [] |
[
"<s>",
"void",
"R600SchedStrategy",
"::",
"releaseTopNode",
"(",
"SUnit",
"*",
"SU",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Top Releasing \"",
";",
"SU",
"->",
"dump",
"(",
"DAG",
")",
";",
")",
";",
"}",
"</s>"
] | [
"SU",
"has",
"had",
"all",
"predecessor",
"dependencies",
"resolved",
"."
] | [
"R600",
"\"Top Releasing \""
] | R600MachineScheduler1 | releaseTopNode | R600 | GPU | LLVM | 4,810 | 28 | 1 | [] |
[
"<s>",
"tree",
"sh_build_va_list",
"(",
")",
"{",
"tree",
"f_next_o",
",",
"f_next_o_limit",
",",
"f_next_fp",
",",
"f_next_fp_limit",
",",
"f_next_stack",
";",
"tree",
"record",
";",
"if",
"(",
"TARGET_SH5",
"||",
"(",
"!",
"TARGET_SH3E",
"&&",
"!",
"TARGET_SH4",
")",
"||",
"TARGET_HITACHI",
")",
"return",
"ptr_type_node",
";",
"record",
"=",
"make_node",
"(",
"RECORD_TYPE",
")",
";",
"f_next_o",
"=",
"build_decl",
"(",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"__va_next_o\"",
")",
",",
"ptr_type_node",
")",
";",
"f_next_o_limit",
"=",
"build_decl",
"(",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"__va_next_o_limit\"",
")",
",",
"ptr_type_node",
")",
";",
"f_next_fp",
"=",
"build_decl",
"(",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"__va_next_fp\"",
")",
",",
"ptr_type_node",
")",
";",
"f_next_fp_limit",
"=",
"build_decl",
"(",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"__va_next_fp_limit\"",
")",
",",
"ptr_type_node",
")",
";",
"f_next_stack",
"=",
"build_decl",
"(",
"FIELD_DECL",
",",
"get_identifier",
"(",
"\"__va_next_stack\"",
")",
",",
"ptr_type_node",
")",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_next_o",
")",
"=",
"record",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_next_o_limit",
")",
"=",
"record",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_next_fp",
")",
"=",
"record",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_next_fp_limit",
")",
"=",
"record",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_next_stack",
")",
"=",
"record",
";",
"TYPE_FIELDS",
"(",
"record",
")",
"=",
"f_next_o",
";",
"TREE_CHAIN",
"(",
"f_next_o",
")",
"=",
"f_next_o_limit",
";",
"TREE_CHAIN",
"(",
"f_next_o_limit",
")",
"=",
"f_next_fp",
";",
"TREE_CHAIN",
"(",
"f_next_fp",
")",
"=",
"f_next_fp_limit",
";",
"TREE_CHAIN",
"(",
"f_next_fp_limit",
")",
"=",
"f_next_stack",
";",
"layout_type",
"(",
"record",
")",
";",
"return",
"record",
";",
"}",
"</s>"
] | [
"Define",
"the",
"`",
"__builtin_va_list",
"'",
"type",
"for",
"the",
"ABI",
"."
] | [
"sh",
"\"__va_next_o\"",
"\"__va_next_o_limit\"",
"\"__va_next_fp\"",
"\"__va_next_fp_limit\"",
"\"__va_next_stack\""
] | sh2 | sh_build_va_list | sh | CPU | GCC | 4,811 | 192 | 1 | [] |
[
"<s>",
"const",
"MCPhysReg",
"*",
"SIRegisterInfo",
"::",
"getCalleeSavedRegs",
"(",
"const",
"MachineFunction",
"*",
"MF",
")",
"const",
"{",
"CallingConv",
"::",
"ID",
"CC",
"=",
"MF",
"->",
"getFunction",
"(",
")",
".",
"getCallingConv",
"(",
")",
";",
"switch",
"(",
"CC",
")",
"{",
"case",
"CallingConv",
"::",
"C",
":",
"case",
"CallingConv",
"::",
"Fast",
":",
"case",
"CallingConv",
"::",
"Cold",
":",
"case",
"CallingConv",
"::",
"AMDGPU_Gfx",
":",
"return",
"CSR_AMDGPU_HighRegs_SaveList",
";",
"default",
":",
"{",
"static",
"const",
"MCPhysReg",
"NoCalleeSavedReg",
"=",
"AMDGPU",
"::",
"NoRegister",
";",
"return",
"&",
"NoCalleeSavedReg",
";",
"}",
"}",
"}",
"</s>"
] | [
"Code",
"Generation",
"virtual",
"methods",
"..."
] | [
"AMDGPU",
"SI",
"AMDGPU",
"AMDGPU",
"AMDGPU::NoRegister"
] | SIRegisterInfo113 | getCalleeSavedRegs | AMDGPU | GPU | LLVM | 4,812 | 76 | 1 | [] |
[
"<s>",
"bool",
"XCoreFrameLowering",
"::",
"restoreCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"MutableArrayRef",
"<",
"CalleeSavedInfo",
">",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"MF",
"->",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"bool",
"AtStart",
"=",
"MI",
"==",
"MBB",
".",
"begin",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"BeforeI",
"=",
"MI",
";",
"if",
"(",
"!",
"AtStart",
")",
"--",
"BeforeI",
";",
"for",
"(",
"const",
"CalleeSavedInfo",
"&",
"CSR",
":",
"CSI",
")",
"{",
"unsigned",
"Reg",
"=",
"CSR",
".",
"getReg",
"(",
")",
";",
"assert",
"(",
"Reg",
"!=",
"XCore",
"::",
"LR",
"&&",
"!",
"(",
"Reg",
"==",
"XCore",
"::",
"R10",
"&&",
"hasFP",
"(",
"*",
"MF",
")",
")",
"&&",
"\"LR & FP are always handled in emitEpilogue\"",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TRI",
"->",
"getMinimalPhysRegClass",
"(",
"Reg",
")",
";",
"TII",
".",
"loadRegFromStackSlot",
"(",
"MBB",
",",
"MI",
",",
"Reg",
",",
"CSR",
".",
"getFrameIdx",
"(",
")",
",",
"RC",
",",
"TRI",
")",
";",
"assert",
"(",
"MI",
"!=",
"MBB",
".",
"begin",
"(",
")",
"&&",
"\"loadRegFromStackSlot didn't insert any code!\"",
")",
";",
"if",
"(",
"AtStart",
")",
"MI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"else",
"{",
"MI",
"=",
"BeforeI",
";",
"++",
"MI",
";",
"}",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"restoreCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"restore",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"load",
"instructions",
"via",
"loadRegToStackSlot",
"(",
")",
"."
] | [
"XCore",
"XCore",
"XCore::LR",
"XCore::R10",
"\"LR & FP are always handled in emitEpilogue\"",
"\"loadRegFromStackSlot didn't insert any code!\""
] | XCoreFrameLowering22 | restoreCalleeSavedRegisters | XCore | MPU | LLVM | 4,813 | 197 | 1 | [] |
[
"<s>",
"void",
"ia64_expand_vecint_cmov",
"(",
"rtx",
"operands",
"[",
"]",
")",
"{",
"enum",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"operands",
"[",
"0",
"]",
")",
";",
"enum",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"operands",
"[",
"3",
"]",
")",
";",
"bool",
"negate",
";",
"rtx",
"cmp",
",",
"x",
",",
"ot",
",",
"of",
";",
"cmp",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"negate",
"=",
"ia64_expand_vecint_compare",
"(",
"code",
",",
"mode",
",",
"cmp",
",",
"operands",
"[",
"4",
"]",
",",
"operands",
"[",
"5",
"]",
")",
";",
"ot",
"=",
"operands",
"[",
"1",
"+",
"negate",
"]",
";",
"of",
"=",
"operands",
"[",
"2",
"-",
"negate",
"]",
";",
"if",
"(",
"ot",
"==",
"CONST0_RTX",
"(",
"mode",
")",
")",
"{",
"if",
"(",
"of",
"==",
"CONST0_RTX",
"(",
"mode",
")",
")",
"{",
"emit_move_insn",
"(",
"operands",
"[",
"0",
"]",
",",
"ot",
")",
";",
"return",
";",
"}",
"x",
"=",
"gen_rtx_NOT",
"(",
"mode",
",",
"cmp",
")",
";",
"x",
"=",
"gen_rtx_AND",
"(",
"mode",
",",
"x",
",",
"of",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"operands",
"[",
"0",
"]",
",",
"x",
")",
")",
";",
"}",
"else",
"if",
"(",
"of",
"==",
"CONST0_RTX",
"(",
"mode",
")",
")",
"{",
"x",
"=",
"gen_rtx_AND",
"(",
"mode",
",",
"cmp",
",",
"ot",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"operands",
"[",
"0",
"]",
",",
"x",
")",
")",
";",
"}",
"else",
"{",
"rtx",
"t",
",",
"f",
";",
"t",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"x",
"=",
"gen_rtx_AND",
"(",
"mode",
",",
"cmp",
",",
"operands",
"[",
"1",
"+",
"negate",
"]",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"t",
",",
"x",
")",
")",
";",
"f",
"=",
"gen_reg_rtx",
"(",
"mode",
")",
";",
"x",
"=",
"gen_rtx_NOT",
"(",
"mode",
",",
"cmp",
")",
";",
"x",
"=",
"gen_rtx_AND",
"(",
"mode",
",",
"x",
",",
"operands",
"[",
"2",
"-",
"negate",
"]",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"f",
",",
"x",
")",
")",
";",
"x",
"=",
"gen_rtx_IOR",
"(",
"mode",
",",
"t",
",",
"f",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"operands",
"[",
"0",
"]",
",",
"x",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"an",
"integral",
"vector",
"conditional",
"move",
"."
] | [
"ia64",
"0",
"3",
"4",
"5",
"1",
"2",
"0",
"0",
"0",
"1",
"2",
"0"
] | ia643 | ia64_expand_vecint_cmov | ia64 | CPU | GCC | 4,814 | 312 | 1 | [] |
[
"<s>",
"ARMBaseTargetMachine",
"::",
"ARMBaseTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Optional",
"<",
"Reloc",
"::",
"Model",
">",
"RM",
",",
"Optional",
"<",
"CodeModel",
"::",
"Model",
">",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
",",
"bool",
"isLittle",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"computeDataLayout",
"(",
"TT",
",",
"CPU",
",",
"Options",
",",
"isLittle",
")",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"getEffectiveRelocModel",
"(",
"TT",
",",
"RM",
")",
",",
"getEffectiveCodeModel",
"(",
"CM",
")",
",",
"OL",
")",
",",
"TargetABI",
"(",
"computeTargetABI",
"(",
"TT",
",",
"CPU",
",",
"Options",
")",
")",
",",
"TLOF",
"(",
"createTLOF",
"(",
"getTargetTriple",
"(",
")",
")",
")",
",",
"isLittle",
"(",
"isLittle",
")",
"{",
"if",
"(",
"Options",
".",
"FloatABIType",
"==",
"FloatABI",
"::",
"Default",
")",
"{",
"if",
"(",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"GNUEABIHF",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"MuslEABIHF",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"EABIHF",
"||",
"TargetTriple",
".",
"isOSWindows",
"(",
")",
"||",
"TargetABI",
"==",
"ARMBaseTargetMachine",
"::",
"ARM_ABI_AAPCS16",
")",
"this",
"->",
"Options",
".",
"FloatABIType",
"=",
"FloatABI",
"::",
"Hard",
";",
"else",
"this",
"->",
"Options",
".",
"FloatABIType",
"=",
"FloatABI",
"::",
"Soft",
";",
"}",
"if",
"(",
"Options",
".",
"EABIVersion",
"==",
"EABI",
"::",
"Default",
"||",
"Options",
".",
"EABIVersion",
"==",
"EABI",
"::",
"Unknown",
")",
"{",
"if",
"(",
"(",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"GNUEABI",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"GNUEABIHF",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"MuslEABI",
"||",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"MuslEABIHF",
")",
"&&",
"!",
"(",
"TargetTriple",
".",
"isOSWindows",
"(",
")",
"||",
"TargetTriple",
".",
"isOSDarwin",
"(",
")",
")",
")",
"this",
"->",
"Options",
".",
"EABIVersion",
"=",
"EABI",
"::",
"GNU",
";",
"else",
"this",
"->",
"Options",
".",
"EABIVersion",
"=",
"EABI",
"::",
"EABI5",
";",
"}",
"initAsmInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"Create",
"an",
"ARM",
"architecture",
"model",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM"
] | ARMTargetMachine22 | ARMBaseTargetMachine | ARM | CPU | LLVM | 4,815 | 297 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"\"X86 Assembly / Object Emitter\"",
";",
"}",
"</s>"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] | [
"X86",
"\"X86 Assembly / Object Emitter\""
] | X86AsmPrinter (2) | getPassName | X86 | CPU | LLVM | 4,816 | 13 | 1 | [] |
[
"<s>",
"DecodeStatus",
"BPFDisassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"Instr",
",",
"uint64_t",
"&",
"Size",
",",
"ArrayRef",
"<",
"uint8_t",
">",
"Bytes",
",",
"uint64_t",
"Address",
",",
"raw_ostream",
"&",
"VStream",
",",
"raw_ostream",
"&",
"CStream",
")",
"const",
"{",
"uint64_t",
"Insn",
";",
"DecodeStatus",
"Result",
";",
"Result",
"=",
"readInstruction64",
"(",
"Bytes",
",",
"Address",
",",
"Size",
",",
"Insn",
")",
";",
"if",
"(",
"Result",
"==",
"MCDisassembler",
"::",
"Fail",
")",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"Result",
"=",
"decodeInstruction",
"(",
"DecoderTableBPF64",
",",
"Instr",
",",
"Insn",
",",
"Address",
",",
"this",
",",
"STI",
")",
";",
"if",
"(",
"Result",
"==",
"MCDisassembler",
"::",
"Fail",
")",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"switch",
"(",
"Instr",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"BPF",
"::",
"LD_imm64",
":",
"{",
"if",
"(",
"Bytes",
".",
"size",
"(",
")",
"<",
"16",
")",
"{",
"Size",
"=",
"0",
";",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"}",
"Size",
"=",
"16",
";",
"uint64_t",
"Hi",
"=",
"(",
"Bytes",
"[",
"12",
"]",
"<<",
"0",
")",
"|",
"(",
"Bytes",
"[",
"13",
"]",
"<<",
"8",
")",
"|",
"(",
"Bytes",
"[",
"14",
"]",
"<<",
"16",
")",
"|",
"(",
"Bytes",
"[",
"15",
"]",
"<<",
"24",
")",
";",
"auto",
"&",
"Op",
"=",
"Instr",
".",
"getOperand",
"(",
"1",
")",
";",
"Op",
".",
"setImm",
"(",
"Make_64",
"(",
"Hi",
",",
"Op",
".",
"getImm",
"(",
")",
")",
")",
";",
"break",
";",
"}",
"case",
"BPF",
"::",
"LD_ABS_B",
":",
"case",
"BPF",
"::",
"LD_ABS_H",
":",
"case",
"BPF",
"::",
"LD_ABS_W",
":",
"case",
"BPF",
"::",
"LD_IND_B",
":",
"case",
"BPF",
"::",
"LD_IND_H",
":",
"case",
"BPF",
"::",
"LD_IND_W",
":",
"{",
"auto",
"Op",
"=",
"Instr",
".",
"getOperand",
"(",
"0",
")",
";",
"Instr",
".",
"clear",
"(",
")",
";",
"Instr",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createReg",
"(",
"BPF",
"::",
"R6",
")",
")",
";",
"Instr",
".",
"addOperand",
"(",
"Op",
")",
";",
"break",
";",
"}",
"}",
"return",
"Result",
";",
"}",
"</s>"
] | [
"Returns",
"the",
"disassembly",
"of",
"a",
"single",
"instruction",
"."
] | [
"BPF",
"BPF",
"BPF",
"BPF::LD_imm64",
"16",
"0",
"16",
"12",
"0",
"13",
"8",
"14",
"16",
"15",
"24",
"1",
"BPF::LD_ABS_B",
"BPF::LD_ABS_H",
"BPF::LD_ABS_W",
"BPF::LD_IND_B",
"BPF::LD_IND_H",
"BPF::LD_IND_W",
"0",
"BPF::R6"
] | BPFDisassembler12 | getInstruction | BPF | Virtual ISA | LLVM | 4,817 | 279 | 1 | [] |
[
"<s>",
"bool",
"riscv_split_symbol",
"(",
"rtx",
"temp",
",",
"rtx",
"addr",
",",
"enum",
"machine_mode",
"mode",
",",
"rtx",
"*",
"low_out",
")",
"{",
"enum",
"riscv_symbol_type",
"symbol_type",
";",
"if",
"(",
"(",
"GET_CODE",
"(",
"addr",
")",
"==",
"HIGH",
"&&",
"mode",
"==",
"MAX_MACHINE_MODE",
")",
"||",
"!",
"riscv_symbolic_constant_p",
"(",
"addr",
",",
"&",
"symbol_type",
")",
"||",
"riscv_symbol_insns",
"(",
"symbol_type",
")",
"==",
"0",
"||",
"!",
"riscv_split_symbol_type",
"(",
"symbol_type",
")",
")",
"return",
"false",
";",
"if",
"(",
"low_out",
")",
"switch",
"(",
"symbol_type",
")",
"{",
"case",
"SYMBOL_ABSOLUTE",
":",
"{",
"rtx",
"high",
"=",
"gen_rtx_HIGH",
"(",
"Pmode",
",",
"copy_rtx",
"(",
"addr",
")",
")",
";",
"high",
"=",
"riscv_force_temporary",
"(",
"temp",
",",
"high",
")",
";",
"*",
"low_out",
"=",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"high",
",",
"addr",
")",
";",
"}",
"break",
";",
"case",
"SYMBOL_PCREL",
":",
"{",
"static",
"unsigned",
"seqno",
";",
"char",
"buf",
"[",
"32",
"]",
";",
"rtx",
"label",
";",
"ssize_t",
"bytes",
"=",
"snprintf",
"(",
"buf",
",",
"sizeof",
"(",
"buf",
")",
",",
"\".LA%u\"",
",",
"seqno",
")",
";",
"gcc_assert",
"(",
"(",
"size_t",
")",
"bytes",
"<",
"sizeof",
"(",
"buf",
")",
")",
";",
"label",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"ggc_strdup",
"(",
"buf",
")",
")",
";",
"SYMBOL_REF_FLAGS",
"(",
"label",
")",
"|=",
"SYMBOL_FLAG_LOCAL",
";",
"if",
"(",
"temp",
"==",
"NULL",
")",
"temp",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"if",
"(",
"Pmode",
"==",
"DImode",
")",
"emit_insn",
"(",
"gen_auipcdi",
"(",
"temp",
",",
"copy_rtx",
"(",
"addr",
")",
",",
"GEN_INT",
"(",
"seqno",
")",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_auipcsi",
"(",
"temp",
",",
"copy_rtx",
"(",
"addr",
")",
",",
"GEN_INT",
"(",
"seqno",
")",
")",
")",
";",
"*",
"low_out",
"=",
"gen_rtx_LO_SUM",
"(",
"Pmode",
",",
"temp",
",",
"label",
")",
";",
"seqno",
"++",
";",
"}",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"If",
"MODE",
"is",
"MAX_MACHINE_MODE",
",",
"ADDR",
"appears",
"as",
"a",
"move",
"operand",
",",
"otherwise",
"it",
"appears",
"in",
"a",
"MEM",
"of",
"that",
"mode",
".",
"Return",
"true",
"if",
"ADDR",
"is",
"a",
"legitimate",
"constant",
"in",
"that",
"context",
"and",
"can",
"be",
"split",
"into",
"high",
"and",
"low",
"parts",
".",
"If",
"so",
",",
"and",
"if",
"LOW_OUT",
"is",
"nonnull",
",",
"emit",
"the",
"high",
"part",
"and",
"store",
"the",
"low",
"part",
"in",
"*",
"LOW_OUT",
".",
"Leave",
"*",
"LOW_OUT",
"unchanged",
"otherwise",
".",
"TEMP",
"is",
"as",
"for",
"riscv_force_temporary",
"and",
"is",
"used",
"to",
"load",
"the",
"high",
"part",
"into",
"a",
"register",
".",
"When",
"MODE",
"is",
"MAX_MACHINE_MODE",
",",
"the",
"low",
"part",
"is",
"guaranteed",
"to",
"be",
"a",
"legitimize",
"SET_SRC",
"for",
"an",
".md",
"pattern",
",",
"otherwise",
"the",
"low",
"part",
"is",
"guaranteed",
"to",
"be",
"a",
"legitimate",
"address",
"for",
"mode",
"MODE",
"."
] | [
"riscv",
"0",
"32",
"\".LA%u\""
] | riscv2 | riscv_split_symbol | riscv | CPU | GCC | 4,818 | 263 | 1 | [] |
[
"<s>",
"static",
"rtx",
"loongarch_got_load_tls_ie",
"(",
"rtx",
"dest",
",",
"rtx",
"sym",
")",
"{",
"return",
"gen_got_load_tls_ie",
"(",
"Pmode",
",",
"dest",
",",
"sym",
")",
";",
"}",
"</s>"
] | [
"Load",
"an",
"entry",
"from",
"the",
"GOT",
"for",
"a",
"TLS",
"IE",
"access",
"."
] | [
"loongarch"
] | loongarch | loongarch_got_load_tls_ie | loongarch | CPU | GCC | 4,819 | 22 | 1 | [] |
[
"<s>",
"bool",
"AMDGPUAlwaysInline",
"::",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"{",
"std",
"::",
"vector",
"<",
"GlobalAlias",
"*",
">",
"AliasesToRemove",
";",
"std",
"::",
"vector",
"<",
"Function",
"*",
">",
"FuncsToClone",
";",
"for",
"(",
"GlobalAlias",
"&",
"A",
":",
"M",
".",
"aliases",
"(",
")",
")",
"{",
"if",
"(",
"Function",
"*",
"F",
"=",
"dyn_cast",
"<",
"Function",
">",
"(",
"A",
".",
"getAliasee",
"(",
")",
")",
")",
"{",
"A",
".",
"replaceAllUsesWith",
"(",
"F",
")",
";",
"AliasesToRemove",
".",
"push_back",
"(",
"&",
"A",
")",
";",
"}",
"}",
"if",
"(",
"GlobalOpt",
")",
"{",
"for",
"(",
"GlobalAlias",
"*",
"A",
":",
"AliasesToRemove",
")",
"{",
"A",
"->",
"eraseFromParent",
"(",
")",
";",
"}",
"}",
"for",
"(",
"Function",
"&",
"F",
":",
"M",
")",
"{",
"if",
"(",
"!",
"F",
".",
"hasLocalLinkage",
"(",
")",
"&&",
"!",
"F",
".",
"isDeclaration",
"(",
")",
"&&",
"!",
"F",
".",
"use_empty",
"(",
")",
"&&",
"!",
"F",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"NoInline",
")",
")",
"FuncsToClone",
".",
"push_back",
"(",
"&",
"F",
")",
";",
"}",
"for",
"(",
"Function",
"*",
"F",
":",
"FuncsToClone",
")",
"{",
"ValueToValueMapTy",
"VMap",
";",
"Function",
"*",
"NewFunc",
"=",
"CloneFunction",
"(",
"F",
",",
"VMap",
")",
";",
"NewFunc",
"->",
"setLinkage",
"(",
"GlobalValue",
"::",
"InternalLinkage",
")",
";",
"F",
"->",
"replaceAllUsesWith",
"(",
"NewFunc",
")",
";",
"}",
"for",
"(",
"Function",
"&",
"F",
":",
"M",
")",
"{",
"if",
"(",
"F",
".",
"hasLocalLinkage",
"(",
")",
"&&",
"!",
"F",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"NoInline",
")",
")",
"{",
"F",
".",
"addFnAttr",
"(",
"Attribute",
"::",
"AlwaysInline",
")",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] | [
"AMDGPU",
"AMDGPU"
] | AMDGPUAlwaysInlinePass10 | runOnModule | AMDGPU | GPU | LLVM | 4,820 | 233 | 1 | [] |
[
"<s>",
"static",
"rtx",
"get_vl",
"(",
"rtx_insn",
"*",
"rinsn",
")",
"{",
"if",
"(",
"has_vl_op",
"(",
"rinsn",
")",
")",
"{",
"extract_insn_cached",
"(",
"rinsn",
")",
";",
"return",
"recog_data",
".",
"operand",
"[",
"get_attr_vl_op_idx",
"(",
"rinsn",
")",
"]",
";",
"}",
"return",
"SET_DEST",
"(",
"XVECEXP",
"(",
"PATTERN",
"(",
"rinsn",
")",
",",
"0",
",",
"0",
")",
")",
";",
"}",
"</s>"
] | [
"Helper",
"function",
"to",
"get",
"VL",
"operand",
"."
] | [
"riscv",
"0",
"0"
] | riscv-vsetvl | get_vl | riscv | CPU | GCC | 4,821 | 51 | 1 | [] |
[
"<s>",
"static",
"void",
"emitSPUpdate",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"&",
"MBBI",
",",
"unsigned",
"StackPtr",
",",
"int64_t",
"NumBytes",
",",
"bool",
"Is64Bit",
",",
"const",
"TargetInstrInfo",
"&",
"TII",
")",
"{",
"bool",
"isSub",
"=",
"NumBytes",
"<",
"0",
";",
"uint64_t",
"Offset",
"=",
"isSub",
"?",
"-",
"NumBytes",
":",
"NumBytes",
";",
"unsigned",
"Opc",
"=",
"isSub",
"?",
"(",
"(",
"Offset",
"<",
"128",
")",
"?",
"(",
"Is64Bit",
"?",
"X86",
"::",
"SUB64ri8",
":",
"X86",
"::",
"SUB32ri8",
")",
":",
"(",
"Is64Bit",
"?",
"X86",
"::",
"SUB64ri32",
":",
"X86",
"::",
"SUB32ri",
")",
")",
":",
"(",
"(",
"Offset",
"<",
"128",
")",
"?",
"(",
"Is64Bit",
"?",
"X86",
"::",
"ADD64ri8",
":",
"X86",
"::",
"ADD32ri8",
")",
":",
"(",
"Is64Bit",
"?",
"X86",
"::",
"ADD64ri32",
":",
"X86",
"::",
"ADD32ri",
")",
")",
";",
"uint64_t",
"Chunk",
"=",
"(",
"1LL",
"<<",
"31",
")",
"-",
"1",
";",
"DebugLoc",
"DL",
"=",
"(",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"?",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
":",
"DebugLoc",
"::",
"getUnknownLoc",
"(",
")",
")",
";",
"while",
"(",
"Offset",
")",
"{",
"uint64_t",
"ThisVal",
"=",
"(",
"Offset",
">",
"Chunk",
")",
"?",
"Chunk",
":",
"Offset",
";",
"MachineInstr",
"*",
"MI",
"=",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addImm",
"(",
"ThisVal",
")",
";",
"MI",
"->",
"getOperand",
"(",
"3",
")",
".",
"setIsDead",
"(",
")",
";",
"Offset",
"-=",
"ThisVal",
";",
"}",
"}",
"</s>"
] | [
"Emit",
"a",
"series",
"of",
"instructions",
"to",
"increment",
"/",
"decrement",
"the",
"stack",
"pointer",
"by",
"a",
"constant",
"value",
"."
] | [
"X86",
"0",
"128",
"X86::SUB64ri8",
"X86::SUB32ri8",
"X86::SUB64ri32",
"X86::SUB32ri",
"128",
"X86::ADD64ri8",
"X86::ADD32ri8",
"X86::ADD64ri32",
"X86::ADD32ri",
"1LL",
"31",
"1",
"3"
] | X86RegisterInfo41 | emitSPUpdate | X86 | CPU | LLVM | 4,822 | 218 | 1 | [] |
[
"<s>",
"void",
"OrderedRegisterList",
"::",
"remove",
"(",
"unsigned",
"VR",
")",
"{",
"iterator",
"L",
"=",
"llvm",
"::",
"lower_bound",
"(",
"Seq",
",",
"VR",
",",
"Ord",
")",
";",
"if",
"(",
"L",
"!=",
"Seq",
".",
"end",
"(",
")",
")",
"Seq",
".",
"erase",
"(",
"L",
")",
";",
"}",
"</s>"
] | [
"remove",
"-",
"Remove",
"the",
"specified",
"key/value",
"pair",
"from",
"the",
"map",
",",
"but",
"do",
"not",
"erase",
"it",
"."
] | [
"Hexagon"
] | HexagonGenInsert10 | remove | Hexagon | DSP | LLVM | 4,823 | 41 | 1 | [] |
[
"<s>",
"static",
"void",
"v850_asm_trampoline_template",
"(",
"FILE",
"*",
"f",
")",
"{",
"fprintf",
"(",
"f",
",",
"\"\\tjarl .+4,r12\\n\"",
")",
";",
"fprintf",
"(",
"f",
",",
"\"\\tld.w 12[r12],r19\\n\"",
")",
";",
"fprintf",
"(",
"f",
",",
"\"\\tld.w 16[r12],r12\\n\"",
")",
";",
"fprintf",
"(",
"f",
",",
"\"\\tjmp [r12]\\n\"",
")",
";",
"fprintf",
"(",
"f",
",",
"\"\\tnop\\n\"",
")",
";",
"fprintf",
"(",
"f",
",",
"\"\\t.long 0\\n\"",
")",
";",
"fprintf",
"(",
"f",
",",
"\"\\t.long 0\\n\"",
")",
";",
"}",
"</s>"
] | [
"Worker",
"function",
"for",
"TARGET_ASM_TRAMPOLINE_TEMPLATE",
"."
] | [
"v850",
"\"\\tjarl .+4,r12\\n\"",
"\"\\tld.w 12[r12],r19\\n\"",
"\"\\tld.w 16[r12],r12\\n\"",
"\"\\tjmp [r12]\\n\"",
"\"\\tnop\\n\"",
"\"\\t.long 0\\n\"",
"\"\\t.long 0\\n\""
] | v850 | v850_asm_trampoline_template | v850 | MPU | GCC | 4,824 | 59 | 1 | [] |
[
"<s>",
"bool",
"X86InstrInfo",
"::",
"findCommutedOpIndices",
"(",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"&",
"SrcOpIdx1",
",",
"unsigned",
"&",
"SrcOpIdx2",
")",
"const",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"X86",
"::",
"CMPPDrri",
":",
"case",
"X86",
"::",
"CMPPSrri",
":",
"case",
"X86",
"::",
"VCMPPDrri",
":",
"case",
"X86",
"::",
"VCMPPSrri",
":",
"case",
"X86",
"::",
"VCMPPDYrri",
":",
"case",
"X86",
"::",
"VCMPPSYrri",
":",
"{",
"unsigned",
"Imm",
"=",
"MI",
"->",
"getOperand",
"(",
"3",
")",
".",
"getImm",
"(",
")",
"&",
"0x7",
";",
"switch",
"(",
"Imm",
")",
"{",
"case",
"0x00",
":",
"case",
"0x03",
":",
"case",
"0x04",
":",
"case",
"0x07",
":",
"return",
"fixCommutedOpIndices",
"(",
"SrcOpIdx1",
",",
"SrcOpIdx2",
",",
"1",
",",
"2",
")",
";",
"}",
"return",
"false",
";",
"}",
"default",
":",
"if",
"(",
"isFMA3",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
")",
"return",
"findFMA3CommutedOpIndices",
"(",
"MI",
",",
"SrcOpIdx1",
",",
"SrcOpIdx2",
")",
";",
"return",
"TargetInstrInfo",
"::",
"findCommutedOpIndices",
"(",
"MI",
",",
"SrcOpIdx1",
",",
"SrcOpIdx2",
")",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"iff",
"the",
"routine",
"could",
"find",
"two",
"commutable",
"operands",
"in",
"the",
"given",
"machine",
"instruction",
"."
] | [
"X86",
"X86",
"X86::CMPPDrri",
"X86::CMPPSrri",
"X86::VCMPPDrri",
"X86::VCMPPSrri",
"X86::VCMPPDYrri",
"X86::VCMPPSYrri",
"3",
"0x7",
"0x00",
"0x03",
"0x04",
"0x07",
"1",
"2"
] | X86InstrInfo (2)2 | findCommutedOpIndices | X86 | CPU | LLVM | 4,825 | 149 | 1 | [] |
[
"<s>",
"MachineBasicBlock",
"::",
"iterator",
"RISCVFrameLowering",
"::",
"eliminateCallFramePseudoInstr",
"(",
"MachineFunction",
"&",
"MF",
",",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
")",
"const",
"{",
"Register",
"SPReg",
"=",
"RISCV",
"::",
"X2",
";",
"DebugLoc",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"!",
"hasReservedCallFrame",
"(",
"MF",
")",
")",
"{",
"int64_t",
"Amount",
"=",
"MI",
"->",
"getOperand",
"(",
"0",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Amount",
"!=",
"0",
")",
"{",
"Amount",
"=",
"alignSPAdjust",
"(",
"Amount",
")",
";",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"RISCV",
"::",
"ADJCALLSTACKDOWN",
")",
"Amount",
"=",
"-",
"Amount",
";",
"adjustReg",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"SPReg",
",",
"SPReg",
",",
"Amount",
",",
"MachineInstr",
"::",
"NoFlags",
")",
";",
"}",
"}",
"return",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"during",
"prolog/epilog",
"code",
"insertion",
"to",
"eliminate",
"call",
"frame",
"setup",
"and",
"destroy",
"pseudo",
"instructions",
"(",
"but",
"only",
"if",
"the",
"Target",
"is",
"using",
"them",
")",
"."
] | [
"RISCV",
"RISCV",
"RISCV::X2",
"0",
"0",
"RISCV::ADJCALLSTACKDOWN"
] | RISCVFrameLowering (2) | eliminateCallFramePseudoInstr | RISCV | CPU | LLVM | 4,826 | 122 | 1 | [] |
[
"<s>",
"bool",
"mep_expand_unary_intrinsic",
"(",
"int",
"ATTRIBUTE_UNUSED",
"intrinsic",
",",
"rtx",
"*",
"operands",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"false",
";",
"}",
"</s>"
] | [
"Apply",
"the",
"given",
"unary",
"intrinsic",
"to",
"OPERANDS",
"[",
"1",
"]",
"and",
"store",
"it",
"on",
"OPERANDS",
"[",
"0",
"]",
".",
"Report",
"an",
"error",
"if",
"the",
"instruction",
"could",
"not",
"be",
"synthesized",
".",
"OPERANDS",
"[",
"1",
"]",
"is",
"a",
"register_operand",
".",
"For",
"sign",
"and",
"zero",
"extensions",
",",
"it",
"may",
"be",
"smaller",
"than",
"SImode",
"."
] | [
"mep"
] | mep | mep_expand_unary_intrinsic | mep | CPU | GCC | 4,827 | 17 | 1 | [] |
[
"<s>",
"unsigned",
"ARMTargetLowering",
"::",
"getRegisterByName",
"(",
"const",
"char",
"*",
"RegName",
")",
"const",
"{",
"unsigned",
"Reg",
"=",
"StringSwitch",
"<",
"unsigned",
">",
"(",
"RegName",
")",
".",
"Case",
"(",
"\"sp\"",
",",
"ARM",
"::",
"SP",
")",
".",
"Default",
"(",
"0",
")",
";",
"if",
"(",
"Reg",
")",
"return",
"Reg",
";",
"report_fatal_error",
"(",
"\"Invalid register name global variable\"",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"register",
"ID",
"of",
"the",
"name",
"passed",
"in",
"."
] | [
"ARM",
"ARM",
"\"sp\"",
"ARM::SP",
"0",
"\"Invalid register name global variable\""
] | ARMISelLowering121 | getRegisterByName | ARM | CPU | LLVM | 4,828 | 50 | 1 | [] |
[
"<s>",
"static",
"bool",
"mips_expand_msa_shuffle",
"(",
"struct",
"expand_vec_perm_d",
"*",
"d",
")",
"{",
"rtx",
"x",
",",
"elts",
"[",
"MAX_VECT_LEN",
"]",
";",
"rtvec",
"v",
";",
"rtx_insn",
"*",
"insn",
";",
"unsigned",
"i",
";",
"if",
"(",
"!",
"ISA_HAS_MSA",
")",
"return",
"false",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"d",
"->",
"nelt",
";",
"i",
"++",
")",
"elts",
"[",
"i",
"]",
"=",
"GEN_INT",
"(",
"d",
"->",
"perm",
"[",
"i",
"]",
")",
";",
"v",
"=",
"gen_rtvec_v",
"(",
"d",
"->",
"nelt",
",",
"elts",
")",
";",
"x",
"=",
"gen_rtx_PARALLEL",
"(",
"VOIDmode",
",",
"v",
")",
";",
"if",
"(",
"!",
"mips_const_vector_shuffle_set_p",
"(",
"x",
",",
"d",
"->",
"vmode",
")",
")",
"return",
"false",
";",
"x",
"=",
"gen_rtx_VEC_SELECT",
"(",
"d",
"->",
"vmode",
",",
"d",
"->",
"op0",
",",
"x",
")",
";",
"x",
"=",
"gen_rtx_SET",
"(",
"d",
"->",
"target",
",",
"x",
")",
";",
"insn",
"=",
"emit_insn",
"(",
"x",
")",
";",
"if",
"(",
"recog_memoized",
"(",
"insn",
")",
"<",
"0",
")",
"{",
"remove_insn",
"(",
"insn",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"Construct",
"(",
"set",
"target",
"(",
"vec_select",
"op0",
"(",
"parallel",
"selector",
")",
")",
")",
"and",
"return",
"true",
"if",
"that",
"'s",
"a",
"valid",
"instruction",
"in",
"the",
"active",
"ISA",
"."
] | [
"mips",
"0",
"0"
] | mips | mips_expand_msa_shuffle | mips | CPU | GCC | 4,829 | 157 | 1 | [] |
[
"<s>",
"rtx",
"mmix_eh_return_handler_rtx",
"(",
")",
"{",
"return",
"gen_rtx_REG",
"(",
"Pmode",
",",
"MMIX_INCOMING_RETURN_ADDRESS_REGNUM",
")",
";",
"}",
"</s>"
] | [
"EH_RETURN_HANDLER_RTX",
"."
] | [
"mmix"
] | mmix2 | mmix_eh_return_handler_rtx | mmix | CPU | GCC | 4,830 | 14 | 1 | [] |
[
"<s>",
"bool",
"X86InstructionSelector",
"::",
"select",
"(",
"MachineInstr",
"&",
"I",
")",
"const",
"{",
"assert",
"(",
"I",
".",
"getParent",
"(",
")",
"&&",
"\"Instruction should be in a basic block!\"",
")",
";",
"assert",
"(",
"I",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"&&",
"\"Instruction should be in a function!\"",
")",
";",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"I",
".",
"getParent",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"unsigned",
"Opcode",
"=",
"I",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"!",
"isPreISelGenericOpcode",
"(",
"Opcode",
")",
")",
"{",
"if",
"(",
"I",
".",
"isCopy",
"(",
")",
")",
"return",
"selectCopy",
"(",
"I",
",",
"MRI",
")",
";",
"return",
"true",
";",
"}",
"assert",
"(",
"I",
".",
"getNumOperands",
"(",
")",
"==",
"I",
".",
"getNumExplicitOperands",
"(",
")",
"&&",
"\"Generic instruction has unexpected implicit operands\\n\"",
")",
";",
"if",
"(",
"selectImpl",
"(",
"I",
")",
")",
"return",
"true",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\" C++ instruction selection: \"",
";",
"I",
".",
"print",
"(",
"dbgs",
"(",
")",
")",
")",
";",
"if",
"(",
"selectLoadStoreOp",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
")",
"return",
"true",
";",
"if",
"(",
"selectFrameIndexOrGep",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
")",
"return",
"true",
";",
"if",
"(",
"selectConstant",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
")",
"return",
"true",
";",
"if",
"(",
"selectTrunc",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
")",
"return",
"true",
";",
"if",
"(",
"selectZext",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
")",
"return",
"true",
";",
"if",
"(",
"selectCmp",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
")",
"return",
"true",
";",
"if",
"(",
"selectUadde",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
")",
"return",
"true",
";",
"if",
"(",
"selectInsert",
"(",
"I",
",",
"MRI",
",",
"MF",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Select",
"the",
"(",
"possibly",
"generic",
")",
"instruction",
"I",
"to",
"only",
"use",
"target-specific",
"opcodes",
"."
] | [
"X86",
"X86",
"\"Instruction should be in a basic block!\"",
"\"Instruction should be in a function!\"",
"\"Generic instruction has unexpected implicit operands\\n\"",
"\" C++ instruction selection: \""
] | X86InstructionSelector3 | select | X86 | CPU | LLVM | 4,831 | 268 | 1 | [] |
[
"<s>",
"InstructionCost",
"X86TTIImpl",
"::",
"getScalarizationOverhead",
"(",
"VectorType",
"*",
"Ty",
",",
"const",
"APInt",
"&",
"DemandedElts",
",",
"bool",
"Insert",
",",
"bool",
"Extract",
")",
"{",
"InstructionCost",
"Cost",
"=",
"0",
";",
"if",
"(",
"Insert",
")",
"{",
"std",
"::",
"pair",
"<",
"InstructionCost",
",",
"MVT",
">",
"LT",
"=",
"TLI",
"->",
"getTypeLegalizationCost",
"(",
"DL",
",",
"Ty",
")",
";",
"MVT",
"MScalarTy",
"=",
"LT",
".",
"second",
".",
"getScalarType",
"(",
")",
";",
"if",
"(",
"(",
"MScalarTy",
"==",
"MVT",
"::",
"i16",
"&&",
"ST",
"->",
"hasSSE2",
"(",
")",
")",
"||",
"(",
"MScalarTy",
".",
"isInteger",
"(",
")",
"&&",
"ST",
"->",
"hasSSE41",
"(",
")",
")",
"||",
"(",
"MScalarTy",
"==",
"MVT",
"::",
"f32",
"&&",
"ST",
"->",
"hasSSE41",
"(",
")",
")",
")",
"{",
"if",
"(",
"LT",
".",
"second",
".",
"getSizeInBits",
"(",
")",
"<=",
"128",
")",
"{",
"Cost",
"+=",
"BaseT",
"::",
"getScalarizationOverhead",
"(",
"Ty",
",",
"DemandedElts",
",",
"Insert",
",",
"false",
")",
";",
"}",
"else",
"{",
"const",
"int",
"CostValue",
"=",
"*",
"LT",
".",
"first",
".",
"getValue",
"(",
")",
";",
"assert",
"(",
"CostValue",
">=",
"0",
"&&",
"\"Negative cost!\"",
")",
";",
"unsigned",
"Num128Lanes",
"=",
"LT",
".",
"second",
".",
"getSizeInBits",
"(",
")",
"/",
"128",
"*",
"CostValue",
";",
"unsigned",
"NumElts",
"=",
"LT",
".",
"second",
".",
"getVectorNumElements",
"(",
")",
"*",
"CostValue",
";",
"APInt",
"WidenedDemandedElts",
"=",
"DemandedElts",
".",
"zextOrSelf",
"(",
"NumElts",
")",
";",
"unsigned",
"Scale",
"=",
"NumElts",
"/",
"Num128Lanes",
";",
"for",
"(",
"unsigned",
"I",
"=",
"0",
";",
"I",
"<",
"NumElts",
";",
"I",
"+=",
"Scale",
")",
"{",
"APInt",
"Mask",
"=",
"WidenedDemandedElts",
".",
"getBitsSet",
"(",
"NumElts",
",",
"I",
",",
"I",
"+",
"Scale",
")",
";",
"APInt",
"MaskedDE",
"=",
"Mask",
"&",
"WidenedDemandedElts",
";",
"unsigned",
"Population",
"=",
"MaskedDE",
".",
"countPopulation",
"(",
")",
";",
"Cost",
"+=",
"(",
"Population",
">",
"0",
"&&",
"Population",
"!=",
"Scale",
"&&",
"I",
"%",
"LT",
".",
"second",
".",
"getVectorNumElements",
"(",
")",
"!=",
"0",
")",
";",
"Cost",
"+=",
"Population",
">",
"0",
";",
"}",
"Cost",
"+=",
"DemandedElts",
".",
"countPopulation",
"(",
")",
";",
"if",
"(",
"MScalarTy",
"==",
"MVT",
"::",
"f32",
")",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"cast",
"<",
"FixedVectorType",
">",
"(",
"Ty",
")",
"->",
"getNumElements",
"(",
")",
";",
"i",
"<",
"e",
";",
"i",
"+=",
"4",
")",
"if",
"(",
"DemandedElts",
"[",
"i",
"]",
")",
"Cost",
"--",
";",
"}",
"}",
"else",
"if",
"(",
"LT",
".",
"second",
".",
"isVector",
"(",
")",
")",
"{",
"if",
"(",
"Ty",
"->",
"isIntOrIntVectorTy",
"(",
")",
")",
"Cost",
"+=",
"DemandedElts",
".",
"countPopulation",
"(",
")",
";",
"unsigned",
"NumElts",
"=",
"LT",
".",
"second",
".",
"getVectorNumElements",
"(",
")",
";",
"unsigned",
"Pow2Elts",
"=",
"PowerOf2Ceil",
"(",
"cast",
"<",
"FixedVectorType",
">",
"(",
"Ty",
")",
"->",
"getNumElements",
"(",
")",
")",
";",
"Cost",
"+=",
"(",
"std",
"::",
"min",
"<",
"unsigned",
">",
"(",
"NumElts",
",",
"Pow2Elts",
")",
"-",
"1",
")",
"*",
"LT",
".",
"first",
";",
"}",
"}",
"if",
"(",
"Extract",
")",
"Cost",
"+=",
"BaseT",
"::",
"getScalarizationOverhead",
"(",
"Ty",
",",
"DemandedElts",
",",
"false",
",",
"Extract",
")",
";",
"return",
"Cost",
";",
"}",
"</s>"
] | [
"Estimate",
"the",
"overhead",
"of",
"scalarizing",
"an",
"instruction",
"."
] | [
"X86",
"X86",
"0",
"MVT::i16",
"MVT::f32",
"128",
"0",
"\"Negative cost!\"",
"128",
"0",
"0",
"0",
"0",
"MVT::f32",
"0",
"4",
"1"
] | X86TargetTransformInfo (2)1 | getScalarizationOverhead | X86 | CPU | LLVM | 4,832 | 444 | 1 | [] |
[
"<s>",
"static",
"unsigned",
"int",
"ix86_autovectorize_vector_modes",
"(",
"vector_modes",
"*",
"modes",
",",
"bool",
"all",
")",
"{",
"if",
"(",
"TARGET_AVX512F",
"&&",
"!",
"TARGET_PREFER_AVX256",
")",
"{",
"modes",
"->",
"safe_push",
"(",
"V64QImode",
")",
";",
"modes",
"->",
"safe_push",
"(",
"V32QImode",
")",
";",
"modes",
"->",
"safe_push",
"(",
"V16QImode",
")",
";",
"}",
"else",
"if",
"(",
"TARGET_AVX512F",
"&&",
"all",
")",
"{",
"modes",
"->",
"safe_push",
"(",
"V32QImode",
")",
";",
"modes",
"->",
"safe_push",
"(",
"V16QImode",
")",
";",
"modes",
"->",
"safe_push",
"(",
"V64QImode",
")",
";",
"}",
"else",
"if",
"(",
"TARGET_AVX",
"&&",
"!",
"TARGET_PREFER_AVX128",
")",
"{",
"modes",
"->",
"safe_push",
"(",
"V32QImode",
")",
";",
"modes",
"->",
"safe_push",
"(",
"V16QImode",
")",
";",
"}",
"else",
"if",
"(",
"TARGET_AVX",
"&&",
"all",
")",
"{",
"modes",
"->",
"safe_push",
"(",
"V16QImode",
")",
";",
"modes",
"->",
"safe_push",
"(",
"V32QImode",
")",
";",
"}",
"else",
"if",
"(",
"TARGET_SSE2",
")",
"modes",
"->",
"safe_push",
"(",
"V16QImode",
")",
";",
"if",
"(",
"TARGET_MMX_WITH_SSE",
")",
"modes",
"->",
"safe_push",
"(",
"V8QImode",
")",
";",
"if",
"(",
"TARGET_SSE2",
")",
"modes",
"->",
"safe_push",
"(",
"V4QImode",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"If",
"AVX",
"is",
"enabled",
"then",
"try",
"vectorizing",
"with",
"both",
"256bit",
"and",
"128bit",
"vectors",
".",
"If",
"AVX512F",
"is",
"enabled",
"then",
"try",
"vectorizing",
"with",
"512bit",
",",
"256bit",
"and",
"128bit",
"vectors",
"."
] | [
"i386",
"0"
] | i386 | ix86_autovectorize_vector_modes | i386 | CPU | GCC | 4,833 | 158 | 1 | [] |
[
"<s>",
"unsigned",
"DLXInstrInfo",
"::",
"isStoreToStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"return",
"1",
";",
"}",
"</s>"
] | [
"isStoreToStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"store",
"to",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"source",
"reg",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] | [
"DLX",
"DLX",
"1"
] | DLXInstrInfo | isStoreToStackSlot | DLX | CPU | LLVM | 4,834 | 20 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"ARMBaseRegisterInfo",
"::",
"getPointerRegClass",
"(",
"unsigned",
"Kind",
")",
"const",
"{",
"return",
"ARM",
"::",
"GPRRegisterClass",
";",
"}",
"</s>"
] | [
"getPointerRegClass",
"-",
"Returns",
"a",
"TargetRegisterClass",
"used",
"for",
"pointer",
"values",
"."
] | [
"ARM",
"ARM",
"ARM::GPRRegisterClass"
] | ARMBaseRegisterInfo1 | getPointerRegClass | ARM | CPU | LLVM | 4,835 | 18 | 1 | [] |
[
"<s>",
"static",
"void",
"h8300_reorg",
"(",
"void",
")",
"{",
"if",
"(",
"flag_delayed_branch",
")",
"shorten_branches",
"(",
"get_insns",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"Delayed-branch",
"scheduling",
"is",
"more",
"effective",
"if",
"we",
"have",
"some",
"idea",
"how",
"long",
"each",
"instruction",
"will",
"be",
".",
"Use",
"a",
"shorten_branches",
"pass",
"to",
"get",
"an",
"initial",
"estimate",
"."
] | [
"h8300"
] | h8300 | h8300_reorg | h8300 | MPU | GCC | 4,836 | 19 | 1 | [] |
[
"<s>",
"unsigned",
"VEMCCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"const",
"MCOperand",
"&",
"MO",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
")",
"const",
"{",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"return",
"Ctx",
".",
"getRegisterInfo",
"(",
")",
"->",
"getEncodingValue",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
";",
"assert",
"(",
"MO",
".",
"isExpr",
"(",
")",
")",
";",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MO",
".",
"getExpr",
"(",
")",
";",
"if",
"(",
"const",
"VEMCExpr",
"*",
"SExpr",
"=",
"dyn_cast",
"<",
"VEMCExpr",
">",
"(",
"Expr",
")",
")",
"{",
"MCFixupKind",
"Kind",
"=",
"(",
"MCFixupKind",
")",
"SExpr",
"->",
"getFixupKind",
"(",
")",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"0",
",",
"Expr",
",",
"Kind",
")",
")",
";",
"return",
"0",
";",
"}",
"int64_t",
"Res",
";",
"if",
"(",
"Expr",
"->",
"evaluateAsAbsolute",
"(",
"Res",
")",
")",
"return",
"Res",
";",
"llvm_unreachable",
"(",
"\"Unhandled expression!\"",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"VE",
"VE",
"VE",
"VE",
"0",
"0",
"\"Unhandled expression!\"",
"0"
] | VEMCCodeEmitter | getMachineOpValue | VE | CPU | LLVM | 4,837 | 160 | 1 | [] |
[
"<s>",
"const",
"MipsSubtarget",
"*",
"MipsTargetMachine",
"::",
"getSubtargetImpl",
"(",
"const",
"Function",
"&",
"F",
")",
"const",
"{",
"AttributeSet",
"FnAttrs",
"=",
"F",
".",
"getAttributes",
"(",
")",
";",
"Attribute",
"CPUAttr",
"=",
"FnAttrs",
".",
"getAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"\"target-cpu\"",
")",
";",
"Attribute",
"FSAttr",
"=",
"FnAttrs",
".",
"getAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"\"target-features\"",
")",
";",
"std",
"::",
"string",
"CPU",
"=",
"!",
"CPUAttr",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"None",
")",
"?",
"CPUAttr",
".",
"getValueAsString",
"(",
")",
".",
"str",
"(",
")",
":",
"TargetCPU",
";",
"std",
"::",
"string",
"FS",
"=",
"!",
"FSAttr",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"None",
")",
"?",
"FSAttr",
".",
"getValueAsString",
"(",
")",
".",
"str",
"(",
")",
":",
"TargetFS",
";",
"bool",
"hasMips16Attr",
"=",
"!",
"FnAttrs",
".",
"getAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"\"mips16\"",
")",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"None",
")",
";",
"bool",
"hasNoMips16Attr",
"=",
"!",
"FnAttrs",
".",
"getAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"\"nomips16\"",
")",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"None",
")",
";",
"Attribute",
"SFAttr",
"=",
"FnAttrs",
".",
"getAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"\"use-soft-float\"",
")",
";",
"bool",
"softFloat",
"=",
"!",
"SFAttr",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"None",
")",
"?",
"SFAttr",
".",
"getValueAsString",
"(",
")",
"==",
"\"true\"",
":",
"Options",
".",
"UseSoftFloat",
";",
"if",
"(",
"hasMips16Attr",
")",
"FS",
"+=",
"FS",
".",
"empty",
"(",
")",
"?",
"\"+mips16\"",
":",
"\",+mips16\"",
";",
"else",
"if",
"(",
"hasNoMips16Attr",
")",
"FS",
"+=",
"FS",
".",
"empty",
"(",
")",
"?",
"\"-mips16\"",
":",
"\",-mips16\"",
";",
"auto",
"&",
"I",
"=",
"SubtargetMap",
"[",
"CPU",
"+",
"FS",
"+",
"(",
"softFloat",
"?",
"\"use-soft-float=true\"",
":",
"\"use-soft-float=false\"",
")",
"]",
";",
"if",
"(",
"!",
"I",
")",
"{",
"resetTargetOptions",
"(",
"F",
")",
";",
"I",
"=",
"llvm",
"::",
"make_unique",
"<",
"MipsSubtarget",
">",
"(",
"TargetTriple",
",",
"CPU",
",",
"FS",
",",
"isLittle",
",",
"*",
"this",
")",
";",
"}",
"return",
"I",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Virtual",
"method",
"implemented",
"by",
"subclasses",
"that",
"returns",
"a",
"reference",
"to",
"that",
"target",
"'s",
"TargetSubtargetInfo-derived",
"member",
"variable",
"."
] | [
"Mips",
"Mips",
"Mips",
"\"target-cpu\"",
"\"target-features\"",
"Mips",
"\"mips16\"",
"Mips",
"\"nomips16\"",
"\"use-soft-float\"",
"\"true\"",
"Mips",
"\"+mips16\"",
"\",+mips16\"",
"Mips",
"\"-mips16\"",
"\",-mips16\"",
"\"use-soft-float=true\"",
"\"use-soft-float=false\"",
"Mips"
] | MipsTargetMachine28 | getSubtargetImpl | Mips | CPU | LLVM | 4,838 | 281 | 1 | [] |
[
"<s>",
"bool",
"aarch64_address_valid_for_prefetch_p",
"(",
"rtx",
"x",
",",
"bool",
"strict_p",
")",
"{",
"struct",
"aarch64_address_info",
"addr",
";",
"bool",
"res",
"=",
"aarch64_classify_address",
"(",
"&",
"addr",
",",
"x",
",",
"DImode",
",",
"strict_p",
")",
";",
"if",
"(",
"!",
"res",
")",
"return",
"false",
";",
"return",
"addr",
".",
"type",
"!=",
"ADDRESS_REG_WB",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"address",
"X",
"is",
"valid",
"for",
"a",
"PRFM",
"instruction",
".",
"STRICT_P",
"is",
"true",
"if",
"we",
"should",
"do",
"strict",
"checking",
"with",
"aarch64_classify_address",
"."
] | [
"aarch64"
] | aarch64 | aarch64_address_valid_for_prefetch_p | aarch64 | CPU | GCC | 4,839 | 45 | 1 | [] |
[
"<s>",
"bool",
"SPUFrameLowering",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"return",
"MFI",
"->",
"getStackSize",
"(",
")",
"&&",
"(",
"DisableFramePointerElim",
"(",
"MF",
")",
"||",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"CellSPU",
"SPU"
] | SPUFrameLowering | hasFP | CellSPU | MPU | LLVM | 4,840 | 44 | 1 | [] |
[
"<s>",
"bool",
"PPCTargetLowering",
"::",
"shouldConvertConstantLoadToIntImm",
"(",
"const",
"APInt",
"&",
"Imm",
",",
"Type",
"*",
"Ty",
")",
"const",
"{",
"assert",
"(",
"Ty",
"->",
"isIntegerTy",
"(",
")",
")",
";",
"unsigned",
"BitSize",
"=",
"Ty",
"->",
"getPrimitiveSizeInBits",
"(",
")",
";",
"if",
"(",
"BitSize",
"==",
"0",
"||",
"BitSize",
">",
"64",
")",
"return",
"false",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Returns",
"true",
"if",
"it",
"is",
"beneficial",
"to",
"convert",
"a",
"load",
"of",
"a",
"constant",
"to",
"just",
"the",
"constant",
"itself",
"."
] | [
"PowerPC",
"PPC",
"0",
"64"
] | PPCISelLowering (2)2 | shouldConvertConstantLoadToIntImm | PowerPC | CPU | LLVM | 4,841 | 51 | 1 | [] |
[
"<s>",
"StringRef",
"getType",
"(",
")",
"{",
"return",
"CurType",
";",
"}",
"</s>"
] | [
"Overload",
"to",
"return",
"most",
"specific",
"vector",
"type",
"."
] | [
"X86"
] | X86AsmParser58 | getType | X86 | CPU | LLVM | 4,842 | 9 | 1 | [] |
[
"<s>",
"X86Subtarget",
"::",
"X86Subtarget",
"(",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"X86TargetMachine",
"&",
"TM",
",",
"unsigned",
"StackAlignOverride",
")",
":",
"X86GenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"X86ProcFamily",
"(",
"Others",
")",
",",
"PICStyle",
"(",
"PICStyles",
"::",
"None",
")",
",",
"TargetTriple",
"(",
"TT",
")",
",",
"StackAlignOverride",
"(",
"StackAlignOverride",
")",
",",
"In64BitMode",
"(",
"TargetTriple",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86_64",
")",
",",
"In32BitMode",
"(",
"TargetTriple",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86",
"&&",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"!=",
"Triple",
"::",
"CODE16",
")",
",",
"In16BitMode",
"(",
"TargetTriple",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86",
"&&",
"TargetTriple",
".",
"getEnvironment",
"(",
")",
"==",
"Triple",
"::",
"CODE16",
")",
",",
"DL",
"(",
"computeDataLayout",
"(",
"*",
"this",
")",
")",
",",
"TSInfo",
"(",
"DL",
")",
",",
"InstrInfo",
"(",
"initializeSubtargetDependencies",
"(",
"CPU",
",",
"FS",
")",
")",
",",
"TLInfo",
"(",
"TM",
")",
",",
"FrameLowering",
"(",
"TargetFrameLowering",
"::",
"StackGrowsDown",
",",
"getStackAlignment",
"(",
")",
",",
"is64Bit",
"(",
")",
"?",
"-",
"8",
":",
"-",
"4",
")",
",",
"JITInfo",
"(",
"hasSSE1",
"(",
")",
")",
"{",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"8",
"4"
] | X86Subtarget100 | X86Subtarget | X86 | CPU | LLVM | 4,843 | 181 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyPrepareForLiveIntervals",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"DEBUG",
"(",
"{",
"dbgs",
"(",
")",
"<<",
"\"********** Prepare For LiveIntervals **********\\n\"",
"<<",
"\"********** Function: \"",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'\\n'",
";",
"}",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"const",
"auto",
"&",
"TII",
"=",
"*",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"MachineBasicBlock",
"&",
"Entry",
"=",
"*",
"MF",
".",
"begin",
"(",
")",
";",
"assert",
"(",
"!",
"mustPreserveAnalysisID",
"(",
"LiveIntervalsID",
")",
"&&",
"\"LiveIntervals shouldn't be active yet!\"",
")",
";",
"MRI",
".",
"leaveSSA",
"(",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"MRI",
".",
"getNumVirtRegs",
"(",
")",
";",
"i",
"<",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"TargetRegisterInfo",
"::",
"index2VirtReg",
"(",
"i",
")",
";",
"if",
"(",
"MRI",
".",
"use_nodbg_empty",
"(",
"Reg",
")",
")",
"continue",
";",
"if",
"(",
"HasArgumentDef",
"(",
"Reg",
",",
"MRI",
")",
")",
"continue",
";",
"BuildMI",
"(",
"Entry",
",",
"Entry",
".",
"begin",
"(",
")",
",",
"DebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"WebAssembly",
"::",
"IMPLICIT_DEF",
")",
",",
"Reg",
")",
";",
"Changed",
"=",
"true",
";",
"}",
"for",
"(",
"auto",
"MII",
"=",
"Entry",
".",
"begin",
"(",
")",
",",
"MIE",
"=",
"Entry",
".",
"end",
"(",
")",
";",
"MII",
"!=",
"MIE",
";",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"MII",
"++",
";",
"if",
"(",
"WebAssembly",
"::",
"isArgument",
"(",
"MI",
")",
")",
"{",
"MI",
".",
"removeFromParent",
"(",
")",
";",
"Entry",
".",
"insert",
"(",
"Entry",
".",
"begin",
"(",
")",
",",
"&",
"MI",
")",
";",
"}",
"}",
"MF",
".",
"getProperties",
"(",
")",
".",
"set",
"(",
"MachineFunctionProperties",
"::",
"Property",
"::",
"TracksLiveness",
")",
";",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"WebAssembly",
"WebAssembly",
"\"********** Prepare For LiveIntervals **********\\n\"",
"\"********** Function: \"",
"WebAssembly",
"\"LiveIntervals shouldn't be active yet!\"",
"0",
"WebAssembly::IMPLICIT_DEF",
"WebAssembly::isArgument"
] | WebAssemblyPrepareForLiveIntervals11 | runOnMachineFunction | WebAssembly | Virtual ISA | LLVM | 4,844 | 264 | 1 | [] |
[
"<s>",
"const",
"char",
"*",
"AMDGPUTargetLowering",
"::",
"getTargetNodeName",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"default",
":",
"return",
"nullptr",
";",
"NODE_NAME_CASE",
"(",
"CALL",
")",
";",
"NODE_NAME_CASE",
"(",
"UMUL",
")",
";",
"NODE_NAME_CASE",
"(",
"DIV_INF",
")",
";",
"NODE_NAME_CASE",
"(",
"RET_FLAG",
")",
";",
"NODE_NAME_CASE",
"(",
"BRANCH_COND",
")",
";",
"NODE_NAME_CASE",
"(",
"DWORDADDR",
")",
"NODE_NAME_CASE",
"(",
"FRACT",
")",
"NODE_NAME_CASE",
"(",
"FMAX",
")",
"NODE_NAME_CASE",
"(",
"SMAX",
")",
"NODE_NAME_CASE",
"(",
"UMAX",
")",
"NODE_NAME_CASE",
"(",
"FMIN",
")",
"NODE_NAME_CASE",
"(",
"SMIN",
")",
"NODE_NAME_CASE",
"(",
"UMIN",
")",
"NODE_NAME_CASE",
"(",
"BFE_U32",
")",
"NODE_NAME_CASE",
"(",
"BFE_I32",
")",
"NODE_NAME_CASE",
"(",
"BFI",
")",
"NODE_NAME_CASE",
"(",
"BFM",
")",
"NODE_NAME_CASE",
"(",
"MUL_U24",
")",
"NODE_NAME_CASE",
"(",
"MUL_I24",
")",
"NODE_NAME_CASE",
"(",
"URECIP",
")",
"NODE_NAME_CASE",
"(",
"DOT4",
")",
"NODE_NAME_CASE",
"(",
"EXPORT",
")",
"NODE_NAME_CASE",
"(",
"CONST_ADDRESS",
")",
"NODE_NAME_CASE",
"(",
"REGISTER_LOAD",
")",
"NODE_NAME_CASE",
"(",
"REGISTER_STORE",
")",
"NODE_NAME_CASE",
"(",
"LOAD_CONSTANT",
")",
"NODE_NAME_CASE",
"(",
"LOAD_INPUT",
")",
"NODE_NAME_CASE",
"(",
"SAMPLE",
")",
"NODE_NAME_CASE",
"(",
"SAMPLEB",
")",
"NODE_NAME_CASE",
"(",
"SAMPLED",
")",
"NODE_NAME_CASE",
"(",
"SAMPLEL",
")",
"NODE_NAME_CASE",
"(",
"STORE_MSKOR",
")",
"NODE_NAME_CASE",
"(",
"TBUFFER_STORE_FORMAT",
")",
"}",
"}",
"</s>"
] | [
"getTargetNodeName",
"-",
"This",
"method",
"returns",
"the",
"name",
"of",
"a",
"target",
"specific"
] | [
"R600"
] | AMDGPUISelLowering68 | getTargetNodeName | R600 | GPU | LLVM | 4,845 | 161 | 1 | [] |
[
"<s>",
"bool",
"PPCInstrInfo",
"::",
"analyzeCompare",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"&",
"SrcReg",
",",
"unsigned",
"&",
"SrcReg2",
",",
"int",
"&",
"Mask",
",",
"int",
"&",
"Value",
")",
"const",
"{",
"unsigned",
"Opc",
"=",
"MI",
"->",
"getOpcode",
"(",
")",
";",
"switch",
"(",
"Opc",
")",
"{",
"default",
":",
"return",
"false",
";",
"case",
"PPC",
"::",
"CMPWI",
":",
"case",
"PPC",
"::",
"CMPLWI",
":",
"case",
"PPC",
"::",
"CMPDI",
":",
"case",
"PPC",
"::",
"CMPLDI",
":",
"SrcReg",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"SrcReg2",
"=",
"0",
";",
"Value",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getImm",
"(",
")",
";",
"Mask",
"=",
"0xFFFF",
";",
"return",
"true",
";",
"case",
"PPC",
"::",
"CMPW",
":",
"case",
"PPC",
"::",
"CMPLW",
":",
"case",
"PPC",
"::",
"CMPD",
":",
"case",
"PPC",
"::",
"CMPLD",
":",
"case",
"PPC",
"::",
"FCMPUS",
":",
"case",
"PPC",
"::",
"FCMPUD",
":",
"SrcReg",
"=",
"MI",
"->",
"getOperand",
"(",
"1",
")",
".",
"getReg",
"(",
")",
";",
"SrcReg2",
"=",
"MI",
"->",
"getOperand",
"(",
"2",
")",
".",
"getReg",
"(",
")",
";",
"return",
"true",
";",
"}",
"}",
"</s>"
] | [
"analyzeCompare",
"-",
"For",
"a",
"comparison",
"instruction",
",",
"return",
"the",
"source",
"registers",
"in",
"SrcReg",
"and",
"SrcReg2",
"if",
"having",
"two",
"register",
"operands",
",",
"and",
"the",
"value",
"it",
"compares",
"against",
"in",
"CmpValue",
"."
] | [
"PowerPC",
"PPC",
"PPC::CMPWI",
"PPC::CMPLWI",
"PPC::CMPDI",
"PPC::CMPLDI",
"1",
"0",
"2",
"0xFFFF",
"PPC::CMPW",
"PPC::CMPLW",
"PPC::CMPD",
"PPC::CMPLD",
"PPC::FCMPUS",
"PPC::FCMPUD",
"1",
"2"
] | PPCInstrInfo (2) | analyzeCompare | PowerPC | CPU | LLVM | 4,846 | 165 | 1 | [] |
[
"<s>",
"void",
"SystemZRegisterInfo",
"::",
"emitPrologue",
"(",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"const",
"TargetFrameInfo",
"&",
"TFI",
"=",
"*",
"MF",
".",
"getTarget",
"(",
")",
".",
"getFrameInfo",
"(",
")",
";",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"SystemZMachineFunctionInfo",
"*",
"SystemZMFI",
"=",
"MF",
".",
"getInfo",
"<",
"SystemZMachineFunctionInfo",
">",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"(",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"?",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
":",
"DebugLoc",
"::",
"getUnknownLoc",
"(",
")",
")",
";",
"uint64_t",
"StackSize",
"=",
"MFI",
"->",
"getStackSize",
"(",
")",
";",
"StackSize",
"-=",
"SystemZMFI",
"->",
"getCalleeSavedFrameSize",
"(",
")",
";",
"uint64_t",
"NumBytes",
"=",
"StackSize",
"-",
"TFI",
".",
"getOffsetOfLocalArea",
"(",
")",
";",
"while",
"(",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
"&&",
"(",
"MBBI",
"->",
"getOpcode",
"(",
")",
"==",
"SystemZ",
"::",
"MOV64mr",
"||",
"MBBI",
"->",
"getOpcode",
"(",
")",
"==",
"SystemZ",
"::",
"MOV64mrm",
")",
")",
"++",
"MBBI",
";",
"if",
"(",
"MBBI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"StackSize",
"||",
"MFI",
"->",
"hasCalls",
"(",
")",
")",
"{",
"assert",
"(",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"isPhysRegUsed",
"(",
"SystemZ",
"::",
"R15D",
")",
"&&",
"\"Invalid stack frame calculation!\"",
")",
";",
"emitSPUpdate",
"(",
"MBB",
",",
"MBBI",
",",
"-",
"(",
"int64_t",
")",
"NumBytes",
",",
"TII",
")",
";",
"}",
"if",
"(",
"hasFP",
"(",
"MF",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"SystemZ",
"::",
"MOV64rr",
")",
",",
"SystemZ",
"::",
"R11D",
")",
".",
"addReg",
"(",
"SystemZ",
"::",
"R15D",
")",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"I",
"=",
"llvm",
"::",
"next",
"(",
"MF",
".",
"begin",
"(",
")",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"I",
"->",
"addLiveIn",
"(",
"SystemZ",
"::",
"R11D",
")",
";",
"}",
"}",
"</s>"
] | [
"emitProlog/emitEpilog",
"-",
"These",
"methods",
"insert",
"prolog",
"and",
"epilog",
"code",
"into",
"the",
"function",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ",
"SystemZ::MOV64mr",
"SystemZ::MOV64mrm",
"SystemZ::R15D",
"\"Invalid stack frame calculation!\"",
"SystemZ::MOV64rr",
"SystemZ::R11D",
"SystemZ::R15D",
"SystemZ::R11D"
] | SystemZRegisterInfo29 | emitPrologue | SystemZ | CPU | LLVM | 4,847 | 303 | 1 | [] |
[
"<s>",
"bool",
"SIPreEmitPeephole",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"GCNSubtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"GCNSubtarget",
">",
"(",
")",
";",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"TRI",
"=",
"&",
"TII",
"->",
"getRegisterInfo",
"(",
")",
";",
"MachineBasicBlock",
"*",
"EmptyMBBAtEnd",
"=",
"nullptr",
";",
"bool",
"Changed",
"=",
"false",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"MBBE",
"=",
"MBB",
".",
"getFirstTerminator",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"TermI",
"=",
"MBBE",
";",
"if",
"(",
"TermI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"TermI",
";",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"AMDGPU",
"::",
"S_CBRANCH_VCCZ",
":",
"case",
"AMDGPU",
"::",
"S_CBRANCH_VCCNZ",
":",
"Changed",
"|=",
"optimizeVccBranch",
"(",
"MI",
")",
";",
"continue",
";",
"default",
":",
"break",
";",
"}",
"}",
"while",
"(",
"TermI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"TermI",
";",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"AMDGPU",
"::",
"SI_RETURN_TO_EPILOG",
")",
"{",
"assert",
"(",
"!",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
"->",
"returnsVoid",
"(",
")",
")",
";",
"if",
"(",
"&",
"MBB",
"!=",
"&",
"MF",
".",
"back",
"(",
")",
"||",
"&",
"MI",
"!=",
"&",
"MBB",
".",
"back",
"(",
")",
")",
"{",
"if",
"(",
"!",
"EmptyMBBAtEnd",
")",
"{",
"EmptyMBBAtEnd",
"=",
"MF",
".",
"CreateMachineBasicBlock",
"(",
")",
";",
"MF",
".",
"insert",
"(",
"MF",
".",
"end",
"(",
")",
",",
"EmptyMBBAtEnd",
")",
";",
"}",
"MBB",
".",
"addSuccessor",
"(",
"EmptyMBBAtEnd",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"&",
"MI",
",",
"MI",
".",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_BRANCH",
")",
")",
".",
"addMBB",
"(",
"EmptyMBBAtEnd",
")",
";",
"MI",
".",
"eraseFromParent",
"(",
")",
";",
"MBBE",
"=",
"MBB",
".",
"getFirstTerminator",
"(",
")",
";",
"TermI",
"=",
"MBBE",
";",
"continue",
";",
"}",
"}",
"TermI",
"++",
";",
"}",
"if",
"(",
"!",
"ST",
".",
"hasVGPRIndexMode",
"(",
")",
")",
"continue",
";",
"MachineInstr",
"*",
"SetGPRMI",
"=",
"nullptr",
";",
"const",
"unsigned",
"Threshold",
"=",
"20",
";",
"unsigned",
"Count",
"=",
"0",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"MBBI",
"!=",
"MBBE",
";",
")",
"{",
"MachineInstr",
"&",
"MI",
"=",
"*",
"MBBI",
";",
"++",
"MBBI",
";",
"if",
"(",
"Count",
"==",
"Threshold",
")",
"SetGPRMI",
"=",
"nullptr",
";",
"else",
"++",
"Count",
";",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"!=",
"AMDGPU",
"::",
"S_SET_GPR_IDX_ON",
")",
"continue",
";",
"Count",
"=",
"0",
";",
"if",
"(",
"!",
"SetGPRMI",
")",
"{",
"SetGPRMI",
"=",
"&",
"MI",
";",
"continue",
";",
"}",
"if",
"(",
"optimizeSetGPR",
"(",
"*",
"SetGPRMI",
",",
"MI",
")",
")",
"Changed",
"=",
"true",
";",
"else",
"SetGPRMI",
"=",
"&",
"MI",
";",
"}",
"}",
"return",
"Changed",
";",
"}",
"</s>"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] | [
"AMDGPU",
"SI",
"AMDGPU::S_CBRANCH_VCCZ",
"AMDGPU::S_CBRANCH_VCCNZ",
"AMDGPU::SI_RETURN_TO_EPILOG",
"SI",
"AMDGPU::S_BRANCH",
"20",
"0",
"AMDGPU::S_SET_GPR_IDX_ON",
"0"
] | SIPreEmitPeephole4 | runOnMachineFunction | AMDGPU | GPU | LLVM | 4,848 | 420 | 1 | [] |
[
"<s>",
"bool",
"llvm",
"::",
"isEqual",
"(",
"const",
"GCNRPTracker",
"::",
"LiveRegSet",
"&",
"S1",
",",
"const",
"GCNRPTracker",
"::",
"LiveRegSet",
"&",
"S2",
")",
"{",
"if",
"(",
"S1",
".",
"size",
"(",
")",
"!=",
"S2",
".",
"size",
"(",
")",
")",
"return",
"false",
";",
"for",
"(",
"const",
"auto",
"&",
"P",
":",
"S1",
")",
"{",
"auto",
"I",
"=",
"S2",
".",
"find",
"(",
"P",
".",
"first",
")",
";",
"if",
"(",
"I",
"==",
"S2",
".",
"end",
"(",
")",
"||",
"I",
"->",
"second",
"!=",
"P",
".",
"second",
")",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}",
"</s>"
] | [
"isEqual",
"-",
"Compares",
"two",
"trees",
"for",
"structural",
"equality",
"and",
"returns",
"true",
"if",
"they",
"are",
"equal",
"."
] | [
"AMDGPU"
] | GCNRegPressure | isEqual | AMDGPU | GPU | LLVM | 4,849 | 85 | 1 | [] |
[
"<s>",
"bool",
"WebAssemblyFastISel",
"::",
"fastSelectInstruction",
"(",
"const",
"Instruction",
"*",
"I",
")",
"{",
"switch",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"Instruction",
"::",
"Call",
":",
"if",
"(",
"selectCall",
"(",
"I",
")",
")",
"return",
"true",
";",
"break",
";",
"case",
"Instruction",
"::",
"Select",
":",
"return",
"selectSelect",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Trunc",
":",
"return",
"selectTrunc",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"ZExt",
":",
"return",
"selectZExt",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"SExt",
":",
"return",
"selectSExt",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"ICmp",
":",
"return",
"selectICmp",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"FCmp",
":",
"return",
"selectFCmp",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"BitCast",
":",
"return",
"selectBitCast",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Load",
":",
"return",
"selectLoad",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Store",
":",
"return",
"selectStore",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Br",
":",
"return",
"selectBr",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Ret",
":",
"return",
"selectRet",
"(",
"I",
")",
";",
"case",
"Instruction",
"::",
"Unreachable",
":",
"return",
"selectUnreachable",
"(",
"I",
")",
";",
"default",
":",
"break",
";",
"}",
"return",
"selectOperator",
"(",
"I",
",",
"I",
"->",
"getOpcode",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"This",
"method",
"is",
"called",
"by",
"target-independent",
"code",
"when",
"the",
"normal",
"FastISel",
"process",
"fails",
"to",
"select",
"an",
"instruction",
"."
] | [
"WebAssembly",
"WebAssembly"
] | WebAssemblyFastISel | fastSelectInstruction | WebAssembly | Virtual ISA | LLVM | 4,850 | 187 | 1 | [] |
[
"<s>",
"X86TargetMachine",
"::",
"X86TargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Optional",
"<",
"Reloc",
"::",
"Model",
">",
"RM",
",",
"Optional",
"<",
"CodeModel",
"::",
"Model",
">",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
",",
"bool",
"JIT",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"computeDataLayout",
"(",
"TT",
")",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"getEffectiveRelocModel",
"(",
"TT",
",",
"JIT",
",",
"RM",
")",
",",
"getEffectiveCodeModel",
"(",
"CM",
",",
"JIT",
",",
"TT",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86_64",
")",
",",
"OL",
")",
",",
"TLOF",
"(",
"createTLOF",
"(",
"getTargetTriple",
"(",
")",
")",
")",
"{",
"if",
"(",
"(",
"TT",
".",
"isOSWindows",
"(",
")",
"&&",
"TT",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86_64",
")",
"||",
"TT",
".",
"isPS4",
"(",
")",
"||",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
")",
"{",
"this",
"->",
"Options",
".",
"TrapUnreachable",
"=",
"true",
";",
"this",
"->",
"Options",
".",
"NoTrapAfterNoreturn",
"=",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
";",
"}",
"if",
"(",
"TT",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"x86_64",
")",
"setMachineOutliner",
"(",
"true",
")",
";",
"initAsmInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"Create",
"an",
"X86",
"target",
"."
] | [
"X86",
"X86",
"X86"
] | X86TargetMachine120 | X86TargetMachine | X86 | CPU | LLVM | 4,851 | 182 | 1 | [] |
[
"<s>",
"void",
"visitCallInst",
"(",
"CallInst",
"&",
"I",
")",
"{",
"if",
"(",
"!",
"I",
".",
"getCalledFunction",
"(",
")",
")",
"return",
";",
"StringRef",
"Name",
"=",
"I",
".",
"getCalledFunction",
"(",
")",
"->",
"getName",
"(",
")",
";",
"if",
"(",
"Name",
"==",
"\"llvm.AMDGPU.tex\"",
")",
"{",
"ReplaceTexIntrinsic",
"(",
"I",
",",
"false",
",",
"TexSign",
",",
"\"llvm.r600.tex\"",
",",
"\"llvm.r600.texc\"",
")",
";",
"return",
";",
"}",
"if",
"(",
"Name",
"==",
"\"llvm.AMDGPU.txl\"",
")",
"{",
"ReplaceTexIntrinsic",
"(",
"I",
",",
"true",
",",
"TexSign",
",",
"\"llvm.r600.txl\"",
",",
"\"llvm.r600.txlc\"",
")",
";",
"return",
";",
"}",
"if",
"(",
"Name",
"==",
"\"llvm.AMDGPU.txb\"",
")",
"{",
"ReplaceTexIntrinsic",
"(",
"I",
",",
"true",
",",
"TexSign",
",",
"\"llvm.r600.txb\"",
",",
"\"llvm.r600.txbc\"",
")",
";",
"return",
";",
"}",
"if",
"(",
"Name",
"==",
"\"llvm.AMDGPU.txf\"",
")",
"{",
"ReplaceTXF",
"(",
"I",
")",
";",
"return",
";",
"}",
"if",
"(",
"Name",
"==",
"\"llvm.AMDGPU.txq\"",
")",
"{",
"ReplaceTexIntrinsic",
"(",
"I",
",",
"false",
",",
"TexQSign",
",",
"\"llvm.r600.txq\"",
",",
"\"llvm.r600.txq\"",
")",
";",
"return",
";",
"}",
"if",
"(",
"Name",
"==",
"\"llvm.AMDGPU.ddx\"",
")",
"{",
"ReplaceTexIntrinsic",
"(",
"I",
",",
"false",
",",
"TexSign",
",",
"\"llvm.r600.ddx\"",
",",
"\"llvm.r600.ddx\"",
")",
";",
"return",
";",
"}",
"if",
"(",
"Name",
"==",
"\"llvm.AMDGPU.ddy\"",
")",
"{",
"ReplaceTexIntrinsic",
"(",
"I",
",",
"false",
",",
"TexSign",
",",
"\"llvm.r600.ddy\"",
",",
"\"llvm.r600.ddy\"",
")",
";",
"return",
";",
"}",
"}",
"</s>"
] | [
"CallInst",
"simplification",
"."
] | [
"AMDGPU",
"\"llvm.AMDGPU.tex\"",
"\"llvm.r600.tex\"",
"\"llvm.r600.texc\"",
"\"llvm.AMDGPU.txl\"",
"\"llvm.r600.txl\"",
"\"llvm.r600.txlc\"",
"\"llvm.AMDGPU.txb\"",
"\"llvm.r600.txb\"",
"\"llvm.r600.txbc\"",
"\"llvm.AMDGPU.txf\"",
"\"llvm.AMDGPU.txq\"",
"\"llvm.r600.txq\"",
"\"llvm.r600.txq\"",
"\"llvm.AMDGPU.ddx\"",
"\"llvm.r600.ddx\"",
"\"llvm.r600.ddx\"",
"\"llvm.AMDGPU.ddy\"",
"\"llvm.r600.ddy\"",
"\"llvm.r600.ddy\""
] | R600TextureIntrinsicsReplacer3 | visitCallInst | AMDGPU | GPU | LLVM | 4,852 | 186 | 1 | [] |
[
"<s>",
"void",
"Thumb1InstrInfo",
"::",
"storeRegToStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"unsigned",
"SrcReg",
",",
"bool",
"isKill",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"RC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"assert",
"(",
"(",
"RC",
"==",
"&",
"ARM",
"::",
"tGPRRegClass",
"||",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"SrcReg",
")",
"&&",
"isARMLowRegister",
"(",
"SrcReg",
")",
")",
")",
"&&",
"\"Unknown regclass!\"",
")",
";",
"if",
"(",
"RC",
"==",
"&",
"ARM",
"::",
"tGPRRegClass",
"||",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"SrcReg",
")",
"&&",
"isARMLowRegister",
"(",
"SrcReg",
")",
")",
")",
"{",
"DebugLoc",
"DL",
";",
"if",
"(",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"I",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"FI",
")",
",",
"MachineMemOperand",
"::",
"MOStore",
",",
"MFI",
".",
"getObjectSize",
"(",
"FI",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FI",
")",
")",
";",
"AddDefaultPred",
"(",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"ARM",
"::",
"tSTRspi",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"0",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
")",
";",
"}",
"}",
"</s>"
] | [
"Store",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"to",
"the",
"specified",
"stack",
"frame",
"index",
"."
] | [
"ARM",
"ARM::tGPRRegClass",
"ARM",
"\"Unknown regclass!\"",
"ARM::tGPRRegClass",
"ARM",
"ARM::tSTRspi",
"0"
] | Thumb1InstrInfo30 | storeRegToStackSlot | ARM | CPU | LLVM | 4,853 | 211 | 1 | [] |
[
"<s>",
"void",
"ARMTargetLowering",
"::",
"HandleByVal",
"(",
"CCState",
"*",
"State",
",",
"unsigned",
"&",
"Size",
",",
"unsigned",
"Align",
")",
"const",
"{",
"Align",
"=",
"std",
"::",
"max",
"(",
"Align",
",",
"4U",
")",
";",
"unsigned",
"Reg",
"=",
"State",
"->",
"AllocateReg",
"(",
"GPRArgRegs",
")",
";",
"if",
"(",
"!",
"Reg",
")",
"return",
";",
"unsigned",
"AlignInRegs",
"=",
"Align",
"/",
"4",
";",
"unsigned",
"Waste",
"=",
"(",
"ARM",
"::",
"R4",
"-",
"Reg",
")",
"%",
"AlignInRegs",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
";",
"i",
"<",
"Waste",
";",
"++",
"i",
")",
"Reg",
"=",
"State",
"->",
"AllocateReg",
"(",
"GPRArgRegs",
")",
";",
"if",
"(",
"!",
"Reg",
")",
"return",
";",
"unsigned",
"Excess",
"=",
"4",
"*",
"(",
"ARM",
"::",
"R4",
"-",
"Reg",
")",
";",
"const",
"unsigned",
"NSAAOffset",
"=",
"State",
"->",
"getNextStackOffset",
"(",
")",
";",
"if",
"(",
"NSAAOffset",
"!=",
"0",
"&&",
"Size",
">",
"Excess",
")",
"{",
"while",
"(",
"State",
"->",
"AllocateReg",
"(",
"GPRArgRegs",
")",
")",
";",
"return",
";",
"}",
"unsigned",
"ByValRegBegin",
"=",
"Reg",
";",
"unsigned",
"ByValRegEnd",
"=",
"std",
"::",
"min",
"<",
"unsigned",
">",
"(",
"Reg",
"+",
"Size",
"/",
"4",
",",
"ARM",
"::",
"R4",
")",
";",
"State",
"->",
"addInRegsParamInfo",
"(",
"ByValRegBegin",
",",
"ByValRegEnd",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"Reg",
"+",
"1",
";",
"i",
"!=",
"ByValRegEnd",
";",
"++",
"i",
")",
"State",
"->",
"AllocateReg",
"(",
"GPRArgRegs",
")",
";",
"Size",
"=",
"std",
"::",
"max",
"<",
"int",
">",
"(",
"Size",
"-",
"Excess",
",",
"0",
")",
";",
"}",
"</s>"
] | [
"Target-specific",
"cleanup",
"for",
"formal",
"ByVal",
"parameters",
"."
] | [
"ARM",
"ARM",
"4U",
"4",
"ARM::R4",
"0",
"4",
"ARM::R4",
"0",
"4",
"ARM::R4",
"1",
"0"
] | ARMISelLowering (2)6 | HandleByVal | ARM | CPU | LLVM | 4,854 | 218 | 1 | [] |
[
"<s>",
"const",
"std",
"::",
"string",
"getName",
"(",
")",
"const",
"override",
"{",
"return",
"\"AAAMDWorkGroupSize\"",
";",
"}",
"</s>"
] | [
"Return",
"a",
"string",
"with",
"the",
"name",
"of",
"the",
"plan",
"and",
"the",
"applicable",
"VFs",
"and",
"UFs",
"."
] | [
"AMDGPU",
"\"AAAMDWorkGroupSize\""
] | AMDGPUAttributor5 | getName | AMDGPU | GPU | LLVM | 4,855 | 14 | 1 | [] |
[
"<s>",
"static",
"bool",
"aarch64_evpc_ext",
"(",
"struct",
"expand_vec_perm_d",
"*",
"d",
")",
"{",
"HOST_WIDE_INT",
"location",
";",
"rtx",
"offset",
";",
"if",
"(",
"d",
"->",
"vec_flags",
"==",
"VEC_SVE_PRED",
"||",
"!",
"d",
"->",
"perm",
"[",
"0",
"]",
".",
"is_constant",
"(",
"&",
"location",
")",
"||",
"!",
"d",
"->",
"perm",
".",
"series_p",
"(",
"0",
",",
"1",
",",
"location",
",",
"1",
")",
")",
"return",
"false",
";",
"if",
"(",
"d",
"->",
"testing_p",
")",
"return",
"true",
";",
"if",
"(",
"BYTES_BIG_ENDIAN",
"&&",
"location",
"!=",
"0",
"&&",
"d",
"->",
"vec_flags",
"==",
"VEC_ADVSIMD",
")",
"{",
"std",
"::",
"swap",
"(",
"d",
"->",
"op0",
",",
"d",
"->",
"op1",
")",
";",
"location",
"=",
"d",
"->",
"perm",
".",
"length",
"(",
")",
".",
"to_constant",
"(",
")",
"-",
"location",
";",
"}",
"offset",
"=",
"GEN_INT",
"(",
"location",
")",
";",
"emit_set_insn",
"(",
"d",
"->",
"target",
",",
"gen_rtx_UNSPEC",
"(",
"d",
"->",
"vmode",
",",
"gen_rtvec",
"(",
"3",
",",
"d",
"->",
"op0",
",",
"d",
"->",
"op1",
",",
"offset",
")",
",",
"UNSPEC_EXT",
")",
")",
";",
"return",
"true",
";",
"}",
"</s>"
] | [
"Recognize",
"patterns",
"for",
"the",
"EXT",
"insn",
"."
] | [
"aarch64",
"0",
"0",
"1",
"1",
"0",
"3"
] | aarch64 | aarch64_evpc_ext | aarch64 | CPU | GCC | 4,856 | 153 | 1 | [] |
[
"<s>",
"bool",
"SystemZInstrInfo",
"::",
"PredicateInstruction",
"(",
"MachineInstr",
"&",
"MI",
",",
"ArrayRef",
"<",
"MachineOperand",
">",
"Pred",
")",
"const",
"{",
"assert",
"(",
"Pred",
".",
"size",
"(",
")",
"==",
"2",
"&&",
"\"Invalid condition\"",
")",
";",
"unsigned",
"CCValid",
"=",
"Pred",
"[",
"0",
"]",
".",
"getImm",
"(",
")",
";",
"unsigned",
"CCMask",
"=",
"Pred",
"[",
"1",
"]",
".",
"getImm",
"(",
")",
";",
"assert",
"(",
"CCMask",
">",
"0",
"&&",
"CCMask",
"<",
"15",
"&&",
"\"Invalid predicate\"",
")",
";",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"STI",
".",
"hasLoadStoreOnCond",
"(",
")",
")",
"{",
"if",
"(",
"unsigned",
"CondOpcode",
"=",
"getConditionalMove",
"(",
"Opcode",
")",
")",
"{",
"MI",
".",
"setDesc",
"(",
"get",
"(",
"CondOpcode",
")",
")",
";",
"MachineInstrBuilder",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
",",
"MI",
")",
".",
"addImm",
"(",
"CCValid",
")",
".",
"addImm",
"(",
"CCMask",
")",
".",
"addReg",
"(",
"SystemZ",
"::",
"CC",
",",
"RegState",
"::",
"Implicit",
")",
";",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Convert",
"the",
"instruction",
"into",
"a",
"predicated",
"instruction",
"."
] | [
"SystemZ",
"SystemZ",
"2",
"\"Invalid condition\"",
"0",
"1",
"0",
"15",
"\"Invalid predicate\"",
"SystemZ::CC"
] | SystemZInstrInfo6 | PredicateInstruction | SystemZ | CPU | LLVM | 4,857 | 152 | 1 | [] |
[
"<s>",
"X86Subtarget",
"::",
"X86Subtarget",
"(",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"unsigned",
"StackAlignOverride",
",",
"bool",
"is64Bit",
")",
":",
"X86GenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"PICStyle",
"(",
"PICStyles",
"::",
"None",
")",
",",
"X86SSELevel",
"(",
"NoMMXSSE",
")",
",",
"X863DNowLevel",
"(",
"NoThreeDNow",
")",
",",
"HasCMov",
"(",
"false",
")",
",",
"HasX86_64",
"(",
"false",
")",
",",
"HasPOPCNT",
"(",
"false",
")",
",",
"HasSSE4A",
"(",
"false",
")",
",",
"HasAVX",
"(",
"false",
")",
",",
"HasAES",
"(",
"false",
")",
",",
"HasCLMUL",
"(",
"false",
")",
",",
"HasFMA3",
"(",
"false",
")",
",",
"HasFMA4",
"(",
"false",
")",
",",
"HasMOVBE",
"(",
"false",
")",
",",
"HasRDRAND",
"(",
"false",
")",
",",
"HasF16C",
"(",
"false",
")",
",",
"HasLZCNT",
"(",
"false",
")",
",",
"HasBMI",
"(",
"false",
")",
",",
"IsBTMemSlow",
"(",
"false",
")",
",",
"IsUAMemFast",
"(",
"false",
")",
",",
"HasVectorUAMem",
"(",
"false",
")",
",",
"HasCmpxchg16b",
"(",
"false",
")",
",",
"stackAlignment",
"(",
"8",
")",
",",
"MaxInlineSizeThreshold",
"(",
"128",
")",
",",
"TargetTriple",
"(",
"TT",
")",
",",
"In64BitMode",
"(",
"is64Bit",
")",
",",
"InNaClMode",
"(",
"false",
")",
"{",
"if",
"(",
"!",
"FS",
".",
"empty",
"(",
")",
"||",
"!",
"CPU",
".",
"empty",
"(",
")",
")",
"{",
"std",
"::",
"string",
"CPUName",
"=",
"CPU",
";",
"if",
"(",
"CPUName",
".",
"empty",
"(",
")",
")",
"{",
"CPUName",
"=",
"sys",
"::",
"getHostCPUName",
"(",
")",
";",
"CPUName",
"=",
"\"generic\"",
";",
"}",
"std",
"::",
"string",
"FullFS",
"=",
"FS",
";",
"if",
"(",
"In64BitMode",
")",
"{",
"if",
"(",
"!",
"FullFS",
".",
"empty",
"(",
")",
")",
"FullFS",
"=",
"\"+64bit,+sse2,\"",
"+",
"FullFS",
";",
"else",
"FullFS",
"=",
"\"+64bit,+sse2\"",
";",
"}",
"ParseSubtargetFeatures",
"(",
"CPUName",
",",
"FullFS",
")",
";",
"}",
"else",
"{",
"AutoDetectSubtargetFeatures",
"(",
")",
";",
"if",
"(",
"In64BitMode",
")",
"{",
"HasX86_64",
"=",
"true",
";",
"ToggleFeature",
"(",
"X86",
"::",
"Feature64Bit",
")",
";",
"HasCMov",
"=",
"true",
";",
"ToggleFeature",
"(",
"X86",
"::",
"FeatureCMOV",
")",
";",
"if",
"(",
"!",
"HasAVX",
"&&",
"X86SSELevel",
"<",
"SSE2",
")",
"{",
"X86SSELevel",
"=",
"SSE2",
";",
"ToggleFeature",
"(",
"X86",
"::",
"FeatureSSE1",
")",
";",
"ToggleFeature",
"(",
"X86",
"::",
"FeatureSSE2",
")",
";",
"}",
"}",
"}",
"if",
"(",
"In64BitMode",
")",
"ToggleFeature",
"(",
"X86",
"::",
"Mode64Bit",
")",
";",
"if",
"(",
"isTargetNaCl",
"(",
")",
")",
"{",
"InNaClMode",
"=",
"true",
";",
"ToggleFeature",
"(",
"X86",
"::",
"ModeNaCl",
")",
";",
"}",
"if",
"(",
"HasAVX",
")",
"X86SSELevel",
"=",
"NoMMXSSE",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"\"Subtarget features: SSELevel \"",
"<<",
"X86SSELevel",
"<<",
"\", 3DNowLevel \"",
"<<",
"X863DNowLevel",
"<<",
"\", 64bit \"",
"<<",
"HasX86_64",
"<<",
"\"\\n\"",
")",
";",
"assert",
"(",
"(",
"!",
"In64BitMode",
"||",
"HasX86_64",
")",
"&&",
"\"64-bit code requested on a subtarget that doesn't support it!\"",
")",
";",
"if",
"(",
"EnableSegmentedStacks",
"&&",
"!",
"isTargetELF",
"(",
")",
")",
"report_fatal_error",
"(",
"\"Segmented stacks are only implemented on ELF.\"",
")",
";",
"if",
"(",
"StackAlignOverride",
")",
"stackAlignment",
"=",
"StackAlignOverride",
";",
"else",
"if",
"(",
"isTargetDarwin",
"(",
")",
"||",
"isTargetFreeBSD",
"(",
")",
"||",
"isTargetLinux",
"(",
")",
"||",
"isTargetSolaris",
"(",
")",
"||",
"In64BitMode",
")",
"stackAlignment",
"=",
"16",
";",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"X86",
"8",
"128",
"\"generic\"",
"\"+64bit,+sse2,\"",
"\"+64bit,+sse2\"",
"X86",
"X86::Feature64Bit",
"X86::FeatureCMOV",
"X86",
"X86",
"X86::FeatureSSE1",
"X86::FeatureSSE2",
"X86::Mode64Bit",
"X86::ModeNaCl",
"X86",
"\"Subtarget features: SSELevel \"",
"X86",
"\", 3DNowLevel \"",
"X86",
"\", 64bit \"",
"X86",
"\"\\n\"",
"X86",
"\"64-bit code requested on a subtarget that doesn't support it!\"",
"\"Segmented stacks are only implemented on ELF.\"",
"16"
] | X86Subtarget92 | X86Subtarget | X86 | CPU | LLVM | 4,858 | 443 | 1 | [] |
[
"<s>",
"const",
"TargetRegisterClass",
"*",
"X86RegisterInfo",
"::",
"getPointerRegClass",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"unsigned",
"Kind",
")",
"const",
"{",
"const",
"X86Subtarget",
"&",
"Subtarget",
"=",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"switch",
"(",
"Kind",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"\"Unexpected Kind in getPointerRegClass!\"",
")",
";",
"case",
"0",
":",
"if",
"(",
"Subtarget",
".",
"isTarget64BitLP64",
"(",
")",
")",
"return",
"&",
"X86",
"::",
"GR64RegClass",
";",
"return",
"&",
"X86",
"::",
"GR32RegClass",
";",
"case",
"1",
":",
"if",
"(",
"Subtarget",
".",
"isTarget64BitLP64",
"(",
")",
")",
"return",
"&",
"X86",
"::",
"GR64_NOSPRegClass",
";",
"return",
"&",
"X86",
"::",
"GR32_NOSPRegClass",
";",
"case",
"2",
":",
"const",
"Function",
"*",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"if",
"(",
"IsWin64",
"||",
"(",
"F",
"&&",
"F",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"X86_64_Win64",
")",
")",
"return",
"&",
"X86",
"::",
"GR64_TCW64RegClass",
";",
"else",
"if",
"(",
"Is64Bit",
")",
"return",
"&",
"X86",
"::",
"GR64_TCRegClass",
";",
"bool",
"hasHipeCC",
"=",
"(",
"F",
"?",
"F",
"->",
"getCallingConv",
"(",
")",
"==",
"CallingConv",
"::",
"HiPE",
":",
"false",
")",
";",
"if",
"(",
"hasHipeCC",
")",
"return",
"&",
"X86",
"::",
"GR32RegClass",
";",
"return",
"&",
"X86",
"::",
"GR32_TCRegClass",
";",
"}",
"}",
"</s>"
] | [
"getPointerRegClass",
"-",
"Returns",
"a",
"TargetRegisterClass",
"used",
"for",
"pointer",
"values",
"."
] | [
"X86",
"X86",
"X86",
"X86",
"\"Unexpected Kind in getPointerRegClass!\"",
"0",
"X86::GR64RegClass",
"X86::GR32RegClass",
"1",
"X86::GR64_NOSPRegClass",
"X86::GR32_NOSPRegClass",
"2",
"X86",
"X86::GR64_TCW64RegClass",
"X86::GR64_TCRegClass",
"X86::GR32RegClass",
"X86::GR32_TCRegClass"
] | X86RegisterInfo71 | getPointerRegClass | X86 | CPU | LLVM | 4,859 | 175 | 1 | [] |
[
"<s>",
"SDValue",
"AArch64SelectionDAGInfo",
"::",
"EmitTargetCodeForMemset",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"SDLoc",
"&",
"dl",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Dst",
",",
"SDValue",
"Src",
",",
"SDValue",
"Size",
",",
"unsigned",
"Align",
",",
"bool",
"isVolatile",
",",
"MachinePointerInfo",
"DstPtrInfo",
")",
"const",
"{",
"ConstantSDNode",
"*",
"V",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Src",
")",
";",
"ConstantSDNode",
"*",
"SizeValue",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Size",
")",
";",
"const",
"AArch64Subtarget",
"&",
"STI",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
";",
"const",
"char",
"*",
"bzeroName",
"=",
"(",
"V",
"&&",
"V",
"->",
"isNullValue",
"(",
")",
")",
"?",
"DAG",
".",
"getTargetLoweringInfo",
"(",
")",
".",
"getLibcallName",
"(",
"RTLIB",
"::",
"BZERO",
")",
":",
"nullptr",
";",
"if",
"(",
"bzeroName",
"&&",
"(",
"!",
"SizeValue",
"||",
"SizeValue",
"->",
"getZExtValue",
"(",
")",
">",
"256",
")",
")",
"{",
"const",
"AArch64TargetLowering",
"&",
"TLI",
"=",
"*",
"STI",
".",
"getTargetLowering",
"(",
")",
";",
"EVT",
"IntPtr",
"=",
"TLI",
".",
"getPointerTy",
"(",
"DAG",
".",
"getDataLayout",
"(",
")",
")",
";",
"Type",
"*",
"IntPtrTy",
"=",
"Type",
"::",
"getInt8PtrTy",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"TargetLowering",
"::",
"ArgListTy",
"Args",
";",
"TargetLowering",
"::",
"ArgListEntry",
"Entry",
";",
"Entry",
".",
"Node",
"=",
"Dst",
";",
"Entry",
".",
"Ty",
"=",
"IntPtrTy",
";",
"Args",
".",
"push_back",
"(",
"Entry",
")",
";",
"Entry",
".",
"Node",
"=",
"Size",
";",
"Args",
".",
"push_back",
"(",
"Entry",
")",
";",
"TargetLowering",
"::",
"CallLoweringInfo",
"CLI",
"(",
"DAG",
")",
";",
"CLI",
".",
"setDebugLoc",
"(",
"dl",
")",
".",
"setChain",
"(",
"Chain",
")",
".",
"setLibCallee",
"(",
"CallingConv",
"::",
"C",
",",
"Type",
"::",
"getVoidTy",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
",",
"DAG",
".",
"getExternalSymbol",
"(",
"bzeroName",
",",
"IntPtr",
")",
",",
"std",
"::",
"move",
"(",
"Args",
")",
")",
".",
"setDiscardResult",
"(",
")",
";",
"std",
"::",
"pair",
"<",
"SDValue",
",",
"SDValue",
">",
"CallResult",
"=",
"TLI",
".",
"LowerCallTo",
"(",
"CLI",
")",
";",
"return",
"CallResult",
".",
"second",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memset",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"256",
"AArch64"
] | AArch64SelectionDAGInfo17 | EmitTargetCodeForMemset | AArch64 | CPU | LLVM | 4,860 | 299 | 1 | [] |
[
"<s>",
"EVT",
"SparcTargetLowering",
"::",
"getSetCCResultType",
"(",
"LLVMContext",
"&",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"!",
"VT",
".",
"isVector",
"(",
")",
")",
"return",
"MVT",
"::",
"i32",
";",
"return",
"VT",
".",
"changeVectorElementTypeToInteger",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"value",
"type",
"to",
"use",
"for",
"ISD",
":",
":SETCC",
"."
] | [
"Sparc",
"Sparc",
"MVT::i32"
] | SparcISelLowering18 | getSetCCResultType | Sparc | CPU | LLVM | 4,861 | 35 | 1 | [] |
[
"<s>",
"bool",
"SystemZAsmParser",
"::",
"ParseInstruction",
"(",
"ParseInstructionInfo",
"&",
"Info",
",",
"StringRef",
"Name",
",",
"SMLoc",
"NameLoc",
",",
"OperandVector",
"&",
"Operands",
")",
"{",
"Operands",
".",
"push_back",
"(",
"SystemZOperand",
"::",
"createToken",
"(",
"Name",
",",
"NameLoc",
")",
")",
";",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"if",
"(",
"parseOperand",
"(",
"Operands",
",",
"Name",
")",
")",
"{",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"true",
";",
"}",
"while",
"(",
"getLexer",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Comma",
")",
")",
"{",
"Parser",
".",
"Lex",
"(",
")",
";",
"if",
"(",
"parseOperand",
"(",
"Operands",
",",
"Name",
")",
")",
"{",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"true",
";",
"}",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"SMLoc",
"Loc",
"=",
"getLexer",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"Error",
"(",
"Loc",
",",
"\"unexpected token in argument list\"",
")",
";",
"}",
"}",
"Parser",
".",
"Lex",
"(",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"ParseInstruction",
"-",
"Parse",
"one",
"assembly",
"instruction",
"."
] | [
"SystemZ",
"SystemZ",
"SystemZ",
"\"unexpected token in argument list\""
] | SystemZAsmParser (2) | ParseInstruction | SystemZ | CPU | LLVM | 4,862 | 160 | 1 | [] |
[
"<s>",
"void",
"relaxInstruction",
"(",
"const",
"MCInst",
"&",
"Inst",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"MCInst",
"&",
"Res",
")",
"const",
"override",
"{",
"llvm_unreachable",
"(",
"\"Not implemented\"",
")",
";",
"}",
"</s>"
] | [
"Relax",
"the",
"instruction",
"in",
"the",
"given",
"fragment",
"to",
"the",
"next",
"wider",
"instruction",
"."
] | [
"AMDGPU",
"\"Not implemented\""
] | AMDGPUAsmBackend11 | relaxInstruction | AMDGPU | GPU | LLVM | 4,863 | 26 | 1 | [] |
[
"<s>",
"WebAssemblyTargetMachine",
"::",
"WebAssemblyTargetMachine",
"(",
"const",
"Target",
"&",
"T",
",",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetOptions",
"&",
"Options",
",",
"Optional",
"<",
"Reloc",
"::",
"Model",
">",
"RM",
",",
"CodeModel",
"::",
"Model",
"CM",
",",
"CodeGenOpt",
"::",
"Level",
"OL",
")",
":",
"LLVMTargetMachine",
"(",
"T",
",",
"TT",
".",
"isArch64Bit",
"(",
")",
"?",
"\"e-m:e-p:64:64-i64:64-n32:64-S128\"",
":",
"\"e-m:e-p:32:32-i64:64-n32:64-S128\"",
",",
"TT",
",",
"CPU",
",",
"FS",
",",
"Options",
",",
"getEffectiveRelocModel",
"(",
"RM",
")",
",",
"CM",
",",
"OL",
")",
",",
"TLOF",
"(",
"make_unique",
"<",
"WebAssemblyTargetObjectFile",
">",
"(",
")",
")",
"{",
"this",
"->",
"Options",
".",
"TrapUnreachable",
"=",
"true",
";",
"initAsmInfo",
"(",
")",
";",
"}",
"</s>"
] | [
"Create",
"an",
"WebAssembly",
"architecture",
"model",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly",
"\"e-m:e-p:64:64-i64:64-n32:64-S128\"",
"\"e-m:e-p:32:32-i64:64-n32:64-S128\"",
"WebAssembly"
] | WebAssemblyTargetMachine1 | WebAssemblyTargetMachine | WebAssembly | Virtual ISA | LLVM | 4,864 | 99 | 1 | [] |
[
"<s>",
"static",
"int",
"mips16_insn_length",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"if",
"(",
"JUMP_TABLE_DATA_P",
"(",
"insn",
")",
")",
"{",
"rtx",
"body",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"body",
")",
"==",
"ADDR_VEC",
")",
"return",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"body",
")",
")",
"*",
"XVECLEN",
"(",
"body",
",",
"0",
")",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"body",
")",
"==",
"ADDR_DIFF_VEC",
")",
"return",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"body",
")",
")",
"*",
"XVECLEN",
"(",
"body",
",",
"1",
")",
";",
"else",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"get_attr_length",
"(",
"insn",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"length",
"of",
"instruction",
"INSN",
"."
] | [
"mips",
"0",
"1"
] | mips | mips16_insn_length | mips | CPU | GCC | 4,865 | 89 | 1 | [] |
[
"<s>",
"void",
"print",
"(",
"raw_ostream",
"&",
"OS",
")",
"const",
"{",
"OS",
"<<",
"\"{\"",
";",
"if",
"(",
"!",
"isValid",
"(",
")",
")",
"OS",
"<<",
"\"Uninitialized\"",
";",
"if",
"(",
"isUnknown",
"(",
")",
")",
"OS",
"<<",
"\"unknown\"",
";",
";",
"if",
"(",
"hasAVLReg",
"(",
")",
")",
"OS",
"<<",
"\"AVLReg=\"",
"<<",
"(",
"unsigned",
")",
"AVLReg",
";",
"if",
"(",
"hasAVLImm",
"(",
")",
")",
"OS",
"<<",
"\"AVLImm=\"",
"<<",
"(",
"unsigned",
")",
"AVLImm",
";",
"OS",
"<<",
"\", \"",
"<<",
"\"VLMul=\"",
"<<",
"(",
"unsigned",
")",
"VLMul",
"<<",
"\", \"",
"<<",
"\"SEW=\"",
"<<",
"(",
"unsigned",
")",
"SEW",
"<<",
"\", \"",
"<<",
"\"TailAgnostic=\"",
"<<",
"(",
"bool",
")",
"TailAgnostic",
"<<",
"\", \"",
"<<",
"\"MaskAgnostic=\"",
"<<",
"(",
"bool",
")",
"MaskAgnostic",
"<<",
"\", \"",
"<<",
"\"MaskRegOp=\"",
"<<",
"(",
"bool",
")",
"MaskRegOp",
"<<",
"\", \"",
"<<",
"\"StoreOp=\"",
"<<",
"(",
"bool",
")",
"StoreOp",
"<<",
"\", \"",
"<<",
"\"ScalarMovOp=\"",
"<<",
"(",
"bool",
")",
"ScalarMovOp",
"<<",
"\", \"",
"<<",
"\"SEWLMULRatioOnly=\"",
"<<",
"(",
"bool",
")",
"SEWLMULRatioOnly",
"<<",
"\"}\"",
";",
"}",
"</s>"
] | [
"print",
"-",
"Print",
"a",
"debug",
"representation",
"of",
"the",
"operand",
"to",
"the",
"given",
"stream",
"."
] | [
"RISCV",
"\"{\"",
"\"Uninitialized\"",
"\"unknown\"",
"\"AVLReg=\"",
"\"AVLImm=\"",
"\", \"",
"\"VLMul=\"",
"\", \"",
"\"SEW=\"",
"\", \"",
"\"TailAgnostic=\"",
"\", \"",
"\"MaskAgnostic=\"",
"\", \"",
"\"MaskRegOp=\"",
"\", \"",
"\"StoreOp=\"",
"\", \"",
"\"ScalarMovOp=\"",
"\", \"",
"\"SEWLMULRatioOnly=\"",
"\"}\""
] | RISCVInsertVSETVLI6 | print | RISCV | CPU | LLVM | 4,866 | 142 | 1 | [] |
[
"<s>",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"const",
"TargetRegisterClass",
"*",
">",
"TLCS900TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"const",
"std",
"::",
"string",
"&",
"Constraint",
",",
"EVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"==",
"1",
")",
"{",
"switch",
"(",
"Constraint",
"[",
"0",
"]",
")",
"{",
"default",
":",
"break",
";",
"case",
"'r'",
":",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"i8",
")",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"TLCS900",
"::",
"GR8RegisterClass",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"0U",
",",
"TLCS900",
"::",
"GR16RegisterClass",
")",
";",
"}",
"}",
"return",
"TargetLowering",
"::",
"getRegForInlineAsmConstraint",
"(",
"Constraint",
",",
"VT",
")",
";",
"}",
"</s>"
] | [
"Given",
"a",
"physical",
"register",
"constraint",
"(",
"e.g",
"."
] | [
"TLCS900",
"TLCS900",
"1",
"0",
"MVT::i8",
"0U",
"TLCS900::GR8RegisterClass",
"0U",
"TLCS900::GR16RegisterClass"
] | TLCS900ISelLowering | getRegForInlineAsmConstraint | TLCS900 | MPU | LLVM | 4,867 | 97 | 1 | [] |
[
"<s>",
"static",
"machine_mode",
"s390_cc_modes_compatible",
"(",
"machine_mode",
"m1",
",",
"machine_mode",
"m2",
")",
"{",
"if",
"(",
"m1",
"==",
"m2",
")",
"return",
"m1",
";",
"switch",
"(",
"m1",
")",
"{",
"case",
"E_CCZmode",
":",
"if",
"(",
"m2",
"==",
"CCUmode",
"||",
"m2",
"==",
"CCTmode",
"||",
"m2",
"==",
"CCZ1mode",
"||",
"m2",
"==",
"CCSmode",
"||",
"m2",
"==",
"CCSRmode",
"||",
"m2",
"==",
"CCURmode",
")",
"return",
"m2",
";",
"return",
"VOIDmode",
";",
"case",
"E_CCSmode",
":",
"case",
"E_CCUmode",
":",
"case",
"E_CCTmode",
":",
"case",
"E_CCSRmode",
":",
"case",
"E_CCURmode",
":",
"case",
"E_CCZ1mode",
":",
"if",
"(",
"m2",
"==",
"CCZmode",
")",
"return",
"m1",
";",
"return",
"VOIDmode",
";",
"default",
":",
"return",
"VOIDmode",
";",
"}",
"return",
"VOIDmode",
";",
"}",
"</s>"
] | [
"If",
"two",
"condition",
"code",
"modes",
"are",
"compatible",
",",
"return",
"a",
"condition",
"code",
"mode",
"which",
"is",
"compatible",
"with",
"both",
".",
"Otherwise",
",",
"return",
"VOIDmode",
"."
] | [
"s390"
] | s390 | s390_cc_modes_compatible | s390 | MPU | GCC | 4,868 | 100 | 1 | [] |
[
"<s>",
"bool",
"XCorePassConfig",
"::",
"addInstSelector",
"(",
")",
"{",
"PM",
".",
"add",
"(",
"createXCoreISelDag",
"(",
"getXCoreTargetMachine",
"(",
")",
",",
"getOptLevel",
"(",
")",
")",
")",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"addInstSelector",
"-",
"This",
"method",
"should",
"install",
"an",
"instruction",
"selector",
"pass",
",",
"which",
"converts",
"from",
"LLVM",
"code",
"to",
"machine",
"instructions",
"."
] | [
"XCore",
"XCore",
"XCore",
"XCore"
] | XCoreTargetMachine18 | addInstSelector | XCore | MPU | LLVM | 4,869 | 27 | 1 | [] |
[
"<s>",
"ARMSubtarget",
"::",
"ARMSubtarget",
"(",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"bool",
"isThumb",
")",
":",
"ARMArchVersion",
"(",
"V4T",
")",
",",
"ARMFPUType",
"(",
"None",
")",
",",
"UseNEONForSinglePrecisionFP",
"(",
"false",
")",
",",
"IsThumb",
"(",
"isThumb",
")",
",",
"ThumbMode",
"(",
"Thumb1",
")",
",",
"IsR9Reserved",
"(",
"ReserveR9",
")",
",",
"stackAlignment",
"(",
"4",
")",
",",
"CPUString",
"(",
"\"generic\"",
")",
",",
"TargetType",
"(",
"isELF",
")",
",",
"TargetABI",
"(",
"ARM_ABI_APCS",
")",
"{",
"if",
"(",
"FloatABIType",
"==",
"FloatABI",
"::",
"Default",
")",
"FloatABIType",
"=",
"FloatABI",
"::",
"Soft",
";",
"CPUString",
"=",
"ParseSubtargetFeatures",
"(",
"FS",
",",
"CPUString",
")",
";",
"unsigned",
"Len",
"=",
"TT",
".",
"length",
"(",
")",
";",
"unsigned",
"Idx",
"=",
"0",
";",
"if",
"(",
"Len",
">=",
"5",
"&&",
"TT",
".",
"substr",
"(",
"0",
",",
"4",
")",
"==",
"\"armv\"",
")",
"Idx",
"=",
"4",
";",
"else",
"if",
"(",
"Len",
">=",
"6",
"&&",
"TT",
".",
"substr",
"(",
"0",
",",
"5",
")",
"==",
"\"thumb\"",
")",
"{",
"IsThumb",
"=",
"true",
";",
"if",
"(",
"Len",
">=",
"7",
"&&",
"TT",
"[",
"5",
"]",
"==",
"'v'",
")",
"Idx",
"=",
"6",
";",
"}",
"if",
"(",
"Idx",
")",
"{",
"unsigned",
"SubVer",
"=",
"TT",
"[",
"Idx",
"]",
";",
"if",
"(",
"SubVer",
">",
"'4'",
"&&",
"SubVer",
"<=",
"'9'",
")",
"{",
"if",
"(",
"SubVer",
">=",
"'7'",
")",
"{",
"ARMArchVersion",
"=",
"V7A",
";",
"}",
"else",
"if",
"(",
"SubVer",
"==",
"'6'",
")",
"{",
"ARMArchVersion",
"=",
"V6",
";",
"if",
"(",
"Len",
">=",
"Idx",
"+",
"3",
"&&",
"TT",
"[",
"Idx",
"+",
"1",
"]",
"==",
"'t'",
"&&",
"TT",
"[",
"Idx",
"+",
"2",
"]",
"==",
"'2'",
")",
"ARMArchVersion",
"=",
"V6T2",
";",
"}",
"else",
"if",
"(",
"SubVer",
"==",
"'5'",
")",
"{",
"ARMArchVersion",
"=",
"V5T",
";",
"if",
"(",
"Len",
">=",
"Idx",
"+",
"3",
"&&",
"TT",
"[",
"Idx",
"+",
"1",
"]",
"==",
"'t'",
"&&",
"TT",
"[",
"Idx",
"+",
"2",
"]",
"==",
"'e'",
")",
"ARMArchVersion",
"=",
"V5TE",
";",
"}",
"if",
"(",
"ARMArchVersion",
">=",
"V6T2",
")",
"ThumbMode",
"=",
"Thumb2",
";",
"}",
"}",
"if",
"(",
"ARMArchVersion",
"<",
"V6T2",
"&&",
"ThumbMode",
">=",
"Thumb2",
")",
"ARMArchVersion",
"=",
"V6T2",
";",
"if",
"(",
"Len",
">=",
"10",
")",
"{",
"if",
"(",
"TT",
".",
"find",
"(",
"\"-darwin\"",
")",
"!=",
"std",
"::",
"string",
"::",
"npos",
")",
"TargetType",
"=",
"isDarwin",
";",
"}",
"if",
"(",
"TT",
".",
"find",
"(",
"\"eabi\"",
")",
"!=",
"std",
"::",
"string",
"::",
"npos",
")",
"TargetABI",
"=",
"ARM_ABI_AAPCS",
";",
"if",
"(",
"isAAPCS_ABI",
"(",
")",
")",
"stackAlignment",
"=",
"8",
";",
"if",
"(",
"isTargetDarwin",
"(",
")",
")",
"IsR9Reserved",
"=",
"ReserveR9",
"|",
"(",
"ARMArchVersion",
"<",
"V6",
")",
";",
"}",
"</s>"
] | [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM",
"ARM",
"4",
"\"generic\"",
"ARM",
"0",
"5",
"0",
"4",
"\"armv\"",
"4",
"6",
"0",
"5",
"\"thumb\"",
"7",
"5",
"6",
"ARM",
"ARM",
"3",
"1",
"2",
"ARM",
"ARM",
"3",
"1",
"2",
"ARM",
"ARM",
"ARM",
"ARM",
"10",
"\"-darwin\"",
"\"eabi\"",
"ARM",
"8",
"ARM"
] | ARMSubtarget34 | ARMSubtarget | ARM | CPU | LLVM | 4,870 | 392 | 1 | [] |
[
"<s>",
"bool",
"XCoreFrameInfo",
"::",
"spillCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"true",
";",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"MF",
"->",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"XCoreFunctionInfo",
"*",
"XFI",
"=",
"MF",
"->",
"getInfo",
"<",
"XCoreFunctionInfo",
">",
"(",
")",
";",
"bool",
"emitFrameMoves",
"=",
"XCoreRegisterInfo",
"::",
"needsFrameMoves",
"(",
"*",
"MF",
")",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"for",
"(",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"::",
"const_iterator",
"it",
"=",
"CSI",
".",
"begin",
"(",
")",
";",
"it",
"!=",
"CSI",
".",
"end",
"(",
")",
";",
"++",
"it",
")",
"{",
"MBB",
".",
"addLiveIn",
"(",
"it",
"->",
"getReg",
"(",
")",
")",
";",
"unsigned",
"Reg",
"=",
"it",
"->",
"getReg",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TRI",
"->",
"getMinimalPhysRegClass",
"(",
"Reg",
")",
";",
"TII",
".",
"storeRegToStackSlot",
"(",
"MBB",
",",
"MI",
",",
"Reg",
",",
"true",
",",
"it",
"->",
"getFrameIdx",
"(",
")",
",",
"RC",
",",
"TRI",
")",
";",
"if",
"(",
"emitFrameMoves",
")",
"{",
"MCSymbol",
"*",
"SaveLabel",
"=",
"MF",
"->",
"getContext",
"(",
")",
".",
"CreateTempSymbol",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"XCore",
"::",
"PROLOG_LABEL",
")",
")",
".",
"addSym",
"(",
"SaveLabel",
")",
";",
"XFI",
"->",
"getSpillLabels",
"(",
")",
".",
"push_back",
"(",
"std",
"::",
"make_pair",
"(",
"SaveLabel",
",",
"*",
"it",
")",
")",
";",
"}",
"}",
"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",
"(",
")",
"."
] | [
"XCore",
"XCore",
"XCore",
"XCore",
"XCore",
"XCore::PROLOG_LABEL"
] | XCoreFrameInfo | spillCalleeSavedRegisters | XCore | MPU | LLVM | 4,871 | 265 | 1 | [] |
[
"<s>",
"static",
"void",
"ix86_test_dumping_memory_blockage",
"(",
")",
"{",
"set_new_first_and_last_insn",
"(",
"NULL",
",",
"NULL",
")",
";",
"rtx",
"pat",
"=",
"gen_memory_blockage",
"(",
")",
";",
"rtx_reuse_manager",
"r",
";",
"r",
".",
"preprocess",
"(",
"pat",
")",
";",
"if",
"(",
"Pmode",
"==",
"DImode",
")",
"ASSERT_RTL_DUMP_EQ_WITH_REUSE",
"(",
"\"(cinsn 1 (set (mem/v:BLK (0|scratch:DI) [0 A8])\\n\"",
"\" (unspec:BLK [\\n\"",
"\" (mem/v:BLK (reuse_rtx 0) [0 A8])\\n\"",
"\" ] UNSPEC_MEMORY_BLOCKAGE)))\\n\"",
",",
"pat",
",",
"&",
"r",
")",
";",
"}",
"</s>"
] | [
"Test",
"dumping",
"an",
"insn",
"with",
"repeated",
"references",
"to",
"the",
"same",
"SCRATCH",
",",
"to",
"verify",
"the",
"rtx_reuse",
"code",
"."
] | [
"i386",
"\"(cinsn 1 (set (mem/v:BLK (0|scratch:DI) [0 A8])\\n\"",
"\" (unspec:BLK [\\n\"",
"\" (mem/v:BLK (reuse_rtx 0) [0 A8])\\n\"",
"\" ] UNSPEC_MEMORY_BLOCKAGE)))\\n\""
] | i386 | ix86_test_dumping_memory_blockage | i386 | CPU | GCC | 4,872 | 50 | 1 | [] |
[
"<s>",
"static",
"void",
"mips_record_lo_sums",
"(",
"const_rtx",
"x",
",",
"mips_offset_table",
"*",
"htab",
")",
"{",
"subrtx_iterator",
"::",
"array_type",
"array",
";",
"FOR_EACH_SUBRTX",
"(",
"iter",
",",
"array",
",",
"x",
",",
"NONCONST",
")",
"if",
"(",
"GET_CODE",
"(",
"*",
"iter",
")",
"==",
"LO_SUM",
")",
"mips_lo_sum_offset_lookup",
"(",
"htab",
",",
"XEXP",
"(",
"*",
"iter",
",",
"1",
")",
",",
"INSERT",
")",
";",
"}",
"</s>"
] | [
"Search",
"X",
"for",
"LO_SUMs",
"and",
"record",
"them",
"in",
"HTAB",
"."
] | [
"mips",
"1"
] | mips | mips_record_lo_sums | mips | CPU | GCC | 4,873 | 53 | 1 | [] |
[
"<s>",
"unsigned",
"ARMCodeEmitter",
"::",
"getMachineOpValue",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"const",
"MachineOperand",
"&",
"MO",
")",
"const",
"{",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"return",
"getARMRegisterNumbering",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"else",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"static_cast",
"<",
"unsigned",
">",
"(",
"MO",
".",
"getImm",
"(",
")",
")",
";",
"else",
"if",
"(",
"MO",
".",
"isGlobal",
"(",
")",
")",
"emitGlobalAddress",
"(",
"MO",
".",
"getGlobal",
"(",
")",
",",
"ARM",
"::",
"reloc_arm_branch",
",",
"true",
",",
"false",
")",
";",
"else",
"if",
"(",
"MO",
".",
"isSymbol",
"(",
")",
")",
"emitExternalSymbolAddress",
"(",
"MO",
".",
"getSymbolName",
"(",
")",
",",
"ARM",
"::",
"reloc_arm_branch",
")",
";",
"else",
"if",
"(",
"MO",
".",
"isCPI",
"(",
")",
")",
"{",
"const",
"TargetInstrDesc",
"&",
"TID",
"=",
"MI",
".",
"getDesc",
"(",
")",
";",
"unsigned",
"Reloc",
"=",
"(",
"(",
"TID",
".",
"TSFlags",
"&",
"ARMII",
"::",
"FormMask",
")",
"==",
"ARMII",
"::",
"VFPLdStFrm",
")",
"?",
"ARM",
"::",
"reloc_arm_vfp_cp_entry",
":",
"ARM",
"::",
"reloc_arm_cp_entry",
";",
"emitConstPoolAddress",
"(",
"MO",
".",
"getIndex",
"(",
")",
",",
"Reloc",
")",
";",
"}",
"else",
"if",
"(",
"MO",
".",
"isJTI",
"(",
")",
")",
"emitJumpTableAddress",
"(",
"MO",
".",
"getIndex",
"(",
")",
",",
"ARM",
"::",
"reloc_arm_relative",
")",
";",
"else",
"if",
"(",
"MO",
".",
"isMBB",
"(",
")",
")",
"emitMachineBasicBlock",
"(",
"MO",
".",
"getMBB",
"(",
")",
",",
"ARM",
"::",
"reloc_arm_branch",
")",
";",
"else",
"llvm_unreachable",
"(",
"\"Unable to encode MachineOperand!\"",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"getMachineOpValue",
"-",
"Return",
"binary",
"encoding",
"of",
"operand",
"."
] | [
"ARM",
"ARM",
"ARM",
"ARM::reloc_arm_branch",
"ARM::reloc_arm_branch",
"ARMII::FormMask",
"ARMII::VFPLdStFrm",
"ARM::reloc_arm_vfp_cp_entry",
"ARM::reloc_arm_cp_entry",
"ARM::reloc_arm_relative",
"ARM::reloc_arm_branch",
"\"Unable to encode MachineOperand!\"",
"0"
] | ARMCodeEmitter10 | getMachineOpValue | ARM | CPU | LLVM | 4,874 | 219 | 1 | [] |
[
"<s>",
"void",
"c4x_optimization_options",
"(",
"int",
"level",
"ATTRIBUTE_UNUSED",
",",
"int",
"size",
"ATTRIBUTE_UNUSED",
")",
"{",
"flag_schedule_insns",
"=",
"0",
";",
"}",
"</s>"
] | [
"This",
"is",
"called",
"before",
"c4x_override_options",
"."
] | [
"c4x",
"0"
] | c4x1 | c4x_optimization_options | c4x | DSP | GCC | 4,875 | 17 | 1 | [] |
[
"<s>",
"bool",
"ARMTargetLowering",
"::",
"isLegalInterleavedAccessType",
"(",
"unsigned",
"Factor",
",",
"FixedVectorType",
"*",
"VecTy",
",",
"Align",
"Alignment",
",",
"const",
"DataLayout",
"&",
"DL",
")",
"const",
"{",
"unsigned",
"VecSize",
"=",
"DL",
".",
"getTypeSizeInBits",
"(",
"VecTy",
")",
";",
"unsigned",
"ElSize",
"=",
"DL",
".",
"getTypeSizeInBits",
"(",
"VecTy",
"->",
"getElementType",
"(",
")",
")",
";",
"if",
"(",
"!",
"Subtarget",
"->",
"hasNEON",
"(",
")",
"&&",
"!",
"Subtarget",
"->",
"hasMVEIntegerOps",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"Subtarget",
"->",
"hasNEON",
"(",
")",
"&&",
"VecTy",
"->",
"getElementType",
"(",
")",
"->",
"isHalfTy",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"Subtarget",
"->",
"hasMVEIntegerOps",
"(",
")",
"&&",
"Factor",
"==",
"3",
")",
"return",
"false",
";",
"if",
"(",
"VecTy",
"->",
"getNumElements",
"(",
")",
"<",
"2",
")",
"return",
"false",
";",
"if",
"(",
"ElSize",
"!=",
"8",
"&&",
"ElSize",
"!=",
"16",
"&&",
"ElSize",
"!=",
"32",
")",
"return",
"false",
";",
"if",
"(",
"Subtarget",
"->",
"hasMVEIntegerOps",
"(",
")",
"&&",
"Alignment",
"<",
"ElSize",
"/",
"8",
")",
"return",
"false",
";",
"if",
"(",
"Subtarget",
"->",
"hasNEON",
"(",
")",
"&&",
"VecSize",
"==",
"64",
")",
"return",
"true",
";",
"return",
"VecSize",
"%",
"128",
"==",
"0",
";",
"}",
"</s>"
] | [
"Returns",
"whether",
"or",
"not",
"generating",
"a",
"interleaved",
"load/store",
"intrinsic",
"for",
"this",
"type",
"will",
"be",
"legal",
"."
] | [
"ARM",
"ARM",
"3",
"2",
"8",
"16",
"32",
"8",
"64",
"128",
"0"
] | ARMISelLowering (2)5 | isLegalInterleavedAccessType | ARM | CPU | LLVM | 4,876 | 171 | 1 | [] |
[
"<s>",
"SDValue",
"AMDGPUTargetLowering",
"::",
"SplitVectorStore",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"StoreSDNode",
"*",
"Store",
"=",
"cast",
"<",
"StoreSDNode",
">",
"(",
"Op",
")",
";",
"EVT",
"MemEltVT",
"=",
"Store",
"->",
"getMemoryVT",
"(",
")",
".",
"getVectorElementType",
"(",
")",
";",
"EVT",
"EltVT",
"=",
"Store",
"->",
"getValue",
"(",
")",
".",
"getValueType",
"(",
")",
".",
"getVectorElementType",
"(",
")",
";",
"EVT",
"PtrVT",
"=",
"Store",
"->",
"getBasePtr",
"(",
")",
".",
"getValueType",
"(",
")",
";",
"unsigned",
"NumElts",
"=",
"Store",
"->",
"getMemoryVT",
"(",
")",
".",
"getVectorNumElements",
"(",
")",
";",
"SDLoc",
"SL",
"(",
"Op",
")",
";",
"SmallVector",
"<",
"SDValue",
",",
"8",
">",
"Chains",
";",
"for",
"(",
"unsigned",
"i",
"=",
"0",
",",
"e",
"=",
"NumElts",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"SDValue",
"Val",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
",",
"SL",
",",
"EltVT",
",",
"Store",
"->",
"getValue",
"(",
")",
",",
"DAG",
".",
"getConstant",
"(",
"i",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"SDValue",
"Ptr",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"SL",
",",
"PtrVT",
",",
"Store",
"->",
"getBasePtr",
"(",
")",
",",
"DAG",
".",
"getConstant",
"(",
"i",
"*",
"(",
"MemEltVT",
".",
"getSizeInBits",
"(",
")",
"/",
"8",
")",
",",
"PtrVT",
")",
")",
";",
"Chains",
".",
"push_back",
"(",
"DAG",
".",
"getTruncStore",
"(",
"Store",
"->",
"getChain",
"(",
")",
",",
"SL",
",",
"Val",
",",
"Ptr",
",",
"MachinePointerInfo",
"(",
"Store",
"->",
"getMemOperand",
"(",
")",
"->",
"getValue",
"(",
")",
")",
",",
"MemEltVT",
",",
"Store",
"->",
"isVolatile",
"(",
")",
",",
"Store",
"->",
"isNonTemporal",
"(",
")",
",",
"Store",
"->",
"getAlignment",
"(",
")",
")",
")",
";",
"}",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TokenFactor",
",",
"SL",
",",
"MVT",
"::",
"Other",
",",
"Chains",
")",
";",
"}",
"</s>"
] | [
"Split",
"a",
"vector",
"store",
"into",
"2",
"stores",
"of",
"half",
"the",
"vector",
"."
] | [
"R600",
"8",
"0",
"ISD::EXTRACT_VECTOR_ELT",
"MVT::i32",
"ISD::ADD",
"8",
"ISD::TokenFactor",
"MVT::Other"
] | AMDGPUISelLowering19 | SplitVectorStore | R600 | GPU | LLVM | 4,877 | 264 | 1 | [] |
[
"<s>",
"void",
"R600MCCodeEmitter",
"::",
"Emit",
"(",
"uint64_t",
"Value",
",",
"raw_ostream",
"&",
"OS",
")",
"const",
"{",
"support",
"::",
"endian",
"::",
"Writer",
"<",
"support",
"::",
"little",
">",
"(",
"OS",
")",
".",
"write",
"(",
"Value",
")",
";",
"}",
"</s>"
] | [
"Emit",
"-",
"Top",
"level",
"entry",
"point",
"."
] | [
"AMDGPU",
"R600",
"support::endian",
"support::little"
] | R600MCCodeEmitter19 | Emit | AMDGPU | GPU | LLVM | 4,878 | 34 | 1 | [] |
[
"<s>",
"bool",
"SPUFrameInfo",
"::",
"hasFP",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"return",
"MFI",
"->",
"getStackSize",
"(",
")",
"&&",
"(",
"DisableFramePointerElim",
"(",
"MF",
")",
"||",
"MFI",
"->",
"hasVarSizedObjects",
"(",
")",
")",
";",
"}",
"</s>"
] | [
"hasFP",
"-",
"Return",
"true",
"if",
"the",
"specified",
"function",
"should",
"have",
"a",
"dedicated",
"frame",
"pointer",
"register",
"."
] | [
"CellSPU",
"SPU"
] | SPUFrameInfo | hasFP | CellSPU | MPU | LLVM | 4,879 | 44 | 1 | [] |
[
"<s>",
"SDValue",
"AArch64SelectionDAGInfo",
"::",
"EmitTargetCodeForMemset",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"SDLoc",
"dl",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Dst",
",",
"SDValue",
"Src",
",",
"SDValue",
"Size",
",",
"unsigned",
"Align",
",",
"bool",
"isVolatile",
",",
"MachinePointerInfo",
"DstPtrInfo",
")",
"const",
"{",
"ConstantSDNode",
"*",
"V",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Src",
")",
";",
"ConstantSDNode",
"*",
"SizeValue",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Size",
")",
";",
"const",
"AArch64Subtarget",
"&",
"STI",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
";",
"const",
"char",
"*",
"bzeroEntry",
"=",
"(",
"V",
"&&",
"V",
"->",
"isNullValue",
"(",
")",
")",
"?",
"STI",
".",
"getBZeroEntry",
"(",
")",
":",
"nullptr",
";",
"if",
"(",
"bzeroEntry",
"&&",
"(",
"!",
"SizeValue",
"||",
"SizeValue",
"->",
"getZExtValue",
"(",
")",
">",
"256",
")",
")",
"{",
"const",
"AArch64TargetLowering",
"&",
"TLI",
"=",
"*",
"STI",
".",
"getTargetLowering",
"(",
")",
";",
"EVT",
"IntPtr",
"=",
"TLI",
".",
"getPointerTy",
"(",
")",
";",
"Type",
"*",
"IntPtrTy",
"=",
"getDataLayout",
"(",
")",
"->",
"getIntPtrType",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"TargetLowering",
"::",
"ArgListTy",
"Args",
";",
"TargetLowering",
"::",
"ArgListEntry",
"Entry",
";",
"Entry",
".",
"Node",
"=",
"Dst",
";",
"Entry",
".",
"Ty",
"=",
"IntPtrTy",
";",
"Args",
".",
"push_back",
"(",
"Entry",
")",
";",
"Entry",
".",
"Node",
"=",
"Size",
";",
"Args",
".",
"push_back",
"(",
"Entry",
")",
";",
"TargetLowering",
"::",
"CallLoweringInfo",
"CLI",
"(",
"DAG",
")",
";",
"CLI",
".",
"setDebugLoc",
"(",
"dl",
")",
".",
"setChain",
"(",
"Chain",
")",
".",
"setCallee",
"(",
"CallingConv",
"::",
"C",
",",
"Type",
"::",
"getVoidTy",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
",",
"DAG",
".",
"getExternalSymbol",
"(",
"bzeroEntry",
",",
"IntPtr",
")",
",",
"std",
"::",
"move",
"(",
"Args",
")",
",",
"0",
")",
".",
"setDiscardResult",
"(",
")",
";",
"std",
"::",
"pair",
"<",
"SDValue",
",",
"SDValue",
">",
"CallResult",
"=",
"TLI",
".",
"LowerCallTo",
"(",
"CLI",
")",
";",
"return",
"CallResult",
".",
"second",
";",
"}",
"return",
"SDValue",
"(",
")",
";",
"}",
"</s>"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memset",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64",
"256",
"AArch64",
"0"
] | AArch64SelectionDAGInfo26 | EmitTargetCodeForMemset | AArch64 | CPU | LLVM | 4,880 | 289 | 1 | [] |
[
"<s>",
"TargetLoweringObjectFile",
"*",
"getObjFileLowering",
"(",
")",
"const",
"override",
"{",
"return",
"TLOF",
".",
"get",
"(",
")",
";",
"}",
"</s>"
] | [
"Return",
"information",
"about",
"object",
"file",
"lowering",
"."
] | [
"Xtensa"
] | XtensaTargetMachine | getObjFileLowering | Xtensa | MPU | LLVM | 4,881 | 16 | 1 | [] |
[
"<s>",
"void",
"PPCHazardRecognizer440",
"::",
"EmitInstruction",
"(",
"SUnit",
"*",
"SU",
")",
"{",
"const",
"MCInstrDesc",
"*",
"MCID",
"=",
"DAG",
"->",
"getInstrDesc",
"(",
"SU",
")",
";",
"if",
"(",
"!",
"MCID",
")",
"{",
"return",
";",
"}",
"ScoreboardHazardRecognizer",
"::",
"EmitInstruction",
"(",
"SU",
")",
";",
"}",
"</s>"
] | [
"EmitInstruction",
"-",
"This",
"callback",
"is",
"invoked",
"when",
"an",
"instruction",
"is",
"emitted",
",",
"to",
"advance",
"the",
"hazard",
"state",
"."
] | [
"PowerPC",
"PPC"
] | PPCHazardRecognizers32 | EmitInstruction | PowerPC | CPU | LLVM | 4,882 | 39 | 1 | [] |
[
"<s>",
"void",
"h8300_pr_interrupt",
"(",
"struct",
"cpp_reader",
"*",
"pfile",
"ATTRIBUTE_UNUSED",
")",
"{",
"pragma_interrupt",
"=",
"1",
";",
"}",
"</s>"
] | [
"Handle",
"machine",
"specific",
"pragmas",
"for",
"compatibility",
"with",
"existing",
"compilers",
"for",
"the",
"H8/300",
".",
"pragma",
"saveall",
"generates",
"prolog/epilog",
"code",
"which",
"saves",
"and",
"restores",
"all",
"the",
"registers",
"on",
"function",
"entry",
".",
"pragma",
"interrupt",
"saves",
"and",
"restores",
"all",
"registers",
",",
"and",
"exits",
"with",
"an",
"rte",
"instruction",
"rather",
"than",
"an",
"rts",
".",
"A",
"pointer",
"to",
"a",
"function",
"with",
"this",
"attribute",
"may",
"be",
"safely",
"used",
"in",
"an",
"interrupt",
"vector",
"."
] | [
"h8300",
"1"
] | h8300 | h8300_pr_interrupt | h8300 | MPU | GCC | 4,883 | 15 | 1 | [] |
[
"<s>",
"rtx",
"sfunc_uses_reg",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"int",
"i",
";",
"rtx",
"pattern",
",",
"part",
",",
"reg_part",
",",
"reg",
";",
"if",
"(",
"!",
"NONJUMP_INSN_P",
"(",
"insn",
")",
")",
"return",
"NULL_RTX",
";",
"pattern",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"pattern",
")",
"!=",
"PARALLEL",
"||",
"get_attr_type",
"(",
"insn",
")",
"!=",
"TYPE_SFUNC",
")",
"return",
"NULL_RTX",
";",
"for",
"(",
"reg_part",
"=",
"NULL_RTX",
",",
"i",
"=",
"XVECLEN",
"(",
"pattern",
",",
"0",
")",
"-",
"1",
";",
"i",
">=",
"1",
";",
"i",
"--",
")",
"{",
"part",
"=",
"XVECEXP",
"(",
"pattern",
",",
"0",
",",
"i",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"part",
")",
"==",
"USE",
"&&",
"GET_MODE",
"(",
"XEXP",
"(",
"part",
",",
"0",
")",
")",
"==",
"SImode",
")",
"reg_part",
"=",
"part",
";",
"}",
"if",
"(",
"!",
"reg_part",
")",
"return",
"NULL_RTX",
";",
"reg",
"=",
"XEXP",
"(",
"reg_part",
",",
"0",
")",
";",
"for",
"(",
"int",
"i",
"=",
"XVECLEN",
"(",
"pattern",
",",
"0",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
")",
"{",
"part",
"=",
"XVECEXP",
"(",
"pattern",
",",
"0",
",",
"i",
")",
";",
"if",
"(",
"part",
"==",
"reg_part",
"||",
"GET_CODE",
"(",
"part",
")",
"==",
"CLOBBER",
")",
"continue",
";",
"if",
"(",
"reg_mentioned_p",
"(",
"reg",
",",
"(",
"(",
"GET_CODE",
"(",
"part",
")",
"==",
"SET",
"&&",
"REG_P",
"(",
"SET_DEST",
"(",
"part",
")",
")",
")",
"?",
"SET_SRC",
"(",
"part",
")",
":",
"part",
")",
")",
")",
"return",
"NULL_RTX",
";",
"}",
"return",
"reg",
";",
"}",
"</s>"
] | [
"If",
"the",
"instruction",
"INSN",
"is",
"implemented",
"by",
"a",
"special",
"function",
",",
"and",
"we",
"can",
"positively",
"find",
"the",
"register",
"that",
"is",
"used",
"to",
"call",
"the",
"sfunc",
",",
"and",
"this",
"register",
"is",
"not",
"used",
"anywhere",
"else",
"in",
"this",
"instruction",
"-",
"except",
"as",
"the",
"destination",
"of",
"a",
"set",
",",
"return",
"this",
"register",
";",
"else",
",",
"return",
"0",
"."
] | [
"sh",
"0",
"1",
"1",
"0",
"0",
"0",
"0",
"1",
"0",
"0"
] | sh | sfunc_uses_reg | sh | CPU | GCC | 4,884 | 225 | 1 | [] |
[
"<s>",
"void",
"MipsAsmPrinter",
"::",
"emitFrameDirective",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"TargetRegisterInfo",
"&",
"RI",
"=",
"*",
"TM",
".",
"getRegisterInfo",
"(",
")",
";",
"unsigned",
"stackReg",
"=",
"RI",
".",
"getFrameRegister",
"(",
"MF",
")",
";",
"unsigned",
"returnReg",
"=",
"RI",
".",
"getRARegister",
"(",
")",
";",
"unsigned",
"stackSize",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
"->",
"getStackSize",
"(",
")",
";",
"O",
"<<",
"\"\\t.frame\\t\"",
"<<",
"'$'",
"<<",
"LowercaseString",
"(",
"RI",
".",
"get",
"(",
"stackReg",
")",
".",
"AsmName",
")",
"<<",
"','",
"<<",
"stackSize",
"<<",
"','",
"<<",
"'$'",
"<<",
"LowercaseString",
"(",
"RI",
".",
"get",
"(",
"returnReg",
")",
".",
"AsmName",
")",
"<<",
"'\\n'",
";",
"}",
"</s>"
] | [
"Frame",
"Directive",
"."
] | [
"Mips",
"Mips",
"\"\\t.frame\\t\""
] | MipsAsmPrinter31 | emitFrameDirective | Mips | CPU | LLVM | 4,885 | 95 | 1 | [] |
[
"<s>",
"bool",
"MipsCCState",
"::",
"originalTypeIsVectorFloat",
"(",
"const",
"Type",
"*",
"Ty",
")",
"{",
"if",
"(",
"Ty",
"->",
"isVectorTy",
"(",
")",
"&&",
"Ty",
"->",
"isFPOrFPVectorTy",
"(",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}",
"</s>"
] | [
"Return",
"true",
"if",
"the",
"original",
"type",
"was",
"vXfXX",
"/",
"vXfXX",
"."
] | [
"Mips",
"Mips"
] | MipsCCState9 | originalTypeIsVectorFloat | Mips | CPU | LLVM | 4,886 | 32 | 1 | [] |
[
"<s>",
"static",
"inline",
"bool",
"save_global_or_fp_reg_p",
"(",
"unsigned",
"int",
"regno",
",",
"int",
"leaf_function",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"!",
"call_used_or_fixed_reg_p",
"(",
"regno",
")",
"&&",
"df_regs_ever_live_p",
"(",
"regno",
")",
";",
"}",
"</s>"
] | [
"Return",
"whether",
"REGNO",
",",
"a",
"global",
"or",
"FP",
"register",
",",
"must",
"be",
"saved/restored",
"."
] | [
"sparc"
] | sparc | save_global_or_fp_reg_p | sparc | CPU | GCC | 4,887 | 27 | 1 | [] |
[
"<s>",
"static",
"void",
"load_pic_register",
"(",
"bool",
"delay_pic_helper",
")",
"{",
"int",
"orig_flag_pic",
"=",
"flag_pic",
";",
"if",
"(",
"!",
"pic_helper_symbol_name",
"[",
"0",
"]",
")",
"{",
"ASM_GENERATE_INTERNAL_LABEL",
"(",
"pic_helper_symbol_name",
",",
"\"LADDPC\"",
",",
"0",
")",
";",
"pic_helper_symbol",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"pic_helper_symbol_name",
")",
";",
"global_offset_table",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"\"_GLOBAL_OFFSET_TABLE_\"",
")",
";",
"}",
"if",
"(",
"!",
"delay_pic_helper",
"&&",
"!",
"pic_helper_emitted_p",
")",
"emit_pic_helper",
"(",
")",
";",
"flag_pic",
"=",
"0",
";",
"if",
"(",
"TARGET_ARCH64",
")",
"emit_insn",
"(",
"gen_load_pcrel_symdi",
"(",
"pic_offset_table_rtx",
",",
"global_offset_table",
",",
"pic_helper_symbol",
")",
")",
";",
"else",
"emit_insn",
"(",
"gen_load_pcrel_symsi",
"(",
"pic_offset_table_rtx",
",",
"global_offset_table",
",",
"pic_helper_symbol",
")",
")",
";",
"flag_pic",
"=",
"orig_flag_pic",
";",
"emit_insn",
"(",
"gen_rtx_USE",
"(",
"VOIDmode",
",",
"pic_offset_table_rtx",
")",
")",
";",
"}",
"</s>"
] | [
"Emit",
"code",
"to",
"load",
"the",
"PIC",
"register",
"."
] | [
"sparc",
"0",
"\"LADDPC\"",
"0",
"\"_GLOBAL_OFFSET_TABLE_\"",
"0"
] | sparc3 | load_pic_register | sparc | CPU | GCC | 4,888 | 110 | 1 | [] |
[
"<s>",
"void",
"arc_expand_compare_and_swap",
"(",
"rtx",
"operands",
"[",
"]",
")",
"{",
"rtx",
"bval",
",",
"rval",
",",
"mem",
",",
"oldval",
",",
"newval",
",",
"is_weak",
",",
"mod_s",
",",
"mod_f",
",",
"x",
";",
"machine_mode",
"mode",
";",
"bval",
"=",
"operands",
"[",
"0",
"]",
";",
"rval",
"=",
"operands",
"[",
"1",
"]",
";",
"mem",
"=",
"operands",
"[",
"2",
"]",
";",
"oldval",
"=",
"operands",
"[",
"3",
"]",
";",
"newval",
"=",
"operands",
"[",
"4",
"]",
";",
"is_weak",
"=",
"operands",
"[",
"5",
"]",
";",
"mod_s",
"=",
"operands",
"[",
"6",
"]",
";",
"mod_f",
"=",
"operands",
"[",
"7",
"]",
";",
"mode",
"=",
"GET_MODE",
"(",
"mem",
")",
";",
"if",
"(",
"reg_overlap_mentioned_p",
"(",
"rval",
",",
"oldval",
")",
")",
"oldval",
"=",
"copy_to_reg",
"(",
"oldval",
")",
";",
"if",
"(",
"mode",
"==",
"SImode",
")",
"{",
"emit_insn",
"(",
"gen_atomic_compare_and_swapsi_1",
"(",
"rval",
",",
"mem",
",",
"oldval",
",",
"newval",
",",
"is_weak",
",",
"mod_s",
",",
"mod_f",
")",
")",
";",
"x",
"=",
"gen_rtx_REG",
"(",
"CC_Zmode",
",",
"CC_REG",
")",
";",
"x",
"=",
"gen_rtx_EQ",
"(",
"SImode",
",",
"x",
",",
"const0_rtx",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"bval",
",",
"x",
")",
")",
";",
"}",
"else",
"{",
"arc_expand_compare_and_swap_qh",
"(",
"bval",
",",
"rval",
",",
"mem",
",",
"oldval",
",",
"newval",
",",
"is_weak",
",",
"mod_s",
",",
"mod_f",
")",
";",
"}",
"}",
"</s>"
] | [
"Helper",
"function",
"used",
"by",
"``",
"atomic_compare_and_swap",
"''",
"expand",
"pattern",
"."
] | [
"arc",
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7"
] | arc | arc_expand_compare_and_swap | arc | MPU | GCC | 4,889 | 191 | 1 | [] |
[
"<s>",
"BitVector",
"TVMRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"TVM",
"::",
"SP",
")",
";",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"TVM",
"TVM",
"TVM::SP"
] | TVMRegisterInfo | getReservedRegs | TVM | Virtual ISA | LLVM | 4,890 | 33 | 1 | [] |
[
"<s>",
"int",
"rs6000_reg_parm_stack_space",
"(",
"tree",
"fun",
",",
"bool",
"incoming",
")",
"{",
"int",
"reg_parm_stack_space",
";",
"switch",
"(",
"DEFAULT_ABI",
")",
"{",
"default",
":",
"reg_parm_stack_space",
"=",
"0",
";",
"break",
";",
"case",
"ABI_AIX",
":",
"case",
"ABI_DARWIN",
":",
"reg_parm_stack_space",
"=",
"TARGET_64BIT",
"?",
"64",
":",
"32",
";",
"break",
";",
"case",
"ABI_ELFv2",
":",
"if",
"(",
"rs6000_function_parms_need_stack",
"(",
"fun",
",",
"incoming",
")",
")",
"reg_parm_stack_space",
"=",
"TARGET_64BIT",
"?",
"64",
":",
"32",
";",
"else",
"reg_parm_stack_space",
"=",
"0",
";",
"break",
";",
"}",
"return",
"reg_parm_stack_space",
";",
"}",
"</s>"
] | [
"Return",
"the",
"size",
"of",
"the",
"REG_PARM_STACK_SPACE",
"are",
"for",
"FUN",
".",
"This",
"is",
"usually",
"a",
"constant",
"depending",
"on",
"the",
"ABI",
".",
"However",
",",
"in",
"the",
"ELFv2",
"ABI",
"the",
"register",
"parameter",
"area",
"is",
"optional",
"when",
"calling",
"a",
"function",
"that",
"has",
"a",
"prototype",
"is",
"scope",
",",
"has",
"no",
"variable",
"argument",
"list",
",",
"and",
"passes",
"all",
"parameters",
"in",
"registers",
"."
] | [
"rs6000",
"0",
"64",
"32",
"64",
"32",
"0"
] | rs6000-call | rs6000_reg_parm_stack_space | rs6000 | CPU | GCC | 4,891 | 74 | 1 | [] |
[
"<s>",
"bool",
"SNESMCExpr",
"::",
"evaluateAsConstant",
"(",
"int64_t",
"&",
"Result",
")",
"const",
"{",
"MCValue",
"Value",
";",
"bool",
"isRelocatable",
"=",
"getSubExpr",
"(",
")",
"->",
"evaluateAsRelocatable",
"(",
"Value",
",",
"nullptr",
",",
"nullptr",
")",
";",
"if",
"(",
"!",
"isRelocatable",
")",
"return",
"false",
";",
"if",
"(",
"Value",
".",
"isAbsolute",
"(",
")",
")",
"{",
"Result",
"=",
"evaluateAsInt64",
"(",
"Value",
".",
"getConstant",
"(",
")",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"</s>"
] | [
"Evaluates",
"the",
"fixup",
"as",
"a",
"constant",
"value",
"."
] | [
"SNES",
"SNES"
] | SNESMCExpr | evaluateAsConstant | SNES | DSP | LLVM | 4,892 | 66 | 1 | [] |
[
"<s>",
"static",
"bool",
"nvptx_goacc_validate_dims",
"(",
"tree",
"decl",
",",
"int",
"dims",
"[",
"]",
",",
"int",
"fn_level",
")",
"{",
"bool",
"changed",
"=",
"false",
";",
"if",
"(",
"fn_level",
"<=",
"GOMP_DIM_VECTOR",
"&&",
"fn_level",
">=",
"-",
"1",
"&&",
"dims",
"[",
"GOMP_DIM_VECTOR",
"]",
">=",
"0",
"&&",
"dims",
"[",
"GOMP_DIM_VECTOR",
"]",
"!=",
"PTX_VECTOR_LENGTH",
")",
"{",
"if",
"(",
"fn_level",
"<",
"0",
"&&",
"dims",
"[",
"GOMP_DIM_VECTOR",
"]",
">=",
"0",
")",
"warning_at",
"(",
"decl",
"?",
"DECL_SOURCE_LOCATION",
"(",
"decl",
")",
":",
"UNKNOWN_LOCATION",
",",
"0",
",",
"dims",
"[",
"GOMP_DIM_VECTOR",
"]",
"?",
"G_",
"(",
"\"using vector_length (%d), ignoring %d\"",
")",
":",
"G_",
"(",
"\"using vector_length (%d), ignoring runtime setting\"",
")",
",",
"PTX_VECTOR_LENGTH",
",",
"dims",
"[",
"GOMP_DIM_VECTOR",
"]",
")",
";",
"dims",
"[",
"GOMP_DIM_VECTOR",
"]",
"=",
"PTX_VECTOR_LENGTH",
";",
"changed",
"=",
"true",
";",
"}",
"if",
"(",
"dims",
"[",
"GOMP_DIM_WORKER",
"]",
">",
"PTX_WORKER_LENGTH",
")",
"{",
"warning_at",
"(",
"decl",
"?",
"DECL_SOURCE_LOCATION",
"(",
"decl",
")",
":",
"UNKNOWN_LOCATION",
",",
"0",
",",
"\"using num_workers (%d), ignoring %d\"",
",",
"PTX_WORKER_LENGTH",
",",
"dims",
"[",
"GOMP_DIM_WORKER",
"]",
")",
";",
"dims",
"[",
"GOMP_DIM_WORKER",
"]",
"=",
"PTX_WORKER_LENGTH",
";",
"changed",
"=",
"true",
";",
"}",
"if",
"(",
"!",
"decl",
")",
"{",
"dims",
"[",
"GOMP_DIM_VECTOR",
"]",
"=",
"PTX_VECTOR_LENGTH",
";",
"if",
"(",
"dims",
"[",
"GOMP_DIM_WORKER",
"]",
"<",
"0",
")",
"dims",
"[",
"GOMP_DIM_WORKER",
"]",
"=",
"PTX_WORKER_LENGTH",
";",
"if",
"(",
"dims",
"[",
"GOMP_DIM_GANG",
"]",
"<",
"0",
")",
"dims",
"[",
"GOMP_DIM_GANG",
"]",
"=",
"PTX_GANG_DEFAULT",
";",
"changed",
"=",
"true",
";",
"}",
"return",
"changed",
";",
"}",
"</s>"
] | [
"Validate",
"compute",
"dimensions",
"of",
"an",
"OpenACC",
"offload",
"or",
"routine",
",",
"fill",
"in",
"non-unity",
"defaults",
".",
"FN_LEVEL",
"indicates",
"the",
"level",
"at",
"which",
"a",
"routine",
"might",
"spawn",
"a",
"loop",
".",
"It",
"is",
"negative",
"for",
"non-routines",
".",
"If",
"DECL",
"is",
"null",
",",
"we",
"are",
"validating",
"the",
"default",
"dimensions",
"."
] | [
"nvptx",
"1",
"0",
"0",
"0",
"0",
"\"using vector_length (%d), ignoring %d\"",
"\"using vector_length (%d), ignoring runtime setting\"",
"0",
"\"using num_workers (%d), ignoring %d\"",
"0",
"0"
] | nvptx4 | nvptx_goacc_validate_dims | nvptx | GPU | GCC | 4,893 | 207 | 1 | [] |
[
"<s>",
"WebAssemblySubtarget",
"&",
"WebAssemblySubtarget",
"::",
"initializeSubtargetDependencies",
"(",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
")",
"{",
"LLVM_DEBUG",
"(",
"llvm",
"::",
"dbgs",
"(",
")",
"<<",
"\"initializeSubtargetDependencies\\n\"",
")",
";",
"if",
"(",
"CPU",
".",
"empty",
"(",
")",
")",
"CPU",
"=",
"\"generic\"",
";",
"ParseSubtargetFeatures",
"(",
"CPU",
",",
"FS",
")",
";",
"return",
"*",
"this",
";",
"}",
"</s>"
] | [
"initializeSubtargetDependencies",
"-",
"Initializes",
"using",
"a",
"CPU",
",",
"a",
"TuneCPU",
",",
"and",
"feature",
"string",
"so",
"that",
"we",
"can",
"use",
"initializer",
"lists",
"for",
"subtarget",
"initialization",
"."
] | [
"WebAssembly",
"WebAssembly",
"WebAssembly",
"\"initializeSubtargetDependencies\\n\"",
"\"generic\""
] | WebAssemblySubtarget10 | initializeSubtargetDependencies | WebAssembly | Virtual ISA | LLVM | 4,894 | 48 | 1 | [] |
[
"<s>",
"void",
"emitValueImpl",
"(",
"const",
"MCExpr",
"*",
"Value",
",",
"unsigned",
"Size",
",",
"SMLoc",
"Loc",
")",
"override",
"{",
"EmitMappingSymbol",
"(",
"\"$d\"",
")",
";",
"MCELFStreamer",
"::",
"emitValueImpl",
"(",
"Value",
",",
"Size",
",",
"Loc",
")",
";",
"}",
"</s>"
] | [
"Overriding",
"these",
"functions",
"allows",
"us",
"to",
"dismiss",
"all",
"labels",
"that",
"are",
"candidates",
"for",
"marking",
"as",
"microMIPS",
"when",
".word/.long/.4byte",
"etc",
"directives",
"are",
"emitted",
"."
] | [
"CSKY",
"\"$d\""
] | CSKYELFStreamer | emitValueImpl | CSKY | CPU | LLVM | 4,895 | 33 | 1 | [] |
[
"<s>",
"static",
"int",
"sh_pr_n_sets",
"(",
"void",
")",
"{",
"return",
"REG_N_SETS",
"(",
"TARGET_SHMEDIA",
"?",
"PR_MEDIA_REG",
":",
"PR_REG",
")",
";",
"}",
"</s>"
] | [
"For",
"use",
"by",
"ALLOCATE_INITIAL_VALUE",
".",
"Note",
"that",
"sh.md",
"contains",
"some",
"'special",
"function",
"'",
"patterns",
"(",
"type",
"sfunc",
")",
"that",
"clobber",
"pr",
",",
"but",
"that",
"do",
"not",
"look",
"like",
"function",
"calls",
"to",
"leaf_function_p",
".",
"Hence",
"we",
"must",
"do",
"this",
"extra",
"check",
"."
] | [
"sh"
] | sh3 | sh_pr_n_sets | sh | CPU | GCC | 4,896 | 18 | 1 | [] |
[
"<s>",
"unsigned",
"PPCTargetLowering",
"::",
"getRegisterByName",
"(",
"const",
"char",
"*",
"RegName",
",",
"EVT",
"VT",
")",
"const",
"{",
"bool",
"isPPC64",
"=",
"Subtarget",
".",
"isPPC64",
"(",
")",
";",
"bool",
"isDarwinABI",
"=",
"Subtarget",
".",
"isDarwinABI",
"(",
")",
";",
"if",
"(",
"(",
"isPPC64",
"&&",
"VT",
"!=",
"MVT",
"::",
"i64",
"&&",
"VT",
"!=",
"MVT",
"::",
"i32",
")",
"||",
"(",
"!",
"isPPC64",
"&&",
"VT",
"!=",
"MVT",
"::",
"i32",
")",
")",
"report_fatal_error",
"(",
"\"Invalid register global variable type\"",
")",
";",
"bool",
"is64Bit",
"=",
"isPPC64",
"&&",
"VT",
"==",
"MVT",
"::",
"i64",
";",
"unsigned",
"Reg",
"=",
"StringSwitch",
"<",
"unsigned",
">",
"(",
"RegName",
")",
".",
"Case",
"(",
"\"r1\"",
",",
"is64Bit",
"?",
"PPC",
"::",
"X1",
":",
"PPC",
"::",
"R1",
")",
".",
"Case",
"(",
"\"r2\"",
",",
"isDarwinABI",
"?",
"0",
":",
"(",
"is64Bit",
"?",
"PPC",
"::",
"X2",
":",
"PPC",
"::",
"R2",
")",
")",
".",
"Case",
"(",
"\"r13\"",
",",
"(",
"!",
"isPPC64",
"&&",
"isDarwinABI",
")",
"?",
"0",
":",
"(",
"is64Bit",
"?",
"PPC",
"::",
"X13",
":",
"PPC",
"::",
"R13",
")",
")",
".",
"Default",
"(",
"0",
")",
";",
"if",
"(",
"Reg",
")",
"return",
"Reg",
";",
"report_fatal_error",
"(",
"\"Invalid register name global variable\"",
")",
";",
"}",
"</s>"
] | [
"Return",
"the",
"register",
"ID",
"of",
"the",
"name",
"passed",
"in",
"."
] | [
"PowerPC",
"PPC",
"PPC",
"PPC",
"PPC",
"MVT::i64",
"MVT::i32",
"PPC",
"MVT::i32",
"\"Invalid register global variable type\"",
"PPC",
"MVT::i64",
"\"r1\"",
"PPC::X1",
"PPC::R1",
"\"r2\"",
"0",
"PPC::X2",
"PPC::R2",
"\"r13\"",
"PPC",
"0",
"PPC::X13",
"PPC::R13",
"0",
"\"Invalid register name global variable\""
] | PPCISelLowering148 | getRegisterByName | PowerPC | CPU | LLVM | 4,897 | 169 | 1 | [] |
[
"<s>",
"static",
"int",
"ia64_spec_check_p",
"(",
"rtx",
"x",
")",
"{",
"x",
"=",
"PATTERN",
"(",
"x",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"COND_EXEC",
")",
"x",
"=",
"COND_EXEC_CODE",
"(",
"x",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"SET",
")",
"return",
"ia64_spec_check_src_p",
"(",
"SET_SRC",
"(",
"x",
")",
")",
";",
"return",
"0",
";",
"}",
"</s>"
] | [
"Return",
"nonzero",
",",
"if",
"X",
"is",
"branchy",
"recovery",
"check",
"."
] | [
"ia64",
"0"
] | ia64 | ia64_spec_check_p | ia64 | CPU | GCC | 4,898 | 53 | 1 | [] |
[
"<s>",
"BitVector",
"AArch64RegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"AArch64FrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"AArch64",
"::",
"WSP",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"AArch64",
"::",
"WZR",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
"||",
"TT",
".",
"isOSDarwin",
"(",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"AArch64",
"::",
"W29",
")",
";",
"if",
"(",
"MF",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
".",
"isX18Reserved",
"(",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"AArch64",
"::",
"W18",
")",
";",
"if",
"(",
"hasBasePointer",
"(",
"MF",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"AArch64",
"::",
"W19",
")",
";",
"assert",
"(",
"checkAllSuperRegsMarked",
"(",
"Reserved",
")",
")",
";",
"return",
"Reserved",
";",
"}",
"</s>"
] | [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
] | [
"AArch64",
"AArch64",
"AArch64",
"AArch64::WSP",
"AArch64::WZR",
"AArch64::W29",
"AArch64",
"AArch64::W18",
"AArch64::W19"
] | AArch64RegisterInfo17 | getReservedRegs | AArch64 | CPU | LLVM | 4,899 | 124 | 1 | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.