Compiler_Type
stringclasses 2
values | Target
stringclasses 176
values | Programming Language
stringclasses 3
values | Task
stringclasses 4
values | Target_Type
stringclasses 7
values | Idx
int64 0
636k
| Ground_Truth
listlengths 0
2.32k
| Input
listlengths 1
1.02k
|
---|---|---|---|---|---|---|---|
LLVM | AArch64 | TD | stmt_completion | CPU | 4,400 | [
",",
"(",
"instregex",
"<STR_LIT>",
")",
">",
";"
] | [
"def",
":",
"InstRW",
"<",
"[",
"KryoWrite_3cyc_XY_noRSV_246ln",
"]"
] |
LLVM | AMDGPU | CPP | program_repair | GPU | 4,401 | [
"<FIXS>",
"MachineOperand",
"&",
"Src",
"=",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"<FIXE>"
] | [
"return",
";",
"}",
"<BUGS>",
"MachineOperand",
"&",
"Src",
"=",
"Inst",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"<BUGE>",
"unsigned",
"TmpReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
")",
";",
"unsigned",
"ResultReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"VReg_64RegClass",
")",
";"
] |
LLVM | PowerPC | CPP | program_repair | CPU | 4,402 | [
"<FIXS>",
"if",
"(",
"ObjSize",
"ArgSize",
"&&",
"!",
"isLittleEndian",
")",
"CurArgOffset",
"+=",
"ArgSize",
"-",
"ObjSize",
";",
"int",
"FI",
"=",
"MFI",
"->",
"CreateFixedObject",
"(",
"ObjSize",
",",
"CurArgOffset",
",",
"isImmutable",
")",
";",
"<FIXE>"
] | [
"if",
"(",
"needsLoad",
")",
"{",
"<BUGS>",
"int",
"FI",
"=",
"MFI",
"->",
"CreateFixedObject",
"(",
"ObjSize",
",",
"CurArgOffset",
"+",
"(",
"ArgSize",
"-",
"ObjSize",
")",
",",
"isImmutable",
")",
";",
"<BUGE>",
"SDValue",
"FIN",
"=",
"DAG",
".",
"getFrameIndex",
"(",
"FI",
",",
"PtrVT",
")",
";",
"ArgVal",
"=",
"DAG",
".",
"getLoad",
"(",
"ObjectVT",
",",
"dl",
",",
"Chain",
",",
"FIN",
",",
"MachinePointerInfo",
"(",
")",
",",
"false",
",",
"false",
",",
"false",
",",
"<NUM_LIT>",
")",
";"
] |
GCC | arm | CPP | stmt_completion | CPU | 4,403 | [
"a",
",",
"_",
"_",
"b",
")",
";"
] | [
"return",
"(",
"uint16x8_t",
")",
"(",
"vabsq_f16",
"(",
"_",
"_",
"a",
")",
">",
"vabsq_f16",
"(",
"_",
"_",
"b",
")",
")",
";",
"return",
"(",
"uint16x8_t",
")",
"_",
"_",
"builtin_neon_vcagtv8hf",
"(",
"_",
"_"
] |
LLVM | AVR | CPP | program_repair | MPU | 4,404 | [
"<FIXS>",
"const",
"TargetInstrInfo",
"&",
"TII",
")",
"{",
"<FIXE>"
] | [
"static",
"void",
"fixStackStores",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"StartMI",
",",
"<BUGS>",
"const",
"TargetInstrInfo",
"&",
"TII",
",",
"Register",
"FP",
")",
"{",
"<BUGE>",
"for",
"(",
"MachineInstr",
"&",
"MI",
":",
"llvm",
"::",
"make_early_inc_range",
"(",
"llvm",
"::",
"make_range",
"(",
"StartMI",
",",
"MBB",
".",
"end",
"(",
")",
")",
")",
")",
"{"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 4,405 | [
";"
] | [
"let",
"hasNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isPredicable",
"=",
"<NUM_LIT>",
";",
"let",
"isPseudo",
"=",
"<NUM_LIT>",
";",
"let",
"isCodeGenOnly",
"=",
"<NUM_LIT>"
] |
GCC | i386 | CPP | stmt_completion | CPU | 4,406 | [
"B",
",",
"_",
"_",
"R",
")",
";"
] | [
"return",
"(",
"_",
"_",
"m128",
")",
"_",
"_",
"builtin_ia32_subss_round",
"(",
"(",
"_",
"_",
"v4sf",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v4sf",
")",
"_",
"_"
] |
LLVM | Mips | CPP | stmt_completion | CPU | 4,407 | [
"Decoder",
")",
";"
] | [
"static",
"DecodeStatus",
"DecodeDSPRegsRegisterClass",
"(",
"MCInst",
"&",
"Inst",
",",
"unsigned",
"RegNo",
",",
"uint64_t",
"Address",
",",
"const",
"void",
"*",
"Decoder",
")",
"{",
"return",
"DecodeCPURegsRegisterClass",
"(",
"Inst",
",",
"RegNo",
",",
"Address",
","
] |
GCC | aarch64 | MD | stmt_completion | CPU | 4,408 | [
")",
")",
")",
"]"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"VS",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"plus",
":",
"VS",
"(",
"unspec",
":",
"VS",
"[",
"(",
"match_operand",
":",
"<",
"VSI2QI",
">",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"<",
"VSI2QI",
">",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_USDOT",
")",
"(",
"match_operand",
":",
"VS",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>"
] |
LLVM | ARM | TD | next_suggestion | CPU | 4,409 | [
"string",
"SuffixLetter",
"=",
"suffixletter",
";"
] | [
"ValueType",
"Pred",
"=",
"pred",
";",
"ValueType",
"DblPred",
"=",
"dblpred",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Size",
"=",
"size",
";",
"bit",
"Unsigned",
"=",
"unsigned",
";",
"int",
"LaneBits",
"=",
"!",
"shl",
"(",
"<NUM_LIT>",
",",
"Size",
")",
";",
"string",
"BitsSuffix",
"=",
"!",
"if",
"(",
"!",
"eq",
"(",
"suffixletter",
",",
"<STR_LIT>",
")",
",",
"!",
"if",
"(",
"!",
"eq",
"(",
"unsigned",
",",
"<NUM_LIT>",
")",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
")",
",",
"!",
"cast",
"<",
"string",
">",
"(",
"LaneBits",
")",
")",
";",
"string",
"Suffix",
"=",
"suffixletter",
"#",
"BitsSuffix",
";"
] |
GCC | arm | CPP | next_suggestion | CPU | 4,410 | [
"}"
] | [
"vst1_lane_s8",
"(",
"int8_t",
"*",
"_",
"_",
"a",
",",
"int8x8_t",
"_",
"_",
"b",
",",
"const",
"int",
"_",
"_",
"c",
")",
"{",
"_",
"_",
"builtin_neon_vst1_lanev8qi",
"(",
"(",
"_",
"_",
"builtin_neon_qi",
"*",
")",
"_",
"_",
"a",
",",
"_",
"_",
"b",
",",
"_",
"_",
"c",
")",
";"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 4,411 | [
"const",
"{"
] | [
"bool",
"hasCARRY",
"(",
")"
] |
GCC | aarch64 | CPP | next_suggestion | CPU | 4,412 | [
"}"
] | [
"if",
"(",
"known_ge",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
",",
"<NUM_LIT>",
")",
")",
"return",
"mode",
";",
"else",
"return",
"SImode",
";"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 4,413 | [
"AU",
".",
"addPreservedID",
"(",
"MachineLoopInfoID",
")",
";"
] | [
"void",
"getAnalysisUsage",
"(",
"AnalysisUsage",
"&",
"AU",
")",
"const",
"override",
"{",
"AU",
".",
"setPreservesCFG",
"(",
")",
";"
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 4,414 | [
"}",
";"
] | [
"unsigned",
"Reg2",
"=",
"RPI",
".",
"Reg2",
";",
"unsigned",
"LdrOpc",
";",
"if",
"(",
"RPI",
".",
"IsGPR",
")",
"LdrOpc",
"=",
"RPI",
".",
"isPaired",
"(",
")",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"else",
"LdrOpc",
"=",
"RPI",
".",
"isPaired",
"(",
")",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"CSR restore: (",
"<STR_LIT>",
"<<",
"printReg",
"(",
"Reg1",
",",
"TRI",
")",
";",
"if",
"(",
"RPI",
".",
"isPaired",
"(",
")",
")",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
", ",
"<STR_LIT>",
"<<",
"printReg",
"(",
"Reg2",
",",
"TRI",
")",
";",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
") -> fi#(",
"<STR_LIT>",
"<<",
"RPI",
".",
"FrameIdx",
";",
"if",
"(",
"RPI",
".",
"isPaired",
"(",
")",
")",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
", ",
"<STR_LIT>",
"<<",
"RPI",
".",
"FrameIdx",
"+",
"<NUM_LIT>",
";",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
")\\n",
"<STR_LIT>",
")",
";",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"LdrOpc",
")",
")",
";",
"if",
"(",
"RPI",
".",
"isPaired",
"(",
")",
")",
"{",
"MIB",
".",
"addReg",
"(",
"Reg2",
",",
"getDefRegState",
"(",
"true",
")",
")",
";",
"MIB",
".",
"addMemOperand",
"(",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"RPI",
".",
"FrameIdx",
"+",
"<NUM_LIT>",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
";",
"}",
"MIB",
".",
"addReg",
"(",
"Reg1",
",",
"getDefRegState",
"(",
"true",
")",
")",
".",
"addReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
".",
"addImm",
"(",
"RPI",
".",
"Offset",
")",
".",
"setMIFlag",
"(",
"MachineInstr",
"::",
"FrameDestroy",
")",
";",
"MIB",
".",
"addMemOperand",
"(",
"MF",
".",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"RPI",
".",
"FrameIdx",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
";"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 4,415 | [
"if",
"(",
"ExtendVT",
"!=",
"TargetVT",
")",
"Res",
"=",
"DAG",
".",
"getNode",
"(",
"ExtendOpcode",
",",
"DL",
",",
"TargetVT",
",",
"Res",
")",
";"
] | [
"if",
"(",
"CMovN",
".",
"getOpcode",
"(",
")",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"||",
"!",
"CMovN",
".",
"hasOneUse",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"EVT",
"TargetVT",
"=",
"Extend",
"->",
"getValueType",
"(",
"<NUM_LIT>",
")",
";",
"unsigned",
"ExtendOpcode",
"=",
"Extend",
"->",
"getOpcode",
"(",
")",
";",
"SDLoc",
"DL",
"(",
"Extend",
")",
";",
"EVT",
"VT",
"=",
"CMovN",
".",
"getValueType",
"(",
")",
";",
"SDValue",
"CMovOp0",
"=",
"CMovN",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"CMovOp1",
"=",
"CMovN",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"CMovOp0",
".",
"getNode",
"(",
")",
")",
"||",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"CMovOp1",
".",
"getNode",
"(",
")",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"TargetVT",
"!=",
"MVT",
"::",
"i32",
"&&",
"TargetVT",
"!=",
"MVT",
"::",
"i64",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"VT",
"!=",
"MVT",
"::",
"i16",
"&&",
"!",
"(",
"ExtendOpcode",
"==",
"ISD",
"::",
"SIGN_EXTEND",
"&&",
"VT",
"==",
"MVT",
"::",
"i32",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"EVT",
"ExtendVT",
"=",
"TargetVT",
";",
"if",
"(",
"TargetVT",
"==",
"MVT",
"::",
"i64",
"&&",
"ExtendOpcode",
"!=",
"ISD",
"::",
"SIGN_EXTEND",
")",
"ExtendVT",
"=",
"MVT",
"::",
"i32",
";",
"CMovOp0",
"=",
"DAG",
".",
"getNode",
"(",
"ExtendOpcode",
",",
"DL",
",",
"ExtendVT",
",",
"CMovOp0",
")",
";",
"CMovOp1",
"=",
"DAG",
".",
"getNode",
"(",
"ExtendOpcode",
",",
"DL",
",",
"ExtendVT",
",",
"CMovOp1",
")",
";",
"SDValue",
"Res",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"ExtendVT",
",",
"CMovOp0",
",",
"CMovOp1",
",",
"CMovN",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"CMovN",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";"
] |
LLVM | ARM | CPP | stmt_completion | CPU | 4,416 | [
"MI",
")",
"{"
] | [
"bool",
"ARMFixCortexA57AES1742098",
"::",
"isFirstAESPairInstr",
"(",
"MachineInstr",
"&"
] |
LLVM | WDC65816 | CPP | stmt_completion | MPU | 4,417 | [
"false",
";"
] | [
"bool",
"WDC65816PassConfig",
"::",
"addInstSelector",
"(",
")",
"{",
"addPass",
"(",
"createWDC65816ISelDag",
"(",
"getWDC65816TargetMachine",
"(",
")",
")",
")",
";",
"return"
] |
GCC | aarch64 | CPP | next_suggestion | CPU | 4,418 | [
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"<NUM_LIT>",
";"
] | [
"poly_int64",
"offset",
"=",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"reg_offset",
"[",
"regno",
"]",
";",
"if",
"(",
"!",
"frame_pointer_needed",
")",
"offset",
"+=",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"frame_size",
"-",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"hard_fp_offset",
";",
"rtx",
"addr",
"=",
"plus_constant",
"(",
"Pmode",
",",
"ptr_reg",
",",
"offset",
")",
";",
"rtx",
"mem",
"=",
"gen_frame_mem",
"(",
"mode",
",",
"addr",
")",
";",
"rtx",
"set",
"=",
"prologue_p",
"?",
"gen_rtx_SET",
"(",
"mem",
",",
"reg",
")",
":",
"gen_rtx_SET",
"(",
"reg",
",",
"mem",
")",
";",
"unsigned",
"regno2",
"=",
"aarch64_get_next_set_bit",
"(",
"components",
",",
"regno",
"+",
"<NUM_LIT>",
")",
";",
"if",
"(",
"regno2",
"==",
"last_regno",
")",
"{",
"insn",
"=",
"emit_insn",
"(",
"set",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"prologue_p",
")",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_OFFSET",
",",
"copy_rtx",
"(",
"set",
")",
")",
";",
"else",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_RESTORE",
",",
"reg",
")",
";",
"break",
";",
"}",
"poly_int64",
"offset2",
"=",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"reg_offset",
"[",
"regno2",
"]",
";",
"if",
"(",
"!",
"satisfies_constraint_Ump",
"(",
"mem",
")",
"||",
"GP_REGNUM_P",
"(",
"regno",
")",
"!=",
"GP_REGNUM_P",
"(",
"regno2",
")",
"||",
"maybe_ne",
"(",
"(",
"offset2",
"-",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"reg_offset",
"[",
"regno",
"]",
")",
",",
"GET_MODE_SIZE",
"(",
"mode",
")",
")",
")",
"{",
"insn",
"=",
"emit_insn",
"(",
"set",
")",
";",
"RTX_FRAME_RELATED_P",
"(",
"insn",
")",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"prologue_p",
")",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_OFFSET",
",",
"copy_rtx",
"(",
"set",
")",
")",
";",
"else",
"add_reg_note",
"(",
"insn",
",",
"REG_CFA_RESTORE",
",",
"reg",
")",
";",
"regno",
"=",
"regno2",
";",
"continue",
";",
"}",
"rtx",
"reg2",
"=",
"gen_rtx_REG",
"(",
"mode",
",",
"regno2",
")",
";",
"if",
"(",
"!",
"frame_pointer_needed",
")",
"offset2",
"+=",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"frame_size",
"-",
"cfun",
"->",
"machine",
"->",
"frame",
".",
"hard_fp_offset",
";",
"rtx",
"addr2",
"=",
"plus_constant",
"(",
"Pmode",
",",
"ptr_reg",
",",
"offset2",
")",
";",
"rtx",
"mem2",
"=",
"gen_frame_mem",
"(",
"mode",
",",
"addr2",
")",
";",
"rtx",
"set2",
"=",
"prologue_p",
"?",
"gen_rtx_SET",
"(",
"mem2",
",",
"reg2",
")",
":",
"gen_rtx_SET",
"(",
"reg2",
",",
"mem2",
")",
";",
"if",
"(",
"prologue_p",
")",
"insn",
"=",
"emit_insn",
"(",
"aarch64_gen_store_pair",
"(",
"mode",
",",
"mem",
",",
"reg",
",",
"mem2",
",",
"reg2",
")",
")",
";",
"else",
"insn",
"=",
"emit_insn",
"(",
"aarch64_gen_load_pair",
"(",
"mode",
",",
"reg",
",",
"mem",
",",
"reg2",
",",
"mem2",
")",
")",
";"
] |
GCC | alpha | CPP | stmt_completion | MPU | 4,419 | [
"<NUM_LIT>",
")",
"<<",
"<NUM_LIT>",
";"
] | [
"static",
"tree",
"alpha_fold_builtin_unpkbw",
"(",
"unsigned",
"HOST_WIDE_INT",
"opint",
"[",
"]",
",",
"long",
"op_const",
")",
"{",
"unsigned",
"HOST_WIDE_INT",
"temp",
";",
"if",
"(",
"op_const",
"==",
"<NUM_LIT>",
")",
"return",
"NULL",
";",
"temp",
"=",
"opint",
"[",
"<NUM_LIT>",
"]",
"&",
"<NUM_LIT>",
";",
"temp",
"|=",
"(",
"opint",
"[",
"<NUM_LIT>",
"]",
"&",
"<NUM_LIT>",
")",
"<<",
"<NUM_LIT>",
";",
"temp",
"|=",
"(",
"opint",
"[",
"<NUM_LIT>",
"]",
"&"
] |
GCC | rs6000 | CPP | stmt_completion | CPU | 4,420 | [
"a",
")",
",",
"b",
")",
")",
")",
";"
] | [
"return",
"(",
"(",
"vec_int4",
")",
"(",
"si_shli",
"(",
"(",
"qword",
")",
"("
] |
GCC | avr | CPP | next_suggestion | MPU | 4,421 | [
"}"
] | [
"if",
"(",
"mode",
"==",
"MAP_FIXED_0_7",
")",
"metric",
"+=",
"ai",
"==",
"i",
";",
"else",
"if",
"(",
"mode",
"==",
"MAP_NONFIXED_0_7",
")",
"metric",
"+=",
"ai",
"<",
"<NUM_LIT>",
"&&",
"ai",
"!=",
"i",
";",
"else",
"if",
"(",
"mode",
"==",
"MAP_MASK_FIXED_0_7",
")",
"metric",
"|=",
"(",
"(",
"unsigned",
")",
"(",
"ai",
"==",
"i",
")",
")",
"<<",
"i",
";",
"else",
"if",
"(",
"mode",
"==",
"MAP_PREIMAGE_0_7",
")",
"metric",
"+=",
"ai",
"<",
"<NUM_LIT>",
";",
"else",
"if",
"(",
"mode",
"==",
"MAP_MASK_PREIMAGE_F",
")",
"metric",
"|=",
"(",
"(",
"unsigned",
")",
"(",
"ai",
"==",
"<NUM_LIT>",
")",
")",
"<<",
"i",
";",
"else",
"gcc_unreachable",
"(",
")",
";"
] |
LLVM | AArch64 | CPP | program_repair | CPU | 4,422 | [
"<FIXS>",
"Operands",
"[",
"<NUM_LIT>",
"]",
"=",
"AArch64Operand",
"::",
"CreateToken",
"(",
"<STR_LIT>",
"ubfm",
"<STR_LIT>",
",",
"Op",
".",
"getStartLoc",
"(",
")",
",",
"getContext",
"(",
")",
")",
";",
"<FIXE>"
] | [
"const",
"MCExpr",
"*",
"NewOp3",
"=",
"MCConstantExpr",
"::",
"create",
"(",
"NewOp3Val",
",",
"getContext",
"(",
")",
")",
";",
"const",
"MCExpr",
"*",
"NewOp4",
"=",
"MCConstantExpr",
"::",
"create",
"(",
"NewOp4Val",
",",
"getContext",
"(",
")",
")",
";",
"<BUGS>",
"Operands",
"[",
"<NUM_LIT>",
"]",
"=",
"AArch64Operand",
"::",
"CreateToken",
"(",
"<STR_LIT>",
"ubfm",
"<STR_LIT>",
",",
"false",
",",
"Op",
".",
"getStartLoc",
"(",
")",
",",
"getContext",
"(",
")",
")",
";",
"<BUGE>",
"Operands",
".",
"push_back",
"(",
"AArch64Operand",
"::",
"CreateImm",
"(",
"NewOp4",
",",
"Op3",
".",
"getStartLoc",
"(",
")",
",",
"Op3",
".",
"getEndLoc",
"(",
")",
",",
"getContext",
"(",
")",
")",
")",
";",
"Operands",
"[",
"<NUM_LIT>",
"]",
"=",
"AArch64Operand",
"::",
"CreateImm",
"(",
"NewOp3",
",",
"Op3",
".",
"getStartLoc",
"(",
")",
","
] |
GCC | m68k | CPP | program_repair | MPU | 4,423 | [
"<FIXS>",
"output_asm_insn",
"(",
"MOTOROLA",
"?",
"<STR_LIT>",
"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjbpl %l1",
"<STR_LIT>",
":",
"<STR_LIT>",
"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1",
"<STR_LIT>",
",",
"<FIXE>"
] | [
"switch",
"(",
"GET_MODE",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
")",
"{",
"case",
"SImode",
":",
"<BUGS>",
"output_asm_insn",
"(",
"MOTOROLA",
"?",
"<STR_LIT>",
"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjbpl %l1",
"<STR_LIT>",
":",
"<STR_LIT>",
"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1",
"<STR_LIT>",
",",
"<BUGE>",
"operands",
")",
";",
"break",
";"
] |
LLVM | VE | CPP | stmt_completion | CPU | 4,424 | [
"(",
"Reg",
")",
")",
";"
] | [
"unsigned",
"Reg",
"=",
"I32RegDecoderTable",
"[",
"RegNo",
"]",
";",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createReg"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 4,425 | [
"<STR_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"CextOpcode",
"="
] |
GCC | i386 | MD | next_suggestion | CPU | 4,426 | [
"<STR_LIT>"
] | [
"(",
"define_expand",
"<STR_LIT>",
"[",
"(",
"match_operand",
":",
"VF_AVX512VL",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"VF_AVX512VL",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"VF_AVX512VL",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"VF_AVX512VL",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"<",
"avx512fmaskmode",
">",
"<NUM_LIT>",
"<STR_LIT>",
")",
"]"
] |
LLVM | RV16K | CPP | stmt_completion | Virtual ISA | 4,427 | [
")",
";"
] | [
"TargetRegistry",
"::",
"RegisterMCSubtargetInfo",
"(",
"T",
",",
"createRV16KMCSubtargetInfo",
")",
";",
"TargetRegistry",
"::",
"RegisterMCInstPrinter",
"(",
"T",
",",
"createRV16KMCInstPrinter",
")",
";",
"TargetRegistry",
"::",
"RegisterMCAsmBackend",
"(",
"T",
",",
"createRV16KAsmBackend"
] |
LLVM | ARM | TD | stmt_completion | CPU | 4,428 | [
"Inst",
"(",
"COPY_TO_REGCLASS",
"ScalarReg",
":",
"$",
"prev",
",",
"rGPR",
")",
",",
"(",
"VTI",
".",
"Vec",
"MQPR",
":",
"$",
"vec",
")",
")",
",",
"ScalarReg",
")",
">",
";"
] | [
"def",
":",
"Pat",
"<",
"(",
"Scalar",
"(",
"unpred_intr",
"(",
"Scalar",
"ScalarReg",
":",
"$",
"prev",
")",
",",
"(",
"VTI",
".",
"Vec",
"MQPR",
":",
"$",
"vec",
")",
")",
")",
",",
"(",
"COPY_TO_REGCLASS",
"("
] |
GCC | ia64 | CPP | next_suggestion | CPU | 4,429 | [
"}"
] | [
"if",
"(",
"!",
"last_block",
")",
"{",
"if",
"(",
"unwind",
")",
"fprintf",
"(",
"out_file",
",",
"<STR_LIT>",
"\\t.label_state %d\\n",
"<STR_LIT>",
",",
"++",
"cfun",
"->",
"machine",
"->",
"state_num",
")",
";",
"need_copy_state",
"=",
"true",
";",
"}",
"if",
"(",
"unwind",
")",
"fprintf",
"(",
"out_file",
",",
"<STR_LIT>",
"\\t.restore sp\\n",
"<STR_LIT>",
")",
";"
] |
GCC | arm | MD | stmt_completion | CPU | 4,430 | [
"(",
"lshiftrt",
"<STR_LIT>",
")",
"]",
")"
] | [
"(",
"define_code_attr",
"shift",
"[",
"(",
"ashiftrt",
"<STR_LIT>",
")",
"(",
"lshiftrt",
"<STR_LIT>",
")",
"]",
")",
"(",
"define_code_attr",
"shifttype",
"[",
"(",
"ashiftrt",
"<STR_LIT>",
")"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 4,431 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] | [
"class",
"BaseSIMDModifiedImm",
"<",
"bit",
"Q",
",",
"bit",
"op",
",",
"bit",
"op2",
",",
"dag",
"oops",
",",
"dag",
"iops",
",",
"string",
"asm",
",",
"string",
"op_string",
",",
"string",
"cstr",
",",
"list",
"<",
"dag",
">",
"pattern",
">",
":",
"I",
"<",
"oops",
",",
"iops",
",",
"asm",
",",
"op_string",
",",
"cstr",
",",
"pattern",
">",
",",
"Sched",
"<",
"[",
"!",
"if",
"(",
"Q",
",",
"WriteVq",
",",
"WriteVd",
")",
"]",
">",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"Rd",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"imm8",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"Q",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"op",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"imm8",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"op2",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 4,432 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
GCC | i386 | MD | next_suggestion | CPU | 4,433 | [
"operands",
"[",
"<NUM_LIT>",
"]",
")",
")"
] | [
"(",
"match_operand",
":",
"<",
"avx512fmaskmode",
">",
"<NUM_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"{",
"emit_insn",
"(",
"gen_",
"<",
"code",
">",
"<",
"mode",
">",
"<NUM_LIT>",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
","
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 4,434 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"imm",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"imm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"sz8_64",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opc",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
GCC | i386 | CPP | stmt_completion | CPU | 4,435 | [
"_",
"_",
"U",
",",
"_",
"_",
"R",
")",
";"
] | [
"return",
"(",
"_",
"_",
"m128h",
")",
"_",
"_",
"builtin_ia32_getmantsh_mask_round",
"(",
"(",
"_",
"_",
"v8hf",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v8hf",
")",
"_",
"_",
"B",
",",
"(",
"_",
"_",
"D",
"<<",
"<NUM_LIT>",
")",
"|",
"_",
"_",
"C",
",",
"(",
"_",
"_",
"v8hf",
")",
"_",
"_",
"W",
","
] |
LLVM | R600 | CPP | code_generation | GPU | 4,436 | [
"bool",
"SILowerControlFlowPass",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"TII",
"=",
"static_cast",
"<",
"const",
"SIInstrInfo",
"*",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"TRI",
"=",
"static_cast",
"<",
"const",
"SIRegisterInfo",
"*",
">",
"(",
"MF",
".",
"getTarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
")",
";",
"SIMachineFunctionInfo",
"*",
"MFI",
"=",
"MF",
".",
"getInfo",
"<",
"SIMachineFunctionInfo",
">",
"(",
")",
";",
"bool",
"HaveKill",
"=",
"false",
";",
"bool",
"NeedM0",
"=",
"false",
";",
"bool",
"NeedWQM",
"=",
"false",
";",
"unsigned",
"Depth",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"BI",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"BE",
"=",
"MF",
".",
"end",
"(",
")",
";",
"BI",
"!=",
"BE",
";",
"++",
"BI",
")",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"BI",
";",
"MachineBasicBlock",
"::",
"iterator",
"I",
",",
"Next",
";",
"for",
"(",
"I",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"I",
"!=",
"MBB",
".",
"end",
"(",
")",
";",
"I",
"=",
"Next",
")",
"{",
"Next",
"=",
"std",
"::",
"next",
"(",
"I",
")",
";",
"MachineInstr",
"&",
"MI",
"=",
"*",
"I",
";",
"if",
"(",
"TII",
"->",
"isDS",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
")",
"{",
"NeedM0",
"=",
"true",
";",
"NeedWQM",
"=",
"true",
";",
"}",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_IF",
":",
"++",
"Depth",
";",
"If",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_ELSE",
":",
"Else",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_BREAK",
":",
"Break",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_IF_BREAK",
":",
"IfBreak",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_ELSE_BREAK",
":",
"ElseBreak",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_LOOP",
":",
"++",
"Depth",
";",
"Loop",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_END_CF",
":",
"if",
"(",
"--",
"Depth",
"==",
"<NUM_LIT>",
"&&",
"HaveKill",
")",
"{",
"SkipIfDead",
"(",
"MI",
")",
";",
"HaveKill",
"=",
"false",
";",
"}",
"EndCf",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_KILL",
":",
"if",
"(",
"Depth",
"==",
"<NUM_LIT>",
")",
"SkipIfDead",
"(",
"MI",
")",
";",
"else",
"HaveKill",
"=",
"true",
";",
"Kill",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"S_BRANCH",
":",
"Branch",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_INDIRECT_SRC",
":",
"IndirectSrc",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"SI_INDIRECT_DST_V1",
":",
"case",
"AMDGPU",
"::",
"SI_INDIRECT_DST_V2",
":",
"case",
"AMDGPU",
"::",
"SI_INDIRECT_DST_V4",
":",
"case",
"AMDGPU",
"::",
"SI_INDIRECT_DST_V8",
":",
"case",
"AMDGPU",
"::",
"SI_INDIRECT_DST_V16",
":",
"IndirectDst",
"(",
"MI",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"V_INTERP_P1_F32",
":",
"case",
"AMDGPU",
"::",
"V_INTERP_P2_F32",
":",
"case",
"AMDGPU",
"::",
"V_INTERP_MOV_F32",
":",
"NeedWQM",
"=",
"true",
";",
"break",
";",
"}",
"}",
"}",
"if",
"(",
"NeedM0",
")",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"InitM0ForLDS",
"(",
"MBB",
".",
"getFirstNonPHI",
"(",
")",
")",
";",
"}",
"if",
"(",
"NeedWQM",
"&&",
"MFI",
"->",
"ShaderType",
"==",
"ShaderType",
"::",
"PIXEL",
")",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"MF",
".",
"front",
"(",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MBB",
".",
"getFirstNonPHI",
"(",
")",
",",
"DebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_WQM_B64",
")",
",",
"AMDGPU",
"::",
"EXEC",
")",
".",
"addReg",
"(",
"AMDGPU",
"::",
"EXEC",
")",
";",
"}",
"return",
"true",
";",
"}"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] |
LLVM | R600 | CPP | next_suggestion | GPU | 4,437 | [
"}"
] | [
"F",
"->",
"replaceAllUsesWith",
"(",
"NewFunc",
")",
";",
"}",
"for",
"(",
"Module",
"::",
"iterator",
"I",
"=",
"M",
".",
"begin",
"(",
")",
",",
"E",
"=",
"M",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"Function",
"&",
"F",
"=",
"*",
"I",
";",
"if",
"(",
"F",
".",
"hasLocalLinkage",
"(",
")",
"&&",
"!",
"F",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"NoInline",
")",
")",
"{",
"F",
".",
"addFnAttr",
"(",
"Attribute",
"::",
"AlwaysInline",
")",
";",
"}"
] |
LLVM | Hexagon | CPP | stmt_completion | DSP | 4,438 | [
"createHexagonNewValueJump",
"(",
")",
"{"
] | [
"FunctionPass",
"*",
"llvm",
"::"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 4,439 | [
"addExpr",
"(",
"Inst",
",",
"getImm",
"(",
")",
")",
";"
] | [
"void",
"addImmOperands",
"(",
"MCInst",
"&",
"Inst",
",",
"unsigned",
"N",
")",
"const",
"{",
"assert",
"(",
"N",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Invalid number of operands!",
"<STR_LIT>",
")",
";"
] |
LLVM | TOY | CPP | code_generation | CPU | 4,440 | [
"unsigned",
"TOYInstrInfo",
"::",
"isStoreToStackSlot",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"if",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isFI",
"(",
")",
")",
"{",
"FrameIndex",
"=",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"}",
"break",
";",
"}",
"return",
"<NUM_LIT>",
";",
"}"
] | [
"isStoreToStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"store",
"to",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"source",
"reg",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
] |
LLVM | SystemZ | CPP | next_suggestion | CPU | 4,441 | [
"if",
"(",
"IDVal",
"==",
"<STR_LIT>",
".insn",
"<STR_LIT>",
")",
"return",
"ParseDirectiveInsn",
"(",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";"
] | [
"bool",
"SystemZAsmParser",
"::",
"ParseDirective",
"(",
"AsmToken",
"DirectiveID",
")",
"{",
"StringRef",
"IDVal",
"=",
"DirectiveID",
".",
"getIdentifier",
"(",
")",
";"
] |
GCC | sparc | CPP | code_generation | CPU | 4,442 | [
"static",
"rtx",
"function_arg_record_value",
"(",
"const_tree",
"type",
",",
"machine_mode",
"mode",
",",
"int",
"slotno",
",",
"int",
"named",
",",
"int",
"regbase",
")",
"{",
"HOST_WIDE_INT",
"typesize",
"=",
"int_size_in_bytes",
"(",
"type",
")",
";",
"struct",
"function_arg_record_value_parms",
"parms",
";",
"unsigned",
"int",
"nregs",
";",
"parms",
".",
"ret",
"=",
"NULL_RTX",
";",
"parms",
".",
"slotno",
"=",
"slotno",
";",
"parms",
".",
"named",
"=",
"named",
";",
"parms",
".",
"regbase",
"=",
"regbase",
";",
"parms",
".",
"stack",
"=",
"<NUM_LIT>",
";",
"parms",
".",
"nregs",
"=",
"<NUM_LIT>",
";",
"parms",
".",
"intoffset",
"=",
"<NUM_LIT>",
";",
"function_arg_record_value_1",
"(",
"type",
",",
"<NUM_LIT>",
",",
"&",
"parms",
",",
"false",
")",
";",
"if",
"(",
"parms",
".",
"intoffset",
"!=",
"-",
"<NUM_LIT>",
")",
"{",
"unsigned",
"int",
"startbit",
",",
"endbit",
";",
"int",
"intslots",
",",
"this_slotno",
";",
"startbit",
"=",
"parms",
".",
"intoffset",
"&",
"-",
"BITS_PER_WORD",
";",
"endbit",
"=",
"(",
"typesize",
"*",
"BITS_PER_UNIT",
"+",
"BITS_PER_WORD",
"-",
"<NUM_LIT>",
")",
"&",
"-",
"BITS_PER_WORD",
";",
"intslots",
"=",
"(",
"endbit",
"-",
"startbit",
")",
"/",
"BITS_PER_WORD",
";",
"this_slotno",
"=",
"slotno",
"+",
"parms",
".",
"intoffset",
"/",
"BITS_PER_WORD",
";",
"if",
"(",
"intslots",
">",
"<NUM_LIT>",
"&&",
"intslots",
">",
"SPARC_INT_ARG_MAX",
"-",
"this_slotno",
")",
"{",
"intslots",
"=",
"MAX",
"(",
"<NUM_LIT>",
",",
"SPARC_INT_ARG_MAX",
"-",
"this_slotno",
")",
";",
"parms",
".",
"stack",
"=",
"<NUM_LIT>",
";",
"}",
"parms",
".",
"nregs",
"+=",
"intslots",
";",
"}",
"nregs",
"=",
"parms",
".",
"nregs",
";",
"if",
"(",
"nregs",
"==",
"<NUM_LIT>",
")",
"{",
"if",
"(",
"typesize",
"<=",
"<NUM_LIT>",
")",
"{",
"return",
"gen_rtx_REG",
"(",
"mode",
",",
"regbase",
")",
";",
"}",
"else",
"{",
"nregs",
"=",
"(",
"typesize",
"+",
"UNITS_PER_WORD",
"-",
"<NUM_LIT>",
")",
"/",
"UNITS_PER_WORD",
";",
"}",
"if",
"(",
"nregs",
"+",
"slotno",
">",
"SPARC_INT_ARG_MAX",
")",
"nregs",
"=",
"SPARC_INT_ARG_MAX",
"-",
"slotno",
";",
"}",
"gcc_assert",
"(",
"nregs",
"!=",
"<NUM_LIT>",
")",
";",
"parms",
".",
"ret",
"=",
"gen_rtx_PARALLEL",
"(",
"mode",
",",
"rtvec_alloc",
"(",
"parms",
".",
"stack",
"+",
"nregs",
")",
")",
";",
"if",
"(",
"parms",
".",
"stack",
")",
"XVECEXP",
"(",
"parms",
".",
"ret",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
"=",
"gen_rtx_EXPR_LIST",
"(",
"VOIDmode",
",",
"NULL_RTX",
",",
"const0_rtx",
")",
";",
"parms",
".",
"nregs",
"=",
"<NUM_LIT>",
";",
"parms",
".",
"intoffset",
"=",
"<NUM_LIT>",
";",
"function_arg_record_value_2",
"(",
"type",
",",
"<NUM_LIT>",
",",
"&",
"parms",
",",
"false",
")",
";",
"function_arg_record_value_3",
"(",
"typesize",
"*",
"BITS_PER_UNIT",
",",
"&",
"parms",
")",
";",
"gcc_assert",
"(",
"parms",
".",
"nregs",
"==",
"nregs",
")",
";",
"return",
"parms",
".",
"ret",
";",
"}"
] | [
"Used",
"by",
"function_arg",
"and",
"sparc_function_value_1",
"to",
"implement",
"the",
"complex",
"conventions",
"of",
"the",
"64-bit",
"ABI",
"for",
"passing",
"and",
"returning",
"structures",
".",
"Return",
"an",
"expression",
"valid",
"as",
"a",
"return",
"value",
"for",
"the",
"FUNCTION_ARG",
"and",
"TARGET_FUNCTION_VALUE",
".",
"TYPE",
"is",
"the",
"data",
"type",
"of",
"the",
"argument",
"(",
"as",
"a",
"tree",
")",
".",
"This",
"is",
"null",
"for",
"libcalls",
"where",
"that",
"information",
"may",
"not",
"be",
"available",
".",
"MODE",
"is",
"the",
"argument",
"'s",
"machine",
"mode",
".",
"SLOTNO",
"is",
"the",
"index",
"number",
"of",
"the",
"argument",
"'s",
"slot",
"in",
"the",
"parameter",
"array",
".",
"NAMED",
"is",
"true",
"if",
"this",
"argument",
"is",
"a",
"named",
"parameter",
"(",
"otherwise",
"it",
"is",
"an",
"extra",
"parameter",
"matching",
"an",
"ellipsis",
")",
".",
"REGBASE",
"is",
"the",
"regno",
"of",
"the",
"base",
"register",
"for",
"the",
"parameter",
"array",
"."
] |
LLVM | Sparc | CPP | next_suggestion | CPU | 4,443 | [
"}"
] | [
"SDValue",
"SubRegOdd",
"=",
"DAG",
".",
"getTargetConstant",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MVT",
"::",
"i32",
")",
";",
"SDNode",
"*",
"Hi64",
"=",
"DAG",
".",
"getMachineNode",
"(",
"TargetOpcode",
"::",
"EXTRACT_SUBREG",
",",
"dl",
",",
"MVT",
"::",
"f64",
",",
"StNode",
"->",
"getValue",
"(",
")",
",",
"SubRegEven",
")",
";",
"SDNode",
"*",
"Lo64",
"=",
"DAG",
".",
"getMachineNode",
"(",
"TargetOpcode",
"::",
"EXTRACT_SUBREG",
",",
"dl",
",",
"MVT",
"::",
"f64",
",",
"StNode",
"->",
"getValue",
"(",
")",
",",
"SubRegOdd",
")",
";",
"unsigned",
"alignment",
"=",
"StNode",
"->",
"getAlignment",
"(",
")",
";",
"if",
"(",
"alignment",
">",
"<NUM_LIT>",
")",
"alignment",
"=",
"<NUM_LIT>",
";",
"SDValue",
"OutChains",
"[",
"<NUM_LIT>",
"]",
";",
"OutChains",
"[",
"<NUM_LIT>",
"]",
"=",
"DAG",
".",
"getStore",
"(",
"StNode",
"->",
"getChain",
"(",
")",
",",
"dl",
",",
"SDValue",
"(",
"Hi64",
",",
"<NUM_LIT>",
")",
",",
"StNode",
"->",
"getBasePtr",
"(",
")",
",",
"MachinePointerInfo",
"(",
")",
",",
"false",
",",
"false",
",",
"alignment",
")",
";",
"EVT",
"addrVT",
"=",
"StNode",
"->",
"getBasePtr",
"(",
")",
".",
"getValueType",
"(",
")",
";",
"SDValue",
"LoPtr",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"dl",
",",
"addrVT",
",",
"StNode",
"->",
"getBasePtr",
"(",
")",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"dl",
",",
"addrVT",
")",
")",
";",
"OutChains",
"[",
"<NUM_LIT>",
"]",
"=",
"DAG",
".",
"getStore",
"(",
"StNode",
"->",
"getChain",
"(",
")",
",",
"dl",
",",
"SDValue",
"(",
"Lo64",
",",
"<NUM_LIT>",
")",
",",
"LoPtr",
",",
"MachinePointerInfo",
"(",
")",
",",
"false",
",",
"false",
",",
"alignment",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TokenFactor",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"OutChains",
")",
";"
] |
LLVM | M680x0 | CPP | next_suggestion | MPU | 4,444 | [
"}"
] | [
"void",
"printAL8Mem",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"int",
"opNum",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"printAbsMem",
"(",
"MI",
",",
"opNum",
",",
"O",
")",
";"
] |
LLVM | ARM | TD | next_suggestion | CPU | 4,445 | [
"bits",
"<",
"<NUM_LIT>",
">",
"addr",
";"
] | [
"def",
"LDRBT_POST_IMM",
":",
"AI2ldstidx",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"(",
"outs",
"GPR",
":",
"$",
"Rt",
",",
"GPR",
":",
"$",
"Rn_wb",
")",
",",
"(",
"ins",
"addr_offset_none",
":",
"$",
"addr",
",",
"am2offset_imm",
":",
"$",
"offset",
")",
",",
"IndexModePost",
",",
"LdFrm",
",",
"IIC_iLoad_bh_ru",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"[",
"]",
">",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"offset",
";"
] |
LLVM | ARM | TD | stmt_completion | CPU | 4,446 | [
"[",
"WriteVST4",
"]",
">",
";"
] | [
"def",
"VST1q64LowQPseudo_UPD",
":",
"VSTQQQQWBPseudo",
"<",
"IIC_VST1x4",
">",
",",
"Sched",
"<"
] |
GCC | cris | CPP | program_repair | MPU | 4,447 | [
"<FIXS>",
"cris_asm_output_case_end",
"(",
"FILE",
"*",
"stream",
",",
"int",
"num",
",",
"rtx_insn",
"*",
"table",
")",
"<FIXE>",
"<FIXS>",
"rtx_insn",
"*",
"whole_jump_insn",
"=",
"prev_nonnote_nondebug_insn",
"(",
"table",
")",
";",
"<FIXE>"
] | [
"void",
"<BUGS>",
"cris_asm_output_case_end",
"(",
"FILE",
"*",
"stream",
",",
"int",
"num",
",",
"rtx",
"table",
")",
"<BUGE>",
"{",
"<BUGS>",
"rtx",
"whole_jump_insn",
"=",
"prev_nonnote_nondebug_insn",
"(",
"table",
")",
";",
"<BUGE>",
"gcc_assert",
"(",
"whole_jump_insn",
"!=",
"NULL_RTX",
"&&",
"LABEL_P",
"(",
"whole_jump_insn",
")",
")",
";",
"whole_jump_insn",
"=",
"prev_nonnote_nondebug_insn",
"(",
"whole_jump_insn",
")",
";",
"gcc_assert",
"(",
"whole_jump_insn",
"!=",
"NULL_RTX"
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 4,448 | [
"SDValue",
"VEXTSrc2",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"dl",
",",
"DestVT",
",",
"Src",
".",
"ShuffleVec",
",",
"DAG",
".",
"getConstant",
"(",
"NumSrcElts",
",",
"dl",
",",
"MVT",
"::",
"i64",
")",
")",
";"
] | [
"unsigned",
"EltNo",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"V",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
"->",
"getZExtValue",
"(",
")",
";",
"Source",
"->",
"MinElt",
"=",
"std",
"::",
"min",
"(",
"Source",
"->",
"MinElt",
",",
"EltNo",
")",
";",
"Source",
"->",
"MaxElt",
"=",
"std",
"::",
"max",
"(",
"Source",
"->",
"MaxElt",
",",
"EltNo",
")",
";",
"}",
"if",
"(",
"Sources",
".",
"size",
"(",
")",
">",
"<NUM_LIT>",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Reshuffle failed: currently only do something sane when at ",
"<STR_LIT>",
"<STR_LIT>",
"most two source vectors are involved\\n",
"<STR_LIT>",
")",
";",
"return",
"SDValue",
"(",
")",
";",
"}",
"EVT",
"SmallestEltTy",
"=",
"VT",
".",
"getVectorElementType",
"(",
")",
";",
"for",
"(",
"auto",
"&",
"Source",
":",
"Sources",
")",
"{",
"EVT",
"SrcEltTy",
"=",
"Source",
".",
"Vec",
".",
"getValueType",
"(",
")",
".",
"getVectorElementType",
"(",
")",
";",
"if",
"(",
"SrcEltTy",
".",
"bitsLT",
"(",
"SmallestEltTy",
")",
")",
"{",
"SmallestEltTy",
"=",
"SrcEltTy",
";",
"}",
"}",
"unsigned",
"ResMultiplier",
"=",
"VT",
".",
"getScalarSizeInBits",
"(",
")",
"/",
"SmallestEltTy",
".",
"getFixedSizeInBits",
"(",
")",
";",
"uint64_t",
"VTSize",
"=",
"VT",
".",
"getFixedSizeInBits",
"(",
")",
";",
"NumElts",
"=",
"VTSize",
"/",
"SmallestEltTy",
".",
"getFixedSizeInBits",
"(",
")",
";",
"EVT",
"ShuffleVT",
"=",
"EVT",
"::",
"getVectorVT",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"SmallestEltTy",
",",
"NumElts",
")",
";",
"for",
"(",
"auto",
"&",
"Src",
":",
"Sources",
")",
"{",
"EVT",
"SrcVT",
"=",
"Src",
".",
"ShuffleVec",
".",
"getValueType",
"(",
")",
";",
"uint64_t",
"SrcVTSize",
"=",
"SrcVT",
".",
"getFixedSizeInBits",
"(",
")",
";",
"if",
"(",
"SrcVTSize",
"==",
"VTSize",
")",
"continue",
";",
"EVT",
"EltVT",
"=",
"SrcVT",
".",
"getVectorElementType",
"(",
")",
";",
"unsigned",
"NumSrcElts",
"=",
"VTSize",
"/",
"EltVT",
".",
"getFixedSizeInBits",
"(",
")",
";",
"EVT",
"DestVT",
"=",
"EVT",
"::",
"getVectorVT",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"EltVT",
",",
"NumSrcElts",
")",
";",
"if",
"(",
"SrcVTSize",
"<",
"VTSize",
")",
"{",
"assert",
"(",
"<NUM_LIT>",
"*",
"SrcVTSize",
"==",
"VTSize",
")",
";",
"Src",
".",
"ShuffleVec",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"CONCAT_VECTORS",
",",
"dl",
",",
"DestVT",
",",
"Src",
".",
"ShuffleVec",
",",
"DAG",
".",
"getUNDEF",
"(",
"Src",
".",
"ShuffleVec",
".",
"getValueType",
"(",
")",
")",
")",
";",
"continue",
";",
"}",
"if",
"(",
"SrcVTSize",
"!=",
"<NUM_LIT>",
"*",
"VTSize",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Reshuffle failed: result vector too small to extract\\n",
"<STR_LIT>",
")",
";",
"return",
"SDValue",
"(",
")",
";",
"}",
"if",
"(",
"Src",
".",
"MaxElt",
"-",
"Src",
".",
"MinElt",
">=",
"NumSrcElts",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Reshuffle failed: span too large for a VEXT to cope\\n",
"<STR_LIT>",
")",
";",
"return",
"SDValue",
"(",
")",
";",
"}",
"if",
"(",
"Src",
".",
"MinElt",
">=",
"NumSrcElts",
")",
"{",
"Src",
".",
"ShuffleVec",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"dl",
",",
"DestVT",
",",
"Src",
".",
"ShuffleVec",
",",
"DAG",
".",
"getConstant",
"(",
"NumSrcElts",
",",
"dl",
",",
"MVT",
"::",
"i64",
")",
")",
";",
"Src",
".",
"WindowBase",
"=",
"-",
"NumSrcElts",
";",
"}",
"else",
"if",
"(",
"Src",
".",
"MaxElt",
"<",
"NumSrcElts",
")",
"{",
"Src",
".",
"ShuffleVec",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"dl",
",",
"DestVT",
",",
"Src",
".",
"ShuffleVec",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"dl",
",",
"MVT",
"::",
"i64",
")",
")",
";",
"}",
"else",
"{",
"SDValue",
"VEXTSrc1",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"dl",
",",
"DestVT",
",",
"Src",
".",
"ShuffleVec",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"dl",
",",
"MVT",
"::",
"i64",
")",
")",
";"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 4,449 | [
"=",
"<NUM_LIT>",
";"
] | [
"def",
"A2_maxu",
":",
"HInst",
"<",
"(",
"outs",
"IntRegs",
":",
"$",
"Rd32",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rs32",
",",
"IntRegs",
":",
"$",
"Rt32",
")",
",",
"<STR_LIT>",
",",
"tc_779080bf",
",",
"TypeALU64",
">",
",",
"Enc_5ab2be",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 4,450 | [
"i32",
">",
"{"
] | [
"def",
"simm7s8",
":",
"Operand",
"<"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 4,451 | [
"return",
"true",
";"
] | [
"bool",
"HasAnyUndefs",
";",
"if",
"(",
"!",
"BVN",
"||",
"!",
"BVN",
"->",
"isConstantSplat",
"(",
"SplatBits",
",",
"SplatUndef",
",",
"SplatBitSize",
",",
"HasAnyUndefs",
",",
"ElementBits",
")",
"||",
"SplatBitSize",
">",
"ElementBits",
")",
"return",
"false",
";",
"Cnt",
"=",
"SplatBits",
".",
"getSExtValue",
"(",
")",
";"
] |
LLVM | Sparc | CPP | stmt_completion | CPU | 4,452 | [
")",
")",
")",
";"
] | [
"PM",
".",
"add",
"(",
"createSparcFPMoverPass",
"(",
"getSparcTargetMachine",
"(",
")",
")",
")",
";",
"PM",
".",
"add",
"(",
"createSparcDelaySlotFillerPass",
"(",
"getSparcTargetMachine",
"("
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 4,453 | [
"=",
"SImm7s8Operand",
";"
] | [
"def",
"simm7s8",
":",
"Operand",
"<",
"i32",
">",
"{",
"let",
"ParserMatchClass"
] |
LLVM | AMDGPU | CPP | program_repair | GPU | 4,454 | [
"<FIXS>",
"bool",
"AMDGPUAsmParser",
"::",
"AddNextRegisterToList",
"(",
"unsigned",
"&",
"Reg",
",",
"unsigned",
"&",
"RegWidth",
",",
"RegisterKind",
"RegKind",
",",
"unsigned",
"Reg1",
",",
"unsigned",
"RegNum",
")",
"{",
"<FIXE>",
"<FIXS>",
"if",
"(",
"Reg",
"==",
"AMDGPU",
"::",
"EXEC_LO",
"&&",
"Reg1",
"==",
"AMDGPU",
"::",
"EXEC_HI",
")",
"{",
"Reg",
"=",
"AMDGPU",
"::",
"EXEC",
";",
"RegWidth",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Reg",
"==",
"AMDGPU",
"::",
"FLAT_SCR_LO",
"&&",
"Reg1",
"==",
"AMDGPU",
"::",
"FLAT_SCR_HI",
")",
"{",
"Reg",
"=",
"AMDGPU",
"::",
"FLAT_SCR",
";",
"RegWidth",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Reg",
"==",
"AMDGPU",
"::",
"VCC_LO",
"&&",
"Reg1",
"==",
"AMDGPU",
"::",
"VCC_HI",
")",
"{",
"Reg",
"=",
"AMDGPU",
"::",
"VCC",
";",
"RegWidth",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Reg",
"==",
"AMDGPU",
"::",
"TBA_LO",
"&&",
"Reg1",
"==",
"AMDGPU",
"::",
"TBA_HI",
")",
"{",
"Reg",
"=",
"AMDGPU",
"::",
"TBA",
";",
"RegWidth",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Reg",
"==",
"AMDGPU",
"::",
"TMA_LO",
"&&",
"Reg1",
"==",
"AMDGPU",
"::",
"TMA_HI",
")",
"{",
"Reg",
"=",
"AMDGPU",
"::",
"TMA",
";",
"RegWidth",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"}",
"<FIXE>",
"<FIXS>",
"if",
"(",
"Reg1",
"!=",
"Reg",
"+",
"RegWidth",
")",
"{",
"return",
"false",
";",
"}",
"<FIXE>"
] | [
"return",
"false",
";",
"}",
"<BUGS>",
"bool",
"AMDGPUAsmParser",
"::",
"AddNextRegisterToList",
"(",
"unsigned",
"&",
"Reg",
",",
"unsigned",
"&",
"RegWidth",
",",
"RegisterKind",
"RegKind",
",",
"unsigned",
"Reg1",
",",
"unsigned",
"RegNum",
")",
"{",
"<BUGE>",
"switch",
"(",
"RegKind",
")",
"{",
"case",
"IS_SPECIAL",
":",
"<BUGS>",
"if",
"(",
"Reg",
"==",
"AMDGPU",
"::",
"EXEC_LO",
"&&",
"Reg1",
"==",
"AMDGPU",
"::",
"EXEC_HI",
")",
"{",
"Reg",
"=",
"AMDGPU",
"::",
"EXEC",
";",
"RegWidth",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Reg",
"==",
"AMDGPU",
"::",
"FLAT_SCR_LO",
"&&",
"Reg1",
"==",
"AMDGPU",
"::",
"FLAT_SCR_HI",
")",
"{",
"Reg",
"=",
"AMDGPU",
"::",
"FLAT_SCR",
";",
"RegWidth",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Reg",
"==",
"AMDGPU",
"::",
"VCC_LO",
"&&",
"Reg1",
"==",
"AMDGPU",
"::",
"VCC_HI",
")",
"{",
"Reg",
"=",
"AMDGPU",
"::",
"VCC",
";",
"RegWidth",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Reg",
"==",
"AMDGPU",
"::",
"TBA_LO",
"&&",
"Reg1",
"==",
"AMDGPU",
"::",
"TBA_HI",
")",
"{",
"Reg",
"=",
"AMDGPU",
"::",
"TBA",
";",
"RegWidth",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Reg",
"==",
"AMDGPU",
"::",
"TMA_LO",
"&&",
"Reg1",
"==",
"AMDGPU",
"::",
"TMA_HI",
")",
"{",
"Reg",
"=",
"AMDGPU",
"::",
"TMA",
";",
"RegWidth",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"}",
"<BUGE>",
"return",
"false",
";",
"case",
"IS_VGPR",
":",
"case",
"IS_SGPR",
":",
"case",
"IS_TTMP",
":",
"<BUGS>",
"if",
"(",
"Reg1",
"!=",
"Reg",
"+",
"RegWidth",
")",
"{",
"return",
"false",
";",
"}",
"<BUGE>",
"RegWidth",
"++",
";",
"return",
"true",
";",
"default",
":"
] |
LLVM | Patmos | CPP | stmt_completion | VLIW | 4,455 | [
"<NUM_LIT>",
";"
] | [
"if",
"(",
"DstTy",
"==",
"NULL",
"||",
"SrcTy",
"==",
"NULL",
")",
"return",
"DstTy",
"==",
"SrcTy",
";",
"if",
"(",
"DstTy",
">",
"SrcTy",
")",
"return",
"areTypesIsomorphic",
"(",
"SrcTy",
",",
"DstTy",
")",
";",
"if",
"(",
"isEmptyStructPointer",
"(",
"DstTy",
")",
"&&",
"SrcTy",
"->",
"isPointerTy",
"(",
")",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"isEmptyStructPointer",
"(",
"SrcTy",
")",
"&&",
"DstTy",
"->",
"isPointerTy",
"(",
")",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"DstTy",
"->",
"getTypeID",
"(",
")",
"!=",
"SrcTy",
"->",
"getTypeID",
"(",
")",
")",
"return",
"<NUM_LIT>",
";",
"equivalent_types_t",
"::",
"const_iterator",
"tmp",
"(",
"EQ",
".",
"find",
"(",
"std",
"::",
"make_pair",
"(",
"DstTy",
",",
"SrcTy",
")",
")",
")",
";",
"if",
"(",
"tmp",
"!=",
"EQ",
".",
"end",
"(",
")",
")",
"{",
"return",
"tmp",
"->",
"second",
";",
"}",
"if",
"(",
"DstTy",
"==",
"SrcTy",
")",
"{",
"return",
"<NUM_LIT>",
";",
"}",
"EQ",
"[",
"std",
"::",
"make_pair",
"(",
"DstTy",
",",
"SrcTy",
")",
"]",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"StructType",
"*",
"SSTy",
"=",
"dyn_cast",
"<",
"StructType",
">",
"(",
"SrcTy",
")",
")",
"{",
"if",
"(",
"SSTy",
"->",
"isOpaque",
"(",
")",
")",
"{",
"assert",
"(",
"false",
")",
";",
"return",
"<NUM_LIT>",
";",
"}",
"if",
"(",
"cast",
"<",
"StructType",
">",
"(",
"DstTy",
")",
"->",
"isOpaque",
"(",
")",
")",
"{",
"assert",
"(",
"false",
")",
";",
"return",
"<NUM_LIT>",
";",
"}",
"}",
"if",
"(",
"SrcTy",
"->",
"getNumContainedTypes",
"(",
")",
"!=",
"DstTy",
"->",
"getNumContainedTypes",
"(",
")",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"isa",
"<",
"IntegerType",
">",
"(",
"DstTy",
")",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"PointerType",
"*",
"PT",
"=",
"dyn_cast",
"<",
"PointerType",
">",
"(",
"DstTy",
")",
")",
"{",
"if",
"(",
"PT",
"->",
"getAddressSpace",
"(",
")",
"!=",
"cast",
"<",
"PointerType",
">",
"(",
"SrcTy",
")",
"->",
"getAddressSpace",
"(",
")",
")",
"return",
"<NUM_LIT>",
";",
"}",
"else",
"if",
"(",
"FunctionType",
"*",
"FT",
"=",
"dyn_cast",
"<",
"FunctionType",
">",
"(",
"DstTy",
")",
")",
"{",
"if",
"(",
"FT",
"->",
"isVarArg",
"(",
")",
"!=",
"cast",
"<",
"FunctionType",
">",
"(",
"SrcTy",
")",
"->",
"isVarArg",
"(",
")",
")",
"return",
"<NUM_LIT>",
";",
"}",
"else",
"if",
"(",
"StructType",
"*",
"DSTy",
"=",
"dyn_cast",
"<",
"StructType",
">",
"(",
"DstTy",
")",
")",
"{",
"StructType",
"*",
"SSTy",
"=",
"cast",
"<",
"StructType",
">",
"(",
"SrcTy",
")",
";",
"if",
"(",
"DSTy",
"->",
"isLiteral",
"(",
")",
"!=",
"SSTy",
"->",
"isLiteral",
"(",
")",
"||",
"DSTy",
"->",
"isPacked",
"(",
")",
"!=",
"SSTy",
"->",
"isPacked",
"(",
")",
")",
"return",
"<NUM_LIT>",
";",
"}",
"else",
"if",
"(",
"ArrayType",
"*",
"DATy",
"=",
"dyn_cast",
"<",
"ArrayType",
">",
"(",
"DstTy",
")",
")",
"{",
"if",
"(",
"DATy",
"->",
"getNumElements",
"(",
")",
"!=",
"cast",
"<",
"ArrayType",
">",
"(",
"SrcTy",
")",
"->",
"getNumElements",
"(",
")",
")",
"return",
"<NUM_LIT>",
";",
"}",
"else",
"if",
"(",
"VectorType",
"*",
"DVTy",
"=",
"dyn_cast",
"<",
"VectorType",
">",
"(",
"DstTy",
")",
")",
"{",
"if",
"(",
"DVTy",
"->",
"getNumElements",
"(",
")",
"!=",
"cast",
"<",
"ArrayType",
">",
"(",
"SrcTy",
")",
"->",
"getNumElements",
"(",
")",
")",
"return",
"<NUM_LIT>",
";",
"}",
"EQ",
"[",
"std",
"::",
"make_pair",
"(",
"DstTy",
",",
"SrcTy",
")",
"]",
"=",
"-",
"<NUM_LIT>",
";",
"int",
"retval",
"="
] |
GCC | bfin | MD | stmt_completion | DSP | 4,456 | [
"(",
"const_int",
"<NUM_LIT>",
")",
")"
] | [
"(",
"if_then_else",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")"
] |
LLVM | ARM | CPP | stmt_completion | CPU | 4,457 | [
"(",
")",
";"
] | [
"return",
"&",
"InstrInfo",
".",
"getRegisterInfo"
] |
LLVM | ARM | TD | stmt_completion | CPU | 4,458 | [
",",
"SDTARMVSHX",
">",
";"
] | [
"def",
"NEONvshrn",
":",
"SDNode",
"<",
"<STR_LIT>"
] |
LLVM | R600 | CPP | code_generation | GPU | 4,459 | [
"void",
"R600InstrInfo",
"::",
"clearFlag",
"(",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"Operand",
",",
"unsigned",
"Flag",
")",
"const",
"{",
"unsigned",
"TargetFlags",
"=",
"get",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
".",
"TSFlags",
";",
"if",
"(",
"HAS_NATIVE_OPERANDS",
"(",
"TargetFlags",
")",
")",
"{",
"MachineOperand",
"&",
"FlagOp",
"=",
"getFlagOp",
"(",
"MI",
",",
"Operand",
",",
"Flag",
")",
";",
"FlagOp",
".",
"setImm",
"(",
"<NUM_LIT>",
")",
";",
"}",
"else",
"{",
"MachineOperand",
"&",
"FlagOp",
"=",
"getFlagOp",
"(",
"MI",
")",
";",
"unsigned",
"InstFlags",
"=",
"FlagOp",
".",
"getImm",
"(",
")",
";",
"InstFlags",
"&=",
"~",
"(",
"Flag",
"<<",
"(",
"NUM_MO_FLAGS",
"*",
"Operand",
")",
")",
";",
"FlagOp",
".",
"setImm",
"(",
"InstFlags",
")",
";",
"}",
"}"
] | [
"Clear",
"the",
"specified",
"flag",
"on",
"the",
"instruction",
"."
] |
GCC | rs6000 | MD | stmt_completion | CPU | 4,460 | [
"<STR_LIT>",
"<STR_LIT>",
")"
] | [
"(",
"define_bypass",
"<NUM_LIT>"
] |
GCC | i386 | CPP | next_suggestion | CPU | 4,461 | [
"}"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m128d",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_maskz_cvtepi32_pd",
"(",
"_",
"_",
"mmask8",
"_",
"_",
"U",
",",
"_",
"_",
"m128i",
"_",
"_",
"A",
")",
"{",
"return",
"(",
"_",
"_",
"m128d",
")",
"_",
"_",
"builtin_ia32_cvtdq2pd128_mask",
"(",
"(",
"_",
"_",
"v4si",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v2df",
")",
"_",
"mm_avx512_setzero_pd",
"(",
")",
",",
"(",
"_",
"_",
"mmask8",
")",
"_",
"_",
"U",
")",
";"
] |
GCC | nds32 | CPP | next_suggestion | CPU | 4,462 | [
"default",
":"
] | [
"case",
"<NUM_LIT>",
":",
"return",
"<NUM_LIT>",
";",
"case",
"<NUM_LIT>",
":",
"return",
"<NUM_LIT>",
";",
"case",
"<NUM_LIT>",
":",
"return",
"<NUM_LIT>",
";"
] |
LLVM | Patmos | CPP | next_suggestion | VLIW | 4,463 | [
"RemoveDeps",
".",
"push_back",
"(",
"&",
"*",
"it",
")",
";"
] | [
"if",
"(",
"MT",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"||",
"MT",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"RemoveDeps",
".",
"push_back",
"(",
"&",
"*",
"it",
")",
";",
"}",
"}",
"}",
"}",
"else",
"{",
"bool",
"IsImplicit",
"=",
"true",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"MI",
"->",
"getNumOperands",
"(",
")",
";",
"i",
"++",
")",
"{",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"i",
")",
";",
"if",
"(",
"!",
"MO",
".",
"isReg",
"(",
")",
")",
"continue",
";",
"if",
"(",
"!",
"isExplicitCFLOperand",
"(",
"MI",
",",
"MO",
")",
")",
"continue",
";",
"if",
"(",
"it",
"->",
"getKind",
"(",
")",
"==",
"SDep",
"::",
"Data",
")",
"{",
"if",
"(",
"MO",
".",
"getReg",
"(",
")",
"==",
"it",
"->",
"getReg",
"(",
")",
")",
"{",
"IsImplicit",
"=",
"false",
";",
"break",
";",
"}",
"}",
"else",
"if",
"(",
"MO",
".",
"isDef",
"(",
")",
")",
"{",
"MachineInstr",
"*",
"PredMI",
"=",
"it",
"->",
"getSUnit",
"(",
")",
"->",
"getInstr",
"(",
")",
";",
"for",
"(",
"unsigned",
"j",
"=",
"<NUM_LIT>",
";",
"j",
"<",
"PredMI",
"->",
"getNumOperands",
"(",
")",
";",
"j",
"++",
")",
"{",
"MachineOperand",
"&",
"PredMO",
"=",
"PredMI",
"->",
"getOperand",
"(",
"j",
")",
";",
"if",
"(",
"PredMO",
".",
"isReg",
"(",
")",
"&&",
"PredMO",
".",
"getReg",
"(",
")",
"==",
"MO",
".",
"getReg",
"(",
")",
")",
"{",
"IsImplicit",
"=",
"false",
";",
"break",
";",
"}",
"}",
"}",
"}",
"if",
"(",
"IsImplicit",
")",
"{"
] |
GCC | aarch64 | CPP | next_suggestion | CPU | 4,464 | [
"}"
] | [
"vtrn_f16",
"(",
"float16x4_t",
"_",
"_",
"a",
",",
"float16x4_t",
"_",
"_",
"b",
")",
"{",
"return",
"(",
"float16x4x2_t",
")",
"{",
"vtrn1_f16",
"(",
"_",
"_",
"a",
",",
"_",
"_",
"b",
")",
",",
"vtrn2_f16",
"(",
"_",
"_",
"a",
",",
"_",
"_",
"b",
")",
"}",
";"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 4,465 | [
"}"
] | [
"bool",
"hasAtomicGlobalPkAddBF16Inst",
"(",
")",
"const",
"{",
"return",
"HasAtomicGlobalPkAddBF16Inst",
";"
] |
GCC | aarch64 | MD | next_suggestion | CPU | 4,466 | [
"return",
"<STR_LIT>"
] | [
"(",
"plus",
":",
"SVE_I",
"(",
"vec_duplicate",
":",
"SVE_I",
"(",
"match_operand",
":",
"<",
"VEL",
">",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"match_operand",
":",
"SVE_I",
"<NUM_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"{",
"operands",
"[",
"<NUM_LIT>",
"]",
"=",
"aarch64_check_zero_based_sve_index_immediate",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 4,467 | [
"pReloc",
",",
"*",
"rsym",
")",
")",
"{"
] | [
"addCopyReloc",
"(",
"*",
"cpy_sym",
".",
"resolveInfo",
"(",
")",
")",
";",
"}",
"else",
"{",
"rsym",
"->",
"setReserved",
"(",
"rsym",
"->",
"reserved",
"(",
")",
"|",
"ReserveRel",
")",
";",
"getTarget",
"(",
")",
".",
"checkAndSetHasTextRel",
"(",
"*",
"pSection",
".",
"getLink",
"(",
")",
")",
";",
"if",
"(",
"llvm",
"::",
"ELF",
"::",
"R_AARCH64_ABS64",
"==",
"pReloc",
".",
"type",
"(",
")",
"&&",
"helper_use_relative_reloc",
"(",
"*",
"rsym",
",",
"*",
"this",
")",
")",
"{",
"Relocation",
"&",
"reloc",
"=",
"helper_DynRela_init",
"(",
"rsym",
",",
"*",
"pReloc",
".",
"targetRef",
"(",
")",
".",
"frag",
"(",
")",
",",
"pReloc",
".",
"targetRef",
"(",
")",
".",
"offset",
"(",
")",
",",
"llvm",
"::",
"ELF",
"::",
"R_AARCH64_RELATIVE",
",",
"*",
"this",
")",
";",
"getRelRelMap",
"(",
")",
".",
"record",
"(",
"pReloc",
",",
"reloc",
")",
";",
"}",
"else",
"{",
"Relocation",
"&",
"reloc",
"=",
"helper_DynRela_init",
"(",
"rsym",
",",
"*",
"pReloc",
".",
"targetRef",
"(",
")",
".",
"frag",
"(",
")",
",",
"pReloc",
".",
"targetRef",
"(",
")",
".",
"offset",
"(",
")",
",",
"pReloc",
".",
"type",
"(",
")",
",",
"*",
"this",
")",
";",
"getRelRelMap",
"(",
")",
".",
"record",
"(",
"pReloc",
",",
"reloc",
")",
";",
"}",
"}",
"}",
"return",
";",
"case",
"llvm",
"::",
"ELF",
"::",
"R_AARCH64_PREL64",
":",
"case",
"llvm",
"::",
"ELF",
"::",
"R_AARCH64_PREL32",
":",
"case",
"llvm",
"::",
"ELF",
"::",
"R_AARCH64_PREL16",
":",
"if",
"(",
"getTarget",
"(",
")",
".",
"symbolNeedsPLT",
"(",
"*",
"rsym",
")",
"&&",
"LinkerConfig",
"::",
"DynObj",
"!=",
"config",
"(",
")",
".",
"codeGenType",
"(",
")",
")",
"{",
"if",
"(",
"!",
"(",
"rsym",
"->",
"reserved",
"(",
")",
"&",
"ReservePLT",
")",
")",
"{",
"helper_PLT_init",
"(",
"pReloc",
",",
"*",
"this",
")",
";",
"rsym",
"->",
"setReserved",
"(",
"rsym",
"->",
"reserved",
"(",
")",
"|",
"ReservePLT",
")",
";",
"}",
"}",
"if",
"(",
"getTarget",
"(",
")",
".",
"isDynamicSymbol",
"(",
"*",
"rsym",
")",
"&&",
"getTarget",
"(",
")",
".",
"symbolNeedsDynRel",
"(",
"*",
"rsym",
",",
"(",
"rsym",
"->",
"reserved",
"(",
")",
"&",
"ReservePLT",
")",
",",
"false",
")",
"&&",
"getTarget",
"(",
")",
".",
"symbolNeedsCopyReloc",
"(",
"pReloc",
",",
"*",
"rsym",
")",
")",
"{",
"LDSymbol",
"&",
"cpy_sym",
"=",
"defineSymbolforCopyReloc",
"(",
"pBuilder",
",",
"*",
"rsym",
")",
";",
"addCopyReloc",
"(",
"*",
"cpy_sym",
".",
"resolveInfo",
"(",
")",
")",
";",
"}",
"return",
";",
"case",
"llvm",
"::",
"ELF",
"::",
"R_AARCH64_CONDBR19",
":",
"case",
"llvm",
"::",
"ELF",
"::",
"R_AARCH64_JUMP26",
":",
"case",
"llvm",
"::",
"ELF",
"::",
"R_AARCH64_CALL26",
":",
"{",
"if",
"(",
"rsym",
"->",
"reserved",
"(",
")",
"&",
"ReservePLT",
")",
"return",
";",
"if",
"(",
"getTarget",
"(",
")",
".",
"symbolFinalValueIsKnown",
"(",
"*",
"rsym",
")",
")",
"return",
";",
"if",
"(",
"rsym",
"->",
"isDefine",
"(",
")",
"&&",
"!",
"rsym",
"->",
"isDyn",
"(",
")",
"&&",
"!",
"getTarget",
"(",
")",
".",
"isSymbolPreemptible",
"(",
"*",
"rsym",
")",
")",
"{",
"return",
";",
"}",
"helper_PLT_init",
"(",
"pReloc",
",",
"*",
"this",
")",
";",
"rsym",
"->",
"setReserved",
"(",
"rsym",
"->",
"reserved",
"(",
")",
"|",
"ReservePLT",
")",
";",
"return",
";",
"}",
"case",
"llvm",
"::",
"ELF",
"::",
"R_AARCH64_ADR_PREL_LO21",
":",
"case",
"llvm",
"::",
"ELF",
"::",
"R_AARCH64_ADR_PREL_PG_HI21",
":",
"case",
"llvm",
"::",
"ELF",
"::",
"R_AARCH64_ADR_PREL_PG_HI21_NC",
":",
"if",
"(",
"getTarget",
"(",
")",
".",
"symbolNeedsDynRel",
"(",
"*",
"rsym",
",",
"(",
"rsym",
"->",
"reserved",
"(",
")",
"&",
"ReservePLT",
")",
",",
"false",
")",
")",
"{",
"if",
"(",
"getTarget",
"(",
")",
".",
"symbolNeedsCopyReloc",
"("
] |
GCC | s390 | CPP | stmt_completion | MPU | 4,468 | [
")",
"return",
"priority",
";"
] | [
"static",
"int",
"s390_adjust_priority",
"(",
"rtx",
"insn",
"ATTRIBUTE_UNUSED",
",",
"int",
"priority",
")",
"{",
"if",
"(",
"!",
"INSN_P",
"(",
"insn",
")",
")",
"return",
"priority",
";",
"if",
"(",
"s390_tune",
"!=",
"PROCESSOR_2084_Z990",
"&&",
"s390_tune",
"!=",
"PROCESSOR_2094_Z9_109"
] |
GCC | arm | CPP | stmt_completion | CPU | 4,469 | [
"builtin_neon_si",
")",
"_",
"_",
"b",
")",
";"
] | [
"vmul_n_u32",
"(",
"uint32x2_t",
"_",
"_",
"a",
",",
"uint32_t",
"_",
"_",
"b",
")",
"{",
"return",
"(",
"uint32x2_t",
")",
"_",
"_",
"builtin_neon_vmul_nv2si",
"(",
"(",
"int32x2_t",
")",
"_",
"_",
"a",
",",
"(",
"_",
"_"
] |
GCC | aarch64 | MD | stmt_completion | CPU | 4,470 | [
"]",
")"
] | [
"(",
"define_int_iterator",
"UNPACK_UNSIGNED",
"[",
"UNSPEC_UNPACKULO",
"UNSPEC_UNPACKUHI"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 4,471 | [
"return",
"false",
";"
] | [
"if",
"(",
"!",
"IsVector",
"&&",
"!",
"Op",
"->",
"isRegList",
"(",
")",
")",
"return",
"Error",
"(",
"L",
",",
"<STR_LIT>",
".save expects GPR registers",
"<STR_LIT>",
")",
";",
"if",
"(",
"IsVector",
"&&",
"!",
"Op",
"->",
"isDPRRegList",
"(",
")",
")",
"return",
"Error",
"(",
"L",
",",
"<STR_LIT>",
".vsave expects DPR registers",
"<STR_LIT>",
")",
";",
"getParser",
"(",
")",
".",
"getStreamer",
"(",
")",
".",
"EmitRegSave",
"(",
"Op",
"->",
"getRegList",
"(",
")",
",",
"IsVector",
")",
";"
] |
GCC | i386 | CPP | stmt_completion | CPU | 4,472 | [
"B",
",",
"(",
"_",
"_",
"v8sf",
")",
"_",
"mm256_avx512_setzero_ps",
"(",
")",
",",
"(",
"_",
"_",
"mmask8",
")",
"-",
"<NUM_LIT>",
")",
";"
] | [
"return",
"(",
"_",
"_",
"m256",
")",
"_",
"_",
"builtin_ia32_scalefps256_mask",
"(",
"(",
"_",
"_",
"v8sf",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v8sf",
")",
"_",
"_"
] |
GCC | msp430 | CPP | code_generation | MPU | 4,473 | [
"static",
"bool",
"msp430_check_plus_not_high_mem",
"(",
"rtx",
"op",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"op",
")",
"!=",
"PLUS",
")",
"return",
"false",
";",
"rtx",
"op0",
"=",
"XEXP",
"(",
"op",
",",
"<NUM_LIT>",
")",
";",
"rtx",
"op1",
"=",
"XEXP",
"(",
"op",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"SYMBOL_REF_P",
"(",
"op0",
")",
"&&",
"(",
"SYMBOL_REF_FLAGS",
"(",
"op0",
")",
"&",
"SYMBOL_FLAG_LOW_MEM",
")",
"&&",
"msp430_check_index_not_high_mem",
"(",
"op1",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}"
] | [
"If",
"this",
"returns",
"true",
",",
"we",
"do",
"n't",
"need",
"a",
"430X",
"insn",
"."
] |
GCC | arm | CPP | stmt_completion | CPU | 4,474 | [
",",
"_",
"_",
"p",
")",
";"
] | [
"return",
"_",
"_",
"builtin_mve_vcaddq_rot270_m_sv4si",
"(",
"_",
"_",
"inactive",
",",
"_",
"_",
"a",
",",
"_",
"_",
"b"
] |
LLVM | ARM | TD | next_suggestion | CPU | 4,475 | [
"}"
] | [
"class",
"VLD3D",
"<",
"bits",
"<",
"<NUM_LIT>",
">",
"op11_8",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"op7_4",
",",
"string",
"Dt",
">",
":",
"NLdSt",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"op11_8",
",",
"op7_4",
",",
"(",
"outs",
"DPR",
":",
"$",
"Vd",
",",
"DPR",
":",
"$",
"dst2",
",",
"DPR",
":",
"$",
"dst3",
")",
",",
"(",
"ins",
"addrmode6",
":",
"$",
"Rn",
")",
",",
"IIC_VLD3",
",",
"<STR_LIT>",
",",
"Dt",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"[",
"]",
">",
",",
"Sched",
"<",
"[",
"WriteVLD3",
"]",
">",
"{",
"let",
"Rm",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"Rn",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"DecoderMethod",
"=",
"<STR_LIT>",
";"
] |
LLVM | ARM | TD | next_suggestion | CPU | 4,476 | [
"let",
"ParserMatchClass",
"=",
"pred_restricted_s_asmoperand",
";"
] | [
"def",
"pred_basic_s",
":",
"VCMPPredicateOperand",
"{",
"let",
"PrintMethod",
"=",
"<STR_LIT>",
";"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 4,477 | [
"<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",
"hasNewValue",
"="
] |
GCC | sparc | MD | program_repair | CPU | 4,478 | [
"<FIXS>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<FIXE>"
] | [
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"<BUGS>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<BUGE>",
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | i386 | MD | stmt_completion | CPU | 4,479 | [
"<STR_LIT>",
")"
] | [
"(",
"define_reservation",
"<STR_LIT>"
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 4,480 | [
"CallSeqStart",
".",
"addImm",
"(",
"Handler",
".",
"StackSize",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
";"
] | [
"for",
"(",
"auto",
"&",
"OrigArg",
":",
"OrigArgs",
")",
"{",
"splitToValueTypes",
"(",
"OrigArg",
",",
"SplitArgs",
",",
"DL",
",",
"MRI",
",",
"CallConv",
",",
"[",
"&",
"]",
"(",
"unsigned",
"Reg",
",",
"uint64_t",
"Offset",
")",
"{",
"MIRBuilder",
".",
"buildExtract",
"(",
"Reg",
",",
"OrigArg",
".",
"Reg",
",",
"Offset",
")",
";",
"}",
")",
";",
"if",
"(",
"OrigArg",
".",
"Ty",
"->",
"isIntegerTy",
"(",
"<NUM_LIT>",
")",
")",
"SplitArgs",
".",
"back",
"(",
")",
".",
"Flags",
".",
"setZExt",
"(",
")",
";",
"}",
"const",
"AArch64TargetLowering",
"&",
"TLI",
"=",
"*",
"getTLI",
"<",
"AArch64TargetLowering",
">",
"(",
")",
";",
"CCAssignFn",
"*",
"AssignFnFixed",
"=",
"TLI",
".",
"CCAssignFnForCall",
"(",
"CallConv",
",",
"false",
")",
";",
"CCAssignFn",
"*",
"AssignFnVarArg",
"=",
"TLI",
".",
"CCAssignFnForCall",
"(",
"CallConv",
",",
"true",
")",
";",
"auto",
"CallSeqStart",
"=",
"MIRBuilder",
".",
"buildInstr",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"auto",
"MIB",
"=",
"MIRBuilder",
".",
"buildInstrNoInsert",
"(",
"Callee",
".",
"isReg",
"(",
")",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"MIB",
".",
"add",
"(",
"Callee",
")",
";",
"auto",
"TRI",
"=",
"MF",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"const",
"uint32_t",
"*",
"Mask",
"=",
"TRI",
"->",
"getCallPreservedMask",
"(",
"MF",
",",
"F",
".",
"getCallingConv",
"(",
")",
")",
";",
"if",
"(",
"MF",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
".",
"hasCustomCallingConv",
"(",
")",
")",
"TRI",
"->",
"UpdateCustomCallPreservedMask",
"(",
"MF",
",",
"&",
"Mask",
")",
";",
"MIB",
".",
"addRegMask",
"(",
"Mask",
")",
";",
"if",
"(",
"TRI",
"->",
"isAnyArgRegReserved",
"(",
"MF",
")",
")",
"TRI",
"->",
"emitReservedArgRegCallError",
"(",
"MF",
")",
";",
"SmallVector",
"<",
"unsigned",
",",
"<NUM_LIT>",
">",
"PhysRegs",
";",
"OutgoingArgHandler",
"Handler",
"(",
"MIRBuilder",
",",
"MRI",
",",
"MIB",
",",
"AssignFnFixed",
",",
"AssignFnVarArg",
")",
";",
"if",
"(",
"!",
"handleAssignments",
"(",
"MIRBuilder",
",",
"SplitArgs",
",",
"Handler",
")",
")",
"return",
"false",
";",
"MIRBuilder",
".",
"insertInstr",
"(",
"MIB",
")",
";",
"if",
"(",
"Callee",
".",
"isReg",
"(",
")",
")",
"MIB",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"setReg",
"(",
"constrainOperandRegClass",
"(",
"MF",
",",
"*",
"TRI",
",",
"MRI",
",",
"*",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
",",
"*",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegBankInfo",
"(",
")",
",",
"*",
"MIB",
",",
"MIB",
"->",
"getDesc",
"(",
")",
",",
"Callee",
",",
"<NUM_LIT>",
")",
")",
";",
"CCAssignFn",
"*",
"RetAssignFn",
"=",
"TLI",
".",
"CCAssignFnForReturn",
"(",
"F",
".",
"getCallingConv",
"(",
")",
")",
";",
"if",
"(",
"OrigRet",
".",
"Reg",
")",
"{",
"SplitArgs",
".",
"clear",
"(",
")",
";",
"SmallVector",
"<",
"uint64_t",
",",
"<NUM_LIT>",
">",
"RegOffsets",
";",
"SmallVector",
"<",
"unsigned",
",",
"<NUM_LIT>",
">",
"SplitRegs",
";",
"splitToValueTypes",
"(",
"OrigRet",
",",
"SplitArgs",
",",
"DL",
",",
"MRI",
",",
"F",
".",
"getCallingConv",
"(",
")",
",",
"[",
"&",
"]",
"(",
"unsigned",
"Reg",
",",
"uint64_t",
"Offset",
")",
"{",
"RegOffsets",
".",
"push_back",
"(",
"Offset",
")",
";",
"SplitRegs",
".",
"push_back",
"(",
"Reg",
")",
";",
"}",
")",
";",
"CallReturnHandler",
"Handler",
"(",
"MIRBuilder",
",",
"MRI",
",",
"MIB",
",",
"RetAssignFn",
")",
";",
"if",
"(",
"!",
"handleAssignments",
"(",
"MIRBuilder",
",",
"SplitArgs",
",",
"Handler",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"RegOffsets",
".",
"empty",
"(",
")",
")",
"MIRBuilder",
".",
"buildSequence",
"(",
"OrigRet",
".",
"Reg",
",",
"SplitRegs",
",",
"RegOffsets",
")",
";",
"}"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 4,481 | [
"Opc",
"=",
"CurDAG",
"->",
"getTargetConstant",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"AddSub",
",",
"ShAmt",
",",
"ShOpcVal",
")",
",",
"MVT",
"::",
"i32",
")",
";"
] | [
"if",
"(",
"RHSC",
"<",
"<NUM_LIT>",
")",
"{",
"AddSub",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"RHSC",
"=",
"-",
"RHSC",
";",
"}",
"Opc",
"=",
"CurDAG",
"->",
"getTargetConstant",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"AddSub",
",",
"RHSC",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
",",
"MVT",
"::",
"i32",
")",
";",
"return",
"AM2_BASE",
";",
"}",
"}",
"if",
"(",
"(",
"Subtarget",
"->",
"isLikeA9",
"(",
")",
"||",
"Subtarget",
"->",
"isSwift",
"(",
")",
")",
"&&",
"!",
"N",
".",
"hasOneUse",
"(",
")",
")",
"{",
"Base",
"=",
"N",
";",
"Offset",
"=",
"CurDAG",
"->",
"getRegister",
"(",
"<NUM_LIT>",
",",
"MVT",
"::",
"i32",
")",
";",
"Opc",
"=",
"CurDAG",
"->",
"getTargetConstant",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<NUM_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
",",
"MVT",
"::",
"i32",
")",
";",
"return",
"AM2_BASE",
";",
"}",
"<STR_LIT>",
"::",
"<STR_LIT>",
"AddSub",
"=",
"N",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"SUB",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"<STR_LIT>",
"::",
"<STR_LIT>",
"ShOpcVal",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOpcode",
"(",
")",
")",
";",
"unsigned",
"ShAmt",
"=",
"<NUM_LIT>",
";",
"Base",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"Offset",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"ShOpcVal",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"if",
"(",
"ConstantSDNode",
"*",
"Sh",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"{",
"ShAmt",
"=",
"Sh",
"->",
"getZExtValue",
"(",
")",
";",
"if",
"(",
"isShifterOpProfitable",
"(",
"Offset",
",",
"ShOpcVal",
",",
"ShAmt",
")",
")",
"Offset",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"else",
"{",
"ShAmt",
"=",
"<NUM_LIT>",
";",
"ShOpcVal",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"}",
"}",
"else",
"{",
"ShOpcVal",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"}",
"}",
"if",
"(",
"N",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"SUB",
"&&",
"ShOpcVal",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"!",
"(",
"Subtarget",
"->",
"isLikeA9",
"(",
")",
"||",
"Subtarget",
"->",
"isSwift",
"(",
")",
"||",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"hasOneUse",
"(",
")",
")",
")",
"{",
"ShOpcVal",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"ShOpcVal",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"if",
"(",
"ConstantSDNode",
"*",
"Sh",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"{",
"ShAmt",
"=",
"Sh",
"->",
"getZExtValue",
"(",
")",
";",
"if",
"(",
"isShifterOpProfitable",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"ShOpcVal",
",",
"ShAmt",
")",
")",
"{",
"Offset",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"Base",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"}",
"else",
"{",
"ShAmt",
"=",
"<NUM_LIT>",
";",
"ShOpcVal",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"}",
"}",
"else",
"{",
"ShOpcVal",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"}",
"}",
"}"
] |
GCC | s390 | CPP | stmt_completion | MPU | 4,482 | [
"indx",
")",
"==",
"PIC_OFFSET_TABLE_REGNUM",
")",
")",
"pointer",
"=",
"indx_ptr",
"=",
"true",
";"
] | [
"}",
"else",
"{",
"base",
"=",
"op0",
";",
"disp",
"=",
"op1",
";",
"}",
"}",
"else",
"if",
"(",
"code0",
"==",
"PLUS",
")",
"{",
"indx",
"=",
"XEXP",
"(",
"op0",
",",
"<NUM_LIT>",
")",
";",
"base",
"=",
"XEXP",
"(",
"op0",
",",
"<NUM_LIT>",
")",
";",
"disp",
"=",
"op1",
";",
"}",
"else",
"{",
"return",
"false",
";",
"}",
"}",
"else",
"disp",
"=",
"addr",
";",
"or",
"ig_disp",
"=",
"disp",
";",
"if",
"(",
"disp",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"disp",
")",
"==",
"CONST_INT",
")",
"{",
"offset",
"=",
"INTVAL",
"(",
"disp",
")",
";",
"disp",
"=",
"NULL_RTX",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"disp",
")",
"==",
"CONST",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"disp",
",",
"<NUM_LIT>",
")",
")",
"==",
"PLUS",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"XEXP",
"(",
"disp",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
")",
"==",
"CONST_INT",
")",
"{",
"offset",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"XEXP",
"(",
"disp",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
")",
";",
"disp",
"=",
"XEXP",
"(",
"XEXP",
"(",
"disp",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
";",
"}",
"}",
"if",
"(",
"disp",
"&&",
"GET_CODE",
"(",
"disp",
")",
"==",
"CONST",
")",
"disp",
"=",
"XEXP",
"(",
"disp",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"disp",
"&&",
"GET_CODE",
"(",
"disp",
")",
"==",
"SYMBOL_REF",
"&&",
"CONSTANT_POOL_ADDRESS_P",
"(",
"disp",
")",
")",
"{",
"if",
"(",
"!",
"base",
")",
"base",
"=",
"fake_pool_base",
",",
"literal_pool",
"=",
"true",
";",
"else",
"if",
"(",
"!",
"indx",
")",
"indx",
"=",
"fake_pool_base",
",",
"literal_pool",
"=",
"true",
";",
"else",
"return",
"false",
";",
"disp",
"=",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"<NUM_LIT>",
",",
"disp",
")",
",",
"UNSPEC_LTREL_OFFSET",
")",
";",
"}",
"if",
"(",
"base",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"base",
")",
"==",
"UNSPEC",
")",
"switch",
"(",
"XINT",
"(",
"base",
",",
"<NUM_LIT>",
")",
")",
"{",
"case",
"UNSPEC_LTREF",
":",
"if",
"(",
"!",
"disp",
")",
"disp",
"=",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"<NUM_LIT>",
",",
"XVECEXP",
"(",
"base",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
",",
"UNSPEC_LTREL_OFFSET",
")",
";",
"else",
"return",
"false",
";",
"base",
"=",
"XVECEXP",
"(",
"base",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"break",
";",
"case",
"UNSPEC_LTREL_BASE",
":",
"if",
"(",
"XVECLEN",
"(",
"base",
",",
"<NUM_LIT>",
")",
"==",
"<NUM_LIT>",
")",
"base",
"=",
"fake_pool_base",
",",
"literal_pool",
"=",
"true",
";",
"else",
"base",
"=",
"XVECEXP",
"(",
"base",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"break",
";",
"default",
":",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"REG_P",
"(",
"base",
")",
"||",
"(",
"GET_MODE",
"(",
"base",
")",
"!=",
"SImode",
"&&",
"GET_MODE",
"(",
"base",
")",
"!=",
"Pmode",
")",
")",
"return",
"false",
";",
"if",
"(",
"REGNO",
"(",
"base",
")",
"==",
"STACK_POINTER_REGNUM",
"||",
"REGNO",
"(",
"base",
")",
"==",
"FRAME_POINTER_REGNUM",
"||",
"(",
"(",
"reload_completed",
"||",
"reload_in_progress",
")",
"&&",
"frame_pointer_needed",
"&&",
"REGNO",
"(",
"base",
")",
"==",
"HARD_FRAME_POINTER_REGNUM",
")",
"||",
"REGNO",
"(",
"base",
")",
"==",
"ARG_POINTER_REGNUM",
"||",
"(",
"flag_pic",
"&&",
"REGNO",
"(",
"base",
")",
"==",
"PIC_OFFSET_TABLE_REGNUM",
")",
")",
"pointer",
"=",
"base_ptr",
"=",
"true",
";",
"if",
"(",
"(",
"reload_completed",
"||",
"reload_in_progress",
")",
"&&",
"base",
"==",
"cfun",
"->",
"machine",
"->",
"base_reg",
")",
"pointer",
"=",
"base_ptr",
"=",
"literal_pool",
"=",
"true",
";",
"}",
"if",
"(",
"indx",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"indx",
")",
"==",
"UNSPEC",
")",
"switch",
"(",
"XINT",
"(",
"indx",
",",
"<NUM_LIT>",
")",
")",
"{",
"case",
"UNSPEC_LTREF",
":",
"if",
"(",
"!",
"disp",
")",
"disp",
"=",
"gen_rtx_UNSPEC",
"(",
"Pmode",
",",
"gen_rtvec",
"(",
"<NUM_LIT>",
",",
"XVECEXP",
"(",
"indx",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
",",
"UNSPEC_LTREL_OFFSET",
")",
";",
"else",
"return",
"false",
";",
"indx",
"=",
"XVECEXP",
"(",
"indx",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"break",
";",
"case",
"UNSPEC_LTREL_BASE",
":",
"if",
"(",
"XVECLEN",
"(",
"indx",
",",
"<NUM_LIT>",
")",
"==",
"<NUM_LIT>",
")",
"indx",
"=",
"fake_pool_base",
",",
"literal_pool",
"=",
"true",
";",
"else",
"indx",
"=",
"XVECEXP",
"(",
"indx",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"break",
";",
"default",
":",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"REG_P",
"(",
"indx",
")",
"||",
"(",
"GET_MODE",
"(",
"indx",
")",
"!=",
"SImode",
"&&",
"GET_MODE",
"(",
"indx",
")",
"!=",
"Pmode",
")",
")",
"return",
"false",
";",
"if",
"(",
"REGNO",
"(",
"indx",
")",
"==",
"STACK_POINTER_REGNUM",
"||",
"REGNO",
"(",
"indx",
")",
"==",
"FRAME_POINTER_REGNUM",
"||",
"(",
"(",
"reload_completed",
"||",
"reload_in_progress",
")",
"&&",
"frame_pointer_needed",
"&&",
"REGNO",
"(",
"indx",
")",
"==",
"HARD_FRAME_POINTER_REGNUM",
")",
"||",
"REGNO",
"(",
"indx",
")",
"==",
"ARG_POINTER_REGNUM",
"||",
"(",
"flag_pic",
"&&",
"REGNO",
"("
] |
LLVM | X86 | CPP | next_suggestion | CPU | 4,483 | [
"}"
] | [
"const",
"TargetInstrInfo",
"*",
"TII",
"=",
"Subtarget",
".",
"getInstrInfo",
"(",
")",
";",
"BuildMI",
"(",
"*",
"BB",
",",
"MI",
",",
"dl",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"XOR32rr",
")",
",",
"X86",
"::",
"ECX",
")",
".",
"addReg",
"(",
"X86",
"::",
"ECX",
")",
".",
"addReg",
"(",
"X86",
"::",
"ECX",
")",
";",
"BuildMI",
"(",
"*",
"BB",
",",
"MI",
",",
"dl",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"RDPKRUr",
")",
")",
";",
"BuildMI",
"(",
"*",
"BB",
",",
"MI",
",",
"dl",
",",
"TII",
"->",
"get",
"(",
"TargetOpcode",
"::",
"COPY",
")",
",",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
".",
"addReg",
"(",
"X86",
"::",
"EAX",
")",
";",
"MI",
"->",
"eraseFromParent",
"(",
")",
";",
"return",
"BB",
";"
] |
LLVM | R600 | CPP | stmt_completion | GPU | 4,484 | [
",",
"Ctx",
")",
";"
] | [
"MCCodeEmitter",
"*",
"llvm",
"::",
"createR600MCCodeEmitter",
"(",
"const",
"MCInstrInfo",
"&",
"MCII",
",",
"const",
"MCRegisterInfo",
"&",
"MRI",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"MCContext",
"&",
"Ctx",
")",
"{",
"return",
"new",
"R600MCCodeEmitter",
"(",
"MCII",
",",
"MRI",
",",
"STI"
] |
GCC | aarch64 | CPP | program_repair | CPU | 4,485 | [
"<FIXS>",
"allocate_gpr_slot",
"(",
"R29_REGNUM",
")",
";",
"allocate_gpr_slot",
"(",
"R30_REGNUM",
")",
";",
"<FIXE>",
"<FIXS>",
"allocate_gpr_slot",
"(",
"regno",
")",
";",
"<FIXE>"
] | [
"bool",
"saves_below_hard_fp_p",
"=",
"maybe_ne",
"(",
"frame",
".",
"below_hard_fp_saved_regs_size",
",",
"<NUM_LIT>",
")",
";",
"frame",
".",
"bytes_below_hard_fp",
"=",
"offset",
";",
"if",
"(",
"frame",
".",
"emit_frame_chain",
")",
"{",
"<BUGS>",
"frame",
".",
"reg_offset",
"[",
"R29_REGNUM",
"]",
"=",
"offset",
";",
"frame",
".",
"wb_push_candidate1",
"=",
"R29_REGNUM",
";",
"frame",
".",
"reg_offset",
"[",
"R30_REGNUM",
"]",
"=",
"offset",
"+",
"UNITS_PER_WORD",
";",
"frame",
".",
"wb_push_candidate2",
"=",
"R30_REGNUM",
";",
"offset",
"+=",
"<NUM_LIT>",
"*",
"UNITS_PER_WORD",
";",
"<BUGE>",
"}",
"for",
"(",
"regno",
"=",
"R0_REGNUM",
";",
"regno",
"<=",
"R30_REGNUM",
";",
"regno",
"++",
")",
"if",
"(",
"known_eq",
"(",
"frame",
".",
"reg_offset",
"[",
"regno",
"]",
",",
"SLOT_REQUIRED",
")",
")",
"<BUGS>",
"{",
"frame",
".",
"reg_offset",
"[",
"regno",
"]",
"=",
"offset",
";",
"if",
"(",
"frame",
".",
"wb_push_candidate1",
"==",
"INVALID_REGNUM",
")",
"frame",
".",
"wb_push_candidate1",
"=",
"regno",
";",
"else",
"if",
"(",
"frame",
".",
"wb_push_candidate2",
"==",
"INVALID_REGNUM",
")",
"frame",
".",
"wb_push_candidate2",
"=",
"regno",
";",
"offset",
"+=",
"UNITS_PER_WORD",
";",
"}",
"<BUGE>",
"poly_int64",
"max_int_offset",
"=",
"offset",
";",
"offset",
"=",
"aligned_upper_bound",
"(",
"offset",
",",
"STACK_BOUNDARY",
"/",
"BITS_PER_UNIT",
")",
";"
] |
GCC | rl78 | CPP | stmt_completion | MPU | 4,486 | [
")",
";"
] | [
"MUST_BE_OK",
"(",
"insn"
] |
LLVM | ARM | TD | program_repair | CPU | 4,487 | [
"<FIXS>",
"def",
"BXr9",
":",
"ABXIx2",
"(",
"outs",
")",
",",
"(",
"ins",
"GPR",
":",
"$",
"func",
",",
"variable_ops",
")",
",",
"<STR_LIT>",
",",
"[",
"(",
"ARMcall_nolink",
"GPR",
":",
"$",
"func",
")",
"]",
">",
",",
"Requires",
"[",
"IsARM",
",",
"IsDarwin",
"]",
">",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"<FIXE>"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"}",
"<BUGS>",
"let",
"Uses",
"=",
"[",
"LR",
"]",
"in",
"{",
"def",
"BXr9",
":",
"ABXIx2",
"(",
"outs",
")",
",",
"(",
"ins",
"GPR",
":",
"$",
"func",
",",
"variable_ops",
")",
",",
"<STR_LIT>",
",",
"[",
"(",
"ARMcall_nolink",
"GPR",
":",
"$",
"func",
")",
"]",
">",
",",
"Requires",
"[",
"IsDarwin",
"]",
">",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"}",
"<BUGE>",
"}",
"}"
] |
LLVM | Mips | CPP | program_repair | CPU | 4,488 | [
"<FIXS>",
"SDValue",
"One",
"=",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"VecTy",
")",
";",
"<FIXE>"
] | [
"case",
"Intrinsic",
"::",
"mips_bneg_w",
":",
"case",
"Intrinsic",
"::",
"mips_bneg_d",
":",
"{",
"EVT",
"VecTy",
"=",
"Op",
"->",
"getValueType",
"(",
"<NUM_LIT>",
")",
";",
"<BUGS>",
"SDValue",
"One",
"=",
"lowerMSASplatImm",
"(",
"DL",
",",
"VecTy",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"MVT",
"::",
"i32",
")",
",",
"DAG",
")",
";",
"<BUGE>",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"XOR",
",",
"DL",
",",
"VecTy",
",",
"Op",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SHL",
",",
"DL",
",",
"VecTy",
",",
"One",
","
] |
LLVM | ARM | CPP | next_suggestion | CPU | 4,489 | [
"}"
] | [
"if",
"(",
"isWhileLoopStart",
"(",
"Terminator",
")",
")",
"return",
"&",
"Terminator",
";",
"}",
"return",
"nullptr",
";"
] |
GCC | rs6000 | MD | next_suggestion | CPU | 4,490 | [
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
] | [
"UNSPEC_XXSPLTI32DX",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | microblaze | MD | next_suggestion | MPU | 4,491 | [
"<STR_LIT>"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]"
] |
LLVM | ARM | TD | next_suggestion | CPU | 4,492 | [
"let",
"RenderMethod",
"=",
"<STR_LIT>",
";"
] | [
"let",
"Name",
"=",
"<STR_LIT>",
";",
"let",
"ParserMethod",
"=",
"<STR_LIT>",
";"
] |
LLVM | ARM | TD | stmt_completion | CPU | 4,493 | [
"<STR_LIT>",
";"
] | [
"let",
"ParserMethod",
"=",
"<STR_LIT>",
";",
"let",
"RenderMethod",
"="
] |
GCC | rs6000 | MD | next_suggestion | CPU | 4,494 | [
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | xtensa | MD | stmt_completion | MPU | 4,495 | [
"<STR_LIT>",
")"
] | [
"<STR_LIT>",
"(",
"and",
"(",
"match_code"
] |
GCC | visium | MD | stmt_completion | Virtual ISA | 4,496 | [
"<STR_LIT>",
")",
")",
")",
"]"
] | [
"[",
"(",
"set",
"(",
"match_operand",
":",
"I",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"lshiftrt",
":",
"I",
"(",
"match_operand",
":",
"I",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>"
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 4,497 | [
"}"
] | [
"auto",
"MOVolatileLoad",
"=",
"MachineMemOperand",
"::",
"MOLoad",
"|",
"MachineMemOperand",
"::",
"MOVolatile",
";",
"return",
"MF",
".",
"getMachineMemOperand",
"(",
"PointerInfo",
",",
"MOVolatileLoad",
",",
"<NUM_LIT>",
",",
"Align",
"(",
"<NUM_LIT>",
")",
")",
";"
] |
LLVM | Hexagon | CPP | next_suggestion | DSP | 4,498 | [
"}"
] | [
"if",
"(",
"Lane",
"==",
"-",
"<NUM_LIT>",
")",
"Lane",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"Lane",
"==",
"<NUM_LIT>",
"&&",
"V1",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SCALAR_TO_VECTOR",
")",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VT",
",",
"V1",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"Lane",
"==",
"<NUM_LIT>",
"&&",
"V1",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"BUILD_VECTOR",
"&&",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"V1",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"{",
"bool",
"IsScalarToVector",
"=",
"true",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"V1",
".",
"getNumOperands",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"!",
"V1",
".",
"getOperand",
"(",
"i",
")",
".",
"isUndef",
"(",
")",
")",
"{",
"IsScalarToVector",
"=",
"false",
";",
"break",
";",
"}",
"}",
"if",
"(",
"IsScalarToVector",
")",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VT",
",",
"V1",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"}",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VT",
",",
"DAG",
".",
"getConstant",
"(",
"Lane",
",",
"dl",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"}",
"if",
"(",
"UseHVX",
")",
"{",
"ArrayRef",
"<",
"int",
">",
"Mask",
"=",
"SVN",
"->",
"getMask",
"(",
")",
";",
"size_t",
"MaskLen",
"=",
"Mask",
".",
"size",
"(",
")",
";",
"unsigned",
"SizeInBits",
"=",
"VT",
".",
"getScalarSizeInBits",
"(",
")",
"*",
"MaskLen",
";",
"if",
"(",
"(",
"Subtarget",
".",
"useHVXSglOps",
"(",
")",
"&&",
"SizeInBits",
"==",
"<NUM_LIT>",
"*",
"<NUM_LIT>",
")",
"||",
"(",
"Subtarget",
".",
"useHVXDblOps",
"(",
")",
"&&",
"SizeInBits",
"==",
"<NUM_LIT>",
"*",
"<NUM_LIT>",
")",
")",
"{",
"StridedLoadKind",
"Pattern",
"=",
"isStridedLoad",
"(",
"Mask",
")",
";",
"if",
"(",
"Pattern",
"==",
"StridedLoadKind",
"::",
"NoPattern",
")",
"return",
"SDValue",
"(",
")",
";",
"unsigned",
"Opc",
"=",
"Pattern",
"==",
"StridedLoadKind",
"::",
"Even",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"return",
"DAG",
".",
"getNode",
"(",
"Opc",
",",
"dl",
",",
"VT",
",",
"{",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
"}",
")",
";",
"}"
] |
LLVM | WebAssembly | TD | program_repair | Virtual ISA | 4,499 | [
"<FIXS>",
"def",
"ADJCALLSTACKUP",
":",
"I",
"(",
"outs",
")",
",",
"(",
"ins",
"i32imm",
":",
"$",
"amt",
",",
"i32imm",
":",
"$",
"amt2",
")",
",",
"[",
"(",
"WebAssemblycallseq_end",
"timm",
":",
"$",
"amt",
",",
"timm",
":",
"$",
"amt2",
")",
"]",
">",
";",
"<FIXE>"
] | [
"let",
"Uses",
"=",
"[",
"SP32",
",",
"SP64",
"]",
",",
"Defs",
"=",
"[",
"SP32",
",",
"SP64",
"]",
",",
"isCodeGenOnly",
"=",
"<NUM_LIT>",
"in",
"{",
"def",
"ADJCALLSTACKDOWN",
":",
"I",
"(",
"outs",
")",
",",
"(",
"ins",
"i32imm",
":",
"$",
"amt",
")",
",",
"[",
"(",
"WebAssemblycallseq_start",
"timm",
":",
"$",
"amt",
")",
"]",
">",
";",
"<BUGS>",
"def",
"ADJCALLSTACKUP",
":",
"I",
"(",
"outs",
")",
",",
"(",
"ins",
"i32imm",
":",
"$",
"amt",
")",
",",
"[",
"(",
"WebAssemblycallseq_end",
"timm",
":",
"$",
"amt",
",",
"undef",
")",
"]",
">",
";",
"<BUGE>",
"}",
"multiclass",
"CALL",
"WebAssemblyRegClass",
"vt",
",",
"string",
"prefix",
">",
"{"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.