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
sequencelengths 0
2.32k
| Input
sequencelengths 1
1.02k
|
---|---|---|---|---|---|---|---|
LLVM | HSAIL | TD | stmt_completion | Virtual ISA | 620,300 | [
"<STR_LIT>",
",",
"<NUM_LIT>",
">",
";"
] | [
"def",
"_F32",
":",
"LD",
"<",
"opName",
",",
"BrigVal",
",",
"(",
"outs",
"GPR32",
":",
"$",
"dest",
")",
">",
",",
"LdStVectorMap",
"<",
"NAME",
"#"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 620,301 | [
"<NUM_LIT>",
";"
] | [
"class",
"Pseudo",
"<",
"dag",
"oops",
",",
"dag",
"iops",
",",
"list",
"<",
"dag",
">",
"pattern",
",",
"string",
"cstr",
"=",
"<STR_LIT>",
">",
":",
"AArch64Inst",
"<",
"PseudoFrm",
",",
"cstr",
">",
"{",
"dag",
"OutOperandList",
"=",
"oops",
";",
"dag",
"InOperandList",
"=",
"iops",
";",
"let",
"Pattern",
"=",
"pattern",
";",
"let",
"isCodeGenOnly",
"=",
"<NUM_LIT>",
";",
"let",
"isPseudo",
"="
] |
GCC | powerpcspe | CPP | code_generation | CPU | 620,302 | [
"static",
"tree",
"rs6000_builtin_vectorized_function",
"(",
"unsigned",
"int",
"fn",
",",
"tree",
"type_out",
",",
"tree",
"type_in",
")",
"{",
"machine_mode",
"in_mode",
",",
"out_mode",
";",
"int",
"in_n",
",",
"out_n",
";",
"if",
"(",
"TARGET_DEBUG_BUILTIN",
")",
"fprintf",
"(",
"stderr",
",",
"<STR_LIT>",
"rs6000_builtin_vectorized_function (%s, %s, %s)\\n",
"<STR_LIT>",
",",
"combined_fn_name",
"(",
"combined_fn",
"(",
"fn",
")",
")",
",",
"GET_MODE_NAME",
"(",
"TYPE_MODE",
"(",
"type_out",
")",
")",
",",
"GET_MODE_NAME",
"(",
"TYPE_MODE",
"(",
"type_in",
")",
")",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"type_out",
")",
"!=",
"VECTOR_TYPE",
"||",
"TREE_CODE",
"(",
"type_in",
")",
"!=",
"VECTOR_TYPE",
"||",
"!",
"TARGET_VECTORIZE_BUILTINS",
")",
"return",
"NULL_TREE",
";",
"out_mode",
"=",
"TYPE_MODE",
"(",
"TREE_TYPE",
"(",
"type_out",
")",
")",
";",
"out_n",
"=",
"TYPE_VECTOR_SUBPARTS",
"(",
"type_out",
")",
";",
"in_mode",
"=",
"TYPE_MODE",
"(",
"TREE_TYPE",
"(",
"type_in",
")",
")",
";",
"in_n",
"=",
"TYPE_VECTOR_SUBPARTS",
"(",
"type_in",
")",
";",
"switch",
"(",
"fn",
")",
"{",
"CASE_CFN_COPYSIGN",
":",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V2DFmode",
")",
"&&",
"out_mode",
"==",
"DFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"DFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_CPSGNDP",
"]",
";",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V4SFmode",
")",
"&&",
"out_mode",
"==",
"SFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"SFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_CPSGNSP",
"]",
";",
"if",
"(",
"VECTOR_UNIT_ALTIVEC_P",
"(",
"V4SFmode",
")",
"&&",
"out_mode",
"==",
"SFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"SFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"ALTIVEC_BUILTIN_COPYSIGN_V4SF",
"]",
";",
"break",
";",
"CASE_CFN_CEIL",
":",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V2DFmode",
")",
"&&",
"out_mode",
"==",
"DFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"DFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_XVRDPIP",
"]",
";",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V4SFmode",
")",
"&&",
"out_mode",
"==",
"SFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"SFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_XVRSPIP",
"]",
";",
"if",
"(",
"VECTOR_UNIT_ALTIVEC_P",
"(",
"V4SFmode",
")",
"&&",
"out_mode",
"==",
"SFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"SFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"ALTIVEC_BUILTIN_VRFIP",
"]",
";",
"break",
";",
"CASE_CFN_FLOOR",
":",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V2DFmode",
")",
"&&",
"out_mode",
"==",
"DFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"DFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_XVRDPIM",
"]",
";",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V4SFmode",
")",
"&&",
"out_mode",
"==",
"SFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"SFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_XVRSPIM",
"]",
";",
"if",
"(",
"VECTOR_UNIT_ALTIVEC_P",
"(",
"V4SFmode",
")",
"&&",
"out_mode",
"==",
"SFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"SFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"ALTIVEC_BUILTIN_VRFIM",
"]",
";",
"break",
";",
"CASE_CFN_FMA",
":",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V2DFmode",
")",
"&&",
"out_mode",
"==",
"DFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"DFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_XVMADDDP",
"]",
";",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V4SFmode",
")",
"&&",
"out_mode",
"==",
"SFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"SFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_XVMADDSP",
"]",
";",
"if",
"(",
"VECTOR_UNIT_ALTIVEC_P",
"(",
"V4SFmode",
")",
"&&",
"out_mode",
"==",
"SFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"SFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"ALTIVEC_BUILTIN_VMADDFP",
"]",
";",
"break",
";",
"CASE_CFN_TRUNC",
":",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V2DFmode",
")",
"&&",
"out_mode",
"==",
"DFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"DFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_XVRDPIZ",
"]",
";",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V4SFmode",
")",
"&&",
"out_mode",
"==",
"SFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"SFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_XVRSPIZ",
"]",
";",
"if",
"(",
"VECTOR_UNIT_ALTIVEC_P",
"(",
"V4SFmode",
")",
"&&",
"out_mode",
"==",
"SFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"SFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"ALTIVEC_BUILTIN_VRFIZ",
"]",
";",
"break",
";",
"CASE_CFN_NEARBYINT",
":",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V2DFmode",
")",
"&&",
"flag_unsafe_math_optimizations",
"&&",
"out_mode",
"==",
"DFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"DFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_XVRDPI",
"]",
";",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V4SFmode",
")",
"&&",
"flag_unsafe_math_optimizations",
"&&",
"out_mode",
"==",
"SFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"SFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_XVRSPI",
"]",
";",
"break",
";",
"CASE_CFN_RINT",
":",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V2DFmode",
")",
"&&",
"!",
"flag_trapping_math",
"&&",
"out_mode",
"==",
"DFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"DFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_XVRDPIC",
"]",
";",
"if",
"(",
"VECTOR_UNIT_VSX_P",
"(",
"V4SFmode",
")",
"&&",
"!",
"flag_trapping_math",
"&&",
"out_mode",
"==",
"SFmode",
"&&",
"out_n",
"==",
"<NUM_LIT>",
"&&",
"in_mode",
"==",
"SFmode",
"&&",
"in_n",
"==",
"<NUM_LIT>",
")",
"return",
"rs6000_builtin_decls",
"[",
"VSX_BUILTIN_XVRSPIC",
"]",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"if",
"(",
"rs6000_veclib_handler",
")",
"return",
"rs6000_veclib_handler",
"(",
"combined_fn",
"(",
"fn",
")",
",",
"type_out",
",",
"type_in",
")",
";",
"return",
"NULL_TREE",
";",
"}"
] | [
"Returns",
"a",
"function",
"decl",
"for",
"a",
"vectorized",
"version",
"of",
"the",
"builtin",
"function",
"with",
"builtin",
"function",
"code",
"FN",
"and",
"the",
"result",
"vector",
"type",
"TYPE",
",",
"or",
"NULL_TREE",
"if",
"it",
"is",
"not",
"available",
".",
"Implement",
"targetm.vectorize.builtin_vectorized_function",
"."
] |
GCC | m68k | MD | stmt_completion | MPU | 620,303 | [
")",
")"
] | [
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 620,304 | [
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";"
] | [
"def",
"J4_cmpeqi_t_jumpnv_t",
":",
"HInst",
"<",
"(",
"outs",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Ns8",
",",
"u5_0Imm",
":",
"$",
"II",
",",
"b30_2Imm",
":",
"$",
"Ii",
")",
",",
"<STR_LIT>",
",",
"tc_bd8382d1",
",",
"TypeNCJ",
">",
",",
"Enc_eafd18",
",",
"PredRel",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";",
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"isRestrictNoSlot1Store",
"=",
"<NUM_LIT>",
";",
"let",
"Defs",
"=",
"[",
"PC",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";"
] |
GCC | sh | CPP | stmt_completion | CPU | 620,305 | [
"reg_",
";"
] | [
"inline",
"rtx",
"base_reg_disp",
"::",
"reg",
"(",
"void",
")",
"const",
"{",
"return"
] |
LLVM | SystemZ | TD | next_suggestion | CPU | 620,306 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"R1",
";"
] | [
"field",
"bits",
"<",
"<NUM_LIT>",
">",
"SoftFail",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"R1",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"R2",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"M3",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"BD4",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"op",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] |
LLVM | Teak | CPP | next_suggestion | DSP | 620,307 | [
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"return",
"<NUM_LIT>",
";"
] | [
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"return",
"<NUM_LIT>",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"return",
"<NUM_LIT>",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"return",
"<NUM_LIT>",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"return",
"<NUM_LIT>",
";"
] |
GCC | rs6000 | CPP | stmt_completion | CPU | 620,308 | [
"rs6000_emit_stack_tie",
"(",
"frame_reg_rtx",
",",
"frame_pointer_needed",
")",
";"
] | [
"rtx",
"updt_reg_rtx",
";",
"if",
"(",
"DEFAULT_ABI",
"==",
"ABI_V4",
"||",
"(",
"TARGET_SPE_ABI",
"&&",
"info",
"->",
"spe_64bit_regs_used",
"!=",
"<NUM_LIT>",
"&&",
"info",
"->",
"first_gp_reg_save",
"!=",
"<NUM_LIT>",
")",
")"
] |
LLVM | ARM | CPP | program_repair | CPU | 620,309 | [
"<FIXS>",
"ArgValue",
"=",
"DAG",
".",
"getLoad",
"(",
"ObjectVT",
",",
"dl",
",",
"Root",
",",
"FIN",
",",
"NULL",
",",
"<NUM_LIT>",
")",
";",
"<FIXE>",
"<FIXS>",
"SDValue",
"ArgValue2",
"=",
"DAG",
".",
"getLoad",
"(",
"MVT",
"::",
"i32",
",",
"dl",
",",
"Root",
",",
"FIN",
",",
"NULL",
",",
"<NUM_LIT>",
")",
";",
"<FIXE>",
"<FIXS>",
"ArgValue",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MVT",
"::",
"f64",
",",
"ArgValue",
",",
"ArgValue2",
")",
";",
"<FIXE>"
] | [
"int",
"FI",
"=",
"MFI",
"->",
"CreateFixedObject",
"(",
"ObjSize",
",",
"ArgOffset",
")",
";",
"SDValue",
"FIN",
"=",
"DAG",
".",
"getFrameIndex",
"(",
"FI",
",",
"MVT",
"::",
"i32",
")",
";",
"if",
"(",
"ObjGPRs",
"==",
"<NUM_LIT>",
")",
"<BUGS>",
"ArgValue",
"=",
"DAG",
".",
"getLoad",
"(",
"ObjectVT",
",",
"Root",
",",
"FIN",
",",
"NULL",
",",
"<NUM_LIT>",
")",
";",
"<BUGE>",
"else",
"{",
"<BUGS>",
"SDValue",
"ArgValue2",
"=",
"DAG",
".",
"getLoad",
"(",
"MVT",
"::",
"i32",
",",
"Root",
",",
"FIN",
",",
"NULL",
",",
"<NUM_LIT>",
")",
";",
"<BUGE>",
"assert",
"(",
"ObjectVT",
"!=",
"MVT",
"::",
"i64",
"&&",
"<STR_LIT>",
"i64 should already be lowered",
"<STR_LIT>",
")",
";",
"<BUGS>",
"ArgValue",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"MVT",
"::",
"f64",
",",
"ArgValue",
",",
"ArgValue2",
")",
";",
"<BUGE>",
"}",
"ArgOffset",
"+=",
"ObjSize",
";"
] |
LLVM | ARM | TD | next_suggestion | CPU | 620,310 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"addr",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"Dbit",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"load",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"addr",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"CRd",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"cop",
";"
] |
GCC | i386 | CPP | stmt_completion | CPU | 620,311 | [
"_",
"_",
"mmask32",
"_",
"_",
"U",
",",
"_",
"_",
"m512i",
"_",
"_",
"A",
",",
"_",
"_",
"m512i",
"_",
"_",
"B",
")",
"{"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m512i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm512_mask_adds_epi16",
"(",
"_",
"_",
"m512i",
"_",
"_",
"W",
","
] |
GCC | bpf | CPP | code_generation | Virtual ISA | 620,312 | [
"const",
"char",
"*",
"bpf_output_call",
"(",
"rtx",
"target",
")",
"{",
"rtx",
"xops",
"[",
"<NUM_LIT>",
"]",
";",
"switch",
"(",
"GET_CODE",
"(",
"target",
")",
")",
"{",
"case",
"CONST_INT",
":",
"output_asm_insn",
"(",
"<STR_LIT>",
"call\\t%0",
"<STR_LIT>",
",",
"&",
"target",
")",
";",
"break",
";",
"case",
"SYMBOL_REF",
":",
"{",
"tree",
"decl",
"=",
"SYMBOL_REF_DECL",
"(",
"target",
")",
";",
"tree",
"attr",
";",
"if",
"(",
"decl",
"&&",
"(",
"attr",
"=",
"lookup_attribute",
"(",
"<STR_LIT>",
"kernel_helper",
"<STR_LIT>",
",",
"DECL_ATTRIBUTES",
"(",
"decl",
")",
")",
")",
")",
"{",
"tree",
"attr_args",
"=",
"TREE_VALUE",
"(",
"attr",
")",
";",
"xops",
"[",
"<NUM_LIT>",
"]",
"=",
"GEN_INT",
"(",
"TREE_INT_CST_LOW",
"(",
"TREE_VALUE",
"(",
"attr_args",
")",
")",
")",
";",
"output_asm_insn",
"(",
"<STR_LIT>",
"call\\t%0",
"<STR_LIT>",
",",
"xops",
")",
";",
"}",
"else",
"output_asm_insn",
"(",
"<STR_LIT>",
"call\\t%0",
"<STR_LIT>",
",",
"&",
"target",
")",
";",
"break",
";",
"}",
"default",
":",
"if",
"(",
"TARGET_XBPF",
")",
"output_asm_insn",
"(",
"<STR_LIT>",
"call\\t%0",
"<STR_LIT>",
",",
"&",
"target",
")",
";",
"else",
"{",
"error",
"(",
"<STR_LIT>",
"indirect call in function, which are not supported by eBPF",
"<STR_LIT>",
")",
";",
"output_asm_insn",
"(",
"<STR_LIT>",
"call 0",
"<STR_LIT>",
",",
"NULL",
")",
";",
"}",
"break",
";",
"}",
"return",
"<STR_LIT>",
"<STR_LIT>",
";",
"}"
] | [
"Return",
"the",
"appropriate",
"instruction",
"to",
"CALL",
"to",
"a",
"function",
".",
"TARGET",
"is",
"an",
"RTX",
"denoting",
"the",
"address",
"of",
"the",
"called",
"function",
".",
"The",
"main",
"purposes",
"of",
"this",
"function",
"are",
":",
"-",
"To",
"reject",
"indirect",
"CALL",
"instructions",
",",
"which",
"are",
"not",
"supported",
"by",
"eBPF",
".",
"-",
"To",
"recognize",
"calls",
"to",
"kernel",
"helper",
"functions",
"and",
"emit",
"the",
"corresponding",
"CALL",
"N",
"instruction",
".",
"This",
"function",
"is",
"called",
"from",
"the",
"expansion",
"of",
"the",
"'call",
"'",
"pattern",
"in",
"bpf.md",
"."
] |
GCC | aarch64 | MD | stmt_completion | CPU | 620,313 | [
"]"
] | [
"[",
"(",
"match_operand",
":",
"<",
"VPRED",
">",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"SVE_STRUCT",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
"]",
"UNSPEC_STN",
")",
")"
] |
GCC | cris | MD | program_repair | MPU | 620,314 | [
"<FIXS>",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"CC",
"CRIS_CC0_REGNUM",
")",
")",
"]",
"<FIXE>"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
":",
"HI",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"<BUGS>",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")",
"]",
"<BUGE>",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
LLVM | M680x0 | CPP | next_suggestion | MPU | 620,315 | [
"MachineInstrBuilder",
"MI",
"=",
"BuildStackAdjustment",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"isSub",
"?",
"-",
"ThisVal",
":",
"ThisVal",
",",
"InEpilogue",
")",
";"
] | [
"Opc",
"=",
"isSub",
"?",
"getSUBrrOpcode",
"(",
")",
":",
"getADDrrOpcode",
"(",
")",
";",
"MachineInstr",
"*",
"MI",
"=",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"StackPtr",
")",
".",
"addReg",
"(",
"StackPtr",
")",
".",
"addReg",
"(",
"Reg",
")",
";",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"setIsDead",
"(",
")",
";",
"Offset",
"=",
"<NUM_LIT>",
";",
"continue",
";",
"}",
"}",
"uint64_t",
"ThisVal",
"=",
"std",
"::",
"min",
"(",
"Offset",
",",
"Chunk",
")",
";"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 620,316 | [
"Changed",
";"
] | [
"bool",
"Changed",
"=",
"false",
";",
"Changed",
"|=",
"trySADReplacement",
"(",
"BO",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"BO",
")",
";",
"Changed",
"|=",
"trySADReplacement",
"(",
"BO",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"BO",
")",
";",
"return"
] |
LLVM | TMS320C64X | CPP | stmt_completion | VLIW | 620,317 | [
"<STR_LIT>",
";"
] | [
"const",
"char",
"*",
"getPassName",
"(",
")",
"const",
"{",
"return",
"<STR_LIT>",
"C64x+ specific post RA scheduler"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 620,318 | [
"[",
"<NUM_LIT>",
"]",
".",
"VectorSize",
";"
] | [
"static",
"inline",
"int",
"getVecSize",
"(",
"const",
"AMDGPULibFunc",
"&",
"FInfo",
")",
"{",
"return",
"FInfo",
".",
"getLeads",
"(",
")"
] |
LLVM | X86 | CPP | program_repair | CPU | 620,319 | [
"<FIXS>",
"if",
"(",
"Op",
".",
"getNumOperands",
"(",
")",
"==",
"(",
"<NUM_LIT>",
"U",
"+",
"HasRounding",
")",
")",
"{",
"<FIXE>"
] | [
"bool",
"HasRounding",
"=",
"IntrWithRoundingModeOpcode",
"!=",
"<NUM_LIT>",
";",
"<BUGS>",
"if",
"(",
"Op",
".",
"getNumOperands",
"(",
")",
"==",
"(",
"<NUM_LIT>",
"+",
"HasRounding",
")",
")",
"{",
"<BUGE>",
"if",
"(",
"HasRounding",
")",
"{",
"SDValue",
"Rnd",
"=",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"!",
"isRoundModeCurDirection",
"(",
"Rnd",
")",
")"
] |
LLVM | LoongArch | CPP | stmt_completion | CPU | 620,320 | [
"const",
"{"
] | [
"Align",
"getPrefFunctionAlignment",
"(",
")"
] |
LLVM | ARM64 | TD | stmt_completion | CPU | 620,321 | [
",",
"[",
"]",
">",
"{"
] | [
"class",
"arith_extended_reg32to64",
"<",
"ValueType",
"Ty",
">",
":",
"Operand",
"<",
"Ty",
">",
",",
"ComplexPattern",
"<",
"Ty",
",",
"<NUM_LIT>",
",",
"<STR_LIT>"
] |
GCC | rs6000 | CPP | program_repair | CPU | 620,322 | [
"<FIXS>",
"rs6000_tune_index",
"=",
"tune_index",
"=",
"cpu_index",
";",
"<FIXE>"
] | [
"if",
"(",
"rs6000_tune_index",
">=",
"<NUM_LIT>",
")",
"tune_index",
"=",
"rs6000_tune_index",
";",
"else",
"if",
"(",
"have_cpu",
")",
"<BUGS>",
"{",
"if",
"(",
"processor_target_table",
"[",
"cpu_index",
"]",
".",
"processor",
"!=",
"PROCESSOR_POWER9",
")",
"rs6000_tune_index",
"=",
"tune_index",
"=",
"cpu_index",
";",
"else",
"{",
"size_t",
"i",
";",
"tune_index",
"=",
"-",
"<NUM_LIT>",
";",
"for",
"(",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"ARRAY_SIZE",
"(",
"processor_target_table",
")",
";",
"i",
"++",
")",
"if",
"(",
"processor_target_table",
"[",
"i",
"]",
".",
"processor",
"==",
"PROCESSOR_POWER8",
")",
"{",
"rs6000_tune_index",
"=",
"tune_index",
"=",
"i",
";",
"break",
";",
"}",
"}",
"}",
"<BUGE>",
"else",
"{",
"size_t",
"i",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 620,323 | [
"}"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"Rtt32",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rtt32",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rdd32",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rdd32",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] |
LLVM | XNCM | CPP | next_suggestion | CPU | 620,324 | [
"}"
] | [
"FunctionPass",
"*",
"llvm",
"::",
"createXNCMISelDag",
"(",
"XNCMTargetMachine",
"&",
"TM",
",",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
")",
"{",
"return",
"new",
"XNCMDAGToDAGISel",
"(",
"TM",
",",
"OptLevel",
")",
";"
] |
GCC | nds32 | MD | stmt_completion | CPU | 620,325 | [
"<STR_LIT>",
")"
] | [
"<STR_LIT>",
"(",
"and",
"(",
"match_code"
] |
GCC | h8300 | MD | next_suggestion | MPU | 620,326 | [
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
] | [
"(",
"plus",
":",
"SI",
"(",
"and",
":",
"SI",
"(",
"ashift",
":",
"SI",
"(",
"subreg",
":",
"SI",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
LLVM | AVR | CPP | next_suggestion | MPU | 620,327 | [
"return",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";"
] | [
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"{",
"if",
"(",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isFI",
"(",
")",
")",
"&&",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isImm",
"(",
")",
")",
"&&",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
"==",
"<NUM_LIT>",
")",
")",
"{",
"FrameIndex",
"=",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getIndex",
"(",
")",
";"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 620,328 | [
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"hasNewValue",
"="
] |
GCC | xtensa | CPP | next_suggestion | MPU | 620,329 | [
"}"
] | [
"HOST_WIDE_INT",
"total_size",
"=",
"compute_frame_size",
"(",
"get_frame_size",
"(",
")",
")",
";",
"rtx",
"frame",
"=",
"frame_pointer_needed",
"?",
"hard_frame_pointer_rtx",
":",
"stack_pointer_rtx",
";",
"rtx",
"a0_addr",
"=",
"plus_constant",
"(",
"Pmode",
",",
"frame",
",",
"total_size",
"-",
"UNITS_PER_WORD",
")",
";",
"rtx",
"not",
"e",
"=",
"gen_rtx_SET",
"(",
"gen_frame_mem",
"(",
"SImode",
",",
"a0_addr",
")",
",",
"gen_rtx_REG",
"(",
"SImode",
",",
"A0_REG",
")",
")",
";",
"rtx",
"insn",
";",
"if",
"(",
"total_size",
">",
"<NUM_LIT>",
")",
"{",
"xtensa_emit_add_imm",
"(",
"scratch",
",",
"frame",
",",
"total_size",
"-",
"UNITS_PER_WORD",
",",
"scratch",
",",
"false",
")",
";",
"a0_addr",
"=",
"scratch",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 620,330 | [
"let",
"InputType",
"=",
"<STR_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>",
";"
] |
LLVM | XCore | TD | stmt_completion | MPU | 620,331 | [
";"
] | [
"let",
"PrintMethod",
"=",
"<STR_LIT>"
] |
GCC | sparc | CPP | next_suggestion | CPU | 620,332 | [
"}"
] | [
"static",
"rtx",
"sparc_got",
"(",
"void",
")",
"{",
"if",
"(",
"!",
"sparc_got_symbol",
")",
"sparc_got_symbol",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"<STR_LIT>",
"_GLOBAL_OFFSET_TABLE_",
"<STR_LIT>",
")",
";",
"return",
"sparc_got_symbol",
";"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 620,333 | [
"assert",
"(",
"!",
"Shuffles",
".",
"empty",
"(",
")",
"&&",
"<STR_LIT>",
"Empty shufflevector input",
"<STR_LIT>",
")",
";"
] | [
"bool",
"X86TargetLowering",
"::",
"lowerInterleavedLoad",
"(",
"LoadInst",
"*",
"LI",
",",
"ArrayRef",
"<",
"ShuffleVectorInst",
"*",
">",
"Shuffles",
",",
"ArrayRef",
"<",
"unsigned",
">",
"Indices",
",",
"unsigned",
"Factor",
")",
"const",
"{",
"assert",
"(",
"Factor",
">=",
"<NUM_LIT>",
"&&",
"Factor",
"<=",
"getMaxSupportedInterleaveFactor",
"(",
")",
"&&",
"<STR_LIT>",
"Invalid interleave factor",
"<STR_LIT>",
")",
";"
] |
LLVM | Mips | CPP | next_suggestion | CPU | 620,334 | [
"Register",
"Tmp",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"Mips",
"::",
"GPR32RegClass",
")",
";"
] | [
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"const",
"TargetInstrInfo",
"*",
"TII",
"=",
"Subtarget",
".",
"getInstrInfo",
"(",
")",
";",
"const",
"bool",
"IsLittle",
"=",
"Subtarget",
".",
"isLittle",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"Register",
"StoreVal",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"Register",
"Address",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"unsigned",
"Imm",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"I",
"(",
"MI",
")",
";",
"if",
"(",
"Subtarget",
".",
"hasMips32r6",
"(",
")",
"||",
"Subtarget",
".",
"hasMips64r6",
"(",
")",
")",
"{",
"Register",
"BitcastW",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"Mips",
"::",
"MSA128WRegClass",
")",
";",
"Register",
"Tmp",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"Mips",
"::",
"GPR32RegClass",
")",
";",
"BuildMI",
"(",
"*",
"BB",
",",
"I",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"Mips",
"::",
"COPY",
")",
")",
".",
"addDef",
"(",
"BitcastW",
")",
".",
"addUse",
"(",
"StoreVal",
")",
";",
"BuildMI",
"(",
"*",
"BB",
",",
"I",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"Mips",
"::",
"COPY_S_W",
")",
")",
".",
"addDef",
"(",
"Tmp",
")",
".",
"addUse",
"(",
"BitcastW",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
";",
"BuildMI",
"(",
"*",
"BB",
",",
"I",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"Mips",
"::",
"SW",
")",
")",
".",
"addUse",
"(",
"Tmp",
")",
".",
"addUse",
"(",
"Address",
")",
".",
"addImm",
"(",
"Imm",
")",
";",
"}",
"else",
"{"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 620,335 | [
"}"
] | [
"def",
"L2_loadrh_pi",
":",
"HInst",
"<",
"(",
"outs",
"IntRegs",
":",
"$",
"Rd32",
",",
"IntRegs",
":",
"$",
"Rx32",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rx32in",
",",
"s4_1Imm",
":",
"$",
"Ii",
")",
",",
"<STR_LIT>",
",",
"tc_44d3da28",
",",
"TypeLD",
">",
",",
"Enc_152467",
",",
"PredNewRel",
",",
"PostInc_BaseImm",
"{",
"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",
"addrMode",
"=",
"PostInc",
";",
"let",
"accessSize",
"=",
"HalfWordAccess",
";",
"let",
"mayLoad",
"=",
"<NUM_LIT>",
";",
"let",
"CextOpcode",
"=",
"<STR_LIT>",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isPredicable",
"=",
"<NUM_LIT>",
";",
"let",
"Constraints",
"=",
"<STR_LIT>",
";"
] |
GCC | sparc | MD | stmt_completion | CPU | 620,336 | [
"<STR_LIT>",
"<STR_LIT>",
")",
")"
] | [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr"
] |
LLVM | R600 | CPP | stmt_completion | GPU | 620,337 | [
"false",
";"
] | [
"const",
"AMDGPUOperand",
"&",
"ParsedOp",
"=",
"(",
"(",
"const",
"AMDGPUOperand",
"&",
")",
"*",
"Operands",
"[",
"i",
"]",
")",
";",
"if",
"(",
"(",
"ParsedOp",
".",
"isImm",
"(",
")",
"&&",
"ParsedOp",
".",
"getImmTy",
"(",
")",
"==",
"OOp",
".",
"Type",
")",
"||",
"(",
"ParsedOp",
".",
"isToken",
"(",
")",
"&&",
"ParsedOp",
".",
"getToken",
"(",
")",
"==",
"OOp",
".",
"Name",
")",
")",
"return",
"true",
";",
"}",
"return"
] |
GCC | i386 | MD | next_suggestion | CPU | 620,338 | [
"(",
"match_operand",
":",
"<",
"avx512fmaskmode",
">",
"<NUM_LIT>",
"<STR_LIT>",
")",
")",
")",
"]"
] | [
"(",
"define_expand",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"VI48_AVX512VL",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"vec_merge",
":",
"VI48_AVX512VL",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")"
] |
GCC | nios2 | MD | next_suggestion | MPU | 620,339 | [
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
")"
] | [
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | tilepro | CPP | code_generation | VLIW | 620,340 | [
"void",
"split_di",
"(",
"rtx",
"operands",
"[",
"]",
",",
"int",
"num",
",",
"rtx",
"lo_half",
"[",
"]",
",",
"rtx",
"hi_half",
"[",
"]",
")",
"{",
"while",
"(",
"num",
"--",
")",
"{",
"rtx",
"op",
"=",
"operands",
"[",
"num",
"]",
";",
"if",
"(",
"MEM_P",
"(",
"op",
")",
")",
"{",
"lo_half",
"[",
"num",
"]",
"=",
"adjust_address",
"(",
"op",
",",
"SImode",
",",
"<NUM_LIT>",
")",
";",
"hi_half",
"[",
"num",
"]",
"=",
"adjust_address",
"(",
"op",
",",
"SImode",
",",
"<NUM_LIT>",
")",
";",
"}",
"else",
"{",
"lo_half",
"[",
"num",
"]",
"=",
"simplify_gen_subreg",
"(",
"SImode",
",",
"op",
",",
"GET_MODE",
"(",
"op",
")",
"==",
"VOIDmode",
"?",
"DImode",
":",
"GET_MODE",
"(",
"op",
")",
",",
"<NUM_LIT>",
")",
";",
"hi_half",
"[",
"num",
"]",
"=",
"simplify_gen_subreg",
"(",
"SImode",
",",
"op",
",",
"GET_MODE",
"(",
"op",
")",
"==",
"VOIDmode",
"?",
"DImode",
":",
"GET_MODE",
"(",
"op",
")",
",",
"<NUM_LIT>",
")",
";",
"}",
"}",
"}"
] | [
"Split",
"one",
"or",
"more",
"DImode",
"RTL",
"references",
"into",
"pairs",
"of",
"SImode",
"references",
".",
"The",
"RTL",
"can",
"be",
"REG",
",",
"offsettable",
"MEM",
",",
"integer",
"constant",
",",
"or",
"CONST_DOUBLE",
".",
"``",
"operands",
"''",
"is",
"a",
"pointer",
"to",
"an",
"array",
"of",
"DImode",
"RTL",
"to",
"split",
"and",
"``",
"num",
"''",
"is",
"its",
"length",
".",
"lo_half",
"and",
"hi_half",
"are",
"output",
"arrays",
"that",
"parallel",
"``",
"operands",
"''",
"."
] |
LLVM | Patmos | CPP | code_generation | VLIW | 620,341 | [
"virtual",
"bool",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"PatmosSinglePathInfo",
"&",
"PSPI",
"=",
"getAnalysis",
"<",
"PatmosSinglePathInfo",
">",
"(",
")",
";",
"bool",
"changed",
"=",
"false",
";",
"if",
"(",
"PSPI",
".",
"isConverting",
"(",
"MF",
")",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"[Single-Path] Preparing ",
"<STR_LIT>",
"<<",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getName",
"(",
")",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"doPrepareFunction",
"(",
"MF",
")",
";",
"changed",
"|=",
"true",
";",
"}",
"return",
"changed",
";",
"}"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] |
LLVM | XCore | CPP | stmt_completion | MPU | 620,342 | [
")",
";"
] | [
"Symbol",
"=",
"Printer",
".",
"GetExternalSymbolSymbol",
"(",
"MO",
".",
"getSymbolName",
"(",
")",
")",
";",
"Offset",
"+=",
"MO",
".",
"getOffset",
"(",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_JumpTableIndex",
":",
"Symbol",
"=",
"Printer",
".",
"GetJTISymbol",
"(",
"MO",
".",
"getIndex",
"(",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_ConstantPoolIndex",
":",
"Symbol",
"=",
"Printer",
".",
"GetCPISymbol",
"(",
"MO",
".",
"getIndex",
"(",
")",
")",
";",
"Offset",
"+=",
"MO",
".",
"getOffset",
"(",
")",
";",
"break",
";",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"<unknown operand type>",
"<STR_LIT>",
")",
";",
"}",
"const",
"MCSymbolRefExpr",
"*",
"MCSym",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"Symbol",
",",
"Kind",
",",
"*",
"Ctx",
")",
";",
"if",
"(",
"!",
"Offset",
")",
"return",
"MCOperand",
"::",
"createExpr",
"(",
"MCSym",
")",
";",
"assert",
"(",
"Offset",
">",
"<NUM_LIT>"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 620,343 | [
")",
"{"
] | [
"unsigned",
"NumSubRegs",
"=",
"SplitParts",
".",
"empty",
"(",
")",
"?",
"<NUM_LIT>",
":",
"SplitParts",
".",
"size",
"(",
")",
";",
"int64_t",
"FrOffset",
"=",
"FrameInfo",
".",
"getObjectOffset",
"(",
"Index",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"NumSubRegs",
";",
"i",
"<",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"SubReg",
"=",
"NumSubRegs",
"==",
"<NUM_LIT>",
"?",
"SuperReg",
":",
"getSubReg",
"(",
"SuperReg",
",",
"SplitParts",
"[",
"i",
"]",
")",
";",
"if",
"(",
"SpillToSMEM",
")",
"{",
"unsigned",
"Align",
"=",
"FrameInfo",
".",
"getObjectAlignment",
"(",
"Index",
")",
";",
"MachinePointerInfo",
"PtrInfo",
"=",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"*",
"MF",
",",
"Index",
",",
"EltSize",
"*",
"i",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
"->",
"getMachineMemOperand",
"(",
"PtrInfo",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"EltSize",
",",
"MinAlign",
"(",
"Align",
",",
"EltSize",
"*",
"i",
")",
")",
";",
"int64_t",
"Offset",
"=",
"(",
"ST",
".",
"getWavefrontSize",
"(",
")",
"*",
"FrOffset",
")",
"+",
"(",
"EltSize",
"*",
"i",
")",
";",
"if",
"(",
"Offset",
"!=",
"<NUM_LIT>",
")",
"{",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_ADD_U32",
")",
",",
"OffsetReg",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchWaveOffsetReg",
"(",
")",
")",
".",
"addImm",
"(",
"Offset",
")",
";",
"}",
"else",
"{",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_MOV_B32",
")",
",",
"OffsetReg",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchWaveOffsetReg",
"(",
")",
")",
";",
"}",
"auto",
"MIB",
"=",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"ScalarLoadOp",
")",
",",
"SubReg",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
")",
".",
"addReg",
"(",
"OffsetReg",
",",
"RegState",
"::",
"Kill",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"if",
"(",
"NumSubRegs",
">",
"<NUM_LIT>",
")",
"MIB",
".",
"addReg",
"(",
"SuperReg",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";",
"continue",
";",
"}",
"if",
"(",
"SpillToVGPR"
] |
GCC | sparc | CPP | stmt_completion | CPU | 620,344 | [
")",
";"
] | [
"rtx",
"word1",
"=",
"adjust_address",
"(",
"src",
",",
"mode",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"reg_overlap_mentioned_p",
"(",
"high_part",
",",
"word1",
")",
")",
"{",
"emit_move_insn_1",
"(",
"low_part",
",",
"word1",
")",
";",
"emit_move_insn_1",
"(",
"high_part",
",",
"word0"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 620,345 | [
"[",
"SDTCisVT",
"<",
"<NUM_LIT>",
",",
"i32",
">",
"]",
">",
";"
] | [
"def",
"SDT_Int32Leaf",
":",
"SDTypeProfile",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
","
] |
LLVM | X86 | CPP | code_generation | CPU | 620,346 | [
"unsigned",
"X86RegisterInfo",
"::",
"eliminateFrameIndex",
"(",
"MachineBasicBlock",
"::",
"iterator",
"II",
",",
"int",
"SPAdj",
",",
"int",
"*",
"Value",
",",
"RegScavenger",
"*",
"RS",
")",
"const",
"{",
"assert",
"(",
"SPAdj",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Unexpected",
"<STR_LIT>",
")",
";",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"II",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"while",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"isFI",
"(",
")",
")",
"{",
"++",
"i",
";",
"assert",
"(",
"i",
"<",
"MI",
".",
"getNumOperands",
"(",
")",
"&&",
"<STR_LIT>",
"Instr doesn't have FrameIndex operand!",
"<STR_LIT>",
")",
";",
"}",
"int",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"getIndex",
"(",
")",
";",
"unsigned",
"BasePtr",
";",
"if",
"(",
"needsStackRealignment",
"(",
"MF",
")",
")",
"BasePtr",
"=",
"(",
"FrameIndex",
"<",
"<NUM_LIT>",
"?",
"FramePtr",
":",
"StackPtr",
")",
";",
"else",
"BasePtr",
"=",
"(",
"hasFP",
"(",
"MF",
")",
"?",
"FramePtr",
":",
"StackPtr",
")",
";",
"MI",
".",
"getOperand",
"(",
"i",
")",
".",
"ChangeToRegister",
"(",
"BasePtr",
",",
"false",
")",
";",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"i",
"+",
"<NUM_LIT>",
")",
".",
"isImm",
"(",
")",
")",
"{",
"int",
"Offset",
"=",
"getFrameIndexOffset",
"(",
"MF",
",",
"FrameIndex",
")",
"+",
"(",
"int",
")",
"(",
"MI",
".",
"getOperand",
"(",
"i",
"+",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
")",
";",
"MI",
".",
"getOperand",
"(",
"i",
"+",
"<NUM_LIT>",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"}",
"else",
"{",
"uint64_t",
"Offset",
"=",
"getFrameIndexOffset",
"(",
"MF",
",",
"FrameIndex",
")",
"+",
"(",
"uint64_t",
")",
"MI",
".",
"getOperand",
"(",
"i",
"+",
"<NUM_LIT>",
")",
".",
"getOffset",
"(",
")",
";",
"MI",
".",
"getOperand",
"(",
"i",
"+",
"<NUM_LIT>",
")",
".",
"setOffset",
"(",
"Offset",
")",
";",
"}",
"return",
"<NUM_LIT>",
";",
"}"
] | [
"This",
"method",
"must",
"be",
"overriden",
"to",
"eliminate",
"abstract",
"frame",
"indices",
"from",
"instructions",
"which",
"may",
"use",
"them",
"."
] |
LLVM | LoongArch | CPP | next_suggestion | CPU | 620,347 | [
"getLexer",
"(",
")",
".",
"Lex",
"(",
")",
";"
] | [
"StringRef",
"Name",
"=",
"getLexer",
"(",
")",
".",
"getTok",
"(",
")",
".",
"getIdentifier",
"(",
")",
";",
"MCRegister",
"RegNo",
";",
"matchRegisterNameHelper",
"(",
"RegNo",
",",
"Name",
")",
";",
"if",
"(",
"RegNo",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"return",
"MatchOperand_NoMatch",
";",
"SMLoc",
"S",
"=",
"getLoc",
"(",
")",
";",
"SMLoc",
"E",
"=",
"SMLoc",
"::",
"getFromPointer",
"(",
"S",
".",
"getPointer",
"(",
")",
"+",
"Name",
".",
"size",
"(",
")",
")",
";"
] |
GCC | aarch64 | CPP | next_suggestion | CPU | 620,348 | [
"}"
] | [
"vqmovnh_s16",
"(",
"int16_t",
"_",
"_",
"a",
")",
"{",
"return",
"(",
"int8_t",
")",
"_",
"_",
"builtin_aarch64_sqmovnhi",
"(",
"_",
"_",
"a",
")",
";"
] |
LLVM | AArch64 | CPP | code_generation | CPU | 620,349 | [
"bool",
"AArch64TargetLowering",
"::",
"lowerInterleavedStore",
"(",
"StoreInst",
"*",
"SI",
",",
"ShuffleVectorInst",
"*",
"SVI",
",",
"unsigned",
"Factor",
")",
"const",
"{",
"assert",
"(",
"Factor",
">=",
"<NUM_LIT>",
"&&",
"Factor",
"<=",
"getMaxSupportedInterleaveFactor",
"(",
")",
"&&",
"<STR_LIT>",
"Invalid interleave factor",
"<STR_LIT>",
")",
";",
"VectorType",
"*",
"VecTy",
"=",
"SVI",
"->",
"getType",
"(",
")",
";",
"assert",
"(",
"VecTy",
"->",
"getVectorNumElements",
"(",
")",
"%",
"Factor",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Invalid interleaved store",
"<STR_LIT>",
")",
";",
"unsigned",
"LaneLen",
"=",
"VecTy",
"->",
"getVectorNumElements",
"(",
")",
"/",
"Factor",
";",
"Type",
"*",
"EltTy",
"=",
"VecTy",
"->",
"getVectorElementType",
"(",
")",
";",
"VectorType",
"*",
"SubVecTy",
"=",
"VectorType",
"::",
"get",
"(",
"EltTy",
",",
"LaneLen",
")",
";",
"const",
"DataLayout",
"&",
"DL",
"=",
"SI",
"->",
"getModule",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"unsigned",
"SubVecSize",
"=",
"DL",
".",
"getTypeSizeInBits",
"(",
"SubVecTy",
")",
";",
"if",
"(",
"!",
"Subtarget",
"->",
"hasNEON",
"(",
")",
"||",
"(",
"SubVecSize",
"!=",
"<NUM_LIT>",
"&&",
"SubVecSize",
"%",
"<NUM_LIT>",
"!=",
"<NUM_LIT>",
")",
")",
"return",
"false",
";",
"unsigned",
"NumStores",
"=",
"getNumInterleavedAccesses",
"(",
"SubVecTy",
",",
"DL",
")",
";",
"Value",
"*",
"Op0",
"=",
"SVI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"Value",
"*",
"Op1",
"=",
"SVI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"IRBuilder",
"<",
">",
"Builder",
"(",
"SI",
")",
";",
"if",
"(",
"EltTy",
"->",
"isPointerTy",
"(",
")",
")",
"{",
"Type",
"*",
"IntTy",
"=",
"DL",
".",
"getIntPtrType",
"(",
"EltTy",
")",
";",
"unsigned",
"NumOpElts",
"=",
"dyn_cast",
"<",
"VectorType",
">",
"(",
"Op0",
"->",
"getType",
"(",
")",
")",
"->",
"getVectorNumElements",
"(",
")",
";",
"Type",
"*",
"IntVecTy",
"=",
"VectorType",
"::",
"get",
"(",
"IntTy",
",",
"NumOpElts",
")",
";",
"Op0",
"=",
"Builder",
".",
"CreatePtrToInt",
"(",
"Op0",
",",
"IntVecTy",
")",
";",
"Op1",
"=",
"Builder",
".",
"CreatePtrToInt",
"(",
"Op1",
",",
"IntVecTy",
")",
";",
"SubVecTy",
"=",
"VectorType",
"::",
"get",
"(",
"IntTy",
",",
"LaneLen",
")",
";",
"}",
"Value",
"*",
"BaseAddr",
"=",
"SI",
"->",
"getPointerOperand",
"(",
")",
";",
"if",
"(",
"NumStores",
">",
"<NUM_LIT>",
")",
"{",
"LaneLen",
"/",
"=",
"NumStores",
";",
"SubVecTy",
"=",
"VectorType",
"::",
"get",
"(",
"SubVecTy",
"->",
"getVectorElementType",
"(",
")",
",",
"LaneLen",
")",
";",
"BaseAddr",
"=",
"Builder",
".",
"CreateBitCast",
"(",
"BaseAddr",
",",
"SubVecTy",
"->",
"getVectorElementType",
"(",
")",
"->",
"getPointerTo",
"(",
"SI",
"->",
"getPointerAddressSpace",
"(",
")",
")",
")",
";",
"}",
"auto",
"Mask",
"=",
"SVI",
"->",
"getShuffleMask",
"(",
")",
";",
"Type",
"*",
"PtrTy",
"=",
"SubVecTy",
"->",
"getPointerTo",
"(",
"SI",
"->",
"getPointerAddressSpace",
"(",
")",
")",
";",
"Type",
"*",
"Tys",
"[",
"<NUM_LIT>",
"]",
"=",
"{",
"SubVecTy",
",",
"PtrTy",
"}",
";",
"static",
"const",
"Intrinsic",
"::",
"ID",
"StoreInts",
"[",
"<NUM_LIT>",
"]",
"=",
"{",
"Intrinsic",
"::",
"aarch64_neon_st2",
",",
"Intrinsic",
"::",
"aarch64_neon_st3",
",",
"Intrinsic",
"::",
"aarch64_neon_st4",
"}",
";",
"Function",
"*",
"StNFunc",
"=",
"Intrinsic",
"::",
"getDeclaration",
"(",
"SI",
"->",
"getModule",
"(",
")",
",",
"StoreInts",
"[",
"Factor",
"-",
"<NUM_LIT>",
"]",
",",
"Tys",
")",
";",
"for",
"(",
"unsigned",
"StoreCount",
"=",
"<NUM_LIT>",
";",
"StoreCount",
"<",
"NumStores",
";",
"++",
"StoreCount",
")",
"{",
"SmallVector",
"<",
"Value",
"*",
",",
"<NUM_LIT>",
">",
"Ops",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"Factor",
";",
"i",
"++",
")",
"{",
"unsigned",
"IdxI",
"=",
"StoreCount",
"*",
"LaneLen",
"*",
"Factor",
"+",
"i",
";",
"if",
"(",
"Mask",
"[",
"IdxI",
"]",
">=",
"<NUM_LIT>",
")",
"{",
"Ops",
".",
"push_back",
"(",
"Builder",
".",
"CreateShuffleVector",
"(",
"Op0",
",",
"Op1",
",",
"createSequentialMask",
"(",
"Builder",
",",
"Mask",
"[",
"IdxI",
"]",
",",
"LaneLen",
",",
"<NUM_LIT>",
")",
")",
")",
";",
"}",
"else",
"{",
"unsigned",
"StartMask",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"unsigned",
"j",
"=",
"<NUM_LIT>",
";",
"j",
"<",
"LaneLen",
";",
"j",
"++",
")",
"{",
"unsigned",
"IdxJ",
"=",
"StoreCount",
"*",
"LaneLen",
"*",
"Factor",
"+",
"j",
";",
"if",
"(",
"Mask",
"[",
"IdxJ",
"*",
"Factor",
"+",
"IdxI",
"]",
">=",
"<NUM_LIT>",
")",
"{",
"StartMask",
"=",
"Mask",
"[",
"IdxJ",
"*",
"Factor",
"+",
"IdxI",
"]",
"-",
"IdxJ",
";",
"break",
";",
"}",
"}",
"Ops",
".",
"push_back",
"(",
"Builder",
".",
"CreateShuffleVector",
"(",
"Op0",
",",
"Op1",
",",
"createSequentialMask",
"(",
"Builder",
",",
"StartMask",
",",
"LaneLen",
",",
"<NUM_LIT>",
")",
")",
")",
";",
"}",
"}",
"if",
"(",
"StoreCount",
">",
"<NUM_LIT>",
")",
"BaseAddr",
"=",
"Builder",
".",
"CreateConstGEP1_32",
"(",
"BaseAddr",
",",
"LaneLen",
"*",
"Factor",
")",
";",
"Ops",
".",
"push_back",
"(",
"Builder",
".",
"CreateBitCast",
"(",
"BaseAddr",
",",
"PtrTy",
")",
")",
";",
"Builder",
".",
"CreateCall",
"(",
"StNFunc",
",",
"Ops",
")",
";",
"}",
"return",
"true",
";",
"}"
] | [
"Lower",
"interleaved",
"store",
"(",
"s",
")",
"into",
"target",
"specific",
"instructions/intrinsics",
"."
] |
GCC | mep | MD | next_suggestion | CPU | 620,350 | [
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
] | [
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
LLVM | PowerPC | CPP | next_suggestion | CPU | 620,351 | [
"BuildMI",
"(",
"*",
"FuncInfo",
".",
"MBB",
",",
"FuncInfo",
".",
"InsertPt",
",",
"MIMD",
",",
"TII",
".",
"get",
"(",
"PPC",
"::",
"FRSP",
")",
",",
"ResultReg",
")",
".",
"addReg",
"(",
"SourcePhysReg",
")",
";"
] | [
"assert",
"(",
"RVLocs",
".",
"size",
"(",
")",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"No support for multi-reg return values!",
"<STR_LIT>",
")",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"<STR_LIT>",
"Can only return in registers!",
"<STR_LIT>",
")",
";",
"MVT",
"DestVT",
"=",
"VA",
".",
"getValVT",
"(",
")",
";",
"MVT",
"CopyVT",
"=",
"DestVT",
";",
"if",
"(",
"RetVT",
"==",
"MVT",
"::",
"i8",
"||",
"RetVT",
"==",
"MVT",
"::",
"i16",
"||",
"RetVT",
"==",
"MVT",
"::",
"i32",
")",
"CopyVT",
"=",
"MVT",
"::",
"i64",
";",
"unsigned",
"SourcePhysReg",
"=",
"VA",
".",
"getLocReg",
"(",
")",
";",
"unsigned",
"ResultReg",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"RetVT",
"==",
"CopyVT",
")",
"{",
"const",
"TargetRegisterClass",
"*",
"CpyRC",
"=",
"TLI",
".",
"getRegClassFor",
"(",
"CopyVT",
")",
";",
"ResultReg",
"=",
"copyRegToRegClass",
"(",
"CpyRC",
",",
"SourcePhysReg",
")",
";",
"}",
"else",
"if",
"(",
"CopyVT",
"==",
"MVT",
"::",
"f64",
")",
"{",
"ResultReg",
"=",
"createResultReg",
"(",
"TLI",
".",
"getRegClassFor",
"(",
"RetVT",
")",
")",
";"
] |
LLVM | Mips | CPP | next_suggestion | CPU | 620,352 | [
"}"
] | [
"explicit",
"MipsDAGToDAGISel",
"(",
"MipsTargetMachine",
"&",
"tm",
")",
":",
"SelectionDAGISel",
"(",
"tm",
")",
",",
"TM",
"(",
"tm",
")",
",",
"Subtarget",
"(",
"tm",
".",
"getSubtarget",
"<",
"MipsSubtarget",
">",
"(",
")",
")",
"{"
] |
GCC | i386 | CPP | stmt_completion | CPU | 620,353 | [
"W",
",",
"_",
"_",
"mmask16",
"_",
"_",
"U",
",",
"_",
"_",
"m512i",
"_",
"_",
"X",
",",
"_",
"_",
"m512",
"_",
"_",
"Y",
")",
"{"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m512",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm512_mask_permutexvar_ps",
"(",
"_",
"_",
"m512",
"_",
"_"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 620,354 | [
"}"
] | [
"def",
"C2_not",
":",
"HInst",
"<",
"(",
"outs",
"PredRegs",
":",
"$",
"Pd4",
")",
",",
"(",
"ins",
"PredRegs",
":",
"$",
"Ps4",
")",
",",
"<STR_LIT>",
",",
"tc_de554571",
",",
"TypeCR",
">",
",",
"Enc_65d691",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 620,355 | [
"OddDeadKill",
"=",
"true",
";"
] | [
"bool",
"BaseUndef",
"=",
"BaseOp",
".",
"isUndef",
"(",
")",
";",
"unsigned",
"OffReg",
"=",
"isT2",
"?",
"<NUM_LIT>",
":",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"bool",
"OffKill",
"=",
"isT2",
"?",
"false",
":",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isKill",
"(",
")",
";",
"bool",
"OffUndef",
"=",
"isT2",
"?",
"false",
":",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isUndef",
"(",
")",
";",
"int",
"OffImm",
"=",
"getMemoryOpOffset",
"(",
"MI",
")",
";",
"unsigned",
"PredReg",
"=",
"<NUM_LIT>",
";",
"<STR_LIT>",
"::",
"<STR_LIT>",
"Pred",
"=",
"llvm",
"::",
"getInstrPredicate",
"(",
"MI",
",",
"PredReg",
")",
";",
"if",
"(",
"OddRegNum",
">",
"EvenRegNum",
"&&",
"OffReg",
"==",
"<NUM_LIT>",
"&&",
"OffImm",
"==",
"<NUM_LIT>",
")",
"{",
"unsigned",
"NewOpc",
"=",
"(",
"isLd",
")",
"?",
"(",
"isT2",
"?",
"ARM",
"::",
"t2LDM",
":",
"ARM",
"::",
"LDM",
")",
":",
"(",
"isT2",
"?",
"ARM",
"::",
"t2STM",
":",
"ARM",
"::",
"STM",
")",
";",
"if",
"(",
"isLd",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"NewOpc",
")",
")",
".",
"addReg",
"(",
"BaseReg",
",",
"getKillRegState",
"(",
"BaseKill",
")",
")",
".",
"addImm",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
".",
"addImm",
"(",
"Pred",
")",
".",
"addReg",
"(",
"PredReg",
")",
".",
"addReg",
"(",
"EvenReg",
",",
"getDefRegState",
"(",
"isLd",
")",
"|",
"getDeadRegState",
"(",
"EvenDeadKill",
")",
")",
".",
"addReg",
"(",
"OddReg",
",",
"getDefRegState",
"(",
"isLd",
")",
"|",
"getDeadRegState",
"(",
"OddDeadKill",
")",
")",
";",
"++",
"NumLDRD2LDM",
";",
"}",
"else",
"{",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"NewOpc",
")",
")",
".",
"addReg",
"(",
"BaseReg",
",",
"getKillRegState",
"(",
"BaseKill",
")",
")",
".",
"addImm",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
".",
"addImm",
"(",
"Pred",
")",
".",
"addReg",
"(",
"PredReg",
")",
".",
"addReg",
"(",
"EvenReg",
",",
"getKillRegState",
"(",
"EvenDeadKill",
")",
"|",
"getUndefRegState",
"(",
"EvenUndef",
")",
")",
".",
"addReg",
"(",
"OddReg",
",",
"getKillRegState",
"(",
"OddDeadKill",
")",
"|",
"getUndefRegState",
"(",
"OddUndef",
")",
")",
";",
"++",
"NumSTRD2STM",
";",
"}",
"NewBBI",
"=",
"llvm",
"::",
"prior",
"(",
"MBBI",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"(",
"!",
"isT2",
"||",
"!",
"OffReg",
")",
"&&",
"<STR_LIT>",
"Thumb2 ldrd / strd does not encode offset register!",
"<STR_LIT>",
")",
";",
"unsigned",
"NewOpc",
"=",
"(",
"isLd",
")",
"?",
"(",
"isT2",
"?",
"(",
"OffImm",
"<",
"<NUM_LIT>",
"?",
"ARM",
"::",
"t2LDRi8",
":",
"ARM",
"::",
"t2LDRi12",
")",
":",
"ARM",
"::",
"LDR",
")",
":",
"(",
"isT2",
"?",
"(",
"OffImm",
"<",
"<NUM_LIT>",
"?",
"ARM",
"::",
"t2STRi8",
":",
"ARM",
"::",
"t2STRi12",
")",
":",
"ARM",
"::",
"STR",
")",
";",
"DebugLoc",
"dl",
"=",
"MBBI",
"->",
"getDebugLoc",
"(",
")",
";",
"if",
"(",
"isLd",
"&&",
"(",
"BaseKill",
"||",
"OffKill",
")",
"&&",
"(",
"TRI",
"->",
"regsOverlap",
"(",
"EvenReg",
",",
"BaseReg",
")",
"||",
"(",
"OffReg",
"&&",
"TRI",
"->",
"regsOverlap",
"(",
"EvenReg",
",",
"OffReg",
")",
")",
")",
")",
"{",
"assert",
"(",
"!",
"TRI",
"->",
"regsOverlap",
"(",
"OddReg",
",",
"BaseReg",
")",
"&&",
"(",
"!",
"OffReg",
"||",
"!",
"TRI",
"->",
"regsOverlap",
"(",
"OddReg",
",",
"OffReg",
")",
")",
")",
";",
"InsertLDR_STR",
"(",
"MBB",
",",
"MBBI",
",",
"OffImm",
"+",
"<NUM_LIT>",
",",
"isLd",
",",
"dl",
",",
"NewOpc",
",",
"OddReg",
",",
"OddDeadKill",
",",
"false",
",",
"BaseReg",
",",
"false",
",",
"BaseUndef",
",",
"OffReg",
",",
"false",
",",
"OffUndef",
",",
"Pred",
",",
"PredReg",
",",
"TII",
",",
"isT2",
")",
";",
"NewBBI",
"=",
"llvm",
"::",
"prior",
"(",
"MBBI",
")",
";",
"InsertLDR_STR",
"(",
"MBB",
",",
"MBBI",
",",
"OffImm",
",",
"isLd",
",",
"dl",
",",
"NewOpc",
",",
"EvenReg",
",",
"EvenDeadKill",
",",
"false",
",",
"BaseReg",
",",
"BaseKill",
",",
"BaseUndef",
",",
"OffReg",
",",
"OffKill",
",",
"OffUndef",
",",
"Pred",
",",
"PredReg",
",",
"TII",
",",
"isT2",
")",
";",
"}",
"else",
"{",
"if",
"(",
"OddReg",
"==",
"EvenReg",
"&&",
"EvenDeadKill",
")",
"{",
"EvenDeadKill",
"=",
"false",
";"
] |
GCC | rs6000 | MD | stmt_completion | CPU | 620,356 | [
"]",
")"
] | [
"(",
"match_operand",
":",
"V16QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_BCDSHIFT",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"CCFP",
"CR6_REGNO",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | rs6000 | CPP | program_repair | CPU | 620,357 | [
"<FIXS>",
"struct",
"rs6000_reg_addr",
"{",
"enum",
"insn_code",
"reload_load",
";",
"enum",
"insn_code",
"reload_store",
";",
"enum",
"insn_code",
"reload_fpr_gpr",
";",
"enum",
"insn_code",
"reload_gpr_vsx",
";",
"enum",
"insn_code",
"reload_vsx_gpr",
";",
"}",
";",
"static",
"struct",
"rs6000_reg_addr",
"reg_addr",
"[",
"NUM_MACHINE_MODES",
"]",
";",
"<FIXE>"
] | [
"#",
"define",
"IS_FP_VECT_REG_TYPE",
"(",
"RTYPE",
")",
"IN_RANGE",
"(",
"RTYPE",
",",
"VSX_REG_TYPE",
",",
"FPR_REG_TYPE",
")",
"<BUGS>",
"static",
"enum",
"insn_code",
"reload_fpr_gpr",
"[",
"NUM_MACHINE_MODES",
"]",
";",
"static",
"enum",
"insn_code",
"reload_gpr_vsx",
"[",
"NUM_MACHINE_MODES",
"]",
";",
"static",
"enum",
"insn_code",
"reload_vsx_gpr",
"[",
"NUM_MACHINE_MODES",
"]",
";",
"<BUGE>"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 620,358 | [
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";"
] | [
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"P0",
"]",
";",
"let",
"Defs",
"=",
"[",
"P0",
",",
"PC",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 620,359 | [
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";"
] | [
"def",
"C2_cmoveit",
":",
"HInst",
"<",
"(",
"outs",
"IntRegs",
":",
"$",
"Rd32",
")",
",",
"(",
"ins",
"PredRegs",
":",
"$",
"Pu4",
",",
"s32_0Imm",
":",
"$",
"Ii",
")",
",",
"<STR_LIT>",
",",
"tc_5a2711e5",
",",
"TypeALU32_2op",
">",
",",
"Enc_cda00a",
",",
"PredNewRel",
",",
"ImmRegRel",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"hasNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"CextOpcode",
"=",
"<STR_LIT>",
";",
"let",
"InputType",
"=",
"<STR_LIT>",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isMoveImm",
"=",
"<NUM_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 620,360 | [
"let",
"isCodeGenOnly",
"=",
"<NUM_LIT>",
";"
] | [
"def",
"L4_iand_memoph_zomap",
":",
"HInst",
"<",
"(",
"outs",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rs32",
",",
"u5_0Imm",
":",
"$",
"II",
")",
",",
"<STR_LIT>",
",",
"tc_096199d3",
",",
"TypeMAPPING",
">",
"{",
"let",
"isPseudo",
"=",
"<NUM_LIT>",
";"
] |
GCC | i386 | CPP | next_suggestion | CPU | 620,361 | [
"}"
] | [
"bool",
"scalar_chain",
"::",
"build",
"(",
"bitmap",
"candidates",
",",
"unsigned",
"insn_uid",
",",
"bitmap",
"disallowed",
")",
"{",
"queue",
"=",
"BITMAP_ALLOC",
"(",
"NULL",
")",
";",
"bitmap_set_bit",
"(",
"queue",
",",
"insn_uid",
")",
";",
"if",
"(",
"dump_file",
")",
"fprintf",
"(",
"dump_file",
",",
"<STR_LIT>",
"Building chain #%d...\\n",
"<STR_LIT>",
",",
"chain_id",
")",
";",
"while",
"(",
"!",
"bitmap_empty_p",
"(",
"queue",
")",
")",
"{",
"insn_uid",
"=",
"bitmap_first_set_bit",
"(",
"queue",
")",
";",
"bitmap_clear_bit",
"(",
"queue",
",",
"insn_uid",
")",
";",
"bitmap_clear_bit",
"(",
"candidates",
",",
"insn_uid",
")",
";",
"if",
"(",
"!",
"add_insn",
"(",
"candidates",
",",
"insn_uid",
",",
"disallowed",
")",
")",
"{",
"bitmap_ior_into",
"(",
"disallowed",
",",
"insns",
")",
";",
"if",
"(",
"dump_file",
")",
"fprintf",
"(",
"dump_file",
",",
"<STR_LIT>",
"Aborted chain #%d discovery\\n",
"<STR_LIT>",
",",
"chain_id",
")",
";",
"BITMAP_FREE",
"(",
"queue",
")",
";",
"return",
"false",
";",
"}",
"}",
"if",
"(",
"dump_file",
")",
"{",
"fprintf",
"(",
"dump_file",
",",
"<STR_LIT>",
"Collected chain #%d...\\n",
"<STR_LIT>",
",",
"chain_id",
")",
";",
"fprintf",
"(",
"dump_file",
",",
"<STR_LIT>",
" insns: ",
"<STR_LIT>",
")",
";",
"dump_bitmap",
"(",
"dump_file",
",",
"insns",
")",
";",
"if",
"(",
"!",
"bitmap_empty_p",
"(",
"defs_conv",
")",
")",
"{",
"bitmap_iterator",
"bi",
";",
"unsigned",
"id",
";",
"const",
"char",
"*",
"comma",
"=",
"<STR_LIT>",
"<STR_LIT>",
";",
"fprintf",
"(",
"dump_file",
",",
"<STR_LIT>",
" defs to convert: ",
"<STR_LIT>",
")",
";",
"EXECUTE_IF_SET_IN_BITMAP",
"(",
"defs_conv",
",",
"<NUM_LIT>",
",",
"id",
",",
"bi",
")",
"{",
"fprintf",
"(",
"dump_file",
",",
"<STR_LIT>",
"%sr%d",
"<STR_LIT>",
",",
"comma",
",",
"id",
")",
";",
"comma",
"=",
"<STR_LIT>",
", ",
"<STR_LIT>",
";"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 620,362 | [
"SubIndices",
"=",
"Sub0_15_64",
";"
] | [
"AMDGPU",
"::",
"sub0_sub1",
",",
"AMDGPU",
"::",
"sub2_sub3",
",",
"AMDGPU",
"::",
"sub4_sub5",
",",
"AMDGPU",
"::",
"sub6_sub7",
",",
"}",
";",
"static",
"const",
"int16_t",
"Sub0_3",
"[",
"]",
"=",
"{",
"AMDGPU",
"::",
"sub0",
",",
"AMDGPU",
"::",
"sub1",
",",
"AMDGPU",
"::",
"sub2",
",",
"AMDGPU",
"::",
"sub3",
",",
"}",
";",
"static",
"const",
"int16_t",
"Sub0_3_64",
"[",
"]",
"=",
"{",
"AMDGPU",
"::",
"sub0_sub1",
",",
"AMDGPU",
"::",
"sub2_sub3",
",",
"}",
";",
"static",
"const",
"int16_t",
"Sub0_2",
"[",
"]",
"=",
"{",
"AMDGPU",
"::",
"sub0",
",",
"AMDGPU",
"::",
"sub1",
",",
"AMDGPU",
"::",
"sub2",
",",
"}",
";",
"static",
"const",
"int16_t",
"Sub0_1",
"[",
"]",
"=",
"{",
"AMDGPU",
"::",
"sub0",
",",
"AMDGPU",
"::",
"sub1",
",",
"}",
";",
"unsigned",
"Opcode",
";",
"ArrayRef",
"<",
"int16_t",
">",
"SubIndices",
";",
"if",
"(",
"AMDGPU",
"::",
"SReg_32RegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"{",
"assert",
"(",
"AMDGPU",
"::",
"SReg_32RegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"S_MOV_B32",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"AMDGPU",
"::",
"SReg_64RegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"{",
"if",
"(",
"DestReg",
"==",
"AMDGPU",
"::",
"VCC",
")",
"{",
"if",
"(",
"AMDGPU",
"::",
"SReg_64RegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"S_MOV_B64",
")",
",",
"AMDGPU",
"::",
"VCC",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"AMDGPU",
"::",
"VGPR_32RegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"V_CMP_NE_I32_e32",
")",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"}",
"return",
";",
"}",
"assert",
"(",
"AMDGPU",
"::",
"SReg_64RegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"S_MOV_B64",
")",
",",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"AMDGPU",
"::",
"SReg_128RegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"{",
"assert",
"(",
"AMDGPU",
"::",
"SReg_128RegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
";",
"Opcode",
"=",
"AMDGPU",
"::",
"S_MOV_B64",
";",
"SubIndices",
"=",
"Sub0_3_64",
";",
"}",
"else",
"if",
"(",
"AMDGPU",
"::",
"SReg_256RegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"{",
"assert",
"(",
"AMDGPU",
"::",
"SReg_256RegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
";",
"Opcode",
"=",
"AMDGPU",
"::",
"S_MOV_B64",
";",
"SubIndices",
"=",
"Sub0_7_64",
";",
"}",
"else",
"if",
"(",
"AMDGPU",
"::",
"SReg_512RegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"{",
"assert",
"(",
"AMDGPU",
"::",
"SReg_512RegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
";",
"Opcode",
"=",
"AMDGPU",
"::",
"S_MOV_B64",
";"
] |
GCC | mips | MD | program_repair | CPU | 620,363 | [
"<FIXS>",
"<STR_LIT>",
"<FIXE>"
] | [
"(",
"unspec",
":",
"V4QI",
"[",
"(",
"match_operand",
":",
"V2HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"V2HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_PRECR_QB_PH",
")",
")",
"]",
"<BUGS>",
"<STR_LIT>",
"<BUGE>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"\t",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"\t",
"<STR_LIT>",
")",
"]",
")"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 620,364 | [
"]",
"=",
"{"
] | [
"if",
"(",
"isa",
"<",
"ConstantExpr",
">",
"(",
"LoadNode",
"->",
"getMemOperand",
"(",
")",
"->",
"getValue",
"(",
")",
")",
"||",
"isa",
"<",
"Constant",
">",
"(",
"LoadNode",
"->",
"getMemOperand",
"(",
")",
"->",
"getValue",
"(",
")",
")",
"||",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"Ptr",
")",
")",
"{",
"SDValue",
"Slots",
"[",
"<NUM_LIT>",
"]",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"<NUM_LIT>",
";",
"i",
"++",
")",
"{",
"SDValue",
"NewPtr",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"Ptr",
".",
"getValueType",
"(",
")",
",",
"Ptr",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
"*",
"i",
"+",
"ConstantBlock",
"*",
"<NUM_LIT>",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"Slots",
"[",
"i",
"]",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"MVT",
"::",
"i32",
",",
"NewPtr",
")",
";",
"}",
"EVT",
"NewVT",
"=",
"MVT",
"::",
"v4i32",
";",
"unsigned",
"NumElements",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"VT",
".",
"isVector",
"(",
")",
")",
"{",
"NewVT",
"=",
"VT",
";",
"NumElements",
"=",
"VT",
".",
"getVectorNumElements",
"(",
")",
";",
"}",
"Result",
"=",
"DAG",
".",
"getBuildVector",
"(",
"NewVT",
",",
"DL",
",",
"makeArrayRef",
"(",
"Slots",
",",
"NumElements",
")",
")",
";",
"}",
"else",
"{",
"Result",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"MVT",
"::",
"v4i32",
",",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SRL",
",",
"DL",
",",
"MVT",
"::",
"i32",
",",
"Ptr",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
")",
",",
"DAG",
".",
"getConstant",
"(",
"LoadNode",
"->",
"getAddressSpace",
"(",
")",
"-",
"AMDGPUAS",
"::",
"CONSTANT_BUFFER_0",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"}",
"if",
"(",
"!",
"VT",
".",
"isVector",
"(",
")",
")",
"{",
"Result",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
",",
"DL",
",",
"MVT",
"::",
"i32",
",",
"Result",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"}",
"SDValue",
"MergedValues",
"[",
"<NUM_LIT>",
"]",
"=",
"{",
"Result",
",",
"Chain",
"}",
";",
"return",
"DAG",
".",
"getMergeValues",
"(",
"MergedValues",
",",
"DL",
")",
";",
"}",
"SDValue",
"LoweredLoad",
";",
"if",
"(",
"LoadNode",
"->",
"getExtensionType",
"(",
")",
"==",
"ISD",
"::",
"SEXTLOAD",
")",
"{",
"EVT",
"MemVT",
"=",
"LoadNode",
"->",
"getMemoryVT",
"(",
")",
";",
"assert",
"(",
"!",
"MemVT",
".",
"isVector",
"(",
")",
"&&",
"(",
"MemVT",
"==",
"MVT",
"::",
"i16",
"||",
"MemVT",
"==",
"MVT",
"::",
"i8",
")",
")",
";",
"SDValue",
"NewLoad",
"=",
"DAG",
".",
"getExtLoad",
"(",
"ISD",
"::",
"EXTLOAD",
",",
"DL",
",",
"VT",
",",
"Chain",
",",
"Ptr",
",",
"LoadNode",
"->",
"getPointerInfo",
"(",
")",
",",
"MemVT",
",",
"LoadNode",
"->",
"getAlignment",
"(",
")",
",",
"LoadNode",
"->",
"getMemOperand",
"(",
")",
"->",
"getFlags",
"(",
")",
")",
";",
"SDValue",
"Res",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SIGN_EXTEND_INREG",
",",
"DL",
",",
"VT",
",",
"NewLoad",
",",
"DAG",
".",
"getValueType",
"(",
"MemVT",
")",
")",
";",
"SDValue",
"MergedValues",
"[",
"<NUM_LIT>",
"]",
"=",
"{",
"Res",
",",
"Chain",
"}",
";",
"return",
"DAG",
".",
"getMergeValues",
"(",
"MergedValues",
",",
"DL",
")",
";",
"}",
"if",
"(",
"LoadNode",
"->",
"getAddressSpace",
"(",
")",
"!=",
"AMDGPUAS",
"::",
"PRIVATE_ADDRESS",
")",
"{",
"return",
"SDValue",
"(",
")",
";",
"}",
"const",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"const",
"R600FrameLowering",
"*",
"TFL",
"=",
"getSubtarget",
"(",
")",
"->",
"getFrameLowering",
"(",
")",
";",
"unsigned",
"StackWidth",
"=",
"TFL",
"->",
"getStackWidth",
"(",
"MF",
")",
";",
"Ptr",
"=",
"stackPtrToRegIndex",
"(",
"Ptr",
",",
"StackWidth",
",",
"DAG",
")",
";",
"if",
"(",
"VT",
".",
"isVector",
"(",
")",
")",
"{",
"unsigned",
"NumElemVT",
"=",
"VT",
".",
"getVectorNumElements",
"(",
")",
";",
"EVT",
"ElemVT",
"=",
"VT",
".",
"getVectorElementType",
"(",
")",
";",
"SDValue",
"Loads",
"[",
"<NUM_LIT>",
"]",
";",
"assert",
"(",
"NumElemVT",
"<=",
"<NUM_LIT>",
")",
";",
"assert",
"(",
"NumElemVT",
">=",
"StackWidth",
"&&",
"<STR_LIT>",
"Stack width cannot be greater than ",
"<STR_LIT>",
"<STR_LIT>",
"vector width in load",
"<STR_LIT>",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"NumElemVT",
";",
"++",
"i",
")",
"{",
"unsigned",
"Channel",
",",
"PtrIncr",
";",
"getStackAddress",
"(",
"StackWidth",
",",
"i",
",",
"Channel",
",",
"PtrIncr",
")",
";",
"Ptr",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"MVT",
"::",
"i32",
",",
"Ptr",
",",
"DAG",
".",
"getConstant",
"(",
"PtrIncr",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"Loads",
"[",
"i",
"]",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"ElemVT",
",",
"Chain",
",",
"Ptr",
",",
"DAG",
".",
"getTargetConstant",
"(",
"Channel",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"}",
"EVT",
"TargetVT",
"=",
"EVT",
"::",
"getVectorVT",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"ElemVT",
",",
"NumElemVT",
")",
";",
"LoweredLoad",
"=",
"DAG",
".",
"getBuildVector",
"(",
"TargetVT",
",",
"DL",
",",
"makeArrayRef",
"(",
"Loads",
",",
"NumElemVT",
")",
")",
";",
"}",
"else",
"{",
"LoweredLoad",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"VT",
",",
"Chain",
",",
"Ptr",
",",
"DAG",
".",
"getTargetConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"}",
"SDValue",
"Ops",
"[",
"<NUM_LIT>"
] |
LLVM | Hexagon | CPP | next_suggestion | DSP | 620,365 | [
"for",
"(",
"mb_iterator",
"I",
"=",
"B",
".",
"begin",
"(",
")",
",",
"E",
"=",
"B",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{"
] | [
"for",
"(",
"mf_iterator",
"A",
"=",
"MFN",
"->",
"begin",
"(",
")",
",",
"Z",
"=",
"MFN",
"->",
"end",
"(",
")",
";",
"A",
"!=",
"Z",
";",
"++",
"A",
")",
"{",
"const",
"MachineBasicBlock",
"&",
"B",
"=",
"*",
"A",
";",
"if",
"(",
"!",
"CMS",
"->",
"BT",
".",
"reached",
"(",
"&",
"B",
")",
")",
"continue",
";",
"using",
"mb_iterator",
"=",
"MachineBasicBlock",
"::",
"const_iterator",
";"
] |
LLVM | ARM64 | TD | next_suggestion | CPU | 620,366 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"dst",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"V",
";",
"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>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"base",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 620,367 | [
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";"
] | [
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"P1",
"]",
";",
"let",
"Defs",
"=",
"[",
"P1",
",",
"PC",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 620,368 | [
"}"
] | [
"unsigned",
"NumVectorInstToHideOverhead",
"=",
"<NUM_LIT>",
";",
"int",
"MaxMergeDistance",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"ST",
"->",
"hasNEON",
"(",
")",
")",
"{",
"if",
"(",
"Ty",
"->",
"isVectorTy",
"(",
")",
"&&",
"SE",
"&&",
"!",
"BaseT",
"::",
"isConstantStridedAccessLessThan",
"(",
"SE",
",",
"Ptr",
",",
"MaxMergeDistance",
"+",
"<NUM_LIT>",
")",
")",
"return",
"NumVectorInstToHideOverhead",
";",
"return",
"<NUM_LIT>",
";",
"}",
"return",
"BaseT",
"::",
"getAddressComputationCost",
"(",
"Ty",
",",
"SE",
",",
"Ptr",
")",
";"
] |
GCC | s390 | MD | next_suggestion | MPU | 620,369 | [
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
] | [
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | i386 | CPP | stmt_completion | CPU | 620,370 | [
"mmask8",
")",
"-",
"<NUM_LIT>",
")",
";"
] | [
"return",
"(",
"_",
"_",
"m256i",
")",
"_",
"_",
"builtin_ia32_prold256_mask",
"(",
"(",
"_",
"_",
"v8si",
")",
"_",
"_",
"A",
",",
"_",
"_",
"B",
",",
"(",
"_",
"_",
"v8si",
")",
"_",
"mm256_setzero_si256",
"(",
")",
",",
"(",
"_",
"_"
] |
GCC | arm | CPP | stmt_completion | CPU | 620,371 | [
"int",
"_",
"_",
"b",
")",
"{"
] | [
"vcvth_n_f16_u32",
"(",
"uint32_t",
"_",
"_",
"a",
",",
"const"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 620,372 | [
"<NUM_LIT>",
";"
] | [
"if",
"(",
"Parser",
".",
"getTok",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"LCurly",
")",
")",
"return",
"MatchOperand_NoMatch",
";",
"SMLoc",
"S",
"=",
"getLoc",
"(",
")",
";",
"StringRef",
"Kind",
";",
"int",
"FirstReg",
"=",
"tryMatchSVEVectorRegister",
"(",
"Parser",
".",
"getLexer",
"(",
")",
".",
"peekTok",
"(",
")",
",",
"Kind",
",",
"false",
")",
";",
"if",
"(",
"FirstReg",
"==",
"-",
"<NUM_LIT>",
")",
"return",
"MatchOperand_NoMatch",
";",
"Parser",
".",
"Lex",
"(",
")",
";",
"Parser",
".",
"Lex",
"(",
")",
";",
"int64_t",
"PrevReg",
"=",
"FirstReg",
";",
"unsigned",
"Count",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"Kind",
".",
"empty",
"(",
")",
")",
"return",
"MatchOperand_NoMatch",
";",
"while",
"(",
"Parser",
".",
"getTok",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Comma",
")",
")",
"{",
"Parser",
".",
"Lex",
"(",
")",
";",
"SMLoc",
"Loc",
"=",
"getLoc",
"(",
")",
";",
"StringRef",
"NextKind",
";",
"int",
"Reg",
"=",
"tryMatchSVEVectorRegister",
"(",
"Parser",
".",
"getTok",
"(",
")",
",",
"NextKind",
",",
"false",
")",
";",
"if",
"(",
"Reg",
"==",
"-",
"<NUM_LIT>",
")",
"return",
"MatchOperand_NoMatch",
";",
"Parser",
".",
"Lex",
"(",
")",
";",
"if",
"(",
"Kind",
"!=",
"NextKind",
")",
"{",
"Error",
"(",
"Loc",
",",
"<STR_LIT>",
"mismatched sve register size suffix",
"<STR_LIT>",
")",
";",
"return",
"MatchOperand_ParseFail",
";",
"}",
"if",
"(",
"getContext",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
"->",
"getEncodingValue",
"(",
"Reg",
")",
"!=",
"(",
"getContext",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
"->",
"getEncodingValue",
"(",
"PrevReg",
")",
"+",
"<NUM_LIT>",
")",
"%",
"<NUM_LIT>",
")",
"{",
"Error",
"(",
"Loc",
",",
"<STR_LIT>",
"sve registers must be sequential",
"<STR_LIT>",
")",
";",
"return",
"MatchOperand_ParseFail",
";",
"}",
"PrevReg",
"=",
"Reg",
";",
"Count",
"++",
";",
"}",
"if",
"(",
"Count",
">",
"<NUM_LIT>",
")",
"{",
"Error",
"(",
"S",
",",
"<STR_LIT>",
"invalid number of sve vectors",
"<STR_LIT>",
")",
";",
"return",
"MatchOperand_ParseFail",
";",
"}",
"if",
"(",
"Parser",
".",
"getTok",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"RCurly",
")",
")",
"{",
"Error",
"(",
"getLoc",
"(",
")",
",",
"<STR_LIT>",
"'}' expected",
"<STR_LIT>",
")",
";",
"return",
"MatchOperand_ParseFail",
";",
"}",
"Parser",
".",
"Lex",
"(",
")",
";",
"const",
"int",
"NumElements",
"="
] |
LLVM | AMDGPU | CPP | program_repair | GPU | 620,373 | [
"<FIXS>",
"Register",
"Tmp",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
")",
";",
"<FIXE>"
] | [
"auto",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
",",
"DestReg",
")",
";",
"if",
"(",
"RI",
".",
"hasAGPRs",
"(",
"RC",
")",
")",
"{",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"<BUGS>",
"unsigned",
"Tmp",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
")",
";",
"<BUGE>",
"MIB",
".",
"addReg",
"(",
"Tmp",
",",
"RegState",
"::",
"Define",
")",
";",
"}",
"MIB",
".",
"addFrameIndex",
"(",
"FrameIndex",
")"
] |
LLVM | BPF | CPP | next_suggestion | Virtual ISA | 620,374 | [
"}"
] | [
"void",
"BPFAsmBackend",
"::",
"applyFixup",
"(",
"const",
"MCAssembler",
"&",
"Asm",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
"Target",
",",
"MutableArrayRef",
"<",
"char",
">",
"Data",
",",
"uint64_t",
"Value",
",",
"bool",
"IsResolved",
",",
"const",
"MCSubtargetInfo",
"*",
"STI",
")",
"const",
"{",
"if",
"(",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"FK_SecRel_4",
"||",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"FK_SecRel_8",
")",
"{",
"if",
"(",
"Value",
")",
"{",
"MCContext",
"&",
"Ctx",
"=",
"Asm",
".",
"getContext",
"(",
")",
";",
"Ctx",
".",
"reportError",
"(",
"Fixup",
".",
"getLoc",
"(",
")",
",",
"<STR_LIT>",
"Unsupported relocation: try to compile with -O2 or above, ",
"<STR_LIT>",
"<STR_LIT>",
"or check your static variable usage",
"<STR_LIT>",
")",
";",
"}",
"}",
"else",
"if",
"(",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"FK_Data_4",
")",
"{",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint32_t",
">",
"(",
"&",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"]",
",",
"Value",
",",
"Endian",
")",
";",
"}",
"else",
"if",
"(",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"FK_Data_8",
")",
"{",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint64_t",
">",
"(",
"&",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"]",
",",
"Value",
",",
"Endian",
")",
";",
"}",
"else",
"if",
"(",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"FK_PCRel_4",
")",
"{",
"Value",
"=",
"(",
"uint32_t",
")",
"(",
"(",
"Value",
"-",
"<NUM_LIT>",
")",
"/",
"<NUM_LIT>",
")",
";",
"if",
"(",
"Endian",
"==",
"support",
"::",
"little",
")",
"{",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"<NUM_LIT>",
"]",
"=",
"<NUM_LIT>",
";",
"support",
"::",
"endian",
"::",
"write32le",
"(",
"&",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"<NUM_LIT>",
"]",
",",
"Value",
")",
";",
"}",
"else",
"{",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"<NUM_LIT>",
"]",
"=",
"<NUM_LIT>",
";",
"support",
"::",
"endian",
"::",
"write32be",
"(",
"&",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"<NUM_LIT>",
"]",
",",
"Value",
")",
";"
] |
GCC | avr | CPP | program_repair | MPU | 620,375 | [
"<FIXS>",
"mcus",
"[",
"ARRAY_SIZE",
"(",
"avr_mcu_types",
")",
"]",
";",
"<FIXE>"
] | [
"#",
"define",
"IN_GEN_AVR_MMCU_TEXI",
"#",
"include",
"<STR_LIT>",
"avr-devices.cc",
"<STR_LIT>",
"static",
"const",
"avr_mcu_t",
"*",
"<BUGS>",
"mcus",
"[",
"sizeof",
"avr_mcu_types",
"/",
"sizeof",
"avr_mcu_types",
"[",
"<NUM_LIT>",
"]",
"]",
";",
"<BUGE>",
"static",
"int",
"letter",
"(",
"char",
"c",
")",
"{"
] |
LLVM | ARM | CPP | code_generation | CPU | 620,376 | [
"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",
"(",
"!",
"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 | i386 | MD | stmt_completion | CPU | 620,377 | [
"<STR_LIT>",
")"
] | [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 620,378 | [
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicated",
"=",
"<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",
"=",
"[",
"P0",
"]",
";",
"let",
"Defs",
"=",
"[",
"P0",
",",
"PC",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";"
] |
LLVM | WebAssembly | CPP | code_generation | Virtual ISA | 620,379 | [
"bool",
"WebAssemblyFastISel",
"::",
"fastLowerArguments",
"(",
")",
"{",
"if",
"(",
"!",
"FuncInfo",
".",
"CanLowerReturn",
")",
"return",
"false",
";",
"const",
"Function",
"*",
"F",
"=",
"FuncInfo",
".",
"Fn",
";",
"if",
"(",
"F",
"->",
"isVarArg",
"(",
")",
")",
"return",
"false",
";",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"auto",
"const",
"&",
"Arg",
":",
"F",
"->",
"args",
"(",
")",
")",
"{",
"const",
"AttributeSet",
"&",
"Attrs",
"=",
"F",
"->",
"getAttributes",
"(",
")",
";",
"if",
"(",
"Attrs",
".",
"hasAttribute",
"(",
"i",
"+",
"<NUM_LIT>",
",",
"Attribute",
"::",
"ByVal",
")",
"||",
"Attrs",
".",
"hasAttribute",
"(",
"i",
"+",
"<NUM_LIT>",
",",
"Attribute",
"::",
"SwiftSelf",
")",
"||",
"Attrs",
".",
"hasAttribute",
"(",
"i",
"+",
"<NUM_LIT>",
",",
"Attribute",
"::",
"SwiftError",
")",
"||",
"Attrs",
".",
"hasAttribute",
"(",
"i",
"+",
"<NUM_LIT>",
",",
"Attribute",
"::",
"InAlloca",
")",
"||",
"Attrs",
".",
"hasAttribute",
"(",
"i",
"+",
"<NUM_LIT>",
",",
"Attribute",
"::",
"Nest",
")",
")",
"return",
"false",
";",
"Type",
"*",
"ArgTy",
"=",
"Arg",
".",
"getType",
"(",
")",
";",
"if",
"(",
"ArgTy",
"->",
"isStructTy",
"(",
")",
"||",
"ArgTy",
"->",
"isArrayTy",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"Subtarget",
"->",
"hasSIMD128",
"(",
")",
"&&",
"ArgTy",
"->",
"isVectorTy",
"(",
")",
")",
"return",
"false",
";",
"unsigned",
"Opc",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
";",
"switch",
"(",
"getSimpleType",
"(",
"ArgTy",
")",
")",
"{",
"case",
"MVT",
"::",
"i1",
":",
"case",
"MVT",
"::",
"i8",
":",
"case",
"MVT",
"::",
"i16",
":",
"case",
"MVT",
"::",
"i32",
":",
"Opc",
"=",
"WebAssembly",
"::",
"ARGUMENT_I32",
";",
"RC",
"=",
"&",
"WebAssembly",
"::",
"I32RegClass",
";",
"break",
";",
"case",
"MVT",
"::",
"i64",
":",
"Opc",
"=",
"WebAssembly",
"::",
"ARGUMENT_I64",
";",
"RC",
"=",
"&",
"WebAssembly",
"::",
"I64RegClass",
";",
"break",
";",
"case",
"MVT",
"::",
"f32",
":",
"Opc",
"=",
"WebAssembly",
"::",
"ARGUMENT_F32",
";",
"RC",
"=",
"&",
"WebAssembly",
"::",
"F32RegClass",
";",
"break",
";",
"case",
"MVT",
"::",
"f64",
":",
"Opc",
"=",
"WebAssembly",
"::",
"ARGUMENT_F64",
";",
"RC",
"=",
"&",
"WebAssembly",
"::",
"F64RegClass",
";",
"break",
";",
"case",
"MVT",
"::",
"v16i8",
":",
"Opc",
"=",
"WebAssembly",
"::",
"ARGUMENT_v16i8",
";",
"RC",
"=",
"&",
"WebAssembly",
"::",
"V128RegClass",
";",
"break",
";",
"case",
"MVT",
"::",
"v8i16",
":",
"Opc",
"=",
"WebAssembly",
"::",
"ARGUMENT_v8i16",
";",
"RC",
"=",
"&",
"WebAssembly",
"::",
"V128RegClass",
";",
"break",
";",
"case",
"MVT",
"::",
"v4i32",
":",
"Opc",
"=",
"WebAssembly",
"::",
"ARGUMENT_v4i32",
";",
"RC",
"=",
"&",
"WebAssembly",
"::",
"V128RegClass",
";",
"break",
";",
"case",
"MVT",
"::",
"v4f32",
":",
"Opc",
"=",
"WebAssembly",
"::",
"ARGUMENT_v4f32",
";",
"RC",
"=",
"&",
"WebAssembly",
"::",
"V128RegClass",
";",
"break",
";",
"default",
":",
"return",
"false",
";",
"}",
"unsigned",
"ResultReg",
"=",
"createResultReg",
"(",
"RC",
")",
";",
"BuildMI",
"(",
"*",
"FuncInfo",
".",
"MBB",
",",
"FuncInfo",
".",
"InsertPt",
",",
"DbgLoc",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"ResultReg",
")",
".",
"addImm",
"(",
"i",
")",
";",
"updateValueMap",
"(",
"&",
"Arg",
",",
"ResultReg",
")",
";",
"++",
"i",
";",
"}",
"MRI",
".",
"addLiveIn",
"(",
"WebAssembly",
"::",
"ARGUMENTS",
")",
";",
"auto",
"*",
"MFI",
"=",
"MF",
"->",
"getInfo",
"<",
"WebAssemblyFunctionInfo",
">",
"(",
")",
";",
"for",
"(",
"auto",
"const",
"&",
"Arg",
":",
"F",
"->",
"args",
"(",
")",
")",
"MFI",
"->",
"addParam",
"(",
"getLegalType",
"(",
"getSimpleType",
"(",
"Arg",
".",
"getType",
"(",
")",
")",
")",
")",
";",
"if",
"(",
"!",
"F",
"->",
"getReturnType",
"(",
")",
"->",
"isVoidTy",
"(",
")",
")",
"MFI",
"->",
"addResult",
"(",
"getLegalType",
"(",
"getSimpleType",
"(",
"F",
"->",
"getReturnType",
"(",
")",
")",
")",
")",
";",
"return",
"true",
";",
"}"
] | [
"This",
"method",
"is",
"called",
"by",
"target-independent",
"code",
"to",
"do",
"target-",
"specific",
"argument",
"lowering",
"."
] |
LLVM | BPF | CPP | program_repair | Virtual ISA | 620,380 | [
"<FIXS>",
"visitDerivedType",
"(",
"DTy",
",",
"TypeId",
",",
"CheckPointer",
",",
"SeenPointer",
")",
";",
"<FIXE>",
"<FIXS>",
"visitTypeEntry",
"(",
"Ty",
",",
"TypeId",
",",
"false",
",",
"false",
")",
";",
"}",
"void",
"BTFDebug",
"::",
"visitMapDefType",
"(",
"const",
"DIType",
"*",
"Ty",
",",
"uint32_t",
"&",
"TypeId",
")",
"{",
"if",
"(",
"!",
"Ty",
"||",
"DIToIdMap",
".",
"find",
"(",
"Ty",
")",
"!=",
"DIToIdMap",
".",
"end",
"(",
")",
")",
"{",
"TypeId",
"=",
"DIToIdMap",
"[",
"Ty",
"]",
";",
"return",
";",
"}",
"const",
"auto",
"*",
"CTy",
"=",
"dyn_cast",
"DICompositeType",
">",
"(",
"Ty",
")",
";",
"if",
"(",
"!",
"CTy",
")",
"return",
";",
"auto",
"Tag",
"=",
"CTy",
"->",
"getTag",
"(",
")",
";",
"if",
"(",
"Tag",
"!=",
"dwarf",
"::",
"DW_TAG_structure_type",
"||",
"CTy",
"->",
"isForwardDecl",
"(",
")",
")",
"return",
";",
"const",
"DINodeArray",
"Elements",
"=",
"CTy",
"->",
"getElements",
"(",
")",
";",
"bool",
"HasBitField",
"=",
"false",
";",
"for",
"(",
"const",
"auto",
"*",
"Element",
":",
"Elements",
")",
"{",
"auto",
"E",
"=",
"cast",
"DIDerivedType",
">",
"(",
"Element",
")",
";",
"if",
"(",
"E",
"->",
"isBitField",
"(",
")",
")",
"{",
"HasBitField",
"=",
"true",
";",
"break",
";",
"}",
"}",
"auto",
"TypeEntry",
"=",
"llvm",
"::",
"make_unique",
"BTFTypeStruct",
">",
"(",
"CTy",
",",
"true",
",",
"HasBitField",
",",
"Elements",
".",
"size",
"(",
")",
")",
";",
"StructTypes",
".",
"push_back",
"(",
"TypeEntry",
".",
"get",
"(",
")",
")",
";",
"TypeId",
"=",
"addType",
"(",
"std",
"::",
"move",
"(",
"TypeEntry",
")",
",",
"CTy",
")",
";",
"for",
"(",
"const",
"auto",
"*",
"Element",
":",
"Elements",
")",
"{",
"const",
"auto",
"*",
"MemberType",
"=",
"cast",
"DIDerivedType",
">",
"(",
"Element",
")",
";",
"visitTypeEntry",
"(",
"MemberType",
"->",
"getBaseType",
"(",
")",
")",
";",
"}",
"<FIXE>"
] | [
"else",
"if",
"(",
"const",
"auto",
"*",
"CTy",
"=",
"dyn_cast",
"DICompositeType",
">",
"(",
"Ty",
")",
")",
"visitCompositeType",
"(",
"CTy",
",",
"TypeId",
")",
";",
"else",
"if",
"(",
"const",
"auto",
"*",
"DTy",
"=",
"dyn_cast",
"DIDerivedType",
">",
"(",
"Ty",
")",
")",
"<BUGS>",
"visitDerivedType",
"(",
"DTy",
",",
"TypeId",
")",
";",
"<BUGE>",
"elsellvm_unreachable",
"(",
"<STR_LIT>",
"Unknown DIType",
"<STR_LIT>",
")",
";",
"}",
"void",
"BTFDebug",
"::",
"visitTypeEntry",
"(",
"const",
"DIType",
"*",
"Ty",
")",
"{",
"uint32_t",
"TypeId",
";",
"<BUGS>",
"visitTypeEntry",
"(",
"Ty",
",",
"TypeId",
")",
";",
"<BUGE>",
"}"
] |
LLVM | SystemZ | TD | next_suggestion | CPU | 620,381 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"I2",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"V3",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"I2",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"M4",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"op",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"V1",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"V3",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] |
LLVM | XCore | CPP | stmt_completion | MPU | 620,382 | [
"::",
"i32",
";"
] | [
"return",
"MVT"
] |
GCC | i386 | CPP | next_suggestion | CPU | 620,383 | [
"}"
] | [
"extern",
"_",
"_",
"inline",
"void",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm256_storeu_ps",
"(",
"float",
"*",
"_",
"_",
"P",
",",
"_",
"_",
"m256",
"_",
"_",
"A",
")",
"{",
"*",
"(",
"_",
"_",
"m256_u",
"*",
")",
"_",
"_",
"P",
"=",
"_",
"_",
"A",
";"
] |
GCC | rs6000 | MD | next_suggestion | CPU | 620,384 | [
"}",
")"
] | [
"(",
"float_truncate",
":",
"TF",
"(",
"match_operand",
":",
"KF",
"<NUM_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"{",
"rs6000_expand_float128_convert",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"false",
")",
"DONE"
] |
GCC | i386 | MD | stmt_completion | CPU | 620,385 | [
"<STR_LIT>",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>"
] |
GCC | arm | CPP | stmt_completion | CPU | 620,386 | [
"mve_pred16_t",
"_",
"_",
"p",
")",
"{"
] | [
"_",
"_",
"arm_vstrbq_p",
"(",
"uint8_t",
"*",
"_",
"_",
"addr",
",",
"uint16x8_t",
"_",
"_",
"value",
","
] |
LLVM | CellSPU | CPP | program_repair | MPU | 620,387 | [
"<FIXS>",
"if",
"(",
"Op0",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"Constant",
"||",
"Op0",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"TargetConstant",
")",
"{",
"<FIXE>"
] | [
"const",
"SDOperand",
"Op0",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"const",
"SDOperand",
"Op1",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"<BUGS>",
"if",
"(",
"Op0",
".",
"getOpcode",
"(",
")",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"<BUGE>",
"ConstantSDNode",
"*",
"CN",
"=",
"cast",
"ConstantSDNode",
">",
"(",
"Op1",
")",
";",
"assert",
"(",
"CN",
"!=",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"SelectDFormAddr/SPUISD::DFormAddr expecting constant",
"<STR_LIT>",
")",
";",
"Base",
"=",
"CurDAG",
"->",
"getTargetConstant",
"(",
"CN",
"->",
"getValue",
"(",
")",
",",
"PtrTy",
")",
";"
] |
LLVM | PowerPC | CPP | stmt_completion | CPU | 620,388 | [
"Imm",
")",
";"
] | [
"return",
"isIntS16Immediate",
"(",
"Op",
".",
"getNode",
"(",
")",
","
] |
LLVM | AMDGPU | CPP | program_repair | GPU | 620,389 | [
"<FIXS>",
"HardwareLimits",
"Limits",
"=",
"{",
"}",
";",
"Limits",
".",
"VmcntMax",
"=",
"AMDGPU",
"::",
"getVmcntBitMask",
"(",
"IV",
")",
";",
"Limits",
".",
"ExpcntMax",
"=",
"AMDGPU",
"::",
"getExpcntBitMask",
"(",
"IV",
")",
";",
"Limits",
".",
"LgkmcntMax",
"=",
"AMDGPU",
"::",
"getLgkmcntBitMask",
"(",
"IV",
")",
";",
"Limits",
".",
"VscntMax",
"=",
"ST",
"->",
"hasVscnt",
"(",
")",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
";",
"<FIXE>",
"<FIXS>",
"RegisterEncoding",
"Encoding",
"=",
"{",
"}",
";",
"Encoding",
".",
"VGPR0",
"=",
"TRI",
"->",
"getEncodingValue",
"(",
"AMDGPU",
"::",
"VGPR0",
")",
";",
"Encoding",
".",
"VGPRL",
"=",
"Encoding",
".",
"VGPR0",
"+",
"NumVGPRsMax",
"-",
"<NUM_LIT>",
";",
"Encoding",
".",
"SGPR0",
"=",
"TRI",
"->",
"getEncodingValue",
"(",
"AMDGPU",
"::",
"SGPR0",
")",
";",
"Encoding",
".",
"SGPRL",
"=",
"Encoding",
".",
"SGPR0",
"+",
"NumSGPRsMax",
"-",
"<NUM_LIT>",
";",
"<FIXE>"
] | [
"for",
"(",
"auto",
"T",
":",
"inst_counter_types",
"(",
")",
")",
"ForceEmitWaitcnt",
"[",
"T",
"]",
"=",
"false",
";",
"<BUGS>",
"HardwareLimits",
".",
"VmcntMax",
"=",
"AMDGPU",
"::",
"getVmcntBitMask",
"(",
"IV",
")",
";",
"HardwareLimits",
".",
"ExpcntMax",
"=",
"AMDGPU",
"::",
"getExpcntBitMask",
"(",
"IV",
")",
";",
"HardwareLimits",
".",
"LgkmcntMax",
"=",
"AMDGPU",
"::",
"getLgkmcntBitMask",
"(",
"IV",
")",
";",
"HardwareLimits",
".",
"VscntMax",
"=",
"ST",
"->",
"hasVscnt",
"(",
")",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
";",
"<BUGE>",
"unsigned",
"NumVGPRsMax",
"=",
"ST",
"->",
"getAddressableNumVGPRs",
"(",
")",
";",
"unsigned",
"NumSGPRsMax",
"=",
"ST",
"->",
"getAddressableNumSGPRs",
"(",
")",
";",
"assert",
"(",
"NumVGPRsMax",
"<=",
"SQ_MAX_PGM_VGPRS",
")",
";",
"assert",
"(",
"NumSGPRsMax",
"<=",
"SQ_MAX_PGM_SGPRS",
")",
";",
"<BUGS>",
"RegisterEncoding",
".",
"VGPR0",
"=",
"TRI",
"->",
"getEncodingValue",
"(",
"AMDGPU",
"::",
"VGPR0",
")",
";",
"RegisterEncoding",
".",
"VGPRL",
"=",
"RegisterEncoding",
".",
"VGPR0",
"+",
"NumVGPRsMax",
"-",
"<NUM_LIT>",
";",
"RegisterEncoding",
".",
"SGPR0",
"=",
"TRI",
"->",
"getEncodingValue",
"(",
"AMDGPU",
"::",
"SGPR0",
")",
";",
"RegisterEncoding",
".",
"SGPRL",
"=",
"RegisterEncoding",
".",
"SGPR0",
"+",
"NumSGPRsMax",
"-",
"<NUM_LIT>",
";",
"<BUGE>",
"TrackedWaitcntSet",
".",
"clear",
"(",
")",
";",
"BlockInfos",
".",
"clear",
"(",
")",
";"
] |
LLVM | ARM64 | TD | next_suggestion | CPU | 620,390 | [
"}"
] | [
"def",
"Xrs",
":",
"BaseAddSubSReg",
"<",
"isSub",
",",
"<NUM_LIT>",
",",
"GPR64",
",",
"arith_shifted_reg64",
",",
"mnemonic",
",",
"OpNode",
">",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 620,391 | [
"Variants",
")",
";"
] | [
"static",
"ArrayRef",
"<",
"unsigned",
">",
"getAllVariants",
"(",
")",
"{",
"static",
"const",
"unsigned",
"Variants",
"[",
"]",
"=",
"{",
"AMDGPUAsmVariants",
"::",
"DEFAULT",
",",
"AMDGPUAsmVariants",
"::",
"VOP3",
",",
"AMDGPUAsmVariants",
"::",
"SDWA",
",",
"AMDGPUAsmVariants",
"::",
"SDWA9",
",",
"AMDGPUAsmVariants",
"::",
"DPP",
"}",
";",
"return",
"makeArrayRef",
"("
] |
LLVM | ARM64 | TD | stmt_completion | CPU | 620,392 | [
"GPR64",
">",
";"
] | [
"def",
"LDRXpost_isel",
":",
"LoadPostIdxPseudo",
"<"
] |
LLVM | Cpu0 | CPP | next_suggestion | CPU | 620,393 | [
"Error",
"(",
"IDLoc",
",",
"<STR_LIT>",
"instruction requires a CPU feature not currently enabled",
"<STR_LIT>",
")",
";"
] | [
"SmallVector",
"<",
"MCInst",
",",
"<NUM_LIT>",
">",
"Instructions",
";",
"expandInstruction",
"(",
"Inst",
",",
"IDLoc",
",",
"Instructions",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"Instructions",
".",
"size",
"(",
")",
";",
"i",
"++",
")",
"{",
"Out",
".",
"EmitInstruction",
"(",
"Instructions",
"[",
"i",
"]",
",",
"getSTI",
"(",
")",
")",
";",
"}",
"}",
"else",
"{",
"Inst",
".",
"setLoc",
"(",
"IDLoc",
")",
";",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
",",
"getSTI",
"(",
")",
")",
";",
"}",
"return",
"false",
";",
"}",
"case",
"Match_MissingFeature",
":"
] |
GCC | i386 | CPP | next_suggestion | CPU | 620,394 | [
"return",
"cost",
";"
] | [
"if",
"(",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
"==",
"<NUM_LIT>",
"&&",
"TARGET_SSE_SPLIT_REGS",
")",
"return",
"cost",
"*",
"<NUM_LIT>",
";",
"if",
"(",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
">",
"<NUM_LIT>",
"&&",
"TARGET_AVX128_OPTIMAL",
")",
"return",
"cost",
"*",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
"/",
"<NUM_LIT>",
";"
] |
GCC | moxie | MD | stmt_completion | CPU | 620,395 | [
")"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mod",
":",
"SI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 620,396 | [
"(",
"RHS",
")",
";"
] | [
"break",
";",
"case",
"MVT",
"::",
"i32",
":",
"case",
"MVT",
"::",
"i64",
":",
"break",
";",
"}",
"MVT",
"SrcVT",
"=",
"RetVT",
";",
"RetVT",
".",
"SimpleTy",
"=",
"std",
"::",
"max",
"(",
"RetVT",
".",
"SimpleTy",
",",
"MVT",
"::",
"i32",
")",
";",
"if",
"(",
"UseAdd",
"&&",
"isa",
"<",
"Constant",
">",
"(",
"LHS",
")",
"&&",
"!",
"isa",
"<",
"Constant",
">",
"(",
"RHS",
")",
")",
"std",
"::",
"swap",
"(",
"LHS",
",",
"RHS",
")",
";",
"if",
"(",
"UseAdd",
"&&",
"LHS",
"->",
"hasOneUse",
"(",
")",
"&&",
"isValueAvailable",
"(",
"LHS",
")",
")",
"if",
"(",
"isMulPowOf2",
"(",
"LHS",
")",
")",
"std",
"::",
"swap",
"(",
"LHS",
",",
"RHS",
")",
";",
"if",
"(",
"UseAdd",
"&&",
"LHS",
"->",
"hasOneUse",
"(",
")",
"&&",
"isValueAvailable",
"(",
"LHS",
")",
")",
"if",
"(",
"const",
"auto",
"*",
"SI",
"=",
"dyn_cast",
"<",
"BinaryOperator",
">",
"(",
"LHS",
")",
")",
"if",
"(",
"isa",
"<",
"ConstantInt",
">",
"(",
"SI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"if",
"(",
"SI",
"->",
"getOpcode",
"(",
")",
"==",
"Instruction",
"::",
"Shl",
"||",
"SI",
"->",
"getOpcode",
"(",
")",
"==",
"Instruction",
"::",
"LShr",
"||",
"SI",
"->",
"getOpcode",
"(",
")",
"==",
"Instruction",
"::",
"AShr",
")",
"std",
"::",
"swap",
"(",
"LHS",
",",
"RHS",
")",
";",
"unsigned",
"LHSReg",
"=",
"getRegForValue",
"(",
"LHS",
")",
";",
"if",
"(",
"!",
"LHSReg",
")",
"return",
"<NUM_LIT>",
";",
"bool",
"LHSIsKill",
"=",
"hasTrivialKill",
"(",
"LHS",
")",
";",
"if",
"(",
"NeedExtend",
")",
"LHSReg",
"=",
"emitIntExt",
"(",
"SrcVT",
",",
"LHSReg",
",",
"RetVT",
",",
"IsZExt",
")",
";",
"unsigned",
"ResultReg",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"const",
"auto",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"RHS",
")",
")",
"{",
"uint64_t",
"Imm",
"=",
"IsZExt",
"?",
"C",
"->",
"getZExtValue",
"(",
")",
":",
"C",
"->",
"getSExtValue",
"(",
")",
";",
"if",
"(",
"C",
"->",
"isNegative",
"(",
")",
")",
"ResultReg",
"=",
"emitAddSub_ri",
"(",
"!",
"UseAdd",
",",
"RetVT",
",",
"LHSReg",
",",
"LHSIsKill",
",",
"-",
"Imm",
",",
"SetFlags",
",",
"WantResult",
")",
";",
"else",
"ResultReg",
"=",
"emitAddSub_ri",
"(",
"UseAdd",
",",
"RetVT",
",",
"LHSReg",
",",
"LHSIsKill",
",",
"Imm",
",",
"SetFlags",
",",
"WantResult",
")",
";",
"}",
"else",
"if",
"(",
"const",
"auto",
"*",
"C",
"=",
"dyn_cast",
"<",
"Constant",
">",
"(",
"RHS",
")",
")",
"if",
"(",
"C",
"->",
"isNullValue",
"(",
")",
")",
"ResultReg",
"=",
"emitAddSub_ri",
"(",
"UseAdd",
",",
"RetVT",
",",
"LHSReg",
",",
"LHSIsKill",
",",
"<NUM_LIT>",
",",
"SetFlags",
",",
"WantResult",
")",
";",
"if",
"(",
"ResultReg",
")",
"return",
"ResultReg",
";",
"if",
"(",
"ExtendType",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"RHS",
"->",
"hasOneUse",
"(",
")",
"&&",
"isValueAvailable",
"(",
"RHS",
")",
")",
"{",
"if",
"(",
"const",
"auto",
"*",
"SI",
"=",
"dyn_cast",
"<",
"BinaryOperator",
">",
"(",
"RHS",
")",
")",
"if",
"(",
"const",
"auto",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantInt",
">",
"(",
"SI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"if",
"(",
"(",
"SI",
"->",
"getOpcode",
"(",
")",
"==",
"Instruction",
"::",
"Shl",
")",
"&&",
"(",
"C",
"->",
"getZExtValue",
"(",
")",
"<",
"<NUM_LIT>",
")",
")",
"{",
"unsigned",
"RHSReg",
"=",
"getRegForValue",
"(",
"SI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"!",
"RHSReg",
")",
"return",
"<NUM_LIT>",
";",
"bool",
"RHSIsKill",
"=",
"hasTrivialKill",
"(",
"SI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"return",
"emitAddSub_rx",
"(",
"UseAdd",
",",
"RetVT",
",",
"LHSReg",
",",
"LHSIsKill",
",",
"RHSReg",
",",
"RHSIsKill",
",",
"ExtendType",
",",
"C",
"->",
"getZExtValue",
"(",
")",
",",
"SetFlags",
",",
"WantResult",
")",
";",
"}",
"unsigned",
"RHSReg",
"=",
"getRegForValue",
"(",
"RHS",
")",
";",
"if",
"(",
"!",
"RHSReg",
")",
"return",
"<NUM_LIT>",
";",
"bool",
"RHSIsKill",
"=",
"hasTrivialKill"
] |
GCC | s390 | CPP | program_repair | MPU | 620,397 | [
"<FIXS>",
"<FIXE>",
"<FIXS>",
"emit_insn",
"(",
"gen_epilogue_tpf",
"(",
"GEN_INT",
"(",
"s390_tpf_trace_hook_epilogue_check",
")",
",",
"GEN_INT",
"(",
"s390_tpf_trace_hook_epilogue_target",
")",
")",
")",
";",
"<FIXE>"
] | [
"int",
"next_offset",
";",
"int",
"i",
";",
"if",
"(",
"TARGET_TPF_PROFILING",
")",
"{",
"<BUGS>",
"<BUGE>",
"emit_insn",
"(",
"gen_blockage",
"(",
")",
")",
";",
"<BUGS>",
"emit_insn",
"(",
"gen_epilogue_tpf",
"(",
")",
")",
";",
"<BUGE>",
"}"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 620,398 | [
"<STR_LIT>",
";"
] | [
"def",
"J2_jumprfpt",
":",
"HInst",
"<",
"(",
"outs",
")",
",",
"(",
"ins",
"PredRegs",
":",
"$",
"Pu4",
",",
"IntRegs",
":",
"$",
"Rs32",
")",
",",
"<STR_LIT>",
",",
"tc_e78647bd",
",",
"TypeJ",
">",
",",
"Enc_88d4d9",
",",
"Requires",
"<",
"[",
"HasV60",
"]",
">",
",",
"PredNewRel",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"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",
"isIndirectBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Defs",
"=",
"[",
"PC",
"]",
";",
"let",
"InputType",
"="
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 620,399 | [
"}"
] | [
"class",
"BaseSingleOperandFPData",
"<",
"bits",
"<",
"<NUM_LIT>",
">",
"opcode",
",",
"RegisterClass",
"regtype",
",",
"ValueType",
"vt",
",",
"string",
"asm",
",",
"SDPatternOperator",
"node",
">",
":",
"I",
"<",
"(",
"outs",
"regtype",
":",
"$",
"Rd",
")",
",",
"(",
"ins",
"regtype",
":",
"$",
"Rn",
")",
",",
"asm",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"[",
"(",
"set",
"(",
"vt",
"regtype",
":",
"$",
"Rd",
")",
",",
"(",
"node",
"(",
"vt",
"regtype",
":",
"$",
"Rn",
")",
")",
")",
"]",
">",
",",
"Sched",
"<",
"[",
"WriteF",
"]",
">",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"Rd",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rn",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opcode",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rn",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rd",
";"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.