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 | TGSI | CPP | stmt_completion | Virtual ISA | 622,500 | [
"CPU",
",",
"FS",
")",
";"
]
| [
"static",
"MCSubtargetInfo",
"*",
"createTGSIMCSubtargetInfo",
"(",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
")",
"{",
"return",
"createTGSIMCSubtargetInfoImpl",
"(",
"TT",
","
]
|
GCC | i386 | CPP | program_repair | CPU | 622,501 | [
"<FIXS>",
"t",
"=",
"make_tree",
"(",
"type",
",",
"crtl",
"->",
"args",
".",
"internal_arg_pointer",
")",
";",
"<FIXE>"
]
| [
"type",
"=",
"TREE_TYPE",
"(",
"ovf",
")",
";",
"<BUGS>",
"t",
"=",
"make_tree",
"(",
"type",
",",
"virtual_incoming_args_rtx",
")",
";",
"<BUGE>",
"if",
"(",
"words",
"!=",
"<NUM_LIT>",
")",
"t",
"=",
"build2",
"(",
"POINTER_PLUS_EXPR",
",",
"type",
",",
"t",
",",
"size_int",
"(",
"words",
"*",
"UNITS_PER_WORD",
")",
")",
";"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 622,502 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
| [
"def",
"F2_sffixupd",
":",
"HInst",
"<",
"(",
"outs",
"IntRegs",
":",
"$",
"Rd32",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rs32",
",",
"IntRegs",
":",
"$",
"Rt32",
")",
",",
"<STR_LIT>",
",",
"tc_3b470976",
",",
"TypeM",
">",
",",
"Enc_5ab2be",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
|
GCC | csky | MD | next_suggestion | CPU | 622,503 | [
"return",
"<NUM_LIT>"
]
| [
"if",
"(",
"CONST_INT_P",
"(",
"op",
")",
"&",
"&",
"(",
"CSKY_CONST_OK_FOR_K",
"(",
"INTVAL",
"(",
"op",
")",
")",
"|",
"|",
"CSKY_CONST_OK_FOR_Uh",
"(",
"INTVAL",
"(",
"op",
")",
")",
")",
")",
"return",
"<NUM_LIT>"
]
|
GCC | i386 | MD | stmt_completion | CPU | 622,504 | [
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"reg",
":",
"CC",
"<NUM_LIT>",
")",
"(",
"unspec",
":",
"CC",
"[",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"<NUM_LIT>",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"plus",
":",
"QI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr"
]
|
GCC | mips | CPP | next_suggestion | CPU | 622,505 | [
"case",
"GT",
":"
]
| [
"case",
"ROTATERT",
":",
"return",
"ISA_HAS_ROR",
";",
"case",
"AND",
":",
"case",
"IOR",
":",
"case",
"XOR",
":",
"return",
"SMALL_OPERAND_UNSIGNED",
"(",
"x",
")",
";",
"case",
"PLUS",
":",
"case",
"LT",
":",
"case",
"LTU",
":",
"return",
"SMALL_OPERAND",
"(",
"x",
")",
";",
"case",
"EQ",
":",
"case",
"NE",
":"
]
|
LLVM | X86 | CPP | stmt_completion | CPU | 622,506 | [
"(",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
"&&",
"isUndefOrEqual",
"(",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
";"
]
| [
"return",
"isUndefOrEqual",
"(",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
"&&",
"isUndefOrEqual",
"(",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
"&&",
"isUndefOrEqual"
]
|
LLVM | AMDGPU | CPP | next_suggestion | GPU | 622,507 | [
"if",
"(",
"MCOpcode",
"==",
"-",
"<NUM_LIT>",
")",
"{"
]
| [
"lowerOperand",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Dest",
")",
";",
"lowerOperand",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Src",
")",
";",
"OutMI",
".",
"addOperand",
"(",
"Dest",
")",
";",
"OutMI",
".",
"addOperand",
"(",
"Src",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"Opcode",
"==",
"AMDGPU",
"::",
"SI_TCRETURN",
")",
"{",
"Opcode",
"=",
"AMDGPU",
"::",
"S_SETPC_B64",
";",
"}",
"int",
"MCOpcode",
"=",
"TII",
"->",
"pseudoToMCOpcode",
"(",
"Opcode",
")",
";"
]
|
LLVM | ARM | TD | stmt_completion | CPU | 622,508 | [
"Imm",
"<",
"<NUM_LIT>",
";"
]
| [
"if",
"(",
"Subtarget",
"-",
">",
"useMovt",
"(",
"*",
"MF",
")",
")",
"return",
"true",
";",
"return",
"ARM_AM",
":",
":",
"isSOImmTwoPartVal",
"(",
"(",
"unsigned",
")",
"N",
"-",
">",
"getZExtValue",
"(",
")",
")",
";",
"}",
"]",
">",
";",
"def",
"Imm0_1AsmOperand",
":",
"ImmAsmOperand",
"{",
"let",
"Name",
"=",
"<STR_LIT>",
";",
"}",
"def",
"imm0_1",
":",
"Operand",
"<",
"i32",
">",
"{",
"let",
"ParserMatchClass",
"=",
"Imm0_1AsmOperand",
";",
"}",
"def",
"Imm0_3AsmOperand",
":",
"ImmAsmOperand",
"{",
"let",
"Name",
"=",
"<STR_LIT>",
";",
"}",
"def",
"imm0_3",
":",
"Operand",
"<",
"i32",
">",
"{",
"let",
"ParserMatchClass",
"=",
"Imm0_3AsmOperand",
";",
"}",
"def",
"Imm0_7AsmOperand",
":",
"ImmAsmOperand",
"{",
"let",
"Name",
"=",
"<STR_LIT>",
";",
"}",
"def",
"imm0_7",
":",
"Operand",
"<",
"i32",
">",
",",
"ImmLeaf",
"<",
"i32",
",",
"[",
"{",
"return",
"Imm",
">",
"=",
"<NUM_LIT>",
"&",
"&"
]
|
LLVM | X86 | CPP | stmt_completion | CPU | 622,509 | [
"getNode",
"(",
")",
"->",
"getNodeId",
"(",
")",
")",
"{"
]
| [
"if",
"(",
"!",
"MatchAddress",
"(",
"N",
".",
"getNode",
"(",
")",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"AM",
",",
"false",
",",
"Depth",
"+",
"<NUM_LIT>",
")",
"&&",
"!",
"MatchAddress",
"(",
"N",
".",
"getNode",
"(",
")",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"AM",
",",
"false",
",",
"Depth",
"+",
"<NUM_LIT>",
")",
")",
"return",
"false",
";",
"AM",
"=",
"Backup",
";",
"if",
"(",
"!",
"MatchAddress",
"(",
"N",
".",
"getNode",
"(",
")",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"AM",
",",
"false",
",",
"Depth",
"+",
"<NUM_LIT>",
")",
"&&",
"!",
"MatchAddress",
"(",
"N",
".",
"getNode",
"(",
")",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"AM",
",",
"false",
",",
"Depth",
"+",
"<NUM_LIT>",
")",
")",
"return",
"false",
";",
"AM",
"=",
"Backup",
";",
"if",
"(",
"AM",
".",
"BaseType",
"==",
"X86ISelAddressMode",
"::",
"RegBase",
"&&",
"!",
"AM",
".",
"Base",
".",
"Reg",
".",
"getNode",
"(",
")",
"&&",
"!",
"AM",
".",
"IndexReg",
".",
"getNode",
"(",
")",
"&&",
"!",
"AM",
".",
"isRIPRel",
")",
"{",
"AM",
".",
"Base",
".",
"Reg",
"=",
"N",
".",
"getNode",
"(",
")",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"AM",
".",
"IndexReg",
"=",
"N",
".",
"getNode",
"(",
")",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"AM",
".",
"Scale",
"=",
"<NUM_LIT>",
";",
"return",
"false",
";",
"}",
"break",
";",
"}",
"case",
"ISD",
"::",
"OR",
":",
"if",
"(",
"ConstantSDNode",
"*",
"CN",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"{",
"X86ISelAddressMode",
"Backup",
"=",
"AM",
";",
"uint64_t",
"Offset",
"=",
"CN",
"->",
"getSExtValue",
"(",
")",
";",
"if",
"(",
"!",
"MatchAddress",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"AM",
",",
"false",
")",
"&&",
"AM",
".",
"GV",
"==",
"NULL",
"&&",
"(",
"!",
"is64Bit",
"||",
"isInt32",
"(",
"AM",
".",
"Disp",
"+",
"Offset",
")",
")",
"&&",
"CurDAG",
"->",
"MaskedValueIsZero",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"CN",
"->",
"getAPIntValue",
"(",
")",
")",
")",
"{",
"AM",
".",
"Disp",
"+=",
"Offset",
";",
"return",
"false",
";",
"}",
"AM",
"=",
"Backup",
";",
"}",
"break",
";",
"case",
"ISD",
"::",
"AND",
":",
"{",
"SDValue",
"Shift",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"Shift",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"SHL",
")",
"break",
";",
"if",
"(",
"AM",
".",
"IndexReg",
".",
"getNode",
"(",
")",
"!=",
"<NUM_LIT>",
"||",
"AM",
".",
"Scale",
"!=",
"<NUM_LIT>",
")",
"break",
";",
"if",
"(",
"AM",
".",
"isRIPRel",
")",
"break",
";",
"ConstantSDNode",
"*",
"C2",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"ConstantSDNode",
"*",
"C1",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Shift",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"!",
"C1",
"||",
"!",
"C2",
")",
"break",
";",
"if",
"(",
"!",
"N",
".",
"hasOneUse",
"(",
")",
"||",
"!",
"Shift",
".",
"hasOneUse",
"(",
")",
")",
"break",
";",
"unsigned",
"ShiftCst",
"=",
"C1",
"->",
"getZExtValue",
"(",
")",
";",
"if",
"(",
"ShiftCst",
"!=",
"<NUM_LIT>",
"&&",
"ShiftCst",
"!=",
"<NUM_LIT>",
"&&",
"ShiftCst",
"!=",
"<NUM_LIT>",
")",
"break",
";",
"SDValue",
"X",
"=",
"Shift",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"NewANDMask",
"=",
"CurDAG",
"->",
"getNode",
"(",
"ISD",
"::",
"SRL",
",",
"dl",
",",
"N",
".",
"getValueType",
"(",
")",
",",
"SDValue",
"(",
"C2",
",",
"<NUM_LIT>",
")",
",",
"SDValue",
"(",
"C1",
",",
"<NUM_LIT>",
")",
")",
";",
"SDValue",
"NewAND",
"=",
"CurDAG",
"->",
"getNode",
"(",
"ISD",
"::",
"AND",
",",
"dl",
",",
"N",
".",
"getValueType",
"(",
")",
",",
"X",
",",
"NewANDMask",
")",
";",
"SDValue",
"NewSHIFT",
"=",
"CurDAG",
"->",
"getNode",
"(",
"ISD",
"::",
"SHL",
",",
"dl",
",",
"N",
".",
"getValueType",
"(",
")",
",",
"NewAND",
",",
"SDValue",
"(",
"C1",
",",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"C1",
"->",
"getNodeId",
"(",
")",
">",
"X",
".",
"getNode",
"(",
")",
"->",
"getNodeId",
"(",
")",
")",
"{",
"CurDAG",
"->",
"RepositionNode",
"(",
"X",
".",
"getNode",
"(",
")",
",",
"C1",
")",
";",
"C1",
"->",
"setNodeId",
"(",
"X",
".",
"getNode",
"(",
")",
"->",
"getNodeId",
"(",
")",
")",
";",
"}",
"if",
"(",
"NewANDMask",
".",
"getNode",
"(",
")",
"->",
"getNodeId",
"(",
")",
"==",
"-",
"<NUM_LIT>",
"||",
"NewANDMask",
".",
"getNode",
"(",
")",
"->",
"getNodeId",
"(",
")",
">",
"X",
"."
]
|
GCC | arm | MD | next_suggestion | CPU | 622,510 | [
")"
]
| [
"(",
"define_reservation",
"<STR_LIT>",
"<STR_LIT>"
]
|
LLVM | Hexagon | TD | stmt_completion | DSP | 622,511 | [
"<NUM_LIT>",
";"
]
| [
"def",
"A2_svsubhs",
":",
"HInst",
"<",
"(",
"outs",
"IntRegs",
":",
"$",
"Rd32",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rt32",
",",
"IntRegs",
":",
"$",
"Rs32",
")",
",",
"<STR_LIT>",
",",
"tc_61830035",
",",
"TypeALU32_3op",
">",
",",
"Enc_bd6011",
"{",
"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",
"="
]
|
LLVM | X86 | CPP | code_generation | CPU | 622,512 | [
"SDValue",
"X86SelectionDAGInfo",
"::",
"EmitTargetCodeForMemcpy",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"DebugLoc",
"dl",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Dst",
",",
"SDValue",
"Src",
",",
"SDValue",
"Size",
",",
"unsigned",
"Align",
",",
"bool",
"isVolatile",
",",
"bool",
"AlwaysInline",
",",
"MachinePointerInfo",
"DstPtrInfo",
",",
"MachinePointerInfo",
"SrcPtrInfo",
")",
"const",
"{",
"ConstantSDNode",
"*",
"ConstantSize",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Size",
")",
";",
"if",
"(",
"!",
"ConstantSize",
")",
"return",
"SDValue",
"(",
")",
";",
"uint64_t",
"SizeVal",
"=",
"ConstantSize",
"->",
"getZExtValue",
"(",
")",
";",
"if",
"(",
"!",
"AlwaysInline",
"&&",
"SizeVal",
">",
"Subtarget",
"->",
"getMaxInlineSizeThreshold",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"!",
"AlwaysInline",
"&&",
"(",
"Align",
"&",
"<NUM_LIT>",
")",
"!=",
"<NUM_LIT>",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"DstPtrInfo",
".",
"getAddrSpace",
"(",
")",
">=",
"<NUM_LIT>",
"||",
"SrcPtrInfo",
".",
"getAddrSpace",
"(",
")",
">=",
"<NUM_LIT>",
")",
"return",
"SDValue",
"(",
")",
";",
"const",
"X86RegisterInfo",
"*",
"TRI",
"=",
"static_cast",
"<",
"const",
"X86RegisterInfo",
"*",
">",
"(",
"DAG",
".",
"getTarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
")",
";",
"if",
"(",
"TRI",
"->",
"hasBasePointer",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
")",
"&&",
"TRI",
"->",
"getBaseRegister",
"(",
")",
"==",
"X86",
"::",
"ESI",
")",
"return",
"SDValue",
"(",
")",
";",
"MVT",
"AVT",
";",
"if",
"(",
"Align",
"&",
"<NUM_LIT>",
")",
"AVT",
"=",
"MVT",
"::",
"i8",
";",
"else",
"if",
"(",
"Align",
"&",
"<NUM_LIT>",
")",
"AVT",
"=",
"MVT",
"::",
"i16",
";",
"else",
"if",
"(",
"Align",
"&",
"<NUM_LIT>",
")",
"AVT",
"=",
"MVT",
"::",
"i32",
";",
"else",
"AVT",
"=",
"Subtarget",
"->",
"is64Bit",
"(",
")",
"?",
"MVT",
"::",
"i64",
":",
"MVT",
"::",
"i32",
";",
"unsigned",
"UBytes",
"=",
"AVT",
".",
"getSizeInBits",
"(",
")",
"/",
"<NUM_LIT>",
";",
"unsigned",
"CountVal",
"=",
"SizeVal",
"/",
"UBytes",
";",
"SDValue",
"Count",
"=",
"DAG",
".",
"getIntPtrConstant",
"(",
"CountVal",
")",
";",
"unsigned",
"BytesLeft",
"=",
"SizeVal",
"%",
"UBytes",
";",
"SDValue",
"InFlag",
"(",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"Subtarget",
"->",
"is64Bit",
"(",
")",
"?",
"X86",
"::",
"RCX",
":",
"X86",
"::",
"ECX",
",",
"Count",
",",
"InFlag",
")",
";",
"InFlag",
"=",
"Chain",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"Subtarget",
"->",
"is64Bit",
"(",
")",
"?",
"X86",
"::",
"RDI",
":",
"X86",
"::",
"EDI",
",",
"Dst",
",",
"InFlag",
")",
";",
"InFlag",
"=",
"Chain",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"Subtarget",
"->",
"is64Bit",
"(",
")",
"?",
"X86",
"::",
"RSI",
":",
"X86",
"::",
"ESI",
",",
"Src",
",",
"InFlag",
")",
";",
"InFlag",
"=",
"Chain",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
";",
"SDVTList",
"Tys",
"=",
"DAG",
".",
"getVTList",
"(",
"MVT",
"::",
"Other",
",",
"MVT",
"::",
"Glue",
")",
";",
"SDValue",
"Ops",
"[",
"]",
"=",
"{",
"Chain",
",",
"DAG",
".",
"getValueType",
"(",
"AVT",
")",
",",
"InFlag",
"}",
";",
"SDValue",
"RepMovs",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"Tys",
",",
"Ops",
",",
"array_lengthof",
"(",
"Ops",
")",
")",
";",
"SmallVector",
"<",
"SDValue",
",",
"<NUM_LIT>",
">",
"Results",
";",
"Results",
".",
"push_back",
"(",
"RepMovs",
")",
";",
"if",
"(",
"BytesLeft",
")",
"{",
"unsigned",
"Offset",
"=",
"SizeVal",
"-",
"BytesLeft",
";",
"EVT",
"DstVT",
"=",
"Dst",
".",
"getValueType",
"(",
")",
";",
"EVT",
"SrcVT",
"=",
"Src",
".",
"getValueType",
"(",
")",
";",
"EVT",
"SizeVT",
"=",
"Size",
".",
"getValueType",
"(",
")",
";",
"Results",
".",
"push_back",
"(",
"DAG",
".",
"getMemcpy",
"(",
"Chain",
",",
"dl",
",",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"dl",
",",
"DstVT",
",",
"Dst",
",",
"DAG",
".",
"getConstant",
"(",
"Offset",
",",
"DstVT",
")",
")",
",",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"dl",
",",
"SrcVT",
",",
"Src",
",",
"DAG",
".",
"getConstant",
"(",
"Offset",
",",
"SrcVT",
")",
")",
",",
"DAG",
".",
"getConstant",
"(",
"BytesLeft",
",",
"SizeVT",
")",
",",
"Align",
",",
"isVolatile",
",",
"AlwaysInline",
",",
"DstPtrInfo",
".",
"getWithOffset",
"(",
"Offset",
")",
",",
"SrcPtrInfo",
".",
"getWithOffset",
"(",
"Offset",
")",
")",
")",
";",
"}",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TokenFactor",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"&",
"Results",
"[",
"<NUM_LIT>",
"]",
",",
"Results",
".",
"size",
"(",
")",
")",
";",
"}"
]
| [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memcpy",
"."
]
|
LLVM | SystemZ | CPP | stmt_completion | CPU | 622,513 | [
";"
]
| [
"static",
"bool",
"isImmZExt12",
"(",
"int64_t",
"Val",
",",
"int64_t",
"&",
"Imm",
")",
"{",
"if",
"(",
"Val",
">=",
"<NUM_LIT>",
"&&",
"Val",
"<=",
"<NUM_LIT>",
")",
"{",
"Imm",
"=",
"Val",
";",
"return",
"true"
]
|
LLVM | Mips | CPP | next_suggestion | CPU | 622,514 | [
"else",
"if",
"(",
"fitsRegularPattern",
"<",
"int",
">",
"(",
"Begin",
"+",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"End",
",",
"Indices",
".",
"size",
"(",
")",
"+",
"HalfSize",
",",
"<NUM_LIT>",
")",
")",
"Ws",
"=",
"Op",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";"
]
| [
"SDValue",
"Ws",
";",
"const",
"auto",
"&",
"Begin",
"=",
"Indices",
".",
"begin",
"(",
")",
";",
"const",
"auto",
"&",
"End",
"=",
"Indices",
".",
"end",
"(",
")",
";",
"if",
"(",
"fitsRegularPattern",
"<",
"int",
">",
"(",
"Begin",
",",
"<NUM_LIT>",
",",
"End",
",",
"HalfSize",
",",
"<NUM_LIT>",
")",
")",
"Wt",
"=",
"Op",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"else",
"if",
"(",
"fitsRegularPattern",
"<",
"int",
">",
"(",
"Begin",
",",
"<NUM_LIT>",
",",
"End",
",",
"Indices",
".",
"size",
"(",
")",
"+",
"HalfSize",
",",
"<NUM_LIT>",
")",
")",
"Wt",
"=",
"Op",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"else",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"fitsRegularPattern",
"<",
"int",
">",
"(",
"Begin",
"+",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"End",
",",
"HalfSize",
",",
"<NUM_LIT>",
")",
")",
"Ws",
"=",
"Op",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";"
]
|
LLVM | AArch64 | CPP | next_suggestion | CPU | 622,515 | [
"if",
"(",
"ST",
".",
"hasFuseCCSelect",
"(",
")",
"&&",
"isCCSelectPair",
"(",
"FirstMI",
",",
"SecondMI",
")",
")",
"return",
"true",
";"
]
| [
"bool",
"CmpOnly",
"=",
"!",
"ST",
".",
"hasArithmeticBccFusion",
"(",
")",
";",
"if",
"(",
"isArithmeticBccPair",
"(",
"FirstMI",
",",
"SecondMI",
",",
"CmpOnly",
")",
")",
"return",
"true",
";",
"}",
"if",
"(",
"ST",
".",
"hasArithmeticCbzFusion",
"(",
")",
"&&",
"isArithmeticCbzPair",
"(",
"FirstMI",
",",
"SecondMI",
")",
")",
"return",
"true",
";",
"if",
"(",
"ST",
".",
"hasFuseAES",
"(",
")",
"&&",
"isAESPair",
"(",
"FirstMI",
",",
"SecondMI",
")",
")",
"return",
"true",
";",
"if",
"(",
"ST",
".",
"hasFuseCryptoEOR",
"(",
")",
"&&",
"isCryptoEORPair",
"(",
"FirstMI",
",",
"SecondMI",
")",
")",
"return",
"true",
";",
"if",
"(",
"ST",
".",
"hasFuseLiterals",
"(",
")",
"&&",
"isLiteralsPair",
"(",
"FirstMI",
",",
"SecondMI",
")",
")",
"return",
"true",
";",
"if",
"(",
"ST",
".",
"hasFuseAddress",
"(",
")",
"&&",
"isAddressLdStPair",
"(",
"FirstMI",
",",
"SecondMI",
")",
")",
"return",
"true",
";"
]
|
GCC | frv | MD | stmt_completion | VLIW | 622,516 | [
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"unspec",
":",
"SI",
"[",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>"
]
|
LLVM | Hexagon | TD | program_repair | DSP | 622,517 | [
"<FIXS>",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
",",
"accessSize",
"=",
"ByteAccess",
"in",
"<FIXE>",
"<FIXS>",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
",",
"accessSize",
"=",
"HalfWordAccess",
"in",
"<FIXE>",
"<FIXS>",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
",",
"accessSize",
"=",
"WordAccess",
"in",
"<FIXE>"
]
| [
"let",
"isExtendable",
"=",
"<NUM_LIT>",
",",
"opExtendable",
"=",
"<NUM_LIT>",
",",
"isExtentSigned",
"=",
"<NUM_LIT>",
",",
"validSubTargets",
"=",
"HasV4SubT",
"in",
"{",
"<BUGS>",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
",",
"accessSize",
"=",
"ByteAccess",
",",
"isCodeGenOnly",
"=",
"<NUM_LIT>",
"in",
"<BUGE>",
"defm",
"memopb_io",
":",
"MemOp_base",
"<STR_LIT>",
",",
"<NUM_LIT>",
",",
"u6_0Ext",
">",
";",
"<BUGS>",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
",",
"accessSize",
"=",
"HalfWordAccess",
",",
"isCodeGenOnly",
"=",
"<NUM_LIT>",
"in",
"<BUGE>",
"defm",
"memoph_io",
":",
"MemOp_base",
"<STR_LIT>",
",",
"<NUM_LIT>",
",",
"u6_1Ext",
">",
";",
"<BUGS>",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
",",
"accessSize",
"=",
"WordAccess",
",",
"isCodeGenOnly",
"=",
"<NUM_LIT>",
"in",
"<BUGE>",
"defm",
"memopw_io",
":",
"MemOp_base",
"<STR_LIT>",
",",
"<NUM_LIT>",
",",
"u6_2Ext",
">",
";",
"}"
]
|
LLVM | Hexagon | TD | stmt_completion | DSP | 622,518 | [
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"Defs",
"=",
"[",
"PC",
",",
"R31",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isPredicable",
"=",
"<NUM_LIT>",
";",
"let",
"hasSideEffects",
"=",
"<NUM_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentAlign"
]
|
GCC | avr | CPP | next_suggestion | MPU | 622,519 | [
"TYPE_FBIT",
"(",
"*",
"node",
")",
"=",
"GET_MODE_FBIT",
"(",
"mode",
")",
";"
]
| [
"static",
"void",
"avr_adjust_type_node",
"(",
"tree",
"*",
"node",
",",
"machine_mode",
"mode",
",",
"int",
"sat_p",
")",
"{",
"*",
"node",
"=",
"make_node",
"(",
"FIXED_POINT_TYPE",
")",
";",
"TYPE_SATURATING",
"(",
"*",
"node",
")",
"=",
"sat_p",
";",
"TYPE_UNSIGNED",
"(",
"*",
"node",
")",
"=",
"UNSIGNED_FIXED_POINT_MODE_P",
"(",
"mode",
")",
";",
"TYPE_IBIT",
"(",
"*",
"node",
")",
"=",
"GET_MODE_IBIT",
"(",
"mode",
")",
";"
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 622,520 | [
")",
";"
]
| [
"for",
"(",
"int",
"I",
"=",
"NumDefs",
",",
"NumOps",
"=",
"MI",
".",
"getNumOperands",
"(",
")",
";",
"I",
"!=",
"NumOps",
";",
"++",
"I",
")",
"{",
"if",
"(",
"!",
"MI",
".",
"getOperand",
"(",
"I",
")",
".",
"isReg",
"(",
")",
")",
"continue",
";",
"if",
"(",
"I",
"==",
"RsrcIdx",
"||",
"I",
"==",
"RsrcIdx",
"+",
"<NUM_LIT>",
")",
"SGPRIndexes",
".",
"push_back",
"(",
"I",
")",
";",
"}",
"executeInWaterfallLoop",
"(",
"MI",
",",
"MRI",
",",
"SGPRIndexes"
]
|
GCC | gcn | MD | next_suggestion | GPU | 622,521 | [
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
]
| [
"[",
"(",
"unspec_volatile",
"[",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPECV_PROLOGUE_USE",
")",
"]",
"<STR_LIT>",
"<STR_LIT>"
]
|
GCC | mips | MD | stmt_completion | CPU | 622,522 | [
"<STR_LIT>",
")"
]
| [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>"
]
|
GCC | frv | MD | next_suggestion | VLIW | 622,523 | [
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")"
]
| [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
LLVM | Hexagon | CPP | next_suggestion | DSP | 622,524 | [
"MachineInstr",
"*",
"LoopInst",
"=",
"findLoopInstr",
"(",
"LoopBB",
",",
"I",
"->",
"getOpcode",
"(",
")",
",",
"I",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getMBB",
"(",
")",
",",
"VisitedBBs",
")",
";"
]
| [
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"LoopBB",
"->",
"getFirstTerminator",
"(",
")",
";",
"if",
"(",
"I",
"!=",
"LoopBB",
"->",
"end",
"(",
")",
"&&",
"isEndLoopN",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
")",
"{",
"SmallPtrSet",
"<",
"MachineBasicBlock",
"*",
",",
"<NUM_LIT>",
">",
"VisitedBBs",
";"
]
|
LLVM | Hexagon | CPP | program_repair | DSP | 622,525 | [
"<FIXS>",
"MCI",
"->",
"addOperand",
"(",
"MCO",
")",
";",
"<FIXE>"
]
| [
"break",
";",
"}",
"<BUGS>",
"MCI",
".",
"addOperand",
"(",
"MCO",
")",
";",
"<BUGE>",
"}",
"}"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 622,526 | [
"let",
"Uses",
"=",
"[",
"USR",
"]",
";"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isFP",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | ARM | CPP | code_generation | CPU | 622,527 | [
"bool",
"Thumb1FrameLowering",
"::",
"restoreCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"STI",
".",
"getInstrInfo",
"(",
")",
";",
"const",
"ARMBaseRegisterInfo",
"*",
"RegInfo",
"=",
"static_cast",
"<",
"const",
"ARMBaseRegisterInfo",
"*",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
")",
";",
"bool",
"isVarArg",
"=",
"AFI",
"->",
"getArgRegsSaveSize",
"(",
")",
">",
"<NUM_LIT>",
";",
"DebugLoc",
"DL",
"=",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
"?",
"MI",
"->",
"getDebugLoc",
"(",
")",
":",
"DebugLoc",
"(",
")",
";",
"SmallSet",
"<",
"unsigned",
",",
"<NUM_LIT>",
">",
"LoRegsToRestore",
";",
"SmallSet",
"<",
"unsigned",
",",
"<NUM_LIT>",
">",
"HiRegsToRestore",
";",
"SmallSet",
"<",
"unsigned",
",",
"<NUM_LIT>",
">",
"CopyRegs",
";",
"for",
"(",
"CalleeSavedInfo",
"I",
":",
"CSI",
")",
"{",
"unsigned",
"Reg",
"=",
"I",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"ARM",
"::",
"tGPRRegClass",
".",
"contains",
"(",
"Reg",
")",
"||",
"Reg",
"==",
"ARM",
"::",
"LR",
")",
"{",
"LoRegsToRestore",
".",
"insert",
"(",
"Reg",
")",
";",
"}",
"else",
"if",
"(",
"ARM",
"::",
"hGPRRegClass",
".",
"contains",
"(",
"Reg",
")",
"&&",
"Reg",
"!=",
"ARM",
"::",
"LR",
")",
"{",
"HiRegsToRestore",
".",
"insert",
"(",
"Reg",
")",
";",
"}",
"else",
"{",
"llvm_unreachable",
"(",
"<STR_LIT>",
"callee-saved register of unexpected class",
"<STR_LIT>",
")",
";",
"}",
"if",
"(",
"(",
"ARM",
"::",
"tGPRRegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"&&",
"!",
"(",
"hasFP",
"(",
"MF",
")",
"&&",
"Reg",
"==",
"RegInfo",
"->",
"getFrameRegister",
"(",
"MF",
")",
")",
")",
"CopyRegs",
".",
"insert",
"(",
"Reg",
")",
";",
"}",
"auto",
"Terminator",
"=",
"MBB",
".",
"getFirstTerminator",
"(",
")",
";",
"if",
"(",
"Terminator",
"!=",
"MBB",
".",
"end",
"(",
")",
"&&",
"Terminator",
"->",
"getOpcode",
"(",
")",
"==",
"ARM",
"::",
"tBX_RET",
")",
"{",
"CopyRegs",
".",
"insert",
"(",
"ARM",
"::",
"R0",
")",
";",
"CopyRegs",
".",
"insert",
"(",
"ARM",
"::",
"R1",
")",
";",
"CopyRegs",
".",
"insert",
"(",
"ARM",
"::",
"R2",
")",
";",
"CopyRegs",
".",
"insert",
"(",
"ARM",
"::",
"R3",
")",
";",
"for",
"(",
"auto",
"Op",
":",
"Terminator",
"->",
"implicit_operands",
"(",
")",
")",
"{",
"if",
"(",
"Op",
".",
"isReg",
"(",
")",
")",
"CopyRegs",
".",
"erase",
"(",
"Op",
".",
"getReg",
"(",
")",
")",
";",
"}",
"}",
"static",
"const",
"unsigned",
"AllCopyRegs",
"[",
"]",
"=",
"{",
"ARM",
"::",
"R0",
",",
"ARM",
"::",
"R1",
",",
"ARM",
"::",
"R2",
",",
"ARM",
"::",
"R3",
",",
"ARM",
"::",
"R4",
",",
"ARM",
"::",
"R5",
",",
"ARM",
"::",
"R6",
",",
"ARM",
"::",
"R7",
"}",
";",
"static",
"const",
"unsigned",
"AllHighRegs",
"[",
"]",
"=",
"{",
"ARM",
"::",
"R8",
",",
"ARM",
"::",
"R9",
",",
"ARM",
"::",
"R10",
",",
"ARM",
"::",
"R11",
"}",
";",
"const",
"unsigned",
"*",
"AllCopyRegsEnd",
"=",
"std",
"::",
"end",
"(",
"AllCopyRegs",
")",
";",
"const",
"unsigned",
"*",
"AllHighRegsEnd",
"=",
"std",
"::",
"end",
"(",
"AllHighRegs",
")",
";",
"auto",
"HiRegToRestore",
"=",
"findNextOrderedReg",
"(",
"std",
"::",
"begin",
"(",
"AllHighRegs",
")",
",",
"HiRegsToRestore",
",",
"AllHighRegsEnd",
")",
";",
"while",
"(",
"HiRegToRestore",
"!=",
"AllHighRegsEnd",
")",
"{",
"assert",
"(",
"!",
"CopyRegs",
".",
"empty",
"(",
")",
")",
";",
"auto",
"CopyReg",
"=",
"findNextOrderedReg",
"(",
"std",
"::",
"begin",
"(",
"AllCopyRegs",
")",
",",
"CopyRegs",
",",
"AllCopyRegsEnd",
")",
";",
"MachineInstrBuilder",
"PopMIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"ARM",
"::",
"tPOP",
")",
")",
".",
"add",
"(",
"predOps",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"while",
"(",
"HiRegToRestore",
"!=",
"AllHighRegsEnd",
"&&",
"CopyReg",
"!=",
"AllCopyRegsEnd",
")",
"{",
"PopMIB",
".",
"addReg",
"(",
"*",
"CopyReg",
",",
"RegState",
"::",
"Define",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"ARM",
"::",
"tMOVr",
")",
")",
".",
"addReg",
"(",
"*",
"HiRegToRestore",
",",
"RegState",
"::",
"Define",
")",
".",
"addReg",
"(",
"*",
"CopyReg",
",",
"RegState",
"::",
"Kill",
")",
".",
"add",
"(",
"predOps",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"CopyReg",
"=",
"findNextOrderedReg",
"(",
"++",
"CopyReg",
",",
"CopyRegs",
",",
"AllCopyRegsEnd",
")",
";",
"HiRegToRestore",
"=",
"findNextOrderedReg",
"(",
"++",
"HiRegToRestore",
",",
"HiRegsToRestore",
",",
"AllHighRegsEnd",
")",
";",
"}",
"}",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MF",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"ARM",
"::",
"tPOP",
")",
")",
".",
"add",
"(",
"predOps",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"bool",
"NeedsPop",
"=",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"<NUM_LIT>",
";",
"--",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"-",
"<NUM_LIT>",
"]",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"!",
"(",
"ARM",
"::",
"tGPRRegClass",
".",
"contains",
"(",
"Reg",
")",
"||",
"Reg",
"==",
"ARM",
"::",
"LR",
")",
")",
"continue",
";",
"if",
"(",
"Reg",
"==",
"ARM",
"::",
"LR",
")",
"{",
"if",
"(",
"MBB",
".",
"succ_empty",
"(",
")",
")",
"{",
"if",
"(",
"isVarArg",
")",
"continue",
";",
"if",
"(",
"!",
"STI",
".",
"hasV5TOps",
"(",
")",
")",
"continue",
";",
"Reg",
"=",
"ARM",
"::",
"PC",
";",
"(",
"*",
"MIB",
")",
".",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"ARM",
"::",
"tPOP_RET",
")",
")",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
")",
"MIB",
".",
"copyImplicitOps",
"(",
"*",
"MI",
")",
";",
"MI",
"=",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"else",
"continue",
";",
"}",
"MIB",
".",
"addReg",
"(",
"Reg",
",",
"getDefRegState",
"(",
"true",
")",
")",
";",
"NeedsPop",
"=",
"true",
";",
"}",
"if",
"(",
"NeedsPop",
")",
"MBB",
".",
"insert",
"(",
"MI",
",",
"&",
"*",
"MIB",
")",
";",
"else",
"MF",
".",
"DeleteMachineInstr",
"(",
"MIB",
")",
";",
"return",
"true",
";",
"}"
]
| [
"restoreCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"restore",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"load",
"instructions",
"via",
"loadRegToStackSlot",
"(",
")",
"."
]
|
LLVM | X86 | CPP | stmt_completion | CPU | 622,528 | [
";"
]
| [
"unsigned",
"ElemsPerChunk",
"=",
"<NUM_LIT>",
"/",
"ElVT",
".",
"getSizeInBits",
"(",
")",
";",
"unsigned",
"NormalizedIdxVal",
"=",
"(",
"(",
"(",
"IdxVal",
"*",
"ElVT",
".",
"getSizeInBits",
"(",
")",
")",
"/",
"<NUM_LIT>",
")",
"*",
"ElemsPerChunk",
")",
";",
"SDValue",
"VecIdx",
"=",
"DAG",
".",
"getConstant",
"(",
"NormalizedIdxVal",
",",
"MVT",
"::",
"i32",
")",
";",
"SDValue",
"Result",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"dl",
",",
"ResultVT",
",",
"Vec",
",",
"VecIdx",
")",
";",
"return",
"Result"
]
|
GCC | arm | CPP | stmt_completion | CPU | 622,529 | [
"_",
"_",
"b",
",",
"_",
"_",
"p",
")",
";"
]
| [
"_",
"_",
"arm_vandq_m_s16",
"(",
"int16x8_t",
"_",
"_",
"inactive",
",",
"int16x8_t",
"_",
"_",
"a",
",",
"int16x8_t",
"_",
"_",
"b",
",",
"mve_pred16_t",
"_",
"_",
"p",
")",
"{",
"return",
"_",
"_",
"builtin_mve_vandq_m_sv8hi",
"(",
"_",
"_",
"inactive",
",",
"_",
"_",
"a",
","
]
|
GCC | i386 | MD | stmt_completion | CPU | 622,530 | [
"]",
")"
]
| [
"(",
"match_operand",
":",
"V16FI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"parallel",
"[",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"]",
")",
")",
"(",
"match_operand",
":",
"<",
"ssequartermode",
">",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"{",
"operands",
"[",
"<NUM_LIT>",
"]",
"=",
"GEN_INT",
"(",
"INTVAL",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
">",
">",
"<NUM_LIT>",
")",
"return",
"<STR_LIT>",
"}",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"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 | AMDGPU | CPP | next_suggestion | GPU | 622,531 | [
"}"
]
| [
"void",
"setRepeat",
"(",
"SIScheduleCandReason",
"R",
")",
"{",
"RepeatReasonSet",
"|=",
"(",
"<NUM_LIT>",
"<<",
"R",
")",
";"
]
|
GCC | c6x | CPP | code_generation | VLIW | 622,532 | [
"static",
"int",
"get_unit_reqs",
"(",
"rtx_insn",
"*",
"insn",
",",
"int",
"*",
"req1",
",",
"int",
"*",
"side1",
",",
"int",
"*",
"req2",
",",
"int",
"*",
"side2",
")",
"{",
"enum",
"attr_units",
"units",
";",
"enum",
"attr_cross",
"cross",
";",
"int",
"side",
",",
"req",
";",
"if",
"(",
"!",
"NONDEBUG_INSN_P",
"(",
"insn",
")",
"||",
"recog_memoized",
"(",
"insn",
")",
"<",
"<NUM_LIT>",
")",
"return",
"<NUM_LIT>",
";",
"units",
"=",
"get_attr_units",
"(",
"insn",
")",
";",
"if",
"(",
"units",
"==",
"UNITS_UNKNOWN",
")",
"return",
"<NUM_LIT>",
";",
"side",
"=",
"get_insn_side",
"(",
"insn",
",",
"units",
")",
";",
"cross",
"=",
"get_attr_cross",
"(",
"insn",
")",
";",
"req",
"=",
"(",
"units",
"==",
"UNITS_D",
"?",
"UNIT_REQ_D",
":",
"units",
"==",
"UNITS_D_ADDR",
"?",
"UNIT_REQ_D",
":",
"units",
"==",
"UNITS_DL",
"?",
"UNIT_REQ_DL",
":",
"units",
"==",
"UNITS_DS",
"?",
"UNIT_REQ_DS",
":",
"units",
"==",
"UNITS_L",
"?",
"UNIT_REQ_L",
":",
"units",
"==",
"UNITS_LS",
"?",
"UNIT_REQ_LS",
":",
"units",
"==",
"UNITS_S",
"?",
"UNIT_REQ_S",
":",
"units",
"==",
"UNITS_M",
"?",
"UNIT_REQ_M",
":",
"units",
"==",
"UNITS_DLS",
"?",
"UNIT_REQ_DLS",
":",
"-",
"<NUM_LIT>",
")",
";",
"gcc_assert",
"(",
"req",
"!=",
"-",
"<NUM_LIT>",
")",
";",
"*",
"req1",
"=",
"req",
";",
"*",
"side1",
"=",
"side",
";",
"if",
"(",
"units",
"==",
"UNITS_D_ADDR",
")",
"{",
"*",
"req2",
"=",
"UNIT_REQ_T",
";",
"*",
"side2",
"=",
"side",
"^",
"(",
"cross",
"==",
"CROSS_Y",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
")",
";",
"return",
"<NUM_LIT>",
";",
"}",
"else",
"if",
"(",
"cross",
"==",
"CROSS_Y",
")",
"{",
"*",
"req2",
"=",
"UNIT_REQ_X",
";",
"*",
"side2",
"=",
"side",
";",
"return",
"<NUM_LIT>",
";",
"}",
"return",
"<NUM_LIT>",
";",
"}"
]
| [
"Examine",
"INSN",
",",
"and",
"store",
"in",
"REQ1/SIDE1",
"and",
"REQ2/SIDE2",
"the",
"unit",
"requirements",
".",
"Returns",
"zero",
"if",
"INSN",
"ca",
"n't",
"be",
"handled",
",",
"otherwise",
"either",
"one",
"or",
"two",
"to",
"show",
"how",
"many",
"of",
"the",
"two",
"pairs",
"are",
"in",
"use",
".",
"REQ1",
"is",
"always",
"used",
",",
"it",
"holds",
"what",
"is",
"normally",
"thought",
"of",
"as",
"the",
"instructions",
"reservation",
",",
"e.g",
".",
"UNIT_REQ_DL",
".",
"REQ2",
"is",
"used",
"to",
"either",
"describe",
"a",
"cross",
"path",
",",
"or",
"for",
"loads/stores",
",",
"the",
"T",
"unit",
"."
]
|
LLVM | X86 | CPP | next_suggestion | CPU | 622,533 | [
"}"
]
| [
"if",
"(",
"!",
"DstTy",
".",
"isVector",
"(",
")",
"||",
"!",
"SrcTy",
".",
"isVector",
"(",
")",
")",
"return",
"false",
";",
"assert",
"(",
"SrcTy",
".",
"getSizeInBits",
"(",
")",
"<",
"DstTy",
".",
"getSizeInBits",
"(",
")",
"&&",
"<STR_LIT>",
"Incorrect Src/Dst register size",
"<STR_LIT>",
")",
";",
"if",
"(",
"SrcTy",
".",
"getSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
")",
"SubIdx",
"=",
"X86",
"::",
"sub_xmm",
";",
"else",
"if",
"(",
"SrcTy",
".",
"getSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
")",
"SubIdx",
"=",
"X86",
"::",
"sub_ymm",
";",
"else",
"return",
"false",
";",
"const",
"TargetRegisterClass",
"*",
"SrcRC",
"=",
"getRegClass",
"(",
"SrcTy",
",",
"SrcReg",
",",
"MRI",
")",
";",
"const",
"TargetRegisterClass",
"*",
"DstRC",
"=",
"getRegClass",
"(",
"DstTy",
",",
"DstReg",
",",
"MRI",
")",
";",
"if",
"(",
"!",
"RBI",
".",
"constrainGenericRegister",
"(",
"SrcReg",
",",
"*",
"SrcRC",
",",
"MRI",
")",
"||",
"!",
"RBI",
".",
"constrainGenericRegister",
"(",
"DstReg",
",",
"*",
"DstRC",
",",
"MRI",
")",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Failed to constrain INSERT_SUBREG\\n",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"BuildMI",
"(",
"*",
"I",
".",
"getParent",
"(",
")",
",",
"I",
",",
"I",
".",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"X86",
"::",
"COPY",
")",
")",
".",
"addReg",
"(",
"DstReg",
",",
"RegState",
"::",
"DefineNoRead",
",",
"SubIdx",
")",
".",
"addReg",
"(",
"SrcReg",
")",
";",
"return",
"true",
";"
]
|
LLVM | ARM | CPP | stmt_completion | CPU | 622,534 | [
"(",
")",
";"
]
| [
"SMLoc",
"S",
"=",
"Parser",
".",
"getTok",
"(",
")",
".",
"getLoc",
"(",
")",
";",
"const",
"AsmToken",
"&",
"Tok",
"=",
"Parser",
".",
"getTok",
"(",
")",
";",
"if",
"(",
"Tok",
".",
"isNot",
"(",
"AsmToken",
"::",
"Identifier",
")",
")",
"return",
"MatchOperand_NoMatch",
";",
"int",
"Num",
"=",
"MatchCoprocessorOperandName",
"(",
"Tok",
".",
"getString",
"(",
")",
",",
"'",
"p",
"'",
")",
";",
"if",
"(",
"Num",
"==",
"-",
"<NUM_LIT>",
")",
"return",
"MatchOperand_NoMatch",
";",
"Parser",
".",
"Lex"
]
|
LLVM | AArch64 | TD | stmt_completion | CPU | 622,535 | [
",",
"GPR32",
">",
";"
]
| [
"def",
"LDAPRH",
":",
"RCPCLoad",
"<",
"<NUM_LIT>",
",",
"<STR_LIT>"
]
|
LLVM | X86 | CPP | next_suggestion | CPU | 622,536 | [
"EmitLEA",
"(",
"*",
"DispOp",
",",
"VT",
",",
"Reg",
",",
"Out",
")",
";"
]
| [
"if",
"(",
"IsStackReg",
"(",
"Op",
".",
"getMemIndexReg",
"(",
")",
")",
")",
"Displacement",
"-=",
"OrigSPOffset",
"*",
"Op",
".",
"getMemScale",
"(",
")",
";",
"assert",
"(",
"Displacement",
">=",
"<NUM_LIT>",
")",
";",
"if",
"(",
"Displacement",
"==",
"<NUM_LIT>",
")",
"{",
"EmitLEA",
"(",
"Op",
",",
"VT",
",",
"Reg",
",",
"Out",
")",
";",
"return",
";",
"}",
"int64_t",
"Residue",
";",
"std",
"::",
"unique_ptr",
"<",
"X86Operand",
">",
"NewOp",
"=",
"AddDisplacement",
"(",
"Op",
",",
"Displacement",
",",
"Ctx",
",",
"&",
"Residue",
")",
";",
"EmitLEA",
"(",
"*",
"NewOp",
",",
"VT",
",",
"Reg",
",",
"Out",
")",
";",
"while",
"(",
"Residue",
"!=",
"<NUM_LIT>",
")",
"{",
"const",
"MCConstantExpr",
"*",
"Disp",
"=",
"MCConstantExpr",
"::",
"Create",
"(",
"ApplyDisplacementBounds",
"(",
"Residue",
")",
",",
"Ctx",
")",
";",
"std",
"::",
"unique_ptr",
"<",
"X86Operand",
">",
"DispOp",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"getPointerWidth",
"(",
")",
",",
"<NUM_LIT>",
",",
"Disp",
",",
"Reg",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"SMLoc",
"(",
")",
",",
"SMLoc",
"(",
")",
")",
";"
]
|
GCC | aarch64 | CPP | next_suggestion | CPU | 622,537 | [
"}"
]
| [
"src",
"=",
"XEXP",
"(",
"src",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"!=",
"MEM",
"||",
"GET_MODE",
"(",
"src",
")",
"!=",
"SImode",
")",
"return",
"SCHED_FUSION_NONE",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"src",
")",
"==",
"MEM",
"&&",
"REG_P",
"(",
"dest",
")",
")",
"extract_base_offset_in_addr",
"(",
"src",
",",
"base",
",",
"offset",
")",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"dest",
")",
"==",
"MEM",
"&&",
"(",
"REG_P",
"(",
"src",
")",
"||",
"src",
"==",
"const0_rtx",
")",
")",
"{",
"fusion",
"=",
"SCHED_FUSION_ST",
";",
"extract_base_offset_in_addr",
"(",
"dest",
",",
"base",
",",
"offset",
")",
";",
"}",
"else",
"return",
"SCHED_FUSION_NONE",
";",
"if",
"(",
"*",
"base",
"==",
"NULL_RTX",
"||",
"*",
"offset",
"==",
"NULL_RTX",
")",
"fusion",
"=",
"SCHED_FUSION_NONE",
";",
"return",
"fusion",
";"
]
|
LLVM | ARM64 | TD | next_suggestion | CPU | 622,538 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"Q",
";"
]
| [
"class",
"BaseSIMDThreeSameVector",
"<",
"bit",
"Q",
",",
"bit",
"U",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"size",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"opcode",
",",
"RegisterOperand",
"regtype",
",",
"string",
"asm",
",",
"string",
"kind",
",",
"list",
"<",
"dag",
">",
"pattern",
">",
":",
"I",
"<",
"(",
"outs",
"regtype",
":",
"$",
"Rd",
")",
",",
"(",
"ins",
"regtype",
":",
"$",
"Rn",
",",
"regtype",
":",
"$",
"Rm",
")",
",",
"asm",
",",
"<STR_LIT>",
"#",
"kind",
"#",
"<STR_LIT>",
"#",
"kind",
"#",
"<STR_LIT>",
"#",
"kind",
"#",
"<STR_LIT>",
"#",
"kind",
"#",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"pattern",
">",
",",
"Sched",
"<",
"[",
"WriteV",
"]",
">",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"Rd",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rn",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | X86 | CPP | program_repair | CPU | 622,539 | [
"<FIXS>",
"DAG",
".",
"getUNDEF",
"(",
"PVT",
")",
",",
"Mask",
")",
";",
"<FIXE>"
]
| [
"V1",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BIT_CONVERT",
",",
"dl",
",",
"PVT",
",",
"V1",
")",
";",
"SDValue",
"Shuffle",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"VECTOR_SHUFFLE",
",",
"dl",
",",
"PVT",
",",
"V1",
",",
"<BUGS>",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"UNDEF",
",",
"PVT",
")",
",",
"Mask",
")",
";",
"<BUGE>",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BIT_CONVERT",
",",
"dl",
",",
"VT",
",",
"Shuffle",
")",
";",
"}"
]
|
LLVM | AArch64 | CPP | stmt_completion | CPU | 622,540 | [
"Reg",
")",
")",
"return",
";"
]
| [
"static",
"void",
"handleRegMaskClobber",
"(",
"const",
"uint32_t",
"*",
"RegMask",
",",
"MCPhysReg",
"Reg",
",",
"LOHInfo",
"*",
"LOHInfos",
")",
"{",
"if",
"(",
"!",
"MachineOperand",
"::",
"clobbersPhysReg",
"(",
"RegMask",
","
]
|
LLVM | Patmos | CPP | program_repair | VLIW | 622,541 | [
"<FIXS>",
"Align",
"Alignment",
")",
"=",
"<NUM_LIT>",
";",
"<FIXE>"
]
| [
"virtual",
"void",
"EmitFStart",
"(",
"const",
"MCSymbol",
"*",
"Start",
",",
"const",
"MCExpr",
"*",
"Size",
",",
"<BUGS>",
"unsigned",
"Alignment",
")",
"=",
"<NUM_LIT>",
";",
"<BUGE>",
"}",
";"
]
|
LLVM | AMDGPU | CPP | next_suggestion | GPU | 622,542 | [
"Register",
"Op0",
"=",
"constrainRegToBank",
"(",
"MRI",
",",
"B",
",",
"InsRegs",
"[",
"L",
"]",
",",
"DstBank",
")",
";"
]
| [
"bool",
"IsDivergentIdx",
"=",
"IdxBank",
"!=",
"AMDGPU",
"::",
"SGPRRegBank",
";",
"LLT",
"VecTy",
"=",
"MRI",
".",
"getType",
"(",
"VecReg",
")",
";",
"unsigned",
"EltSize",
"=",
"VecTy",
".",
"getScalarSizeInBits",
"(",
")",
";",
"unsigned",
"NumElem",
"=",
"VecTy",
".",
"getNumElements",
"(",
")",
";",
"if",
"(",
"!",
"SITargetLowering",
"::",
"shouldExpandVectorDynExt",
"(",
"EltSize",
",",
"NumElem",
",",
"IsDivergentIdx",
")",
")",
"return",
"false",
";",
"MachineIRBuilder",
"B",
"(",
"MI",
")",
";",
"LLT",
"S32",
"=",
"LLT",
"::",
"scalar",
"(",
"<NUM_LIT>",
")",
";",
"const",
"RegisterBank",
"&",
"DstBank",
"=",
"*",
"OpdMapper",
".",
"getInstrMapping",
"(",
")",
".",
"getOperandMapping",
"(",
"<NUM_LIT>",
")",
".",
"BreakDown",
"[",
"<NUM_LIT>",
"]",
".",
"RegBank",
";",
"const",
"RegisterBank",
"&",
"SrcBank",
"=",
"*",
"OpdMapper",
".",
"getInstrMapping",
"(",
")",
".",
"getOperandMapping",
"(",
"<NUM_LIT>",
")",
".",
"BreakDown",
"[",
"<NUM_LIT>",
"]",
".",
"RegBank",
";",
"const",
"RegisterBank",
"&",
"InsBank",
"=",
"*",
"OpdMapper",
".",
"getInstrMapping",
"(",
")",
".",
"getOperandMapping",
"(",
"<NUM_LIT>",
")",
".",
"BreakDown",
"[",
"<NUM_LIT>",
"]",
".",
"RegBank",
";",
"const",
"RegisterBank",
"&",
"CCBank",
"=",
"(",
"DstBank",
"==",
"AMDGPU",
"::",
"SGPRRegBank",
"&&",
"SrcBank",
"==",
"AMDGPU",
"::",
"SGPRRegBank",
"&&",
"InsBank",
"==",
"AMDGPU",
"::",
"SGPRRegBank",
"&&",
"IdxBank",
"==",
"AMDGPU",
"::",
"SGPRRegBank",
")",
"?",
"AMDGPU",
"::",
"SGPRRegBank",
":",
"AMDGPU",
"::",
"VCCRegBank",
";",
"LLT",
"CCTy",
"=",
"(",
"CCBank",
"==",
"AMDGPU",
"::",
"SGPRRegBank",
")",
"?",
"S32",
":",
"LLT",
"::",
"scalar",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"CCBank",
"==",
"AMDGPU",
"::",
"VCCRegBank",
"&&",
"IdxBank",
"==",
"AMDGPU",
"::",
"SGPRRegBank",
")",
"{",
"Idx",
"=",
"B",
".",
"buildCopy",
"(",
"S32",
",",
"Idx",
")",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"MRI",
".",
"setRegBank",
"(",
"Idx",
",",
"AMDGPU",
"::",
"VGPRRegBank",
")",
";",
"}",
"LLT",
"EltTy",
"=",
"VecTy",
".",
"getScalarType",
"(",
")",
";",
"SmallVector",
"<",
"Register",
",",
"<NUM_LIT>",
">",
"InsRegs",
"(",
"OpdMapper",
".",
"getVRegs",
"(",
"<NUM_LIT>",
")",
")",
";",
"unsigned",
"NumLanes",
"=",
"InsRegs",
".",
"size",
"(",
")",
";",
"if",
"(",
"!",
"NumLanes",
")",
"{",
"NumLanes",
"=",
"<NUM_LIT>",
";",
"InsRegs",
".",
"push_back",
"(",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
";",
"}",
"else",
"{",
"EltTy",
"=",
"MRI",
".",
"getType",
"(",
"InsRegs",
"[",
"<NUM_LIT>",
"]",
")",
";",
"}",
"auto",
"UnmergeToEltTy",
"=",
"B",
".",
"buildUnmerge",
"(",
"EltTy",
",",
"VecReg",
")",
";",
"SmallVector",
"<",
"Register",
",",
"<NUM_LIT>",
">",
"Ops",
"(",
"NumElem",
"*",
"NumLanes",
")",
";",
"for",
"(",
"unsigned",
"I",
"=",
"<NUM_LIT>",
";",
"I",
"<",
"NumElem",
";",
"++",
"I",
")",
"{",
"auto",
"IC",
"=",
"B",
".",
"buildConstant",
"(",
"S32",
",",
"I",
")",
";",
"MRI",
".",
"setRegBank",
"(",
"IC",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
",",
"AMDGPU",
"::",
"SGPRRegBank",
")",
";",
"auto",
"Cmp",
"=",
"B",
".",
"buildICmp",
"(",
"CmpInst",
"::",
"ICMP_EQ",
",",
"CCTy",
",",
"Idx",
",",
"IC",
")",
";",
"MRI",
".",
"setRegBank",
"(",
"Cmp",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
",",
"CCBank",
")",
";",
"for",
"(",
"unsigned",
"L",
"=",
"<NUM_LIT>",
";",
"L",
"<",
"NumLanes",
";",
"++",
"L",
")",
"{"
]
|
GCC | i386 | MD | stmt_completion | CPU | 622,543 | [
"V4HF",
"V4HI",
"]",
")"
]
| [
"(",
"define_mode_iterator",
"V24FI",
"[",
"V2SF",
"V2SI"
]
|
LLVM | TPC | CPP | next_suggestion | Virtual ISA | 622,544 | [
"Res",
"->",
"MovDualGroup",
".",
"Name",
"=",
"Name",
";"
]
| [
"auto",
"Res",
"=",
"std",
"::",
"make_unique",
"<",
"TPCOperand",
">",
"(",
"OpKind",
"::",
"WEG",
",",
"StartLoc",
",",
"EndLoc",
")",
";",
"Res",
"->",
"MovDualGroup",
".",
"Val",
"=",
"Val",
";"
]
|
LLVM | Hexagon | TD | stmt_completion | DSP | 622,545 | [
"<NUM_LIT>",
";"
]
| [
"def",
"L2_loadbzw4_pbr",
":",
"HInst",
"<",
"(",
"outs",
"DoubleRegs",
":",
"$",
"Rdd32",
",",
"IntRegs",
":",
"$",
"Rx32",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rx32in",
",",
"ModRegs",
":",
"$",
"Mu2",
")",
",",
"<STR_LIT>",
",",
"tc_44d3da28",
",",
"TypeLD",
">",
",",
"Enc_7eee72",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"="
]
|
LLVM | X86 | TD | stmt_completion | CPU | 622,546 | [
"<NUM_LIT>",
"]",
";"
]
| [
"let",
"NumMicroOps",
"=",
"<NUM_LIT>",
";",
"let",
"ResourceCycles",
"=",
"[",
"<NUM_LIT>",
","
]
|
LLVM | Lanai | CPP | stmt_completion | CPU | 622,547 | [
"::",
"i32",
",",
"Hi",
")",
";"
]
| [
"}",
"else",
"{",
"uint8_t",
"OpFlagHi",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"uint8_t",
"OpFlagLo",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"SDValue",
"Hi",
"=",
"DAG",
".",
"getTargetConstantPool",
"(",
"C",
",",
"MVT",
"::",
"i32",
",",
"N",
"->",
"getAlignment",
"(",
")",
",",
"N",
"->",
"getOffset",
"(",
")",
",",
"OpFlagHi",
")",
";",
"SDValue",
"Lo",
"=",
"DAG",
".",
"getTargetConstantPool",
"(",
"C",
",",
"MVT",
"::",
"i32",
",",
"N",
"->",
"getAlignment",
"(",
")",
",",
"N",
"->",
"getOffset",
"(",
")",
",",
"OpFlagLo",
")",
";",
"Hi",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"MVT"
]
|
LLVM | X86 | CPP | next_suggestion | CPU | 622,548 | [
"break",
";"
]
| [
"case",
"X86",
"::",
"FsFLD0SD",
":",
"Alignment",
"=",
"<NUM_LIT>",
";",
"break",
";",
"case",
"X86",
"::",
"FsFLD0SS",
":",
"Alignment",
"=",
"<NUM_LIT>",
";",
"break",
";",
"default",
":",
"return",
"<NUM_LIT>",
";",
"}",
"if",
"(",
"Ops",
".",
"size",
"(",
")",
"==",
"<NUM_LIT>",
"&&",
"Ops",
"[",
"<NUM_LIT>",
"]",
"==",
"<NUM_LIT>",
"&&",
"Ops",
"[",
"<NUM_LIT>",
"]",
"==",
"<NUM_LIT>",
")",
"{",
"unsigned",
"NewOpc",
"=",
"<NUM_LIT>",
";",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"NULL",
";",
"case",
"X86",
"::",
"TEST8rr",
":",
"NewOpc",
"=",
"X86",
"::",
"CMP8ri",
";",
"break",
";",
"case",
"X86",
"::",
"TEST16rr",
":",
"NewOpc",
"=",
"X86",
"::",
"CMP16ri8",
";",
"break",
";",
"case",
"X86",
"::",
"TEST32rr",
":",
"NewOpc",
"=",
"X86",
"::",
"CMP32ri8",
";",
"break",
";",
"case",
"X86",
"::",
"TEST64rr",
":",
"NewOpc",
"=",
"X86",
"::",
"CMP64ri8",
";",
"break",
";",
"}",
"MI",
"->",
"setDesc",
"(",
"get",
"(",
"NewOpc",
")",
")",
";",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"ChangeToImmediate",
"(",
"<NUM_LIT>",
")",
";",
"}",
"else",
"if",
"(",
"Ops",
".",
"size",
"(",
")",
"!=",
"<NUM_LIT>",
")",
"return",
"NULL",
";",
"if",
"(",
"LoadMI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getSubReg",
"(",
")",
"!=",
"MI",
"->",
"getOperand",
"(",
"Ops",
"[",
"<NUM_LIT>",
"]",
")",
".",
"getSubReg",
"(",
")",
")",
"return",
"NULL",
";",
"SmallVector",
"<",
"MachineOperand",
",",
"X86",
"::",
"AddrNumOperands",
">",
"MOs",
";",
"switch",
"(",
"LoadMI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"X86",
"::",
"V_SET0",
":",
"case",
"X86",
"::",
"V_SETALLONES",
":",
"case",
"X86",
"::",
"AVX2_SETALLONES",
":",
"case",
"X86",
"::",
"AVX_SET0",
":",
"case",
"X86",
"::",
"FsFLD0SD",
":",
"case",
"X86",
"::",
"FsFLD0SS",
":",
"{",
"if",
"(",
"TM",
".",
"getCodeModel",
"(",
")",
"!=",
"CodeModel",
"::",
"Small",
"&&",
"TM",
".",
"getCodeModel",
"(",
")",
"!=",
"CodeModel",
"::",
"Kernel",
")",
"return",
"NULL",
";",
"unsigned",
"PICBase",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"TM",
".",
"getRelocationModel",
"(",
")",
"==",
"Reloc",
"::",
"PIC_",
")",
"{",
"if",
"(",
"TM",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
".",
"is64Bit",
"(",
")",
")",
"PICBase",
"=",
"X86",
"::",
"RIP",
";",
"else",
"return",
"NULL",
";",
"}",
"MachineConstantPool",
"&",
"MCP",
"=",
"*",
"MF",
".",
"getConstantPool",
"(",
")",
";",
"Type",
"*",
"Ty",
";",
"unsigned",
"Opc",
"=",
"LoadMI",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"Opc",
"==",
"X86",
"::",
"FsFLD0SS",
")",
"Ty",
"=",
"Type",
"::",
"getFloatTy",
"(",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getContext",
"(",
")",
")",
";",
"else",
"if",
"(",
"Opc",
"==",
"X86",
"::",
"FsFLD0SD",
")",
"Ty",
"=",
"Type",
"::",
"getDoubleTy",
"(",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getContext",
"(",
")",
")",
";",
"else",
"if",
"(",
"Opc",
"==",
"X86",
"::",
"AVX2_SETALLONES",
"||",
"Opc",
"==",
"X86",
"::",
"AVX_SET0",
")",
"Ty",
"=",
"VectorType",
"::",
"get",
"(",
"Type",
"::",
"getInt32Ty",
"(",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getContext",
"(",
")",
")",
",",
"<NUM_LIT>",
")",
";",
"else",
"Ty",
"=",
"VectorType",
"::",
"get",
"(",
"Type",
"::",
"getInt32Ty",
"(",
"MF",
".",
"getFunction",
"(",
")",
"->",
"getContext",
"(",
")",
")",
",",
"<NUM_LIT>",
")",
";",
"bool",
"IsAllOnes",
"=",
"(",
"Opc",
"==",
"X86",
"::",
"V_SETALLONES",
"||",
"Opc",
"==",
"X86",
"::",
"AVX2_SETALLONES",
")",
";",
"const",
"Constant",
"*",
"C",
"=",
"IsAllOnes",
"?",
"Constant",
"::",
"getAllOnesValue",
"(",
"Ty",
")",
":",
"Constant",
"::",
"getNullValue",
"(",
"Ty",
")",
";",
"unsigned",
"CPI",
"=",
"MCP",
".",
"getConstantPoolIndex",
"(",
"C",
",",
"Alignment",
")",
";",
"MOs",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateReg",
"(",
"PICBase",
",",
"false",
")",
")",
";",
"MOs",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateImm",
"(",
"<NUM_LIT>",
")",
")",
";",
"MOs",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateReg",
"(",
"<NUM_LIT>",
",",
"false",
")",
")",
";",
"MOs",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateCPI",
"(",
"CPI",
",",
"<NUM_LIT>",
")",
")",
";",
"MOs",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateReg",
"(",
"<NUM_LIT>",
",",
"false",
")",
")",
";"
]
|
LLVM | AArch64 | CPP | next_suggestion | CPU | 622,549 | [
"O",
"<<",
"<STR_LIT>",
"#0x",
"<STR_LIT>",
";"
]
| [
"void",
"AArch64InstPrinter",
"::",
"printLogicalImm",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"unsigned",
"OpNum",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"uint64_t",
"Val",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNum",
")",
".",
"getImm",
"(",
")",
";"
]
|
LLVM | X86 | CPP | stmt_completion | CPU | 622,550 | [
"Flags",
";"
]
| [
"static",
"StructReturnType",
"callIsStructReturn",
"(",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"OutputArg",
">",
"&",
"Outs",
")",
"{",
"if",
"(",
"Outs",
".",
"empty",
"(",
")",
")",
"return",
"NotStructReturn",
";",
"const",
"ISD",
"::",
"ArgFlagsTy",
"&",
"Flags",
"=",
"Outs",
"[",
"<NUM_LIT>",
"]",
"."
]
|
GCC | vax | CPP | next_suggestion | CPU | 622,551 | [
"}"
]
| [
"static",
"bool",
"indirectable_constant_address_p",
"(",
"rtx",
"x",
",",
"bool",
"indirect",
"ATTRIBUTE_UNUSED",
")",
"{",
"return",
"CONSTANT_ADDRESS_P",
"(",
"x",
")",
";"
]
|
GCC | sh | CPP | stmt_completion | CPU | 622,552 | [
"(",
"x",
")",
")",
")",
"return",
"GENERAL_REGS",
";"
]
| [
"return",
"NO_REGS",
";",
"case",
"E_DFmode",
":",
"sri",
"->",
"icode",
"=",
"CODE_FOR_reload_indf__frn",
";",
"return",
"NO_REGS",
";",
"case",
"E_SImode",
":",
"return",
"FPUL_REGS",
";",
"default",
":",
"abort",
"(",
")",
";",
"}",
"if",
"(",
"rclass",
"==",
"FPUL_REGS",
"&&",
"(",
"(",
"REG_P",
"(",
"x",
")",
"&&",
"(",
"REGNO",
"(",
"x",
")",
"==",
"MACL_REG",
"||",
"REGNO",
"(",
"x",
")",
"==",
"MACH_REG",
"||",
"REGNO",
"(",
"x",
")",
"==",
"T_REG",
")",
")",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
")",
")",
"return",
"GENERAL_REGS",
";",
"if",
"(",
"rclass",
"==",
"FPUL_REGS",
"&&",
"immediate_operand",
"(",
"x",
",",
"mode",
")",
")",
"{",
"if",
"(",
"satisfies_constraint_I08",
"(",
"x",
")",
"||",
"fp_zero_operand",
"(",
"x",
")",
")",
"return",
"GENERAL_REGS",
";",
"else",
"if",
"(",
"mode",
"==",
"SFmode",
")",
"return",
"FP_REGS",
";",
"sri",
"->",
"icode",
"=",
"CODE_FOR_reload_insi__i_fpul",
";",
"return",
"NO_REGS",
";",
"}",
"if",
"(",
"rclass",
"==",
"FPSCR_REGS",
"&&",
"(",
"(",
"REG_P",
"(",
"x",
")",
"&&",
"REGNO",
"(",
"x",
")",
">=",
"FIRST_PSEUDO_REGISTER",
")",
"||",
"(",
"MEM_P",
"(",
"x",
")",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"==",
"PLUS",
")",
")",
")",
"return",
"GENERAL_REGS",
";",
"}",
"if",
"(",
"(",
"(",
"REGCLASS_HAS_FP_REG",
"(",
"rclass",
")",
"&&",
"(",
"REG_P",
"(",
"x",
")",
"&&",
"(",
"GENERAL_OR_AP_REGISTER_P",
"(",
"REGNO",
"(",
"x",
")",
")",
"||",
"(",
"FP_REGISTER_P",
"(",
"REGNO",
"(",
"x",
")",
")",
"&&",
"mode",
"==",
"SImode",
"&&",
"TARGET_FMOVD",
")",
")",
")",
")",
"||",
"(",
"REGCLASS_HAS_GENERAL_REG",
"(",
"rclass",
")",
"&&",
"REG_P",
"(",
"x",
")",
"&&",
"FP_REGISTER_P",
"(",
"REGNO",
"(",
"x",
")",
")",
")",
")",
"&&",
"(",
"mode",
"==",
"SFmode",
"||",
"mode",
"==",
"SImode",
")",
")",
"return",
"FPUL_REGS",
";",
"if",
"(",
"(",
"rclass",
"==",
"FPUL_REGS",
"||",
"(",
"REGCLASS_HAS_FP_REG",
"(",
"rclass",
")",
"&&",
"mode",
"==",
"SImode",
")",
")",
"&&",
"(",
"MEM_P",
"(",
"x",
")",
"||",
"(",
"REG_P",
"(",
"x",
")",
"&&",
"(",
"REGNO",
"(",
"x",
")",
">=",
"FIRST_PSEUDO_REGISTER",
"||",
"REGNO",
"(",
"x",
")",
"==",
"T_REG",
"||",
"system_reg_operand",
"(",
"x",
",",
"VOIDmode",
")",
")",
")",
")",
")",
"{",
"if",
"(",
"rclass",
"==",
"FPUL_REGS",
")",
"return",
"GENERAL_REGS",
";",
"return",
"NO_REGS",
";",
"}",
"if",
"(",
"(",
"rclass",
"==",
"MAC_REGS",
"||",
"rclass",
"==",
"PR_REGS",
")",
"&&",
"REG_P",
"(",
"x",
")",
"&&",
"!",
"GENERAL_REGISTER_P",
"(",
"REGNO",
"(",
"x",
")",
")",
"&&",
"rclass",
"!=",
"REGNO_REG_CLASS",
"(",
"REGNO"
]
|
LLVM | ARM | CPP | next_suggestion | CPU | 622,553 | [
"for",
"(",
"int",
"i",
"=",
"MI",
"->",
"getNumOperands",
"(",
")",
"-",
"<NUM_LIT>",
";",
"i",
">=",
"RegListIdx",
";",
"--",
"i",
")",
"MI",
"->",
"removeOperand",
"(",
"i",
")",
";"
]
| [
"for",
"(",
"int",
"CurRegEnc",
"=",
"FirstRegEnc",
"-",
"<NUM_LIT>",
";",
"CurRegEnc",
">=",
"<NUM_LIT>",
"&&",
"RegsNeeded",
";",
"--",
"CurRegEnc",
")",
"{",
"unsigned",
"CurReg",
"=",
"RegClass",
"->",
"getRegister",
"(",
"CurRegEnc",
")",
";",
"if",
"(",
"IsT1PushPop",
"&&",
"CurRegEnc",
">",
"TRI",
"->",
"getEncodingValue",
"(",
"ARM",
"::",
"R7",
")",
")",
"continue",
";",
"if",
"(",
"!",
"IsPop",
")",
"{",
"RegList",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateReg",
"(",
"CurReg",
",",
"false",
",",
"false",
",",
"false",
",",
"false",
",",
"true",
")",
")",
";",
"--",
"RegsNeeded",
";",
"continue",
";",
"}",
"if",
"(",
"isCalleeSavedRegister",
"(",
"CurReg",
",",
"CSRegs",
")",
"||",
"MI",
"->",
"getParent",
"(",
")",
"->",
"computeRegisterLiveness",
"(",
"TRI",
",",
"CurReg",
",",
"MI",
")",
"!=",
"MachineBasicBlock",
"::",
"LQR_Dead",
")",
"{",
"if",
"(",
"IsVFPPushPop",
")",
"return",
"false",
";",
"else",
"continue",
";",
"}",
"RegList",
".",
"push_back",
"(",
"MachineOperand",
"::",
"CreateReg",
"(",
"CurReg",
",",
"true",
",",
"false",
",",
"false",
",",
"true",
")",
")",
";",
"--",
"RegsNeeded",
";",
"}",
"if",
"(",
"RegsNeeded",
">",
"<NUM_LIT>",
")",
"return",
"false",
";"
]
|
LLVM | ARM | CPP | stmt_completion | CPU | 622,554 | [
"else",
"{"
]
| [
"SwitchToDataSection",
"(",
"<STR_LIT>",
".lazy_symbol_pointer",
"<STR_LIT>",
",",
"<NUM_LIT>",
")",
";",
"printSuffixedName",
"(",
"p",
",",
"<STR_LIT>",
"$lazy_ptr",
"<STR_LIT>",
")",
";",
"O",
"<<",
"<STR_LIT>",
":\\n",
"<STR_LIT>",
";",
"O",
"<<",
"<STR_LIT>",
"\\t.indirect_symbol ",
"<STR_LIT>",
"<<",
"p",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
";",
"O",
"<<",
"<STR_LIT>",
"\\t.long\\tdyld_stub_binding_helper\\n",
"<STR_LIT>",
";",
"}",
"O",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
";",
"if",
"(",
"!",
"GVNonLazyPtrs",
".",
"empty",
"(",
")",
")",
"{",
"SwitchToDataSection",
"(",
"<STR_LIT>",
"\\t.non_lazy_symbol_pointer",
"<STR_LIT>",
",",
"<NUM_LIT>",
")",
";",
"for",
"(",
"StringSet",
"<",
">",
"::",
"iterator",
"i",
"=",
"GVNonLazyPtrs",
".",
"begin",
"(",
")",
",",
"e",
"=",
"GVNonLazyPtrs",
".",
"end",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"const",
"char",
"*",
"p",
"=",
"i",
"->",
"getKeyData",
"(",
")",
";",
"printSuffixedName",
"(",
"p",
",",
"<STR_LIT>",
"$non_lazy_ptr",
"<STR_LIT>",
")",
";",
"O",
"<<",
"<STR_LIT>",
":\\n",
"<STR_LIT>",
";",
"O",
"<<",
"<STR_LIT>",
"\\t.indirect_symbol ",
"<STR_LIT>",
"<<",
"p",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
";",
"O",
"<<",
"<STR_LIT>",
"\\t.long\\t0\\n",
"<STR_LIT>",
";",
"}",
"}",
"if",
"(",
"!",
"HiddenGVNonLazyPtrs",
".",
"empty",
"(",
")",
")",
"{",
"SwitchToSection",
"(",
"TAI",
"->",
"getDataSection",
"(",
")",
")",
";",
"for",
"(",
"StringSet",
"<",
">",
"::",
"iterator",
"i",
"=",
"HiddenGVNonLazyPtrs",
".",
"begin",
"(",
")",
",",
"e",
"=",
"HiddenGVNonLazyPtrs",
".",
"end",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"const",
"char",
"*",
"p",
"=",
"i",
"->",
"getKeyData",
"(",
")",
";",
"EmitAlignment",
"(",
"<NUM_LIT>",
")",
";",
"printSuffixedName",
"(",
"p",
",",
"<STR_LIT>",
"$non_lazy_ptr",
"<STR_LIT>",
")",
";",
"O",
"<<",
"<STR_LIT>",
":\\n",
"<STR_LIT>",
";",
"O",
"<<",
"<STR_LIT>",
"\\t.long ",
"<STR_LIT>",
"<<",
"p",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
";",
"}",
"}",
"DW",
"->",
"EndModule",
"(",
")",
";",
"O",
"<<",
"<STR_LIT>",
"\\t.subsections_via_symbols\\n",
"<STR_LIT>",
";",
"}"
]
|
LLVM | X86 | TD | stmt_completion | CPU | 622,555 | [
"]",
",",
"IIC_OUTS",
">",
",",
"OpSize16",
";"
]
| [
"def",
"OUTSW",
":",
"I",
"<",
"<NUM_LIT>",
",",
"RawFrmSrc",
",",
"(",
"outs",
")",
",",
"(",
"ins",
"srcidx16",
":",
"$",
"src",
")",
",",
"<STR_LIT>",
",",
"["
]
|
GCC | ft32 | MD | next_suggestion | MPU | 622,556 | [
"<STR_LIT>"
]
| [
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]"
]
|
LLVM | ARM | CPP | next_suggestion | CPU | 622,557 | [
"O",
"<<",
"<STR_LIT>",
"]",
"<STR_LIT>",
";"
]
| [
"O",
"<<",
"<STR_LIT>",
"[",
"<STR_LIT>",
"<<",
"TRI",
"->",
"getAsmName",
"(",
"MO1",
".",
"getReg",
"(",
")",
")",
";",
"if",
"(",
"MO2",
".",
"getReg",
"(",
")",
")",
"{",
"O",
"<<",
"<STR_LIT>",
", ",
"<STR_LIT>",
"<<",
"(",
"char",
")",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"MO3",
".",
"getImm",
"(",
")",
")",
"<<",
"TRI",
"->",
"getAsmName",
"(",
"MO2",
".",
"getReg",
"(",
")",
")",
"<<",
"<STR_LIT>",
"]",
"<STR_LIT>",
";",
"return",
";",
"}",
"if",
"(",
"unsigned",
"ImmOffs",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"MO3",
".",
"getImm",
"(",
")",
")",
")",
"O",
"<<",
"<STR_LIT>",
", #",
"<STR_LIT>",
"<<",
"(",
"char",
")",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"MO3",
".",
"getImm",
"(",
")",
")",
"<<",
"ImmOffs",
";"
]
|
GCC | iq2000 | MD | stmt_completion | CPU | 622,558 | [
"<STR_LIT>",
")"
]
| [
"(",
"define_attr",
"<STR_LIT>",
"<STR_LIT>",
"(",
"if_then_else",
"(",
"eq_attr",
"<STR_LIT>"
]
|
LLVM | ARM | CPP | stmt_completion | CPU | 622,559 | [
"!=",
"v",
"[",
"i",
"]",
".",
"first",
"+",
"<NUM_LIT>",
")",
"result",
".",
"push_back",
"(",
"{",
"v",
"[",
"i",
"]",
".",
"first",
"+",
"<NUM_LIT>",
",",
"LegacyLegalizeActions",
"::",
"Unsupported",
"}",
")",
";"
]
| [
"if",
"(",
"i",
"+",
"<NUM_LIT>",
"<",
"v",
"[",
"i",
"]",
".",
"first",
"&&",
"i",
"+",
"<NUM_LIT>",
"<",
"v",
".",
"size",
"(",
")",
"&&",
"v",
"[",
"i",
"+",
"<NUM_LIT>",
"]",
".",
"first"
]
|
GCC | i386 | CPP | next_suggestion | CPU | 622,560 | [
"}"
]
| [
"extern",
"_",
"_",
"inline",
"_",
"_",
"mmask8",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm256_cmpneq_epi32_mask",
"(",
"_",
"_",
"m256i",
"_",
"_",
"X",
",",
"_",
"_",
"m256i",
"_",
"_",
"Y",
")",
"{",
"return",
"(",
"_",
"_",
"mmask8",
")",
"_",
"_",
"builtin_ia32_cmpd256_mask",
"(",
"(",
"_",
"_",
"v8si",
")",
"_",
"_",
"X",
",",
"(",
"_",
"_",
"v8si",
")",
"_",
"_",
"Y",
",",
"<NUM_LIT>",
",",
"(",
"_",
"_",
"mmask8",
")",
"-",
"<NUM_LIT>",
")",
";"
]
|
GCC | epiphany | CPP | program_repair | MPU | 622,561 | [
"<FIXS>",
"todo",
".",
"release",
"(",
")",
";",
"<FIXE>"
]
| [
"insert_insn_on_edge",
"(",
"seq",
",",
"e",
")",
";",
"}",
"}",
"<BUGS>",
"VEC_free",
"(",
"basic_block",
",",
"heap",
",",
"todo",
")",
";",
"<BUGE>",
"sbitmap_free",
"(",
"pushed",
")",
";",
"if",
"(",
"need_commit",
")",
"commit_edge_insertions",
"(",
")",
";"
]
|
LLVM | Mips | TD | program_repair | CPU | 622,562 | [
"<FIXS>",
"def",
"MipsExtractHI",
":",
"SDNode",
"<STR_LIT>",
",",
"SDT_ExtractLOHI",
">",
";",
"def",
"MipsExtractLO",
":",
"SDNode",
"<STR_LIT>",
",",
"SDT_ExtractLOHI",
">",
";",
"<FIXE>"
]
| [
"[",
"SDNPHasChain",
",",
"SDNPSideEffect",
",",
"SDNPOptInGlue",
",",
"SDNPOutGlue",
"]",
">",
";",
"<BUGS>",
"def",
"ExtractLOHI",
":",
"SDNode",
"<STR_LIT>",
",",
"SDT_ExtractLOHI",
">",
";",
"<BUGE>",
"def",
"InsertLOHI",
":",
"SDNode",
"<STR_LIT>",
",",
"SDT_InsertLOHI",
">",
";"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 622,563 | [
"const",
"int",
"_",
"_",
"M",
")",
"{"
]
| [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m256d",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm256_permute4x64_pd",
"(",
"_",
"_",
"m256d",
"_",
"_",
"X",
","
]
|
GCC | rs6000 | MD | stmt_completion | CPU | 622,564 | [
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")"
]
| [
"(",
"ior",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr"
]
|
GCC | powerpcspe | CPP | stmt_completion | CPU | 622,565 | [
"qword",
"a",
",",
"qword",
"b",
")",
"{"
]
| [
"static",
"_",
"_",
"inline",
"qword",
"si_clgth",
"("
]
|
GCC | sparc | MD | next_suggestion | CPU | 622,566 | [
"(",
"reg",
":",
"DI",
"GSR_REG",
")",
"]"
]
| [
"[",
"(",
"set",
"(",
"match_operand",
":",
"V4QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"unspec",
":",
"V4QI",
"[",
"(",
"match_operand",
":",
"V4HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
LLVM | SystemZ | TD | stmt_completion | CPU | 622,567 | [
"}",
"=",
"BD2",
";"
]
| [
"bits",
"<",
"<NUM_LIT>",
">",
"I3",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"op",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"BDL1",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"I3",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"BDL1",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>"
]
|
LLVM | ARM | CPP | program_repair | CPU | 622,568 | [
"<FIXS>",
"Register",
"ResultReg",
";",
"<FIXE>"
]
| [
"}",
"bool",
"RV",
";",
"<BUGS>",
"unsigned",
"ResultReg",
";",
"<BUGE>",
"RV",
"=",
"ARMEmitLoad",
"(",
"VT",
",",
"ResultReg",
",",
"Src",
")",
";",
"assert",
"(",
"RV",
"&&",
"<STR_LIT>",
"Should be able to handle this load.",
"<STR_LIT>",
")",
";",
"RV",
"=",
"ARMEmitStore",
"(",
"VT",
",",
"ResultReg",
",",
"Dest",
")",
";"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 622,569 | [
"_",
"mm512_rsqrt28_round_pd",
"(",
"_",
"_",
"m512d",
"_",
"_",
"A",
",",
"int",
"_",
"_",
"R",
")",
"{"
]
| [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m512d",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")"
]
|
LLVM | ARM | CPP | stmt_completion | CPU | 622,570 | [
"true",
")",
";"
]
| [
"bool",
"isThumb",
"=",
"ThunkIt",
"->",
"isThumb",
";",
"const",
"TargetInstrInfo",
"*",
"TII",
"=",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"MachineBasicBlock",
"*",
"Entry",
"=",
"&",
"MF",
".",
"front",
"(",
")",
";",
"Entry",
"->",
"clear",
"(",
")",
";",
"Entry",
"->",
"addLiveIn",
"(",
"ThunkReg",
")",
";",
"if",
"(",
"isThumb",
")",
"BuildMI",
"(",
"Entry",
",",
"DebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"ARM",
"::",
"tBX",
")",
")",
".",
"addReg",
"(",
"ThunkReg",
")",
".",
"add",
"(",
"predOps",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"else",
"BuildMI",
"(",
"Entry",
",",
"DebugLoc",
"(",
")",
",",
"TII",
"->",
"get",
"(",
"ARM",
"::",
"BX",
")",
")",
".",
"addReg",
"(",
"ThunkReg",
")",
";",
"insertSpeculationBarrier",
"(",
"&",
"MF",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
",",
"*",
"Entry",
",",
"Entry",
"->",
"end",
"(",
")",
",",
"DebugLoc",
"(",
")",
","
]
|
GCC | v850 | CPP | code_generation | MPU | 622,571 | [
"static",
"int",
"const_costs",
"(",
"rtx",
"r",
",",
"enum",
"rtx_code",
"c",
")",
"{",
"HOST_WIDE_INT",
"high",
",",
"low",
";",
"switch",
"(",
"c",
")",
"{",
"case",
"CONST_INT",
":",
"return",
"const_costs_int",
"(",
"INTVAL",
"(",
"r",
")",
",",
"<NUM_LIT>",
")",
";",
"case",
"CONST_DOUBLE",
":",
"const_double_split",
"(",
"r",
",",
"&",
"high",
",",
"&",
"low",
")",
";",
"if",
"(",
"GET_MODE",
"(",
"r",
")",
"==",
"SFmode",
")",
"return",
"const_costs_int",
"(",
"high",
",",
"<NUM_LIT>",
")",
";",
"else",
"return",
"const_costs_int",
"(",
"high",
",",
"<NUM_LIT>",
")",
"+",
"const_costs_int",
"(",
"low",
",",
"<NUM_LIT>",
")",
";",
"case",
"SYMBOL_REF",
":",
"case",
"LABEL_REF",
":",
"case",
"CONST",
":",
"return",
"<NUM_LIT>",
";",
"case",
"HIGH",
":",
"return",
"<NUM_LIT>",
";",
"default",
":",
"return",
"<NUM_LIT>",
";",
"}",
"}"
]
| [
"Return",
"the",
"cost",
"of",
"the",
"rtx",
"R",
"with",
"code",
"CODE",
"."
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 622,572 | [
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";"
]
| [
"def",
"J4_cmpeqn1_fp0_jump_nt",
":",
"HInst",
"<",
"(",
"outs",
")",
",",
"(",
"ins",
"GeneralSubRegs",
":",
"$",
"Rs16",
",",
"n1Const",
":",
"$",
"n1",
",",
"b30_2Imm",
":",
"$",
"Ii",
")",
",",
"<STR_LIT>",
",",
"tc_3d495a39",
",",
"TypeCJ",
">",
",",
"Enc_1de724",
",",
"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",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedFalse",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | R600 | CPP | stmt_completion | GPU | 622,573 | [
"::",
"ALU_CONST",
")",
"{"
]
| [
"SmallVector",
"<",
"std",
"::",
"pair",
"<",
"MachineOperand",
"*",
",",
"int64_t",
">",
",",
"<NUM_LIT>",
">",
"R600InstrInfo",
"::",
"getSrcs",
"(",
"MachineInstr",
"*",
"MI",
")",
"const",
"{",
"SmallVector",
"<",
"std",
"::",
"pair",
"<",
"MachineOperand",
"*",
",",
"int64_t",
">",
",",
"<NUM_LIT>",
">",
"Result",
";",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"==",
"AMDGPU",
"::",
"DOT_4",
")",
"{",
"static",
"const",
"unsigned",
"OpTable",
"[",
"<NUM_LIT>",
"]",
"[",
"<NUM_LIT>",
"]",
"=",
"{",
"{",
"AMDGPU",
"::",
"OpName",
"::",
"src0_X",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src0_sel_X",
"}",
",",
"{",
"AMDGPU",
"::",
"OpName",
"::",
"src0_Y",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src0_sel_Y",
"}",
",",
"{",
"AMDGPU",
"::",
"OpName",
"::",
"src0_Z",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src0_sel_Z",
"}",
",",
"{",
"AMDGPU",
"::",
"OpName",
"::",
"src0_W",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src0_sel_W",
"}",
",",
"{",
"AMDGPU",
"::",
"OpName",
"::",
"src1_X",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src1_sel_X",
"}",
",",
"{",
"AMDGPU",
"::",
"OpName",
"::",
"src1_Y",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src1_sel_Y",
"}",
",",
"{",
"AMDGPU",
"::",
"OpName",
"::",
"src1_Z",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src1_sel_Z",
"}",
",",
"{",
"AMDGPU",
"::",
"OpName",
"::",
"src1_W",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src1_sel_W",
"}",
",",
"}",
";",
"for",
"(",
"unsigned",
"j",
"=",
"<NUM_LIT>",
";",
"j",
"<",
"<NUM_LIT>",
";",
"j",
"++",
")",
"{",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"getOperandIdx",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
",",
"OpTable",
"[",
"j",
"]",
"[",
"<NUM_LIT>",
"]",
")",
")",
";",
"unsigned",
"Reg",
"=",
"MO",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"Reg",
"==",
"AMDGPU",
"::",
"ALU_CONST",
")",
"{",
"unsigned",
"Sel",
"=",
"MI",
"->",
"getOperand",
"(",
"getOperandIdx",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
",",
"OpTable",
"[",
"j",
"]",
"[",
"<NUM_LIT>",
"]",
")",
")",
".",
"getImm",
"(",
")",
";",
"Result",
".",
"push_back",
"(",
"std",
"::",
"pair",
"<",
"MachineOperand",
"*",
",",
"int64_t",
">",
"(",
"&",
"MO",
",",
"Sel",
")",
")",
";",
"continue",
";",
"}",
"}",
"return",
"Result",
";",
"}",
"static",
"const",
"unsigned",
"OpTable",
"[",
"<NUM_LIT>",
"]",
"[",
"<NUM_LIT>",
"]",
"=",
"{",
"{",
"AMDGPU",
"::",
"OpName",
"::",
"src0",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src0_sel",
"}",
",",
"{",
"AMDGPU",
"::",
"OpName",
"::",
"src1",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src1_sel",
"}",
",",
"{",
"AMDGPU",
"::",
"OpName",
"::",
"src2",
",",
"AMDGPU",
"::",
"OpName",
"::",
"src2_sel",
"}",
",",
"}",
";",
"for",
"(",
"unsigned",
"j",
"=",
"<NUM_LIT>",
";",
"j",
"<",
"<NUM_LIT>",
";",
"j",
"++",
")",
"{",
"int",
"SrcIdx",
"=",
"getOperandIdx",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
",",
"OpTable",
"[",
"j",
"]",
"[",
"<NUM_LIT>",
"]",
")",
";",
"if",
"(",
"SrcIdx",
"<",
"<NUM_LIT>",
")",
"break",
";",
"MachineOperand",
"&",
"MO",
"=",
"MI",
"->",
"getOperand",
"(",
"SrcIdx",
")",
";",
"unsigned",
"Reg",
"=",
"MI",
"->",
"getOperand",
"(",
"SrcIdx",
")",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"Reg",
"==",
"AMDGPU"
]
|
LLVM | Cpu0 | CPP | stmt_completion | CPU | 622,574 | [
"|0",
"<STR_LIT>",
";"
]
| [
"if",
"(",
"i",
"!=",
"<NUM_LIT>",
")",
"{",
"O",
"<<",
"<STR_LIT>",
", ",
"<STR_LIT>",
";",
"}",
"O",
"<<",
"<STR_LIT>",
"$r",
"<STR_LIT>",
"<<",
"i",
"<<",
"<STR_LIT>"
]
|
LLVM | Mips | CPP | program_repair | CPU | 622,575 | [
"<FIXS>",
"using",
"RegIter",
"=",
"TargetRegisterClass",
"::",
"const_iterator",
";",
"<FIXE>"
]
| [
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"const",
"MipsSubtarget",
"&",
"Subtarget",
"=",
"MF",
".",
"getSubtarget",
"MipsSubtarget",
">",
"(",
")",
";",
"<BUGS>",
"typedef",
"TargetRegisterClass",
"::",
"const_iterator",
"RegIter",
";",
"<BUGE>",
"for",
"(",
"unsigned",
"I",
"=",
"<NUM_LIT>",
";",
"I",
"array_lengthof",
"(",
"ReservedGPR32",
")",
";",
"++",
"I",
")",
"Reserved",
".",
"set",
"(",
"ReservedGPR32",
"[",
"I",
"]",
")",
";"
]
|
GCC | xtensa | MD | stmt_completion | MPU | 622,576 | [
"<STR_LIT>",
")",
"]",
")"
]
| [
"[",
"(",
"unspec",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
"UNSPEC_NOP",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"\t",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"\t",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"\t"
]
|
LLVM | AArch64 | TD | next_suggestion | CPU | 622,577 | [
"let",
"ParserMatchClass",
"=",
"Imm0_15Operand",
";"
]
| [
"}",
"]",
">",
"{",
"let",
"EncoderMethod",
"=",
"<STR_LIT>",
";",
"let",
"DecoderMethod",
"=",
"<STR_LIT>",
";"
]
|
LLVM | ARM | CPP | stmt_completion | CPU | 622,578 | [
")",
";"
]
| [
"}",
"}",
"if",
"(",
"Subtarget",
"->",
"isThumb1Only",
"(",
")",
")",
"{",
"SDValue",
"RHS",
"=",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"ConstantSDNode",
"*",
"C",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"RHS",
")",
")",
"{",
"int32_t",
"imm",
"=",
"C",
"->",
"getSExtValue",
"(",
")",
";",
"if",
"(",
"imm",
"<",
"<NUM_LIT>",
"&&",
"imm",
">",
"std",
"::",
"numeric_limits",
"<",
"int",
">",
"::",
"min",
"(",
")",
")",
"{",
"SDLoc",
"DL",
"(",
"N",
")",
";",
"RHS",
"=",
"DAG",
".",
"getConstant",
"(",
"-",
"imm",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
";",
"unsigned",
"Opcode",
"=",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"return",
"DAG",
".",
"getNode",
"(",
"Opcode",
",",
"DL",
",",
"N",
"->",
"getVTList",
"(",
")",
",",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"RHS",
")",
";",
"}",
"}",
"}",
"return",
"SDValue",
"("
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 622,579 | [
")",
";"
]
| [
"Register",
"NewDest",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"SReg_32RegClass",
")",
";",
"Register",
"Interm",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"SReg_32RegClass",
")",
";",
"MachineInstr",
"&",
"Op",
"=",
"*",
"BuildMI",
"(",
"MBB",
",",
"MII",
",",
"DL",
",",
"get",
"(",
"Opcode",
")",
",",
"Interm",
")",
".",
"add",
"(",
"Src0",
")",
".",
"add",
"(",
"Src1",
")",
";",
"MachineInstr",
"&",
"Not",
"=",
"*",
"BuildMI",
"(",
"MBB",
",",
"MII",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"S_NOT_B32",
")",
",",
"NewDest",
")",
".",
"addReg",
"(",
"Interm",
")",
";",
"Worklist",
".",
"insert",
"(",
"&",
"Op",
")",
";",
"Worklist",
".",
"insert",
"(",
"&",
"Not",
")",
";",
"MRI",
".",
"replaceRegWith",
"(",
"Dest",
".",
"getReg",
"(",
")",
",",
"NewDest"
]
|
LLVM | Hexagon | TD | stmt_completion | DSP | 622,580 | [
";"
]
| [
"def",
"C2_cmpltu",
":",
"HInst",
"<",
"(",
"outs",
"PredRegs",
":",
"$",
"Pd4",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rs32",
",",
"IntRegs",
":",
"$",
"Rt32",
")",
",",
"<STR_LIT>",
",",
"tc_56f114f4",
",",
"TypeALU32_3op",
">",
"{",
"let",
"isCompare",
"=",
"<NUM_LIT>",
";",
"let",
"isPseudo",
"=",
"<NUM_LIT>",
";",
"let",
"isCodeGenOnly",
"=",
"<NUM_LIT>"
]
|
LLVM | TPC | TD | next_suggestion | Virtual ISA | 622,581 | [
"let",
"Constraints",
"=",
"<STR_LIT>",
";"
]
| [
"let",
"isNotUsedInDisasm",
"=",
"!",
"if",
"(",
"!",
"eq",
"(",
"!",
"cast",
"<",
"string",
">",
"(",
"Rsrc",
")",
",",
"<STR_LIT>",
")",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"dest",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"src",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"sw",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"pred",
";",
"let",
"SrcA",
"=",
"src",
";",
"let",
"SrcB",
"=",
"{",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"dest",
"}",
";",
"let",
"Switches",
"=",
"{",
"sw",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
",",
"<NUM_LIT>",
"}",
";",
"let",
"PredAddress",
"=",
"pred",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"VectorPred",
"=",
"!",
"eq",
"(",
"!",
"cast",
"<",
"string",
">",
"(",
"Pred",
")",
",",
"<STR_LIT>",
")",
";",
"let",
"PredPolarity",
"=",
"pred",
"{",
"<NUM_LIT>",
"}",
";"
]
|
LLVM | SPIRV | CPP | next_suggestion | Virtual ISA | 622,582 | [
"return",
"NewI",
";"
]
| [
"IRBuilder",
"<",
">",
"B",
"(",
"I",
".",
"getParent",
"(",
")",
")",
";",
"B",
".",
"SetInsertPoint",
"(",
"&",
"I",
")",
";",
"SmallVector",
"<",
"Value",
"*",
">",
"Args",
"(",
"I",
".",
"op_begin",
"(",
")",
",",
"I",
".",
"op_end",
"(",
")",
")",
";",
"auto",
"*",
"NewI",
"=",
"B",
".",
"CreateIntrinsic",
"(",
"Intrinsic",
"::",
"spv_insertelt",
",",
"{",
"Types",
"}",
",",
"{",
"Args",
"}",
")",
";",
"std",
"::",
"string",
"InstName",
"=",
"I",
".",
"hasName",
"(",
")",
"?",
"I",
".",
"getName",
"(",
")",
".",
"str",
"(",
")",
":",
"<STR_LIT>",
"<STR_LIT>",
";",
"I",
".",
"replaceAllUsesWith",
"(",
"NewI",
")",
";",
"I",
".",
"eraseFromParent",
"(",
")",
";",
"NewI",
"->",
"setName",
"(",
"InstName",
")",
";"
]
|
LLVM | CellSPU | CPP | stmt_completion | MPU | 622,583 | [
"{"
]
| [
"}",
"else",
"{",
"unsigned",
"Opc",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"RC",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"}",
"else",
"if",
"(",
"RC",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"}",
"else",
"if",
"(",
"RC",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"}",
"else",
"if",
"(",
"RC",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"}",
"else",
"if",
"(",
"RC",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"}",
"else",
"if",
"(",
"RC",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"}",
"else"
]
|
LLVM | AMDGPU | CPP | program_repair | GPU | 622,584 | [
"<FIXS>",
"Error",
"(",
"getLoc",
"(",
")",
",",
"Msg",
")",
";",
"<FIXE>"
]
| [
"StringRef",
"Msg",
"=",
"(",
"Res",
"==",
"MatchOperand_ParseFail",
")",
"?",
"<STR_LIT>",
"failed parsing operand.",
"<STR_LIT>",
":",
"<STR_LIT>",
"not a valid operand.",
"<STR_LIT>",
";",
"<BUGS>",
"Error",
"(",
"getLexer",
"(",
")",
".",
"getLoc",
"(",
")",
",",
"Msg",
")",
";",
"<BUGE>",
"}",
"while",
"(",
"!",
"trySkipToken",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"Parser",
".",
"Lex",
"(",
")",
";"
]
|
LLVM | Hexagon | CPP | stmt_completion | DSP | 622,585 | [
"::",
"LDw_GP_cNotPt_V4",
":"
]
| [
"case",
"Hexagon",
"::",
"STrib_indexed_shl_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"POST_STbri_cNotPt",
":",
"case",
"Hexagon",
"::",
"POST_STbri_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STrih_cNotPt",
":",
"case",
"Hexagon",
"::",
"STrih_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STrih_indexed_cNotPt",
":",
"case",
"Hexagon",
"::",
"STrih_indexed_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STrih_indexed_shl_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STrih_indexed_shl_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"POST_SThri_cNotPt",
":",
"case",
"Hexagon",
"::",
"POST_SThri_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STriw_cNotPt",
":",
"case",
"Hexagon",
"::",
"STriw_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STriw_indexed_cNotPt",
":",
"case",
"Hexagon",
"::",
"STriw_indexed_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STriw_indexed_shl_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STriw_indexed_shl_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"POST_STwri_cNotPt",
":",
"case",
"Hexagon",
"::",
"POST_STwri_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STrib_imm_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STrib_imm_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STrid_cNotPt",
":",
"case",
"Hexagon",
"::",
"STrid_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STrid_indexed_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STrid_indexed_cNotPt",
":",
"case",
"Hexagon",
"::",
"STrid_indexed_shl_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STrid_indexed_shl_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"POST_STdri_cNotPt",
":",
"case",
"Hexagon",
"::",
"POST_STdri_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STrih_imm_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STrih_imm_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STriw_imm_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"STriw_imm_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"JMP_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"LDrid_cNotPt",
":",
"case",
"Hexagon",
"::",
"LDrid_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"LDrid_indexed_cNotPt",
":",
"case",
"Hexagon",
"::",
"LDrid_indexed_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"POST_LDrid_cNotPt",
":",
"case",
"Hexagon",
"::",
"POST_LDrid_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDriw_cNotPt",
":",
"case",
"Hexagon",
"::",
"LDriw_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"LDriw_indexed_cNotPt",
":",
"case",
"Hexagon",
"::",
"LDriw_indexed_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"POST_LDriw_cNotPt",
":",
"case",
"Hexagon",
"::",
"POST_LDriw_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDrih_cNotPt",
":",
"case",
"Hexagon",
"::",
"LDrih_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"LDrih_indexed_cNotPt",
":",
"case",
"Hexagon",
"::",
"LDrih_indexed_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"POST_LDrih_cNotPt",
":",
"case",
"Hexagon",
"::",
"POST_LDrih_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDrib_cNotPt",
":",
"case",
"Hexagon",
"::",
"LDrib_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"LDrib_indexed_cNotPt",
":",
"case",
"Hexagon",
"::",
"LDrib_indexed_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"POST_LDrib_cNotPt",
":",
"case",
"Hexagon",
"::",
"POST_LDrib_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDriuh_cNotPt",
":",
"case",
"Hexagon",
"::",
"LDriuh_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"LDriuh_indexed_cNotPt",
":",
"case",
"Hexagon",
"::",
"LDriuh_indexed_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"POST_LDriuh_cNotPt",
":",
"case",
"Hexagon",
"::",
"POST_LDriuh_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDriub_cNotPt",
":",
"case",
"Hexagon",
"::",
"LDriub_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"LDriub_indexed_cNotPt",
":",
"case",
"Hexagon",
"::",
"LDriub_indexed_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"POST_LDriub_cNotPt",
":",
"case",
"Hexagon",
"::",
"POST_LDriub_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDrid_indexed_shl_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDrid_indexed_shl_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDrib_indexed_shl_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDrib_indexed_shl_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDriub_indexed_shl_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDriub_indexed_shl_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDrih_indexed_shl_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDrih_indexed_shl_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDriuh_indexed_shl_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDriuh_indexed_shl_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDriw_indexed_shl_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDriw_indexed_shl_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"ADD_ri_cNotPt",
":",
"case",
"Hexagon",
"::",
"ADD_ri_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"ADD_rr_cNotPt",
":",
"case",
"Hexagon",
"::",
"ADD_rr_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"XOR_rr_cNotPt",
":",
"case",
"Hexagon",
"::",
"XOR_rr_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"AND_rr_cNotPt",
":",
"case",
"Hexagon",
"::",
"AND_rr_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"OR_rr_cNotPt",
":",
"case",
"Hexagon",
"::",
"OR_rr_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"SUB_rr_cNotPt",
":",
"case",
"Hexagon",
"::",
"SUB_rr_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"COMBINE_rr_cNotPt",
":",
"case",
"Hexagon",
"::",
"COMBINE_rr_cdnNotPt",
":",
"case",
"Hexagon",
"::",
"ASLH_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"ASLH_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"ASRH_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"ASRH_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"SXTB_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"SXTB_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"SXTH_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"SXTH_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"ZXTB_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"ZXTB_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"ZXTH_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"ZXTH_cdnNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDd_GP_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDb_GP_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDub_GP_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDh_GP_cNotPt_V4",
":",
"case",
"Hexagon",
"::",
"LDuh_GP_cNotPt_V4",
":",
"case",
"Hexagon"
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 622,586 | [
"const",
"{"
]
| [
"bool",
"hasIntClamp",
"(",
")"
]
|
LLVM | PowerPC | CPP | next_suggestion | CPU | 622,587 | [
"auto",
"NodeTy",
"=",
"(",
"MemVT",
"==",
"MVT",
"::",
"i8",
")",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
";"
]
| [
"auto",
"*",
"AtomicNode",
"=",
"cast",
"<",
"AtomicSDNode",
">",
"(",
"Op",
".",
"getNode",
"(",
")",
")",
";",
"EVT",
"MemVT",
"=",
"AtomicNode",
"->",
"getMemoryVT",
"(",
")",
";",
"if",
"(",
"MemVT",
".",
"getSizeInBits",
"(",
")",
">=",
"<NUM_LIT>",
")",
"return",
"Op",
";",
"SDValue",
"CmpOp",
"=",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"auto",
"HighBits",
"=",
"APInt",
"::",
"getHighBitsSet",
"(",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"-",
"MemVT",
".",
"getSizeInBits",
"(",
")",
")",
";",
"if",
"(",
"DAG",
".",
"MaskedValueIsZero",
"(",
"CmpOp",
",",
"HighBits",
")",
")",
"return",
"Op",
";",
"unsigned",
"MaskVal",
"=",
"(",
"<NUM_LIT>",
"<<",
"MemVT",
".",
"getSizeInBits",
"(",
")",
")",
"-",
"<NUM_LIT>",
";",
"SDValue",
"NewCmpOp",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AND",
",",
"dl",
",",
"MVT",
"::",
"i32",
",",
"CmpOp",
",",
"DAG",
".",
"getConstant",
"(",
"MaskVal",
",",
"dl",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"SmallVector",
"<",
"SDValue",
",",
"<NUM_LIT>",
">",
"Ops",
";",
"for",
"(",
"int",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"AtomicNode",
"->",
"getNumOperands",
"(",
")",
";",
"i",
"<",
"e",
";",
"i",
"++",
")",
"Ops",
".",
"push_back",
"(",
"AtomicNode",
"->",
"getOperand",
"(",
"i",
")",
")",
";",
"Ops",
"[",
"<NUM_LIT>",
"]",
"=",
"NewCmpOp",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"AtomicNode",
"->",
"getMemOperand",
"(",
")",
";",
"SDVTList",
"Tys",
"=",
"DAG",
".",
"getVTList",
"(",
"MVT",
"::",
"i32",
",",
"MVT",
"::",
"Other",
")",
";"
]
|
GCC | aarch64 | CPP | stmt_completion | CPU | 622,588 | [
";"
]
| [
"rtx",
"op0",
"=",
"XEXP",
"(",
"base",
",",
"<NUM_LIT>",
")",
";",
"rtx",
"op1",
"=",
"XEXP",
"(",
"base",
",",
"<NUM_LIT>",
")",
";",
"op0",
"=",
"force_reg",
"(",
"Pmode",
",",
"op0",
")",
";",
"op1",
"=",
"force_reg",
"(",
"Pmode",
",",
"op1",
")",
";",
"if",
"(",
"REG_POINTER",
"(",
"op1",
")",
")",
"std",
"::",
"swap",
"(",
"op0",
",",
"op1",
")",
";",
"if",
"(",
"virt_or_elim_regno_p",
"(",
"REGNO",
"(",
"op0",
")",
")",
")",
"{",
"base",
"=",
"expand_binop",
"(",
"Pmode",
",",
"add_optab",
",",
"op0",
",",
"offset_rtx",
",",
"NULL_RTX",
",",
"true",
",",
"OPTAB_DIRECT",
")",
";",
"return",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"base",
",",
"op1",
")",
";",
"}",
"base",
"=",
"expand_binop",
"(",
"Pmode",
",",
"add_optab",
",",
"op0",
",",
"op1",
",",
"NULL_RTX",
",",
"true",
",",
"OPTAB_DIRECT",
")",
";",
"x",
"=",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"base",
",",
"offset_rtx",
")",
";",
"}",
"HOST_WIDE_INT",
"base_offset",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
">",
"<NUM_LIT>",
"||",
"mode",
"==",
"TImode",
")",
"base_offset",
"=",
"(",
"(",
"offset",
"+",
"<NUM_LIT>",
"*",
"GET_MODE_SIZE",
"(",
"mode",
")",
")",
"&",
"~",
"(",
"(",
"<NUM_LIT>",
"*",
"GET_MODE_SIZE",
"(",
"mode",
")",
")",
"-",
"<NUM_LIT>",
")",
")",
";",
"else",
"if",
"(",
"offset",
"&",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"-",
"<NUM_LIT>",
")",
")",
"base_offset",
"=",
"(",
"offset",
"+",
"<NUM_LIT>",
")",
"&",
"~",
"<NUM_LIT>",
";",
"else",
"base_offset",
"=",
"offset",
"&",
"~",
"<NUM_LIT>",
";",
"if",
"(",
"base_offset",
"!=",
"<NUM_LIT>",
")",
"{",
"base",
"=",
"plus_constant",
"(",
"Pmode",
",",
"base",
",",
"base_offset",
")",
";",
"base",
"=",
"force_operand",
"(",
"base",
",",
"NULL_RTX",
")",
";",
"return",
"plus_constant",
"(",
"Pmode",
",",
"base",
",",
"offset",
"-",
"base_offset",
")",
";",
"}",
"}",
"return",
"x"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 622,589 | [
"let",
"hasNewValue",
"=",
"<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>",
";"
]
|
LLVM | ARM | TD | next_suggestion | CPU | 622,590 | [
"}"
]
| [
"let",
"Rm",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rn",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"DecoderMethod",
"=",
"<STR_LIT>",
";"
]
|
LLVM | SystemZ | CPP | stmt_completion | CPU | 622,591 | [
")",
";"
]
| [
"return",
"parseAnyRegister",
"(",
"Operands"
]
|
GCC | mips | MD | next_suggestion | CPU | 622,592 | [
"<STR_LIT>",
")"
]
| [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")"
]
|
GCC | aarch64 | CPP | code_generation | CPU | 622,593 | [
"rtx",
"aarch64_reverse_mask",
"(",
"enum",
"machine_mode",
"mode",
")",
"{",
"rtx",
"mask",
";",
"rtvec",
"v",
"=",
"rtvec_alloc",
"(",
"<NUM_LIT>",
")",
";",
"int",
"i",
",",
"j",
";",
"int",
"nunits",
"=",
"GET_MODE_NUNITS",
"(",
"mode",
")",
";",
"int",
"usize",
"=",
"GET_MODE_UNIT_SIZE",
"(",
"mode",
")",
";",
"gcc_assert",
"(",
"BYTES_BIG_ENDIAN",
")",
";",
"gcc_assert",
"(",
"AARCH64_VALID_SIMD_QREG_MODE",
"(",
"mode",
")",
")",
";",
"for",
"(",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"nunits",
";",
"i",
"++",
")",
"for",
"(",
"j",
"=",
"<NUM_LIT>",
";",
"j",
"<",
"usize",
";",
"j",
"++",
")",
"RTVEC_ELT",
"(",
"v",
",",
"i",
"*",
"usize",
"+",
"j",
")",
"=",
"GEN_INT",
"(",
"(",
"i",
"+",
"<NUM_LIT>",
")",
"*",
"usize",
"-",
"<NUM_LIT>",
"-",
"j",
")",
";",
"mask",
"=",
"gen_rtx_CONST_VECTOR",
"(",
"V16QImode",
",",
"v",
")",
";",
"return",
"force_reg",
"(",
"V16QImode",
",",
"mask",
")",
";",
"}"
]
| [
"Generate",
"a",
"byte",
"permute",
"mask",
"for",
"a",
"register",
"of",
"mode",
"MODE",
",",
"which",
"has",
"NUNITS",
"units",
"."
]
|
GCC | alpha | MD | next_suggestion | MPU | 622,594 | [
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"(",
"match_operand",
":",
"SF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 622,595 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
| [
"def",
"A4_tfrcpp",
":",
"HInst",
"<",
"(",
"outs",
"DoubleRegs",
":",
"$",
"Rdd32",
")",
",",
"(",
"ins",
"CtrRegs64",
":",
"$",
"Css32",
")",
",",
"<STR_LIT>",
",",
"tc_b9272d6c",
",",
"TypeCR",
">",
",",
"Enc_667b39",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | AMDGPU | CPP | next_suggestion | GPU | 622,596 | [
"AMDGPUPerfHint",
"Analyzer",
"(",
"FIM",
",",
"ST",
"->",
"getTargetLowering",
"(",
")",
")",
";"
]
| [
"Function",
"*",
"F",
"=",
"I",
"->",
"getFunction",
"(",
")",
";",
"if",
"(",
"!",
"F",
"||",
"F",
"->",
"isDeclaration",
"(",
")",
")",
"continue",
";",
"const",
"TargetSubtargetInfo",
"*",
"ST",
"=",
"TM",
".",
"getSubtargetImpl",
"(",
"*",
"F",
")",
";"
]
|
LLVM | AMDGPU | CPP | program_repair | GPU | 622,597 | [
"<FIXS>",
"bool",
"SIInsertWaitcnts",
"::",
"isLoopBottom",
"(",
"const",
"MachineLoop",
"*",
"Loop",
",",
"const",
"MachineBasicBlock",
"*",
"Block",
")",
"{",
"for",
"(",
"MachineBasicBlock",
"*",
"MBB",
":",
"Loop",
"->",
"blocks",
"(",
")",
")",
"{",
"if",
"(",
"MBB",
"==",
"Block",
"&&",
"MBB",
"->",
"isSuccessor",
"(",
"Loop",
"->",
"getHeader",
"(",
")",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}",
"unsigned",
"SIInsertWaitcnts",
"::",
"countNumBottomBlocks",
"(",
"const",
"MachineLoop",
"*",
"Loop",
")",
"{",
"unsigned",
"Count",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"MachineBasicBlock",
"*",
"MBB",
":",
"Loop",
"->",
"blocks",
"(",
")",
")",
"{",
"if",
"(",
"MBB",
"->",
"isSuccessor",
"(",
"Loop",
"->",
"getHeader",
"(",
")",
")",
")",
"{",
"Count",
"++",
";",
"}",
"}",
"return",
"Count",
";",
"<FIXE>"
]
| [
"}",
"}",
"<BUGS>",
"MachineBasicBlock",
"*",
"SIInsertWaitcnts",
"::",
"loopBottom",
"(",
"const",
"MachineLoop",
"*",
"Loop",
")",
"{",
"MachineBasicBlock",
"*",
"Bottom",
"=",
"Loop",
"->",
"getHeader",
"(",
")",
";",
"for",
"(",
"MachineBasicBlock",
"*",
"MBB",
":",
"Loop",
"->",
"blocks",
"(",
")",
")",
"if",
"(",
"MBB",
"->",
"getNumber",
"(",
")",
">",
"Bottom",
"->",
"getNumber",
"(",
")",
")",
"Bottom",
"=",
"MBB",
";",
"return",
"Bottom",
";",
"<BUGE>",
"}"
]
|
LLVM | R600 | CPP | stmt_completion | GPU | 622,598 | [
";"
]
| [
"MCFixupKind",
"Kind",
"=",
"MCFixupKind",
"(",
"FK_PCRel_4",
")",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"Create",
"(",
"<NUM_LIT>",
",",
"Expr",
",",
"Kind",
",",
"MI",
".",
"getLoc",
"(",
")",
")",
")",
";",
"return",
"<NUM_LIT>",
";",
"}",
"unsigned",
"OpNo",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"unsigned",
"e",
"=",
"MI",
".",
"getNumOperands",
"(",
")",
";",
"OpNo",
"<",
"e",
";",
"++",
"OpNo",
")",
"{",
"if",
"(",
"&",
"MO",
"==",
"&",
"MI",
".",
"getOperand",
"(",
"OpNo",
")",
")",
"break",
";",
"}",
"const",
"MCInstrDesc",
"&",
"Desc",
"=",
"MCII",
".",
"get",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
";",
"if",
"(",
"isSrcOperand",
"(",
"Desc",
",",
"OpNo",
")",
")",
"{",
"uint32_t",
"Enc",
"=",
"getLitEncoding",
"(",
"MO",
")",
";",
"if",
"(",
"Enc",
"!=",
"~",
"<NUM_LIT>",
"U",
"&&",
"(",
"Enc",
"!=",
"<NUM_LIT>",
"||",
"Desc",
".",
"getSize",
"(",
")",
"==",
"<NUM_LIT>",
")",
")",
"return",
"Enc",
";",
"}",
"else",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"return",
"MO",
".",
"getImm",
"(",
")",
";",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Encoding of this operand type is not supported yet.",
"<STR_LIT>",
")",
";",
"return",
"<NUM_LIT>"
]
|
LLVM | ARM | CPP | next_suggestion | CPU | 622,599 | [
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"align",
")",
")",
";"
]
| [
"Rd",
"|=",
"fieldFromInstruction",
"(",
"Insn",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
"<<",
"<NUM_LIT>",
";",
"unsigned",
"Rn",
"=",
"fieldFromInstruction",
"(",
"Insn",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"unsigned",
"Rm",
"=",
"fieldFromInstruction",
"(",
"Insn",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"unsigned",
"align",
"=",
"fieldFromInstruction",
"(",
"Insn",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"unsigned",
"size",
"=",
"<NUM_LIT>",
"<<",
"fieldFromInstruction",
"(",
"Insn",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"align",
"*=",
"<NUM_LIT>",
"*",
"size",
";",
"switch",
"(",
"Inst",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"ARM",
"::",
"VLD2DUPd16",
":",
"case",
"ARM",
"::",
"VLD2DUPd32",
":",
"case",
"ARM",
"::",
"VLD2DUPd8",
":",
"case",
"ARM",
"::",
"VLD2DUPd16wb_fixed",
":",
"case",
"ARM",
"::",
"VLD2DUPd16wb_register",
":",
"case",
"ARM",
"::",
"VLD2DUPd32wb_fixed",
":",
"case",
"ARM",
"::",
"VLD2DUPd32wb_register",
":",
"case",
"ARM",
"::",
"VLD2DUPd8wb_fixed",
":",
"case",
"ARM",
"::",
"VLD2DUPd8wb_register",
":",
"if",
"(",
"!",
"Check",
"(",
"S",
",",
"DecodeDPairRegisterClass",
"(",
"Inst",
",",
"Rd",
",",
"Address",
",",
"Decoder",
")",
")",
")",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"break",
";",
"case",
"ARM",
"::",
"VLD2DUPd16x2",
":",
"case",
"ARM",
"::",
"VLD2DUPd32x2",
":",
"case",
"ARM",
"::",
"VLD2DUPd8x2",
":",
"case",
"ARM",
"::",
"VLD2DUPd16x2wb_fixed",
":",
"case",
"ARM",
"::",
"VLD2DUPd16x2wb_register",
":",
"case",
"ARM",
"::",
"VLD2DUPd32x2wb_fixed",
":",
"case",
"ARM",
"::",
"VLD2DUPd32x2wb_register",
":",
"case",
"ARM",
"::",
"VLD2DUPd8x2wb_fixed",
":",
"case",
"ARM",
"::",
"VLD2DUPd8x2wb_register",
":",
"if",
"(",
"!",
"Check",
"(",
"S",
",",
"DecodeDPairSpacedRegisterClass",
"(",
"Inst",
",",
"Rd",
",",
"Address",
",",
"Decoder",
")",
")",
")",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"break",
";",
"default",
":",
"if",
"(",
"!",
"Check",
"(",
"S",
",",
"DecodeDPRRegisterClass",
"(",
"Inst",
",",
"Rd",
",",
"Address",
",",
"Decoder",
")",
")",
")",
"return",
"MCDisassembler",
"::",
"Fail",
";",
"break",
";",
"}",
"if",
"(",
"Rm",
"!=",
"<NUM_LIT>",
")",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"!",
"Check",
"(",
"S",
",",
"DecodeGPRRegisterClass",
"(",
"Inst",
",",
"Rn",
",",
"Address",
",",
"Decoder",
")",
")",
")",
"return",
"MCDisassembler",
"::",
"Fail",
";"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.