Compiler_Type
stringclasses 2
values | Target
stringclasses 176
values | Programming Language
stringclasses 3
values | Task
stringclasses 4
values | Target_Type
stringclasses 7
values | Idx
int64 0
636k
| Ground_Truth
listlengths 0
2.32k
| Input
listlengths 1
1.02k
|
---|---|---|---|---|---|---|---|
LLVM | AArch64 | CPP | code_generation | CPU | 4,000 | [
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"override",
"{",
"return",
"<STR_LIT>",
"AArch64 Conditional Compares",
"<STR_LIT>",
";",
"}"
] | [
"getPassName",
"-",
"Return",
"a",
"nice",
"clean",
"name",
"for",
"a",
"pass",
"."
] |
LLVM | ARM | CPP | stmt_completion | CPU | 4,001 | [
"override",
"{"
] | [
"const",
"ARMFrameLowering",
"*",
"getFrameLowering",
"(",
")",
"const"
] |
LLVM | WebAssembly | CPP | next_suggestion | Virtual ISA | 4,002 | [
"}"
] | [
"if",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isMBB",
"(",
")",
")",
"return",
"true",
";",
"Cond",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateImm",
"(",
"false",
")",
")",
";",
"Cond",
".",
"push_back",
"(",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"TBB",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getMBB",
"(",
")",
";",
"HaveCond",
"=",
"true",
";",
"break",
";",
"case",
"WebAssembly",
"::",
"BR",
":",
"if",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isMBB",
"(",
")",
")",
"return",
"true",
";",
"if",
"(",
"!",
"HaveCond",
")",
"TBB",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getMBB",
"(",
")",
";",
"else",
"FBB",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getMBB",
"(",
")",
";",
"break",
";"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 4,003 | [
"return",
"false",
";"
] | [
"if",
"(",
"ConstantPoolSDNode",
"*",
"CP",
"=",
"dyn_cast",
"<",
"ConstantPoolSDNode",
">",
"(",
"WrapperOp",
")",
")",
"if",
"(",
"ConstantFP",
"*",
"CFP",
"=",
"dyn_cast",
"<",
"ConstantFP",
">",
"(",
"CP",
"->",
"getConstVal",
"(",
")",
")",
")",
"return",
"CFP",
"->",
"getValueAPF",
"(",
")",
".",
"isPosZero",
"(",
")",
";",
"}",
"}"
] |
GCC | cris | MD | stmt_completion | MPU | 4,004 | [
"<STR_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
] | [
"(",
"define_subst_attr",
"<STR_LIT>",
"<STR_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"define_subst_attr",
"<STR_LIT>",
"<STR_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"define_subst_attr",
"<STR_LIT>"
] |
LLVM | R600 | CPP | code_generation | GPU | 4,005 | [
"bool",
"SIInstrInfo",
"::",
"hasVALU32BitEncoding",
"(",
"unsigned",
"Opcode",
")",
"const",
"{",
"int",
"Op32",
"=",
"AMDGPU",
"::",
"getVOPe32",
"(",
"Opcode",
")",
";",
"if",
"(",
"Op32",
"==",
"-",
"<NUM_LIT>",
")",
"return",
"false",
";",
"return",
"pseudoToMCOpcode",
"(",
"Op32",
")",
"!=",
"-",
"<NUM_LIT>",
";",
"}"
] | [
"Return",
"true",
"if",
"this",
"64-bit",
"VALU",
"instruction",
"has",
"a",
"32-bit",
"encoding",
"."
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 4,006 | [
"}"
] | [
"if",
"(",
"Kind",
"==",
"k_ShiftExtend",
")",
"return",
"ShiftExtend",
".",
"HasExplicitAmount",
";",
"if",
"(",
"Kind",
"==",
"k_Register",
")",
"return",
"Reg",
".",
"ShiftExtend",
".",
"HasExplicitAmount",
";",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Invalid access!",
"<STR_LIT>",
")",
";"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 4,007 | [
"(",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
"return",
"<STR_LIT>",
"__bzero",
"<STR_LIT>",
";"
] | [
"const",
"char",
"*",
"X86Subtarget",
"::",
"getBZeroEntry",
"(",
")",
"const",
"{",
"if",
"(",
"getTargetTriple",
"(",
")",
".",
"isMacOSX",
"(",
")",
"&&",
"!",
"getTargetTriple",
"(",
")",
".",
"isMacOSXVersionLT"
] |
GCC | mips | CPP | stmt_completion | CPU | 4,008 | [
"+",
"argno",
"*",
"UNITS_PER_WORD",
";"
] | [
"if",
"(",
"!",
"MEM_P",
"(",
"dest",
")",
"||",
"!",
"REG_P",
"(",
"src",
")",
"||",
"GET_MODE",
"(",
"dest",
")",
"!=",
"word_mode",
")",
"return",
"false",
";",
"regno",
"=",
"REGNO",
"(",
"src",
")",
";",
"if",
"(",
"!",
"IN_RANGE",
"(",
"regno",
",",
"GP_ARG_FIRST",
",",
"GP_ARG_LAST",
")",
"||",
"reg_values",
"[",
"regno",
"]",
")",
"return",
"false",
";",
"argno",
"=",
"regno",
"-",
"GP_ARG_FIRST",
";",
"addr",
"=",
"mips16e_collect_propagate_value",
"(",
"XEXP",
"(",
"dest",
",",
"<NUM_LIT>",
")",
",",
"reg_values",
")",
";",
"mips_split_plus",
"(",
"addr",
",",
"&",
"base",
",",
"&",
"offset",
")",
";",
"required_offset",
"=",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"total_size"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 4,009 | [
"return",
"std",
"::",
"make_pair",
"(",
"nullptr",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";"
] | [
"const",
"MachineOperand",
"*",
"Src0",
"=",
"TII",
"->",
"getNamedOperand",
"(",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src0",
")",
";",
"const",
"MachineOperand",
"*",
"Src1",
"=",
"TII",
"->",
"getNamedOperand",
"(",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src1",
")",
";",
"if",
"(",
"Src0",
"->",
"isReg",
"(",
")",
"&&",
"Src1",
"->",
"isReg",
"(",
")",
"&&",
"Src0",
"->",
"getReg",
"(",
")",
"==",
"Src1",
"->",
"getReg",
"(",
")",
"&&",
"Src0",
"->",
"getSubReg",
"(",
")",
"==",
"Src1",
"->",
"getSubReg",
"(",
")",
"&&",
"!",
"TII",
"->",
"hasModifiersSet",
"(",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src0_modifiers",
")",
"&&",
"!",
"TII",
"->",
"hasModifiersSet",
"(",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src1_modifiers",
")",
"&&",
"!",
"TII",
"->",
"hasModifiersSet",
"(",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"clamp",
")",
"&&",
"!",
"TII",
"->",
"hasModifiersSet",
"(",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"omod",
")",
")",
"return",
"std",
"::",
"make_pair",
"(",
"Src0",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"nullptr",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"}",
"default",
":"
] |
GCC | pa | CPP | program_repair | CPU | 4,010 | [
"<FIXS>",
"fprintf",
"(",
"file",
",",
"HOST_WIDE_INT_PRINT_DEC",
",",
"~",
"INTVAL",
"(",
"x",
")",
")",
";",
"<FIXE>",
"<FIXS>",
"fprintf",
"(",
"file",
",",
"HOST_WIDE_INT_PRINT_DEC",
",",
"<NUM_LIT>",
"-",
"(",
"INTVAL",
"(",
"x",
")",
"&",
"<NUM_LIT>",
")",
")",
";",
"<FIXE>",
"<FIXS>",
"fprintf",
"(",
"file",
",",
"HOST_WIDE_INT_PRINT_DEC",
",",
"<NUM_LIT>",
"-",
"(",
"INTVAL",
"(",
"x",
")",
"&",
"<NUM_LIT>",
")",
")",
";",
"<FIXE>"
] | [
"case",
"'",
"k",
"'",
":",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST_INT",
")",
"{",
"<BUGS>",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"%d",
"<STR_LIT>",
",",
"~",
"INTVAL",
"(",
"x",
")",
")",
";",
"<BUGE>",
"return",
";",
"}",
"abort",
"(",
")",
";",
"case",
"'",
"Q",
"'",
":",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST_INT",
")",
"{",
"<BUGS>",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"%d",
"<STR_LIT>",
",",
"<NUM_LIT>",
"-",
"(",
"INTVAL",
"(",
"x",
")",
"&",
"<NUM_LIT>",
")",
")",
";",
"<BUGE>",
"return",
";",
"}",
"abort",
"(",
")",
";",
"case",
"'",
"L",
"'",
":",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"CONST_INT",
")",
"{",
"<BUGS>",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"%d",
"<STR_LIT>",
",",
"<NUM_LIT>",
"-",
"(",
"INTVAL",
"(",
"x",
")",
"&",
"<NUM_LIT>",
")",
")",
";",
"<BUGE>",
"return",
";",
"}",
"abort",
"(",
")",
";"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 4,011 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"idx",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"idx",
";"
] |
LLVM | X86 | TD | program_repair | CPU | 4,012 | [
"<FIXS>",
"EVEX_V128",
",",
"TB",
",",
"EVEX_CD8",
"<NUM_LIT>",
",",
"CD8VF",
">",
";",
"<FIXE>",
"<FIXS>",
"EVEX_V256",
",",
"TB",
",",
"EVEX_CD8",
"<NUM_LIT>",
",",
"CD8VF",
">",
";",
"<FIXE>"
] | [
"let",
"Predicates",
"=",
"[",
"HasVLX",
"]",
"in",
"{",
"defm",
"PSZ128",
":",
"avx512_sqrt_packed",
"opc",
",",
"!",
"strconcat",
"(",
"OpcodeStr",
",",
"<STR_LIT>",
")",
",",
"sched",
".",
"PS",
".",
"XMM",
",",
"v4f32x_info",
">",
",",
"<BUGS>",
"EVEX_V128",
",",
"TB",
",",
"PS",
",",
"EVEX_CD8",
"<NUM_LIT>",
",",
"CD8VF",
">",
";",
"<BUGE>",
"defm",
"PSZ256",
":",
"avx512_sqrt_packed",
"opc",
",",
"!",
"strconcat",
"(",
"OpcodeStr",
",",
"<STR_LIT>",
")",
",",
"sched",
".",
"PS",
".",
"YMM",
",",
"v8f32x_info",
">",
",",
"<BUGS>",
"EVEX_V256",
",",
"TB",
",",
"PS",
",",
"EVEX_CD8",
"<NUM_LIT>",
",",
"CD8VF",
">",
";",
"<BUGE>",
"defm",
"PDZ128",
":",
"avx512_sqrt_packed",
"opc",
",",
"!",
"strconcat",
"(",
"OpcodeStr",
",",
"<STR_LIT>",
")",
",",
"sched",
".",
"PD",
".",
"XMM",
",",
"v2f64x_info",
">",
",",
"EVEX_V128",
",",
"REX_W",
",",
"TB",
",",
"PD",
",",
"EVEX_CD8",
"<NUM_LIT>",
",",
"CD8VF",
">",
";"
] |
GCC | rl78 | CPP | stmt_completion | MPU | 4,013 | [
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
";"
] | [
"int",
"rl78_saddr_p",
"(",
"rtx",
"x",
")",
"{",
"const",
"char",
"*",
"c",
";",
"if",
"(",
"MEM_P",
"(",
"x",
")",
")",
"x",
"=",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
")",
"x",
"="
] |
LLVM | X86 | CPP | stmt_completion | CPU | 4,014 | [
"isUndefOrEqual",
"(",
"Op",
"->",
"getMaskElt",
"(",
"i",
")",
",",
"i",
"+",
"<NUM_LIT>",
")",
")",
"return",
"false",
";"
] | [
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"<NUM_LIT>",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"if",
"(",
"!",
"isUndefOrEqual",
"(",
"Op",
"->",
"getMaskElt",
"(",
"i",
")",
",",
"i",
"+",
"<NUM_LIT>",
")",
")",
"return",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"!=",
"<NUM_LIT>",
";",
"++",
"i",
")",
"if",
"(",
"!"
] |
GCC | i386 | MD | program_repair | CPU | 4,015 | [
"<FIXS>",
"(",
"match_operand",
":",
"VI14_128",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<FIXE>"
] | [
"[",
"(",
"set",
"(",
"match_operand",
":",
"VI14_128",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"smaxmin",
":",
"VI14_128",
"(",
"match_operand",
":",
"VI14_128",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"<BUGS>",
"(",
"match_operand",
":",
"VI14_128",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<BUGE>",
"<STR_LIT>"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 4,016 | [
"(",
"TheX86_64Target",
")",
";"
] | [
"RegisterTargetMachine",
"<",
"X86TargetMachine",
">",
"X",
"(",
"TheX86_32Target",
")",
";",
"RegisterTargetMachine",
"<",
"X86TargetMachine",
">",
"Y"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 4,017 | [
"<STR_LIT>",
"}",
";"
] | [
"static",
"Register",
"createDTuple",
"(",
"ArrayRef",
"<",
"Register",
">",
"Regs",
",",
"MachineIRBuilder",
"&",
"MIB",
")",
"{",
"static",
"const",
"unsigned",
"RegClassIDs",
"[",
"]",
"=",
"{",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::"
] |
GCC | i386 | CPP | code_generation | CPU | 4,018 | [
"static",
"bool",
"expand_vec_perm_broadcast",
"(",
"struct",
"expand_vec_perm_d",
"*",
"d",
")",
"{",
"unsigned",
"i",
",",
"elt",
",",
"nelt",
"=",
"d",
"->",
"nelt",
";",
"if",
"(",
"!",
"d",
"->",
"one_operand_p",
")",
"return",
"false",
";",
"elt",
"=",
"d",
"->",
"perm",
"[",
"<NUM_LIT>",
"]",
";",
"for",
"(",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"nelt",
";",
"++",
"i",
")",
"if",
"(",
"d",
"->",
"perm",
"[",
"i",
"]",
"!=",
"elt",
")",
"return",
"false",
";",
"return",
"expand_vec_perm_broadcast_1",
"(",
"d",
")",
";",
"}"
] | [
"Pattern",
"match",
"broadcast",
"permutations",
"."
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 4,019 | [
"}"
] | [
"SDLoc",
"SL",
"(",
"Op",
")",
";",
"SDValue",
"Src",
"=",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"const",
"SDValue",
"K",
"=",
"getLog2EVal",
"(",
"DAG",
",",
"SL",
",",
"VT",
")",
";",
"SDValue",
"Mul",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"FMUL",
",",
"SL",
",",
"VT",
",",
"Src",
",",
"K",
",",
"Op",
"->",
"getFlags",
"(",
")",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"FEXP2",
",",
"SL",
",",
"VT",
",",
"Mul",
",",
"Op",
"->",
"getFlags",
"(",
")",
")",
";"
] |
LLVM | AVR | TD | program_repair | MPU | 4,020 | [
"<FIXS>",
"(",
"ins",
"LD8",
":",
"$",
"src",
",",
"imm_ldi8",
":",
"$",
"k",
")",
",",
"<FIXE>"
] | [
"def",
"SUBIRdK",
":",
"FRdK",
"<NUM_LIT>",
",",
"(",
"outs",
"LD8",
":",
"$",
"rd",
")",
",",
"<BUGS>",
"(",
"ins",
"LD8",
":",
"$",
"src",
",",
"i8imm",
":",
"$",
"k",
")",
",",
"<BUGE>",
"<STR_LIT>",
",",
"[",
"(",
"set",
"i8",
":",
"$",
"rd",
",",
"(",
"sub",
"i8",
":",
"$",
"src",
",",
"imm",
":",
"$",
"k",
")",
")",
",",
"(",
"implicit",
"SREG",
")",
"]",
">",
";"
] |
GCC | arm | CPP | code_generation | CPU | 4,021 | [
"static",
"rtx",
"arm_expand_builtin_1",
"(",
"int",
"fcode",
",",
"tree",
"exp",
",",
"rtx",
"target",
",",
"arm_builtin_datum",
"*",
"d",
")",
"{",
"enum",
"insn_code",
"icode",
"=",
"d",
"->",
"code",
";",
"builtin_arg",
"args",
"[",
"SIMD_MAX_BUILTIN_ARGS",
"+",
"<NUM_LIT>",
"]",
";",
"int",
"num_args",
"=",
"insn_data",
"[",
"d",
"->",
"code",
"]",
".",
"n_operands",
";",
"int",
"is_void",
"=",
"<NUM_LIT>",
";",
"int",
"k",
";",
"bool",
"neon",
"=",
"false",
";",
"if",
"(",
"IN_RANGE",
"(",
"fcode",
",",
"ARM_BUILTIN_VFP_BASE",
",",
"ARM_BUILTIN_ACLE_BASE",
"-",
"<NUM_LIT>",
")",
")",
"neon",
"=",
"true",
";",
"is_void",
"=",
"!",
"!",
"(",
"d",
"->",
"qualifiers",
"[",
"<NUM_LIT>",
"]",
"&",
"qualifier_void",
")",
";",
"num_args",
"+=",
"is_void",
";",
"for",
"(",
"k",
"=",
"<NUM_LIT>",
";",
"k",
"<",
"num_args",
";",
"k",
"++",
")",
"{",
"int",
"qualifiers_k",
"=",
"k",
";",
"int",
"operands_k",
"=",
"k",
"-",
"is_void",
";",
"int",
"expr_args_k",
"=",
"k",
"-",
"<NUM_LIT>",
";",
"if",
"(",
"d",
"->",
"qualifiers",
"[",
"qualifiers_k",
"]",
"&",
"qualifier_lane_index",
")",
"args",
"[",
"k",
"]",
"=",
"ARG_BUILTIN_LANE_INDEX",
";",
"else",
"if",
"(",
"d",
"->",
"qualifiers",
"[",
"qualifiers_k",
"]",
"&",
"qualifier_struct_load_store_lane_index",
")",
"args",
"[",
"k",
"]",
"=",
"ARG_BUILTIN_STRUCT_LOAD_STORE_LANE_INDEX",
";",
"else",
"if",
"(",
"d",
"->",
"qualifiers",
"[",
"qualifiers_k",
"]",
"&",
"qualifier_immediate",
")",
"args",
"[",
"k",
"]",
"=",
"ARG_BUILTIN_CONSTANT",
";",
"else",
"if",
"(",
"d",
"->",
"qualifiers",
"[",
"qualifiers_k",
"]",
"&",
"qualifier_maybe_immediate",
")",
"{",
"rtx",
"arg",
"=",
"expand_normal",
"(",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"(",
"expr_args_k",
")",
")",
")",
";",
"bool",
"op_const_int_p",
"=",
"(",
"CONST_INT_P",
"(",
"arg",
")",
"&&",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"operands_k",
"]",
".",
"predicate",
")",
"(",
"arg",
",",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"operands_k",
"]",
".",
"mode",
")",
")",
";",
"args",
"[",
"k",
"]",
"=",
"op_const_int_p",
"?",
"ARG_BUILTIN_CONSTANT",
":",
"ARG_BUILTIN_COPY_TO_REG",
";",
"}",
"else",
"if",
"(",
"d",
"->",
"qualifiers",
"[",
"qualifiers_k",
"]",
"&",
"qualifier_pointer",
")",
"{",
"if",
"(",
"neon",
")",
"args",
"[",
"k",
"]",
"=",
"ARG_BUILTIN_NEON_MEMORY",
";",
"else",
"args",
"[",
"k",
"]",
"=",
"ARG_BUILTIN_MEMORY",
";",
"}",
"else",
"args",
"[",
"k",
"]",
"=",
"ARG_BUILTIN_COPY_TO_REG",
";",
"}",
"args",
"[",
"k",
"]",
"=",
"ARG_BUILTIN_STOP",
";",
"return",
"arm_expand_builtin_args",
"(",
"target",
",",
"d",
"->",
"mode",
",",
"fcode",
",",
"icode",
",",
"!",
"is_void",
",",
"exp",
",",
"&",
"args",
"[",
"<NUM_LIT>",
"]",
")",
";",
"}"
] | [
"Expand",
"a",
"builtin",
".",
"These",
"builtins",
"are",
"``",
"special",
"''",
"because",
"they",
"do",
"n't",
"have",
"symbolic",
"constants",
"defined",
"per-instruction",
"or",
"per",
"instruction-variant",
".",
"Instead",
",",
"the",
"required",
"info",
"is",
"looked",
"up",
"in",
"the",
"ARM_BUILTIN_DATA",
"record",
"that",
"is",
"passed",
"into",
"the",
"function",
"."
] |
LLVM | PowerPC | CPP | program_repair | CPU | 4,022 | [
"<FIXS>",
"case",
"PPC",
"::",
"INSLWI_rec",
":",
"{",
"<FIXE>",
"<FIXS>",
"TmpInst",
".",
"setOpcode",
"(",
"Opcode",
"==",
"PPC",
"::",
"INSLWI",
"?",
"PPC",
"::",
"RLWIMI",
":",
"PPC",
"::",
"RLWIMI_rec",
")",
";",
"<FIXE>"
] | [
"break",
";",
"}",
"case",
"PPC",
"::",
"INSLWI",
":",
"<BUGS>",
"case",
"PPC",
"::",
"INSLWIo",
":",
"{",
"<BUGE>",
"MCInst",
"TmpInst",
";",
"int64_t",
"N",
"=",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
";",
"int64_t",
"B",
"=",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
";",
"<BUGS>",
"TmpInst",
".",
"setOpcode",
"(",
"Opcode",
"==",
"PPC",
"::",
"INSLWI",
"?",
"PPC",
"::",
"RLWIMI",
":",
"PPC",
"::",
"RLWIMIo",
")",
";",
"<BUGE>",
"TmpInst",
".",
"addOperand",
"(",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"TmpInst",
".",
"addOperand",
"(",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"TmpInst",
".",
"addOperand",
"(",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 4,023 | [
"let",
"Defs",
"=",
"[",
"P1",
",",
"PC",
"]",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedFalse",
"=",
"<NUM_LIT>",
";",
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";",
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"P1",
"]",
";"
] |
GCC | arm | MD | program_repair | CPU | 4,024 | [
"<FIXS>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<FIXE>"
] | [
"<STR_LIT>",
"movqi",
"<STR_LIT>",
"general_operand",
"<STR_LIT>",
"<STR_LIT>",
"general_operand",
"<STR_LIT>",
"<STR_LIT>",
"TARGET_EITHER",
"<STR_LIT>"
] |
GCC | bfin | CPP | code_generation | DSP | 4,025 | [
"void",
"asm_conditional_branch",
"(",
"rtx_insn",
"*",
"insn",
",",
"rtx",
"*",
"operands",
",",
"int",
"n_nops",
",",
"int",
"predict_taken",
")",
"{",
"int",
"offset",
"=",
"branch_dest",
"(",
"insn",
")",
"-",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"insn",
")",
")",
";",
"int",
"len",
"=",
"(",
"offset",
">=",
"-",
"<NUM_LIT>",
"&&",
"offset",
"<=",
"<NUM_LIT>",
"?",
"<NUM_LIT>",
":",
"offset",
">=",
"-",
"<NUM_LIT>",
"&&",
"offset",
"<=",
"<NUM_LIT>",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
")",
";",
"int",
"bp",
"=",
"predict_taken",
"&&",
"len",
"==",
"<NUM_LIT>",
"?",
"<NUM_LIT>",
":",
"cbranch_predicted_taken_p",
"(",
"insn",
")",
";",
"int",
"idx",
"=",
"(",
"bp",
"<<",
"<NUM_LIT>",
")",
"|",
"(",
"GET_CODE",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"==",
"EQ",
"?",
"BRF",
":",
"BRT",
")",
";",
"output_asm_insn",
"(",
"ccbranch_templates",
"[",
"idx",
"]",
"[",
"len",
"]",
",",
"operands",
")",
";",
"gcc_assert",
"(",
"n_nops",
"==",
"<NUM_LIT>",
"||",
"!",
"bp",
")",
";",
"if",
"(",
"len",
"==",
"<NUM_LIT>",
")",
"while",
"(",
"n_nops",
"--",
">",
"<NUM_LIT>",
")",
"output_asm_insn",
"(",
"<STR_LIT>",
"nop;",
"<STR_LIT>",
",",
"NULL",
")",
";",
"}"
] | [
"Output",
"INSN",
",",
"which",
"is",
"a",
"conditional",
"branch",
"instruction",
"with",
"operands",
"OPERANDS",
".",
"We",
"deal",
"with",
"the",
"various",
"forms",
"of",
"conditional",
"branches",
"that",
"can",
"be",
"generated",
"by",
"bfin_reorg",
"to",
"prevent",
"the",
"hardware",
"from",
"doing",
"speculative",
"loads",
",",
"by",
"-",
"emitting",
"a",
"sufficient",
"number",
"of",
"nops",
",",
"if",
"N_NOPS",
"is",
"nonzero",
",",
"or",
"-",
"always",
"emitting",
"the",
"branch",
"as",
"predicted",
"taken",
",",
"if",
"PREDICT_TAKEN",
"is",
"true",
".",
"Either",
"of",
"these",
"is",
"only",
"necessary",
"if",
"the",
"branch",
"is",
"short",
",",
"otherwise",
"the",
"template",
"we",
"use",
"ends",
"in",
"an",
"unconditional",
"jump",
"which",
"flushes",
"the",
"pipeline",
"anyway",
"."
] |
LLVM | CellSPU | CPP | stmt_completion | MPU | 4,026 | [
"(",
")",
";"
] | [
"return",
"(",
"(",
"<NUM_LIT>",
"<<",
"<NUM_LIT>",
")",
"-",
"<NUM_LIT>",
")",
"*",
"stackSlotSize"
] |
GCC | mcore | CPP | stmt_completion | MPU | 4,027 | [
"(",
"insn",
",",
"cond",
")",
")",
")",
"{"
] | [
"cond",
"=",
"(",
"cond",
"==",
"<NUM_LIT>",
")",
";",
"br_lab_num",
"=",
"CODE_LABEL_NUMBER",
"(",
"XEXP",
"(",
"XEXP",
"(",
"XEXP",
"(",
"br_pat",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
")",
";",
"}",
"for",
"(",
"insn",
"=",
"NEXT_INSN",
"(",
"first",
")",
";",
"insn",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"{",
"enum",
"rtx_code",
"code",
";",
"code",
"=",
"GET_CODE",
"(",
"insn",
")",
";",
"if",
"(",
"code",
"==",
"CODE_LABEL",
"&&",
"CODE_LABEL_NUMBER",
"(",
"insn",
")",
"==",
"br_lab_num",
")",
"break",
";",
"if",
"(",
"code",
"!=",
"BARRIER",
"&&",
"code",
"!=",
"NOTE",
"&&",
"!",
"is_cond_candidate",
"(",
"insn",
")",
")",
"return",
"NEXT_INSN",
"(",
"insn",
")",
";",
"if",
"(",
"code",
"==",
"JUMP_INSN",
"||",
"code",
"==",
"INSN",
")",
"{",
"blk_size",
"++",
";",
"end_blk_2_insn",
"=",
"insn",
";",
"}",
"}",
"if",
"(",
"!",
"insn",
")",
"return",
"insn",
";",
"if",
"(",
"optimize",
">",
"<NUM_LIT>",
"&&",
"blk_size",
">",
"<NUM_LIT>",
")",
"return",
"insn",
";",
"start_blk_3_lab",
"=",
"insn",
";",
"for",
"(",
"insn",
"=",
"NEXT_INSN",
"(",
"end_blk_1_br",
")",
";",
"insn",
"!=",
"start_blk_3_lab",
";",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
"{",
"rtx_insn",
"*",
"new",
"insn",
";",
"if",
"(",
"insn",
"->",
"delete",
"d",
"(",
")",
")",
"continue",
";",
"if",
"(",
"(",
"new",
"insn",
"=",
"emit_new_cond_insn"
] |
LLVM | SystemZ | CPP | next_suggestion | CPU | 4,028 | [
"}"
] | [
"for",
"(",
"int",
"I",
"=",
"MFFrame",
".",
"getObjectIndexBegin",
"(",
")",
";",
"I",
"!=",
"<NUM_LIT>",
";",
"++",
"I",
")",
"{",
"if",
"(",
"MFFrame",
".",
"getObjectOffset",
"(",
"I",
")",
">=",
"<NUM_LIT>",
")",
"{",
"int64_t",
"ObjOffset",
"=",
"MFFrame",
".",
"getObjectOffset",
"(",
"I",
")",
"+",
"MFFrame",
".",
"getObjectSize",
"(",
"I",
")",
";",
"LargestArgOffset",
"=",
"std",
"::",
"max",
"(",
"ObjOffset",
",",
"LargestArgOffset",
")",
";",
"}",
"}",
"uint64_t",
"MaxReach",
"=",
"(",
"StackSize",
"+",
"Regs",
".",
"getCallFrameSize",
"(",
")",
"+",
"Regs",
".",
"getStackPointerBias",
"(",
")",
"+",
"LargestArgOffset",
")",
";",
"if",
"(",
"!",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"MaxReach",
")",
")",
"{",
"RS",
"->",
"addScavengingFrameIndex",
"(",
"MFFrame",
".",
"CreateStackObject",
"(",
"<NUM_LIT>",
",",
"Align",
"(",
"<NUM_LIT>",
")",
",",
"false",
")",
")",
";",
"RS",
"->",
"addScavengingFrameIndex",
"(",
"MFFrame",
".",
"CreateStackObject",
"(",
"<NUM_LIT>",
",",
"Align",
"(",
"<NUM_LIT>",
")",
",",
"false",
")",
")",
";",
"}"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 4,029 | [
"::",
"aarch64_sve_dupq_lane",
":"
] | [
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SMIN",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_neon_umin",
":",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"UMIN",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_sunpkhi",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_sunpklo",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_uunpkhi",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_uunpklo",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_clasta_n",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_clastb_n",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_lasta",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_lastb",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_rev",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_tbl",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_trn1",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_trn2",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_uzp1",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_uzp2",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_zip1",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_zip2",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic",
"::",
"aarch64_sve_ptrue",
":",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"case",
"Intrinsic"
] |
LLVM | AArch64 | CPP | code_generation | CPU | 4,030 | [
"void",
"AArch64BranchFixup",
"::",
"verify",
"(",
")",
"{",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MBBI",
"=",
"MF",
"->",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
"->",
"end",
"(",
")",
";",
"MBBI",
"!=",
"E",
";",
"++",
"MBBI",
")",
"{",
"MachineBasicBlock",
"*",
"MBB",
"=",
"MBBI",
";",
"unsigned",
"MBBId",
"=",
"MBB",
"->",
"getNumber",
"(",
")",
";",
"assert",
"(",
"!",
"MBBId",
"||",
"BBInfo",
"[",
"MBBId",
"-",
"<NUM_LIT>",
"]",
".",
"postOffset",
"(",
")",
"<=",
"BBInfo",
"[",
"MBBId",
"]",
".",
"Offset",
")",
";",
"}",
"}"
] | [
"Check",
"if",
"this",
"register",
"bank",
"is",
"valid",
"."
] |
LLVM | MBlaze | CPP | next_suggestion | MPU | 4,031 | [
"}"
] | [
"if",
"(",
"!",
"Reg",
")",
"return",
"false",
";",
"unsigned",
"SizeInBytes",
"=",
"ValVT",
".",
"getSizeInBits",
"(",
")",
">>",
"<NUM_LIT>",
";",
"State",
".",
"AllocateStack",
"(",
"SizeInBytes",
",",
"SizeInBytes",
")",
";",
"State",
".",
"addLoc",
"(",
"CCValAssign",
"::",
"getReg",
"(",
"ValNo",
",",
"ValVT",
",",
"Reg",
",",
"LocVT",
",",
"LocInfo",
")",
")",
";",
"return",
"true",
";"
] |
GCC | avr | MD | next_suggestion | MPU | 4,032 | [
"(",
"plus",
":",
"QI",
"(",
"lt",
":",
"QI",
"(",
"match_dup",
"<NUM_LIT>",
")"
] | [
"(",
"define_insn_and_split",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"plus",
":",
"QI",
"(",
"lt",
":",
"QI",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"parallel",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")"
] |
GCC | rs6000 | MD | next_suggestion | CPU | 4,033 | [
"<STR_LIT>",
")"
] | [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
] |
LLVM | Mips | CPP | stmt_completion | CPU | 4,034 | [
"raw_ostream",
"&",
"O",
")",
";"
] | [
"const",
"MipsSubtarget",
"*",
"Subtarget",
";",
"const",
"MipsFunctionInfo",
"*",
"MipsFI",
";",
"MipsMCInstLower",
"MCInstLowering",
";",
"explicit",
"MipsAsmPrinter",
"(",
"TargetMachine",
"&",
"TM",
",",
"MCStreamer",
"&",
"Streamer",
")",
":",
"AsmPrinter",
"(",
"TM",
",",
"Streamer",
")",
",",
"MCP",
"(",
"<NUM_LIT>",
")",
",",
"InConstantPool",
"(",
"false",
")",
",",
"MCInstLowering",
"(",
"*",
"this",
")",
"{",
"Subtarget",
"=",
"&",
"TM",
".",
"getSubtarget",
"<",
"MipsSubtarget",
">",
"(",
")",
";",
"UsingConstantPools",
"=",
"(",
"Subtarget",
"->",
"inMips16Mode",
"(",
")",
"&&",
"Subtarget",
"->",
"useConstantIslands",
"(",
")",
")",
";",
"}",
"virtual",
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"<STR_LIT>",
"Mips Assembly Printer",
"<STR_LIT>",
";",
"}",
"virtual",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
";",
"virtual",
"void",
"EmitConstantPool",
"(",
")",
"LLVM_OVERRIDE",
"{",
"if",
"(",
"!",
"UsingConstantPools",
")",
"AsmPrinter",
"::",
"EmitConstantPool",
"(",
")",
";",
"}",
"void",
"EmitInstruction",
"(",
"const",
"MachineInstr",
"*",
"MI",
")",
";",
"void",
"printSavedRegsBitmask",
"(",
"raw_ostream",
"&",
"O",
")",
";",
"void",
"printHex32",
"(",
"unsigned",
"int",
"Value",
",",
"raw_ostream",
"&",
"O",
")",
";",
"void",
"emitFrameDirective",
"(",
")",
";",
"const",
"char",
"*",
"getCurrentABIString",
"(",
")",
"const",
";",
"virtual",
"void",
"EmitFunctionEntryLabel",
"(",
")",
";",
"virtual",
"void",
"EmitFunctionBodyStart",
"(",
")",
";",
"virtual",
"void",
"EmitFunctionBodyEnd",
"(",
")",
";",
"virtual",
"bool",
"isBlockOnlyReachableByFallthrough",
"(",
"const",
"MachineBasicBlock",
"*",
"MBB",
")",
"const",
";",
"bool",
"PrintAsmOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"O",
")",
";",
"bool",
"PrintAsmMemoryOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNum",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
",",
"raw_ostream",
"&",
"O",
")",
";",
"void",
"printOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"opNum",
",",
"raw_ostream",
"&",
"O",
")",
";",
"void",
"printUnsignedImm",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"opNum",
",",
"raw_ostream",
"&",
"O",
")",
";",
"void",
"printMemOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"opNum",
","
] |
LLVM | SystemZ | TD | next_suggestion | CPU | 4,035 | [
"bits",
"<",
"<NUM_LIT>",
">",
"BD2",
";"
] | [
"field",
"bits",
"<",
"<NUM_LIT>",
">",
"Inst",
";",
"field",
"bits",
"<",
"<NUM_LIT>",
">",
"SoftFail",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"R1",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"M3",
";"
] |
GCC | h8300 | MD | stmt_completion | MPU | 4,036 | [
")",
")",
")",
")",
")"
] | [
"(",
"udiv",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"zero_extend",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"truncate",
":",
"HI",
"(",
"umod",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"zero_extend",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>"
] |
LLVM | PowerPC | CPP | stmt_completion | CPU | 4,037 | [
"nullopt",
")",
"==",
"PPC",
"::",
"AM_PrefixDForm",
";"
] | [
"return",
"PPCLowering",
"->",
"SelectOptimalAddrMode",
"(",
"Parent",
",",
"N",
",",
"Disp",
",",
"Base",
",",
"*",
"CurDAG",
",",
"std",
"::"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 4,038 | [
"if",
"(",
"Subtarget",
"->",
"isTargetELF",
"(",
")",
")",
"return",
"new",
"TargetLoweringObjectFileELF",
"(",
")",
";"
] | [
"if",
"(",
"Subtarget",
"->",
"isTargetEnvMacho",
"(",
")",
")",
"{",
"if",
"(",
"is64Bit",
")",
"return",
"new",
"X86_64MachoTargetObjectFile",
"(",
")",
";",
"return",
"new",
"TargetLoweringObjectFileMachO",
"(",
")",
";",
"}",
"if",
"(",
"Subtarget",
"->",
"isTargetLinux",
"(",
")",
")",
"return",
"new",
"X86LinuxTargetObjectFile",
"(",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isTargetNaCl",
"(",
")",
")",
"return",
"new",
"TargetLoweringObjectFileNaCl",
"(",
")",
";"
] |
GCC | rs6000 | CPP | stmt_completion | CPU | 4,039 | [
")",
"_",
"_",
"X",
"*",
"_",
"_",
"Y",
";"
] | [
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mulx_u32",
"(",
"unsigned",
"int",
"_",
"_",
"X",
",",
"unsigned",
"int",
"_",
"_",
"Y",
",",
"unsigned",
"int",
"*",
"_",
"_",
"P",
")",
"{",
"unsigned",
"long",
"long",
"_",
"_",
"res",
"=",
"(",
"unsigned",
"long",
"long"
] |
GCC | m32r | MD | stmt_completion | MPU | 4,040 | [
")",
")"
] | [
"(",
"and",
"(",
"match_code",
"<STR_LIT>",
")",
"(",
"match_test",
"<STR_LIT>",
")"
] |
GCC | i386 | CPP | stmt_completion | CPU | 4,041 | [
"v8si",
")",
"_",
"_",
"B",
")",
";"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m256i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm256_packus_epi32",
"(",
"_",
"_",
"m256i",
"_",
"_",
"A",
",",
"_",
"_",
"m256i",
"_",
"_",
"B",
")",
"{",
"return",
"(",
"_",
"_",
"m256i",
")",
"_",
"_",
"builtin_ia32_packusdw256",
"(",
"(",
"_",
"_",
"v8si",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_"
] |
LLVM | Hexagon | CPP | next_suggestion | DSP | 4,042 | [
"removeDeadCode",
"(",
")",
";"
] | [
"PDT",
"=",
"&",
"getAnalysis",
"<",
"PostDominatorTreeWrapperPass",
">",
"(",
")",
".",
"getPostDomTree",
"(",
")",
";",
"LI",
"=",
"&",
"getAnalysis",
"<",
"LoopInfoWrapperPass",
">",
"(",
")",
".",
"getLoopInfo",
"(",
")",
";",
"Ctx",
"=",
"&",
"F",
".",
"getContext",
"(",
")",
";",
"Nodes",
".",
"clear",
"(",
")",
";",
"Uses",
".",
"clear",
"(",
")",
";",
"NodeOrder",
".",
"clear",
"(",
")",
";",
"SpecificBumpPtrAllocator",
"<",
"GepNode",
">",
"Allocator",
";",
"Mem",
"=",
"&",
"Allocator",
";",
"collect",
"(",
")",
";",
"common",
"(",
")",
";",
"NodeToValueMap",
"Loc",
";",
"computeNodePlacement",
"(",
"Loc",
")",
";",
"materialize",
"(",
"Loc",
")",
";"
] |
LLVM | ARM | TD | program_repair | CPU | 4,043 | [
"<FIXS>",
"ComplexPattern",
"i32",
",",
"<NUM_LIT>",
",",
"<STR_LIT>",
",",
"[",
"]",
",",
"[",
"SDNPWantRoot",
"]",
">",
"{",
"<FIXE>"
] | [
"}",
"def",
"am3offset",
":",
"Operand",
"i32",
">",
",",
"<BUGS>",
"ComplexPattern",
"i32",
",",
"<NUM_LIT>",
",",
"<STR_LIT>",
",",
"[",
"]",
">",
"{",
"<BUGE>",
"let",
"PrintMethod",
"=",
"<STR_LIT>",
";",
"let",
"MIOperandInfo",
"=",
"(",
"ops",
"GPR",
",",
"i32imm",
")",
";",
"}"
] |
GCC | i386 | MD | stmt_completion | CPU | 4,044 | [
"<NUM_LIT>",
")",
"<",
"<",
"<NUM_LIT>"
] | [
"(",
"parallel",
"[",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"]",
")",
")",
")",
"]",
"<STR_LIT>",
"{",
"int",
"mask",
"mask",
"=",
"INTVAL",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"mask",
"|",
"=",
"(",
"INTVAL",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"-"
] |
GCC | arm | CPP | stmt_completion | CPU | 4,045 | [
"_",
"_",
"p",
")",
";"
] | [
"_",
"_",
"arm_vstrhq_scatter_offset_p_u16",
"(",
"uint16_t",
"*",
"_",
"_",
"base",
",",
"uint16x8_t",
"_",
"_",
"offset",
",",
"uint16x8_t",
"_",
"_",
"value",
",",
"mve_pred16_t",
"_",
"_",
"p",
")",
"{",
"_",
"_",
"builtin_mve_vstrhq_scatter_offset_p_uv8hi",
"(",
"(",
"_",
"_",
"builtin_neon_hi",
"*",
")",
"_",
"_",
"base",
",",
"_",
"_",
"offset",
",",
"_",
"_",
"value",
","
] |
LLVM | ARM64 | TD | next_suggestion | CPU | 4,046 | [
"let",
"ParserMatchClass",
"=",
"MemoryIndexed64SImm7",
";"
] | [
"def",
"am_indexed64simm7",
":",
"Operand",
"<",
"i32",
">",
"{",
"let",
"PrintMethod",
"=",
"<STR_LIT>",
";"
] |
LLVM | Mips | CPP | stmt_completion | CPU | 4,047 | [
"<STR_LIT>",
"Invalid rule identifier",
"<STR_LIT>",
")",
";"
] | [
"MipsPostLegalizerCombiner",
"::",
"MipsPostLegalizerCombiner",
"(",
"bool",
"IsOptNone",
")",
":",
"MachineFunctionPass",
"(",
"ID",
")",
",",
"IsOptNone",
"(",
"IsOptNone",
")",
"{",
"initializeMipsPostLegalizerCombinerPass",
"(",
"*",
"PassRegistry",
"::",
"getPassRegistry",
"(",
")",
")",
";",
"if",
"(",
"!",
"RuleConfig",
".",
"parseCommandLineOption",
"(",
")",
")",
"report_fatal_error",
"("
] |
GCC | i386 | CPP | stmt_completion | CPU | 4,048 | [
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_cvttps_epi32",
"(",
"_",
"_",
"m128",
"_",
"_",
"A",
")",
"{"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m128i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__"
] |
LLVM | ARM | CPP | code_generation | CPU | 4,049 | [
"BitVector",
"ARMBaseRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"const",
"ARMSubtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"const",
"ARMFrameLowering",
"*",
"TFI",
"=",
"getFrameLowering",
"(",
"MF",
")",
";",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"SP",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"PC",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"FPSCR",
")",
";",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"APSR_NZCV",
")",
";",
"if",
"(",
"TFI",
"->",
"hasFP",
"(",
"MF",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"getFramePointerReg",
"(",
"STI",
")",
")",
";",
"if",
"(",
"hasBasePointer",
"(",
"MF",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"BasePtr",
")",
";",
"if",
"(",
"STI",
".",
"isR9Reserved",
"(",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"R9",
")",
";",
"if",
"(",
"MF",
".",
"getFunction",
"(",
")",
".",
"isPagerando",
"(",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"R9",
")",
";",
"if",
"(",
"!",
"STI",
".",
"hasVFP3",
"(",
")",
"||",
"STI",
".",
"hasD16",
"(",
")",
")",
"{",
"static_assert",
"(",
"ARM",
"::",
"D31",
"==",
"ARM",
"::",
"D16",
"+",
"<NUM_LIT>",
",",
"<STR_LIT>",
"Register list not consecutive!",
"<STR_LIT>",
")",
";",
"for",
"(",
"unsigned",
"R",
"=",
"<NUM_LIT>",
";",
"R",
"<",
"<NUM_LIT>",
";",
"++",
"R",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"ARM",
"::",
"D16",
"+",
"R",
")",
";",
"}",
"const",
"TargetRegisterClass",
"&",
"RC",
"=",
"ARM",
"::",
"GPRPairRegClass",
";",
"for",
"(",
"unsigned",
"Reg",
":",
"RC",
")",
"for",
"(",
"MCSubRegIterator",
"SI",
"(",
"Reg",
",",
"this",
")",
";",
"SI",
".",
"isValid",
"(",
")",
";",
"++",
"SI",
")",
"if",
"(",
"Reserved",
".",
"test",
"(",
"*",
"SI",
")",
")",
"markSuperRegs",
"(",
"Reserved",
",",
"Reg",
")",
";",
"assert",
"(",
"checkAllSuperRegsMarked",
"(",
"Reserved",
")",
")",
";",
"return",
"Reserved",
";",
"}"
] | [
"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",
"."
] |
GCC | m68k | CPP | code_generation | MPU | 4,050 | [
"poly_int64",
"m68k_push_rounding",
"(",
"poly_int64",
"bytes",
")",
"{",
"if",
"(",
"TARGET_COLDFIRE",
")",
"return",
"bytes",
";",
"return",
"(",
"bytes",
"+",
"<NUM_LIT>",
")",
"&",
"~",
"<NUM_LIT>",
";",
"}"
] | [
"Implement",
"PUSH_ROUNDING",
".",
"On",
"the",
"680x0",
",",
"sp",
"@",
"-",
"in",
"a",
"byte",
"insn",
"really",
"pushes",
"a",
"word",
".",
"On",
"the",
"ColdFire",
",",
"sp",
"@",
"-",
"in",
"a",
"byte",
"insn",
"pushes",
"just",
"a",
"byte",
"."
] |
LLVM | X86 | CPP | next_suggestion | CPU | 4,051 | [
"case",
"X86",
"::",
"reloc_global_offset_table",
":"
] | [
"Modifier",
"=",
"MCSymbolRefExpr",
"::",
"VK_GOT",
";",
"IsPCRel",
"=",
"true",
";",
"return",
"RT64_64",
";",
"case",
"FK_Data_8",
":",
"return",
"RT64_64",
";",
"case",
"X86",
"::",
"reloc_signed_4byte",
":",
"if",
"(",
"Modifier",
"==",
"MCSymbolRefExpr",
"::",
"VK_None",
"&&",
"!",
"IsPCRel",
")",
"return",
"RT64_32S",
";",
"return",
"RT64_32",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 4,052 | [
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"hasNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";"
] |
LLVM | ARM64 | TD | next_suggestion | CPU | 4,053 | [
"let",
"DecoderMethod",
"=",
"<STR_LIT>",
";"
] | [
"def",
"vecshiftR32Narrow",
":",
"Operand",
"<",
"i32",
">",
",",
"ImmLeaf",
"<",
"i32",
",",
"[",
"{",
"return",
"(",
"(",
"(",
"uint32_t",
")",
"Imm",
")",
">",
"<NUM_LIT>",
")",
"&",
"&",
"(",
"(",
"(",
"uint32_t",
")",
"Imm",
")",
"<",
"<NUM_LIT>",
")",
";",
"}",
"]",
">",
"{",
"let",
"EncoderMethod",
"=",
"<STR_LIT>",
";"
] |
GCC | s390 | CPP | next_suggestion | MPU | 4,054 | [
"return",
"true",
";"
] | [
"static",
"bool",
"s390_function_ok_for_sibcall",
"(",
"tree",
"decl",
",",
"tree",
"exp",
")",
"{",
"if",
"(",
"TARGET_TPF_PROFILING",
")",
"return",
"false",
";",
"if",
"(",
"!",
"TARGET_64BIT",
"&&",
"flag_pic",
"&&",
"decl",
"&&",
"TREE_PUBLIC",
"(",
"decl",
")",
")",
"return",
"false",
";",
"if",
"(",
"TREE_OPERAND",
"(",
"exp",
",",
"<NUM_LIT>",
")",
"&&",
"s390_call_saved_register_used",
"(",
"TREE_OPERAND",
"(",
"exp",
",",
"<NUM_LIT>",
")",
")",
")",
"return",
"false",
";"
] |
LLVM | RV16K | CPP | program_repair | Virtual ISA | 4,055 | [
"<FIXS>",
"case",
"AsmToken",
"::",
"Identifier",
":",
"{",
"StringRef",
"Identifier",
";",
"if",
"(",
"getParser",
"(",
")",
".",
"parseIdentifier",
"(",
"Identifier",
")",
")",
"return",
"MatchOperand_ParseFail",
";",
"MCSymbol",
"*",
"Sym",
"=",
"getContext",
"(",
")",
".",
"getOrCreateSymbol",
"(",
"Identifier",
")",
";",
"Res",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"Sym",
",",
"MCSymbolRefExpr",
"::",
"VK_None",
",",
"getContext",
"(",
")",
")",
";",
"break",
";",
"}",
"}",
"<FIXE>",
"<FIXS>",
"Operands",
".",
"push_back",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"Res",
",",
"S",
",",
"E",
")",
")",
";",
"<FIXE>"
] | [
"}",
"OperandMatchResultTy",
"RV16KAsmParser",
"::",
"parseImmediate",
"(",
"OperandVector",
"&",
"Operands",
")",
"{",
"switch",
"(",
"getLexer",
"(",
")",
".",
"getKind",
"(",
")",
")",
"{",
"default",
":",
"return",
"MatchOperand_NoMatch",
";",
"case",
"AsmToken",
"::",
"LParen",
":",
"case",
"AsmToken",
"::",
"Minus",
":",
"case",
"AsmToken",
"::",
"Plus",
":",
"case",
"AsmToken",
"::",
"Integer",
":",
"case",
"AsmToken",
"::",
"String",
":",
"break",
";",
"<BUGS>",
"}",
"const",
"MCExpr",
"*",
"IdVal",
";",
"SMLoc",
"S",
"=",
"getLoc",
"(",
")",
";",
"if",
"(",
"getParser",
"(",
")",
".",
"parseExpression",
"(",
"IdVal",
")",
")",
"return",
"MatchOperand_ParseFail",
";",
"<BUGE>",
"<BUGS>",
"SMLoc",
"E",
"=",
"SMLoc",
"::",
"getFromPointer",
"(",
"S",
".",
"getPointer",
"(",
")",
"-",
"<NUM_LIT>",
")",
";",
"Operands",
".",
"push_back",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"IdVal",
",",
"S",
",",
"E",
")",
")",
";",
"<BUGE>",
"return",
"MatchOperand_Success",
";",
"}"
] |
LLVM | ARM64 | TD | next_suggestion | CPU | 4,056 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"base",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"offset",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"extend",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"sz",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"V",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opc",
";"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 4,057 | [
"return",
"AMDGPU",
"::",
"S_CMP_NLG_F16",
";"
] | [
"}",
"}",
"if",
"(",
"Size",
"==",
"<NUM_LIT>",
")",
"{",
"switch",
"(",
"P",
")",
"{",
"case",
"CmpInst",
"::",
"ICMP_NE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_LG_U32",
";",
"case",
"CmpInst",
"::",
"ICMP_EQ",
":",
"return",
"AMDGPU",
"::",
"S_CMP_EQ_U32",
";",
"case",
"CmpInst",
"::",
"ICMP_SGT",
":",
"return",
"AMDGPU",
"::",
"S_CMP_GT_I32",
";",
"case",
"CmpInst",
"::",
"ICMP_SGE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_GE_I32",
";",
"case",
"CmpInst",
"::",
"ICMP_SLT",
":",
"return",
"AMDGPU",
"::",
"S_CMP_LT_I32",
";",
"case",
"CmpInst",
"::",
"ICMP_SLE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_LE_I32",
";",
"case",
"CmpInst",
"::",
"ICMP_UGT",
":",
"return",
"AMDGPU",
"::",
"S_CMP_GT_U32",
";",
"case",
"CmpInst",
"::",
"ICMP_UGE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_GE_U32",
";",
"case",
"CmpInst",
"::",
"ICMP_ULT",
":",
"return",
"AMDGPU",
"::",
"S_CMP_LT_U32",
";",
"case",
"CmpInst",
"::",
"ICMP_ULE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_LE_U32",
";",
"case",
"CmpInst",
"::",
"FCMP_OEQ",
":",
"return",
"AMDGPU",
"::",
"S_CMP_EQ_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_OGT",
":",
"return",
"AMDGPU",
"::",
"S_CMP_GT_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_OGE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_GE_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_OLT",
":",
"return",
"AMDGPU",
"::",
"S_CMP_LT_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_OLE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_LE_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_ONE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_LG_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_ORD",
":",
"return",
"AMDGPU",
"::",
"S_CMP_O_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_UNO",
":",
"return",
"AMDGPU",
"::",
"S_CMP_U_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_UEQ",
":",
"return",
"AMDGPU",
"::",
"S_CMP_NLG_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_UGT",
":",
"return",
"AMDGPU",
"::",
"S_CMP_NLE_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_UGE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_NLT_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_ULT",
":",
"return",
"AMDGPU",
"::",
"S_CMP_NGE_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_ULE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_NGT_F32",
";",
"case",
"CmpInst",
"::",
"FCMP_UNE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_NEQ_F32",
";",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unknown condition code!",
"<STR_LIT>",
")",
";",
"}",
"}",
"if",
"(",
"Size",
"==",
"<NUM_LIT>",
")",
"{",
"if",
"(",
"!",
"STI",
".",
"hasSALUFloatInsts",
"(",
")",
")",
"return",
"-",
"<NUM_LIT>",
";",
"switch",
"(",
"P",
")",
"{",
"case",
"CmpInst",
"::",
"FCMP_OEQ",
":",
"return",
"AMDGPU",
"::",
"S_CMP_EQ_F16",
";",
"case",
"CmpInst",
"::",
"FCMP_OGT",
":",
"return",
"AMDGPU",
"::",
"S_CMP_GT_F16",
";",
"case",
"CmpInst",
"::",
"FCMP_OGE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_GE_F16",
";",
"case",
"CmpInst",
"::",
"FCMP_OLT",
":",
"return",
"AMDGPU",
"::",
"S_CMP_LT_F16",
";",
"case",
"CmpInst",
"::",
"FCMP_OLE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_LE_F16",
";",
"case",
"CmpInst",
"::",
"FCMP_ONE",
":",
"return",
"AMDGPU",
"::",
"S_CMP_LG_F16",
";",
"case",
"CmpInst",
"::",
"FCMP_ORD",
":",
"return",
"AMDGPU",
"::",
"S_CMP_O_F16",
";",
"case",
"CmpInst",
"::",
"FCMP_UNO",
":",
"return",
"AMDGPU",
"::",
"S_CMP_U_F16",
";",
"case",
"CmpInst",
"::",
"FCMP_UEQ",
":"
] |
LLVM | ARM | CPP | program_repair | CPU | 4,058 | [
"<FIXS>",
"getRegisterEnum",
"(",
"B",
",",
"RegClass",
",",
"decodeVFPRd",
"(",
"insn",
",",
"isSP",
")",
")",
")",
")",
";",
"+",
"OpIdx",
";",
"<FIXE>"
] | [
"bool",
"isSP",
"=",
"(",
"RegClass",
"==",
"ARM",
"::",
"SPRRegClassID",
")",
";",
"MI",
".",
"addOperand",
"(",
"MCOperand",
"::",
"CreateReg",
"(",
"<BUGS>",
"getRegisterEnum",
"(",
"RegClass",
",",
"decodeVFPRd",
"(",
"insn",
",",
"isSP",
")",
")",
")",
")",
";",
"<BUGE>"
] |
LLVM | Lanai | CPP | stmt_completion | CPU | 4,059 | [
";",
"++",
"i",
")",
"{"
] | [
"unsigned",
"Idx",
"=",
"(",
"FullSize",
"-",
"<NUM_LIT>",
"-",
"i",
")",
";",
"CurVal",
"|=",
"static_cast",
"<",
"uint64_t",
">",
"(",
"static_cast",
"<",
"uint8_t",
">",
"(",
"Data",
"[",
"Offset",
"+",
"Idx",
"]",
")",
")",
"<<",
"(",
"i",
"*",
"<NUM_LIT>",
")",
";",
"}",
"uint64_t",
"Mask",
"=",
"(",
"static_cast",
"<",
"uint64_t",
">",
"(",
"-",
"<NUM_LIT>",
")",
">>",
"(",
"<NUM_LIT>",
"-",
"getFixupKindInfo",
"(",
"Kind",
")",
".",
"TargetSize",
")",
")",
";",
"CurVal",
"|=",
"Value",
"&",
"Mask",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"!=",
"NumBytes"
] |
LLVM | Hexagon | CPP | stmt_completion | DSP | 4,060 | [
"=",
"true",
";"
] | [
"auto",
"&",
"HMFI",
"=",
"*",
"MF",
".",
"getInfo",
"<",
"HexagonMachineFunctionInfo",
">",
"(",
")",
";",
"unsigned",
"FrameSize",
"=",
"MFI",
".",
"getStackSize",
"(",
")",
";",
"Register",
"SP",
"=",
"HRI",
".",
"getStackRegister",
"(",
")",
";",
"Register",
"FP",
"=",
"HRI",
".",
"getFrameRegister",
"(",
")",
";",
"Register",
"AP",
"=",
"HMFI",
".",
"getStackAlignBasePhysReg",
"(",
")",
";",
"if",
"(",
"AP",
"==",
"<NUM_LIT>",
")",
"AP",
"=",
"FP",
";",
"bool",
"UseFP",
"=",
"false",
",",
"UseAP",
"=",
"false",
";",
"if",
"(",
"NoOpt",
"&&",
"!",
"HasExtraAlign",
")",
"UseFP",
"=",
"true",
";",
"if",
"(",
"MFI",
".",
"isFixedObjectIndex",
"(",
"FI",
")",
"||",
"MFI",
".",
"isObjectPreAllocated",
"(",
"FI",
")",
")",
"{",
"UseFP",
"|=",
"(",
"HasAlloca",
"||",
"HasExtraAlign",
")",
";",
"}",
"else",
"{",
"if",
"(",
"HasAlloca",
")",
"{",
"if",
"(",
"HasExtraAlign",
")",
"UseAP"
] |
GCC | i386 | CPP | code_generation | CPU | 4,061 | [
"static",
"bool",
"dimode_scalar_to_vector_candidate_p",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"rtx",
"def_set",
"=",
"single_set",
"(",
"insn",
")",
";",
"if",
"(",
"!",
"def_set",
")",
"return",
"false",
";",
"if",
"(",
"has_non_address_hard_reg",
"(",
"insn",
")",
")",
"return",
"false",
";",
"rtx",
"src",
"=",
"SET_SRC",
"(",
"def_set",
")",
";",
"rtx",
"dst",
"=",
"SET_DEST",
"(",
"def_set",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"COMPARE",
")",
"return",
"convertible_comparison_p",
"(",
"insn",
")",
";",
"if",
"(",
"(",
"GET_MODE",
"(",
"src",
")",
"!=",
"DImode",
"&&",
"!",
"CONST_INT_P",
"(",
"src",
")",
")",
"||",
"GET_MODE",
"(",
"dst",
")",
"!=",
"DImode",
")",
"return",
"false",
";",
"if",
"(",
"!",
"REG_P",
"(",
"dst",
")",
"&&",
"!",
"MEM_P",
"(",
"dst",
")",
")",
"return",
"false",
";",
"switch",
"(",
"GET_CODE",
"(",
"src",
")",
")",
"{",
"case",
"ASHIFT",
":",
"case",
"LSHIFTRT",
":",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
"||",
"!",
"IN_RANGE",
"(",
"INTVAL",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
"return",
"false",
";",
"break",
";",
"case",
"PLUS",
":",
"case",
"MINUS",
":",
"case",
"IOR",
":",
"case",
"XOR",
":",
"case",
"AND",
":",
"if",
"(",
"!",
"REG_P",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
"&&",
"!",
"MEM_P",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
"&&",
"!",
"CONST_INT_P",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
")",
"return",
"false",
";",
"break",
";",
"case",
"NEG",
":",
"case",
"NOT",
":",
"break",
";",
"case",
"REG",
":",
"return",
"true",
";",
"case",
"MEM",
":",
"case",
"CONST_INT",
":",
"return",
"REG_P",
"(",
"dst",
")",
";",
"default",
":",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"REG_P",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
"&&",
"!",
"MEM_P",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
"&&",
"!",
"CONST_INT_P",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
"&&",
"(",
"GET_CODE",
"(",
"src",
")",
"!=",
"AND",
"||",
"GET_CODE",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
"!=",
"NOT",
"||",
"!",
"REG_P",
"(",
"XEXP",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"(",
"GET_MODE",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
"!=",
"DImode",
"&&",
"!",
"CONST_INT_P",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
")",
"||",
"(",
"GET_CODE",
"(",
"src",
")",
"!=",
"NEG",
"&&",
"GET_CODE",
"(",
"src",
")",
"!=",
"NOT",
"&&",
"GET_MODE",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
"!=",
"DImode",
"&&",
"!",
"CONST_INT_P",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
")",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}"
] | [
"The",
"DImode",
"version",
"of",
"scalar_to_vector_candidate_p",
"."
] |
GCC | mips | MD | stmt_completion | CPU | 4,062 | [
"]",
")"
] | [
"(",
"define_mode_iterator",
"VH",
"[",
"V4HI"
] |
LLVM | TPC | CPP | stmt_completion | Virtual ISA | 4,063 | [
"X",
";"
] | [
"Format",
"="
] |
LLVM | Hexagon | TD | program_repair | DSP | 4,064 | [
"<FIXS>",
"let",
"isFP",
"=",
"<NUM_LIT>",
",",
"hasNewValue",
"=",
"<NUM_LIT>",
"in",
"<FIXE>"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rdd",
";",
"}",
"<BUGS>",
"let",
"Uses",
"=",
"[",
"USR",
"]",
",",
"isFP",
"=",
"<NUM_LIT>",
",",
"hasNewValue",
"=",
"<NUM_LIT>",
"in",
"<BUGE>",
"class",
"F2_RD_RSS_CONVERT",
"string",
"mnemonic",
",",
"bits",
"<NUM_LIT>",
">",
"MinOp",
",",
"SDNode",
"Op",
",",
"PatLeaf",
"RCOut",
",",
"PatLeaf",
"RCIn",
",",
"string",
"chop",
"=",
"<STR_LIT>",
">"
] |
GCC | arm | MD | next_suggestion | CPU | 4,065 | [
")"
] | [
"(",
"match_operand",
":",
"VDQX",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]"
] |
GCC | arm | CPP | program_repair | CPU | 4,066 | [
"<FIXS>",
"gcc_unreachable",
"(",
")",
";",
"<FIXE>",
"<FIXS>",
"gcc_unreachable",
"(",
")",
";",
"<FIXE>"
] | [
"return",
"<NUM_LIT>",
";",
"default",
":",
"<BUGS>",
"break",
";",
"<BUGE>",
"}",
"<BUGS>",
"abort",
"(",
")",
";",
"<BUGE>",
"case",
"CONST_INT",
":",
"if",
"(",
"const_ok_for_arm",
"(",
"INTVAL",
"(",
"x",
")",
")",
")"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 4,067 | [
"}"
] | [
"bool",
"X86",
"::",
"isZeroNode",
"(",
"SDValue",
"Elt",
")",
"{",
"return",
"isNullConstant",
"(",
"Elt",
")",
"||",
"isNullFPConstant",
"(",
"Elt",
")",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 4,068 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] | [
"def",
"A4_vcmpbeq_any",
":",
"HInst",
"<",
"(",
"outs",
"PredRegs",
":",
"$",
"Pd4",
")",
",",
"(",
"ins",
"DoubleRegs",
":",
"$",
"Rss32",
",",
"DoubleRegs",
":",
"$",
"Rtt32",
")",
",",
"<STR_LIT>",
",",
"tc_85d5d03f",
",",
"TypeALU64",
">",
",",
"Enc_fcf7a7",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
GCC | c6x | CPP | next_suggestion | VLIW | 4,069 | [
"pat",
"=",
"gen_real_ret",
"(",
"XEXP",
"(",
"XVECEXP",
"(",
"pat",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
")",
";"
] | [
"callee",
"=",
"XEXP",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"SIBLING_CALL_P",
"(",
"insn",
")",
")",
"{",
"if",
"(",
"REG_P",
"(",
"callee",
")",
")",
"new",
"pat",
"=",
"gen_indirect_sibcall_shadow",
"(",
")",
";",
"else",
"new",
"pat",
"=",
"gen_sibcall_shadow",
"(",
"callee",
")",
";",
"pat",
"=",
"gen_real_jump",
"(",
"callee",
")",
";",
"}",
"else",
"if",
"(",
"dest",
"!=",
"NULL_RTX",
")",
"{",
"if",
"(",
"REG_P",
"(",
"callee",
")",
")",
"new",
"pat",
"=",
"gen_indirect_call_value_shadow",
"(",
"dest",
")",
";",
"else",
"new",
"pat",
"=",
"gen_call_value_shadow",
"(",
"dest",
",",
"callee",
")",
";",
"pat",
"=",
"gen_real_call",
"(",
"callee",
")",
";",
"}",
"else",
"{",
"if",
"(",
"REG_P",
"(",
"callee",
")",
")",
"new",
"pat",
"=",
"gen_indirect_call_shadow",
"(",
")",
";",
"else",
"new",
"pat",
"=",
"gen_call_shadow",
"(",
"callee",
")",
";",
"pat",
"=",
"gen_real_call",
"(",
"callee",
")",
";",
"}",
"pat",
"=",
"duplicate_cond",
"(",
"pat",
",",
"insn",
")",
";",
"new",
"pat",
"=",
"duplicate_cond",
"(",
"new",
"pat",
",",
"insn",
")",
";",
"}",
"else",
"{",
"rtx",
"src",
",",
"op",
";",
"if",
"(",
"GET_CODE",
"(",
"pat",
")",
"==",
"PARALLEL",
"&&",
"GET_CODE",
"(",
"XVECEXP",
"(",
"pat",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
"==",
"RETURN",
")",
"{",
"new",
"pat",
"=",
"gen_return_shadow",
"(",
")",
";",
"pat",
"=",
"gen_real_ret",
"(",
"XEXP",
"(",
"XVECEXP",
"(",
"pat",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
")",
";",
"new",
"pat",
"=",
"duplicate_cond",
"(",
"new",
"pat",
",",
"insn",
")",
";",
"}",
"else",
"switch",
"(",
"code",
")",
"{",
"case",
"CODE_FOR_br_true",
":",
"case",
"CODE_FOR_br_false",
":",
"src",
"=",
"SET_SRC",
"(",
"pat",
")",
";",
"op",
"=",
"XEXP",
"(",
"src",
",",
"code",
"==",
"CODE_FOR_br_true",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
")",
";",
"new",
"pat",
"=",
"gen_condjump_shadow",
"(",
"op",
")",
";",
"pat",
"=",
"gen_real_jump",
"(",
"op",
")",
";",
"if",
"(",
"code",
"==",
"CODE_FOR_br_true",
")",
"pat",
"=",
"gen_rtx_COND_EXEC",
"(",
"VOIDmode",
",",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
",",
"pat",
")",
";",
"else",
"pat",
"=",
"gen_rtx_COND_EXEC",
"(",
"VOIDmode",
",",
"reversed_comparison",
"(",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
",",
"VOIDmode",
")",
",",
"pat",
")",
";",
"break",
";",
"case",
"CODE_FOR_jump",
":",
"op",
"=",
"SET_SRC",
"(",
"pat",
")",
";",
"new",
"pat",
"=",
"gen_jump_shadow",
"(",
"op",
")",
";",
"break",
";",
"case",
"CODE_FOR_indirect_jump",
":",
"new",
"pat",
"=",
"gen_indirect_jump_shadow",
"(",
")",
";",
"break",
";",
"case",
"CODE_FOR_return_internal",
":",
"new",
"pat",
"=",
"gen_return_shadow",
"(",
")",
";"
] |
GCC | m68k | MD | stmt_completion | MPU | 4,070 | [
"<STR_LIT>",
")",
")"
] | [
"(",
"and",
"(",
"and",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"eq_attr",
"<STR_LIT>"
] |
LLVM | ARM | TD | stmt_completion | CPU | 4,071 | [
"<STR_LIT>",
";"
] | [
"let",
"ParserMatchClass",
"=",
"DPRRegListAsmOperand",
";",
"let",
"PrintMethod",
"=",
"<STR_LIT>",
";",
"let",
"DecoderMethod",
"="
] |
GCC | m68k | MD | stmt_completion | MPU | 4,072 | [
")",
")",
")"
] | [
"(",
"ior",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"match_test",
"<STR_LIT>",
")",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")"
] |
LLVM | ARM | TD | stmt_completion | CPU | 4,073 | [
"(",
"i32",
"(",
"InstN",
"$",
"vec",
")",
")",
">",
";"
] | [
"def",
":",
"Pat",
"<",
"(",
"i32",
"(",
"vecreduce_add",
"(",
"VTI",
".",
"Vec",
"MQPR",
":",
"$",
"vec",
")",
")",
")",
","
] |
GCC | arm | CPP | stmt_completion | CPU | 4,074 | [
"_",
"_",
"a",
")",
";"
] | [
"_",
"_",
"rv",
".",
"_",
"_",
"o",
"=",
"_",
"_",
"builtin_neon_vld1q_x4v8hi",
"(",
"(",
"const",
"_",
"_",
"builtin_neon_hi",
"*",
")"
] |
LLVM | Hexagon | CPP | stmt_completion | DSP | 4,075 | [
":",
"C2_cmoveif",
";"
] | [
"switch",
"(",
"TRI",
"->",
"getRegSizeInBits",
"(",
"*",
"RC",
")",
")",
"{",
"case",
"<NUM_LIT>",
":",
"return",
"IfTrue",
"?",
"A2_tfrt",
":",
"A2_tfrf",
";",
"case",
"<NUM_LIT>",
":",
"return",
"IfTrue",
"?",
"A2_tfrpt",
":",
"A2_tfrpf",
";",
"}",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Invalid register operand",
"<STR_LIT>",
")",
";",
"}",
"switch",
"(",
"SO",
".",
"getType",
"(",
")",
")",
"{",
"case",
"MachineOperand",
"::",
"MO_Immediate",
":",
"case",
"MachineOperand",
"::",
"MO_FPImmediate",
":",
"case",
"MachineOperand",
"::",
"MO_ConstantPoolIndex",
":",
"case",
"MachineOperand",
"::",
"MO_TargetIndex",
":",
"case",
"MachineOperand",
"::",
"MO_JumpTableIndex",
":",
"case",
"MachineOperand",
"::",
"MO_ExternalSymbol",
":",
"case",
"MachineOperand",
"::",
"MO_GlobalAddress",
":",
"case",
"MachineOperand",
"::",
"MO_BlockAddress",
":",
"return",
"IfTrue",
"?",
"C2_cmoveit"
] |
GCC | m32r | CPP | next_suggestion | MPU | 4,076 | [
"}"
] | [
"else",
"if",
"(",
"frame_pointer_needed",
")",
"{",
"unsigned",
"int",
"reg_offset",
"=",
"var_size",
"+",
"args_size",
";",
"if",
"(",
"reg_offset",
"==",
"<NUM_LIT>",
")",
"emit_insn",
"(",
"gen_movsi",
"(",
"stack_pointer_rtx",
",",
"frame_pointer_rtx",
")",
")",
";",
"else",
"if",
"(",
"reg_offset",
"<",
"<NUM_LIT>",
")",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"frame_pointer_rtx",
",",
"GEN_INT",
"(",
"reg_offset",
")",
")",
")",
";",
"else",
"{",
"rtx",
"tmp",
"=",
"gen_rtx_REG",
"(",
"Pmode",
",",
"PROLOGUE_TMP_REGNUM",
")",
";",
"emit_insn",
"(",
"gen_movsi",
"(",
"tmp",
",",
"GEN_INT",
"(",
"reg_offset",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_movsi",
"(",
"stack_pointer_rtx",
",",
"frame_pointer_rtx",
")",
")",
";",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"tmp",
")",
")",
";",
"}",
"}",
"else",
"gcc_unreachable",
"(",
")",
";",
"if",
"(",
"current_frame_info",
".",
"save_lr",
")",
"pop",
"(",
"RETURN_ADDR_REGNUM",
")",
";",
"gmask",
"&=",
"~",
"(",
"FRAME_POINTER_MASK",
"|",
"RETURN_ADDR_MASK",
")",
";",
"for",
"(",
"regno",
"=",
"M32R_MAX_INT_REGS",
"-",
"<NUM_LIT>",
";",
"regno",
">=",
"<NUM_LIT>",
";",
"--",
"regno",
")",
"{",
"if",
"(",
"(",
"gmask",
"&",
"(",
"<NUM_LIT>",
"L",
"<<",
"regno",
")",
")",
"!=",
"<NUM_LIT>",
")",
"pop",
"(",
"regno",
")",
";",
"}",
"if",
"(",
"current_frame_info",
".",
"save_fp",
")",
"pop",
"(",
"FRAME_POINTER_REGNUM",
")",
";",
"if",
"(",
"current_frame_info",
".",
"pretend_size",
"!=",
"<NUM_LIT>",
")",
"emit_insn",
"(",
"gen_addsi3",
"(",
"stack_pointer_rtx",
",",
"stack_pointer_rtx",
",",
"GEN_INT",
"(",
"current_frame_info",
".",
"pretend_size",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"}"
] |
GCC | i386 | MD | next_suggestion | CPU | 4,077 | [
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
")"
] | [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | arm | MD | program_repair | CPU | 4,078 | [
"<FIXS>",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<FIXE>"
] | [
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"<BUGS>",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<BUGE>",
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"match_parallel",
"<NUM_LIT>",
"<STR_LIT>"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 4,079 | [
"BaseClass",
":",
"BaseClasses",
")",
"{"
] | [
"assert",
"(",
"!",
"TargetRegisterInfo",
"::",
"isVirtualRegister",
"(",
"Reg",
")",
")",
";",
"static",
"const",
"TargetRegisterClass",
"*",
"const",
"BaseClasses",
"[",
"]",
"=",
"{",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
",",
"&",
"AMDGPU",
"::",
"SReg_32RegClass",
",",
"&",
"AMDGPU",
"::",
"VReg_64RegClass",
",",
"&",
"AMDGPU",
"::",
"SReg_64RegClass",
",",
"&",
"AMDGPU",
"::",
"VReg_96RegClass",
",",
"&",
"AMDGPU",
"::",
"VReg_128RegClass",
",",
"&",
"AMDGPU",
"::",
"SReg_128RegClass",
",",
"&",
"AMDGPU",
"::",
"VReg_256RegClass",
",",
"&",
"AMDGPU",
"::",
"SReg_256RegClass",
",",
"&",
"AMDGPU",
"::",
"VReg_512RegClass",
",",
"&",
"AMDGPU",
"::",
"SReg_512RegClass",
",",
"&",
"AMDGPU",
"::",
"SCC_CLASSRegClass",
",",
"&",
"AMDGPU",
"::",
"Pseudo_SReg_32RegClass",
",",
"&",
"AMDGPU",
"::",
"Pseudo_SReg_128RegClass",
",",
"}",
";",
"for",
"(",
"const",
"TargetRegisterClass",
"*"
] |
GCC | ia64 | CPP | next_suggestion | CPU | 4,080 | [
"}"
] | [
"int",
"i",
",",
"nelt",
",",
"which",
";",
"rtx",
"sel",
";",
"d",
".",
"target",
"=",
"operands",
"[",
"<NUM_LIT>",
"]",
";",
"d",
".",
"op0",
"=",
"operands",
"[",
"<NUM_LIT>",
"]",
";",
"d",
".",
"op1",
"=",
"operands",
"[",
"<NUM_LIT>",
"]",
";",
"sel",
"=",
"operands",
"[",
"<NUM_LIT>",
"]",
";",
"d",
".",
"vmode",
"=",
"GET_MODE",
"(",
"d",
".",
"target",
")",
";",
"gcc_assert",
"(",
"VECTOR_MODE_P",
"(",
"d",
".",
"vmode",
")",
")",
";",
"d",
".",
"nelt",
"=",
"nelt",
"=",
"GET_MODE_NUNITS",
"(",
"d",
".",
"vmode",
")",
";",
"d",
".",
"testing_p",
"=",
"false",
";",
"gcc_assert",
"(",
"GET_CODE",
"(",
"sel",
")",
"==",
"CONST_VECTOR",
")",
";",
"gcc_assert",
"(",
"XVECLEN",
"(",
"sel",
",",
"<NUM_LIT>",
")",
"==",
"nelt",
")",
";",
"gcc_checking_assert",
"(",
"sizeof",
"(",
"d",
".",
"perm",
")",
"==",
"sizeof",
"(",
"perm",
")",
")",
";",
"for",
"(",
"i",
"=",
"which",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"nelt",
";",
"++",
"i",
")",
"{",
"rtx",
"e",
"=",
"XVECEXP",
"(",
"sel",
",",
"<NUM_LIT>",
",",
"i",
")",
";",
"int",
"ei",
"=",
"INTVAL",
"(",
"e",
")",
"&",
"(",
"<NUM_LIT>",
"*",
"nelt",
"-",
"<NUM_LIT>",
")",
";",
"which",
"|=",
"(",
"ei",
"<",
"nelt",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
")",
";",
"d",
".",
"perm",
"[",
"i",
"]",
"=",
"ei",
";",
"perm",
"[",
"i",
"]",
"=",
"ei",
";",
"}",
"switch",
"(",
"which",
")",
"{",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"case",
"<NUM_LIT>",
":",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"d",
".",
"op0",
",",
"d",
".",
"op1",
")",
")",
"{",
"d",
".",
"one_operand_p",
"=",
"false",
";",
"break",
";",
"}",
"for",
"(",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"nelt",
";",
"++",
"i",
")",
"if",
"(",
"d",
".",
"perm",
"[",
"i",
"]",
">=",
"nelt",
")",
"d",
".",
"perm",
"[",
"i",
"]",
"-=",
"nelt",
";",
"case",
"<NUM_LIT>",
":",
"d",
".",
"op1",
"=",
"d",
".",
"op0",
";",
"d",
".",
"one_operand_p",
"=",
"true",
";",
"break",
";",
"case",
"<NUM_LIT>",
":",
"for",
"(",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"nelt",
";",
"++",
"i",
")",
"d",
".",
"perm",
"[",
"i",
"]",
"-=",
"nelt",
";",
"d",
".",
"op0",
"=",
"d",
".",
"op1",
";",
"d",
".",
"one_operand_p",
"=",
"true",
";",
"break",
";",
"}",
"if",
"(",
"ia64_expand_vec_perm_const_1",
"(",
"&",
"d",
")",
")",
"return",
"true",
";",
"if",
"(",
"which",
"==",
"<NUM_LIT>",
"&&",
"d",
".",
"one_operand_p",
")",
"{",
"memcpy",
"(",
"d",
".",
"perm",
",",
"perm",
",",
"sizeof",
"(",
"perm",
")",
")",
";",
"d",
".",
"one_operand_p",
"=",
"false",
";",
"return",
"ia64_expand_vec_perm_const_1",
"(",
"&",
"d",
")",
";"
] |
GCC | rs6000 | CPP | stmt_completion | CPU | 4,081 | [
"ATOMIC_RELEASE",
")",
";"
] | [
"extern",
"_",
"_",
"inline",
"void",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_lfence",
"(",
"void",
")",
"{",
"_",
"_",
"atomic_thread_fence",
"(",
"_",
"_"
] |
LLVM | SystemZ | TD | stmt_completion | CPU | 4,082 | [
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"M6",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"M5",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"M4",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"V1",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"V2",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"V3",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"op"
] |
GCC | i386 | MD | stmt_completion | CPU | 4,083 | [
")"
] | [
"if",
"(",
"find_regno_note",
"(",
"insn",
",",
"REG_DEAD",
",",
"REGNO",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
")",
")",
"return",
"<STR_LIT>",
"else",
"return",
"<STR_LIT>",
"default",
":",
"abort",
"(",
")",
"}",
"}",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>"
] |
LLVM | ARM64 | TD | stmt_completion | CPU | 4,084 | [
"=",
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opc",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"offset",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"extend",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"extend",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}"
] |
LLVM | Hexagon | CPP | stmt_completion | DSP | 4,085 | [
"Op",
")",
";"
] | [
"Op",
"->",
"StartLoc",
"=",
"S",
";",
"Op",
"->",
"EndLoc",
"=",
"E",
";",
"return",
"std",
"::",
"unique_ptr",
"<",
"HexagonOperand",
">",
"("
] |
GCC | m68k | MD | next_suggestion | MPU | 4,086 | [
"<STR_LIT>",
")"
] | [
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
] |
GCC | epiphany | MD | stmt_completion | MPU | 4,087 | [
")"
] | [
"(",
"and",
"(",
"match_code",
"<STR_LIT>",
")",
"(",
"match_test",
"<STR_LIT>"
] |
LLVM | SystemZ | TD | next_suggestion | CPU | 4,088 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"M3",
";"
] | [
"class",
"InstRRFc",
"<",
"bits",
"<",
"<NUM_LIT>",
">",
"op",
",",
"dag",
"outs",
",",
"dag",
"ins",
",",
"string",
"asmstr",
",",
"list",
"<",
"dag",
">",
"pattern",
">",
":",
"InstSystemZ",
"<",
"<NUM_LIT>",
",",
"outs",
",",
"ins",
",",
"asmstr",
",",
"pattern",
">",
"{",
"field",
"bits",
"<",
"<NUM_LIT>",
">",
"Inst",
";",
"field",
"bits",
"<",
"<NUM_LIT>",
">",
"SoftFail",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"R1",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"R2",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"M3",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"op",
";"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 4,089 | [
";"
] | [
"bool",
"IsStore",
"=",
"MI",
"->",
"mayStore",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"auto",
"*",
"TRI",
"=",
"static_cast",
"<",
"const",
"SIRegisterInfo",
"*",
">",
"(",
"MRI",
".",
"getTargetRegisterInfo",
"(",
")",
")",
";",
"unsigned",
"Dst",
"=",
"IsStore",
"?",
"Reg",
":",
"ValueReg",
";",
"unsigned",
"Src",
"=",
"IsStore",
"?",
"ValueReg",
":",
"Reg",
";",
"bool",
"IsVGPR",
"=",
"TRI",
"->",
"isVGPR",
"(",
"MRI",
",",
"Reg",
")",
";",
"DebugLoc",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"IsVGPR",
"==",
"TRI",
"->",
"isVGPR",
"(",
"MRI",
",",
"ValueReg",
")",
")",
"{",
"auto",
"CopyMIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"COPY",
")",
",",
"Dst",
")",
".",
"addReg",
"(",
"Src",
",",
"getKillRegState",
"(",
"IsKill",
")",
")",
";",
"CopyMIB",
"->",
"setAsmPrinterFlag",
"(",
"MachineInstr",
"::",
"ReloadReuse",
")",
";",
"return",
"CopyMIB"
] |
GCC | arm | CPP | stmt_completion | CPU | 4,090 | [
"_",
"_",
"b",
")",
";"
] | [
"_",
"_",
"arm_vshlq_s8",
"(",
"int8x16_t",
"_",
"_",
"a",
",",
"int8x16_t",
"_",
"_",
"b",
")",
"{",
"return",
"_",
"_",
"builtin_mve_vshlq_sv16qi",
"(",
"_",
"_",
"a",
","
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 4,091 | [
"Ra",
")",
")",
",",
"(",
"FMLSvvv_4S",
"VPR128",
":",
"$",
"Ra",
",",
"VPR128",
":",
"$",
"Rn",
",",
"VPR128",
":",
"$",
"Rm",
")",
">",
";"
] | [
"def",
":",
"Pat",
"<",
"(",
"v4f32",
"(",
"fma",
"(",
"fneg",
"VPR128",
":",
"$",
"Rn",
")",
",",
"VPR128",
":",
"$",
"Rm",
",",
"VPR128",
":",
"$"
] |
LLVM | ARM | TD | stmt_completion | CPU | 4,092 | [
",",
"<STR_LIT>",
",",
"addrmode6align64",
">",
";"
] | [
"def",
"VST1d16",
":",
"VST1D",
"<",
"{",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"?",
"}"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 4,093 | [
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"addrMode",
"=",
"BaseLongOffset",
";",
"let",
"accessSize",
"=",
"ByteAccess",
";",
"let",
"mayLoad",
"=",
"<NUM_LIT>",
";",
"let",
"isExtended",
"=",
"<NUM_LIT>",
";",
"let",
"InputType",
"=",
"<STR_LIT>",
";",
"let",
"DecoderNamespace",
"=",
"<STR_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 4,094 | [
"}"
] | [
"def",
"LogicalImm32Operand",
":",
"AsmOperandClass",
"{",
"let",
"Name",
"=",
"<STR_LIT>",
";",
"let",
"PredicateMethod",
"=",
"<STR_LIT>",
";",
"let",
"RenderMethod",
"=",
"<STR_LIT>",
";"
] |
GCC | tilegx | MD | next_suggestion | VLIW | 4,095 | [
"UNSPEC_INSN_CMULAF",
")",
")",
"]"
] | [
"[",
"(",
"set",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"unspec",
":",
"DI",
"[",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]"
] |
GCC | mmix | MD | next_suggestion | CPU | 4,096 | [
"(",
"match_operand",
":",
"CC",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]"
] | [
"(",
"define_expand",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"CC",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | spu | CPP | next_suggestion | MPU | 4,097 | [
"}"
] | [
"emit_move_insn",
"(",
"mask",
",",
"GEN_INT",
"(",
"-",
"<NUM_LIT>",
")",
")",
";",
"emit_insn",
"(",
"gen_rotqby_ti",
"(",
"s0",
",",
"s0",
",",
"r0",
")",
")",
";",
"emit_insn",
"(",
"gen_rotqby_ti",
"(",
"s1",
",",
"s1",
",",
"r0",
")",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"r0",
")",
"==",
"CONST_INT",
")",
"r1",
"=",
"GEN_INT",
"(",
"INTVAL",
"(",
"r0",
")",
"&",
"<NUM_LIT>",
")",
";",
"else",
"emit_insn",
"(",
"gen_andsi3",
"(",
"r1",
",",
"r0",
",",
"GEN_INT",
"(",
"<NUM_LIT>",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_shlqby_ti",
"(",
"mask",
",",
"mask",
",",
"r1",
")",
")",
";",
"emit_insn",
"(",
"gen_selb",
"(",
"s0",
",",
"s1",
",",
"s0",
",",
"mask",
")",
")",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"SUBREG",
")",
"{",
"rtx",
"r",
"=",
"SUBREG_REG",
"(",
"src",
")",
";",
"gcc_assert",
"(",
"REG_P",
"(",
"r",
")",
"&&",
"SCALAR_INT_MODE_P",
"(",
"GET_MODE",
"(",
"r",
")",
")",
")",
";",
"s0",
"=",
"gen_reg_rtx",
"(",
"TImode",
")",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"r",
")",
")",
"<",
"GET_MODE_SIZE",
"(",
"TImode",
")",
")",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"s0",
",",
"gen_rtx_ZERO_EXTEND",
"(",
"TImode",
",",
"r",
")",
")",
")",
";",
"else",
"emit_move_insn",
"(",
"s0",
",",
"src",
")",
";"
] |
GCC | arm | MD | stmt_completion | CPU | 4,098 | [
"V2SI",
"V4SI",
"V2DI",
"]",
")"
] | [
"(",
"define_mode_iterator",
"VDQHSD",
"[",
"V4HI",
"V8HI"
] |
LLVM | ARM | CPP | stmt_completion | CPU | 4,099 | [
"dl",
",",
"HalfT",
",",
"Tmp",
",",
"Lo",
")",
";"
] | [
"Tmp",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SRA",
",",
"dl",
",",
"HalfT",
",",
"Hi",
",",
"DAG",
".",
"getConstant",
"(",
"OpTypeBits",
"-",
"<NUM_LIT>",
",",
"dl",
",",
"getShiftAmountTy",
"(",
"HalfT",
",",
"DAG",
".",
"getDataLayout",
"(",
")",
")",
")",
")",
";",
"Lo",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"UADDO",
",",
"dl",
",",
"VTList",
",",
"Tmp",
",",
"Lo",
")",
";",
"Hi",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADDCARRY",
",",
"dl",
",",
"VTList",
",",
"Tmp",
",",
"Hi",
",",
"SDValue",
"(",
"Lo",
".",
"getNode",
"(",
")",
",",
"<NUM_LIT>",
")",
")",
";",
"Hi",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"XOR",
",",
"dl",
",",
"HalfT",
",",
"Tmp",
",",
"Hi",
")",
";",
"Lo",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"XOR",
","
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.