Compiler_Type
stringclasses 2
values | Target
stringclasses 176
values | Programming Language
stringclasses 3
values | Task
stringclasses 4
values | Target_Type
stringclasses 7
values | Idx
int64 0
636k
| Ground_Truth
sequencelengths 0
2.32k
| Input
sequencelengths 1
1.02k
|
---|---|---|---|---|---|---|---|
LLVM | X86 | CPP | stmt_completion | CPU | 620,000 | [
",",
"Adj",
")",
";"
] | [
"void",
"Emitter",
"<",
"CodeEmitter",
">",
"::",
"emitDisplacementField",
"(",
"const",
"MachineOperand",
"*",
"RelocOp",
",",
"int",
"DispVal",
",",
"intptr_t",
"Adj",
",",
"bool",
"IsPCRel",
")",
"{",
"if",
"(",
"!",
"RelocOp",
")",
"{",
"emitConstant",
"(",
"DispVal",
",",
"<NUM_LIT>",
")",
";",
"return",
";",
"}",
"if",
"(",
"RelocOp",
"->",
"isGlobal",
"(",
")",
")",
"{",
"unsigned",
"rt",
"=",
"Is64BitMode",
"?",
"(",
"IsPCRel",
"?",
"X86",
"::",
"reloc_pcrel_word",
":",
"X86",
"::",
"reloc_absolute_word_sext",
")",
":",
"(",
"IsPIC",
"?",
"X86",
"::",
"reloc_picrel_word",
":",
"X86",
"::",
"reloc_absolute_word",
")",
";",
"bool",
"NeedStub",
"=",
"isa",
"<",
"Function",
">",
"(",
"RelocOp",
"->",
"getGlobal",
"(",
")",
")",
";",
"bool",
"Indirect",
"=",
"gvNeedsNonLazyPtr",
"(",
"*",
"RelocOp",
",",
"TM",
")",
";",
"emitGlobalAddress",
"(",
"RelocOp",
"->",
"getGlobal",
"(",
")",
",",
"rt",
",",
"RelocOp",
"->",
"getOffset",
"(",
")",
",",
"Adj",
",",
"NeedStub",
",",
"Indirect",
")",
";",
"}",
"else",
"if",
"(",
"RelocOp",
"->",
"isCPI",
"(",
")",
")",
"{",
"unsigned",
"rt",
"=",
"Is64BitMode",
"?",
"(",
"IsPCRel",
"?",
"X86",
"::",
"reloc_pcrel_word",
":",
"X86",
"::",
"reloc_absolute_word_sext",
")",
":",
"(",
"IsPCRel",
"?",
"X86",
"::",
"reloc_picrel_word",
":",
"X86",
"::",
"reloc_absolute_word",
")",
";",
"emitConstPoolAddress",
"(",
"RelocOp",
"->",
"getIndex",
"(",
")",
",",
"rt",
",",
"RelocOp",
"->",
"getOffset",
"(",
")"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 620,001 | [
"bool",
"requiresRealignment",
"=",
"(",
"(",
"MFI",
"->",
"getMaxAlignment",
"(",
")",
">",
"StackAlign",
")",
"||",
"F",
"->",
"hasFnAttribute",
"(",
"Attribute",
"::",
"StackAlignment",
")",
")",
";"
] | [
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"const",
"Function",
"*",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"unsigned",
"StackAlign",
"=",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getFrameLowering",
"(",
")",
"->",
"getStackAlignment",
"(",
")",
";"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 620,002 | [
"return",
"true",
";"
] | [
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"ARM",
"::",
"tPUSH",
")",
")",
";",
"AddDefaultPred",
"(",
"MIB",
")",
";",
"MIB",
".",
"addReg",
"(",
"<NUM_LIT>",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"<NUM_LIT>",
";",
"--",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"-",
"<NUM_LIT>",
"]",
".",
"getReg",
"(",
")",
";",
"MBB",
".",
"addLiveIn",
"(",
"Reg",
")",
";",
"MIB",
".",
"addReg",
"(",
"Reg",
",",
"RegState",
"::",
"Kill",
")",
";",
"}"
] |
LLVM | PIC16 | CPP | next_suggestion | MPU | 620,003 | [
"}"
] | [
"Entry",
"=",
"PIC16Section",
"::",
"Create",
"(",
"Name",
",",
"Ty",
",",
"Address",
",",
"Color",
",",
"getContext",
"(",
")",
")",
";",
"return",
"Entry",
";"
] |
LLVM | Mips | TD | stmt_completion | CPU | 620,004 | [
";"
] | [
"let",
"EncoderMethod",
"=",
"<STR_LIT>",
";",
"let",
"ParserMatchClass",
"=",
"MipsMemSimm11AsmOperand"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 620,005 | [
"emitWordLE",
"(",
"Binary",
")",
";"
] | [
"const",
"MachineOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OpIdx",
")",
";",
"if",
"(",
"(",
"TID",
".",
"TSFlags",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"emitWordLE",
"(",
"Binary",
"|",
"getMachineSoRegOpValue",
"(",
"MI",
",",
"TID",
",",
"MO",
",",
"OpIdx",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"{",
"emitWordLE",
"(",
"Binary",
"|",
"ARMRegisterInfo",
"::",
"getRegisterNumbering",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
")",
";",
"return",
";",
"}",
"Binary",
"|=",
"getMachineSoImmOpValue",
"(",
"(",
"unsigned",
")",
"MO",
".",
"getImm",
"(",
")",
")",
";"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 620,006 | [
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"<NUM_LIT>",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";"
] | [
"FI",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"return",
";",
"}",
"if",
"(",
"Opc",
"==",
"X86",
"::",
"LEA64_32r",
"&&",
"X86",
"::",
"GR32RegClass",
".",
"contains",
"(",
"BasePtr",
")",
")",
"BasePtr",
"=",
"getX86SubSuperRegister",
"(",
"BasePtr",
",",
"<NUM_LIT>",
")",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
")",
".",
"ChangeToRegister",
"(",
"BasePtr",
",",
"false",
")",
";",
"int",
"FIOffset",
";",
"if",
"(",
"AfterFPPop",
")",
"{",
"const",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"FIOffset",
"=",
"MFI",
"->",
"getObjectOffset",
"(",
"FrameIndex",
")",
"-",
"TFI",
"->",
"getOffsetOfLocalArea",
"(",
")",
";",
"}",
"else",
"FIOffset",
"=",
"TFI",
"->",
"getFrameIndexReference",
"(",
"MF",
",",
"FrameIndex",
",",
"IgnoredFrameReg",
")",
";",
"if",
"(",
"BasePtr",
"==",
"StackPtr",
")",
"FIOffset",
"+=",
"SPAdj",
";",
"if",
"(",
"Opc",
"==",
"TargetOpcode",
"::",
"STACKMAP",
"||",
"Opc",
"==",
"TargetOpcode",
"::",
"PATCHPOINT",
")",
"{",
"assert",
"(",
"BasePtr",
"==",
"FramePtr",
"&&",
"<STR_LIT>",
"Expected the FP as base register",
"<STR_LIT>",
")",
";",
"int64_t",
"Offset",
"=",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
"+",
"FIOffset",
";",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"<NUM_LIT>",
")",
".",
"ChangeToImmediate",
"(",
"Offset",
")",
";",
"return",
";",
"}",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"<NUM_LIT>",
")",
".",
"isImm",
"(",
")",
")",
"{",
"int",
"Imm",
"=",
"(",
"int",
")",
"(",
"MI",
".",
"getOperand",
"(",
"FIOperandNum",
"+",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
")",
";",
"int",
"Offset",
"=",
"FIOffset",
"+",
"Imm",
";",
"assert",
"(",
"(",
"!",
"Is64Bit",
"||",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"(",
"long",
"long",
")",
"FIOffset",
"+",
"Imm",
")",
")",
"&&",
"<STR_LIT>",
"Requesting 64-bit offset in 32-bit immediate!",
"<STR_LIT>",
")",
";"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 620,007 | [
"return",
"DAG",
".",
"getNode",
"(",
"IsSub",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"VTs",
",",
"X",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"VT",
")",
",",
"Cmp1",
")",
";"
] | [
"}",
"if",
"(",
"(",
"!",
"IsSub",
"&&",
"CC",
"==",
"X86",
"::",
"COND_BE",
"&&",
"ConstantX",
"->",
"isAllOnesValue",
"(",
")",
")",
"||",
"(",
"IsSub",
"&&",
"CC",
"==",
"X86",
"::",
"COND_A",
"&&",
"ConstantX",
"->",
"isNullValue",
"(",
")",
")",
")",
"{",
"SDValue",
"EFLAGS",
"=",
"Y",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"EFLAGS",
".",
"getOpcode",
"(",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"EFLAGS",
".",
"hasOneUse",
"(",
")",
"&&",
"EFLAGS",
".",
"getValueType",
"(",
")",
".",
"isInteger",
"(",
")",
"&&",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"EFLAGS",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"{",
"SDValue",
"NewSub",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"SDLoc",
"(",
"EFLAGS",
")",
",",
"EFLAGS",
".",
"getNode",
"(",
")",
"->",
"getVTList",
"(",
")",
",",
"EFLAGS",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"EFLAGS",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"SDValue",
"NewEFLAGS",
"=",
"SDValue",
"(",
"NewSub",
".",
"getNode",
"(",
")",
",",
"EFLAGS",
".",
"getResNo",
"(",
")",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"VT",
",",
"DAG",
".",
"getTargetConstant",
"(",
"X86",
"::",
"COND_B",
",",
"DL",
",",
"MVT",
"::",
"i8",
")",
",",
"NewEFLAGS",
")",
";",
"}",
"}",
"}",
"if",
"(",
"CC",
"==",
"X86",
"::",
"COND_B",
")",
"{",
"return",
"DAG",
".",
"getNode",
"(",
"IsSub",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"DAG",
".",
"getVTList",
"(",
"VT",
",",
"MVT",
"::",
"i32",
")",
",",
"X",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"VT",
")",
",",
"Y",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"}",
"if",
"(",
"CC",
"==",
"X86",
"::",
"COND_A",
")",
"{",
"SDValue",
"EFLAGS",
"=",
"Y",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"EFLAGS",
".",
"getOpcode",
"(",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"EFLAGS",
".",
"getNode",
"(",
")",
"->",
"hasOneUse",
"(",
")",
"&&",
"EFLAGS",
".",
"getValueType",
"(",
")",
".",
"isInteger",
"(",
")",
"&&",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"EFLAGS",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"{",
"SDValue",
"NewSub",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"SDLoc",
"(",
"EFLAGS",
")",
",",
"EFLAGS",
".",
"getNode",
"(",
")",
"->",
"getVTList",
"(",
")",
",",
"EFLAGS",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"EFLAGS",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"SDValue",
"NewEFLAGS",
"=",
"SDValue",
"(",
"NewSub",
".",
"getNode",
"(",
")",
",",
"EFLAGS",
".",
"getResNo",
"(",
")",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"IsSub",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"DAG",
".",
"getVTList",
"(",
"VT",
",",
"MVT",
"::",
"i32",
")",
",",
"X",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"VT",
")",
",",
"NewEFLAGS",
")",
";",
"}",
"}",
"if",
"(",
"CC",
"!=",
"X86",
"::",
"COND_E",
"&&",
"CC",
"!=",
"X86",
"::",
"COND_NE",
")",
"return",
"SDValue",
"(",
")",
";",
"SDValue",
"Cmp",
"=",
"Y",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"Cmp",
".",
"getOpcode",
"(",
")",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"||",
"!",
"Cmp",
".",
"hasOneUse",
"(",
")",
"||",
"!",
"X86",
"::",
"isZeroNode",
"(",
"Cmp",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
"||",
"!",
"Cmp",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getValueType",
"(",
")",
".",
"isInteger",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"SDValue",
"Z",
"=",
"Cmp",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"EVT",
"ZVT",
"=",
"Z",
".",
"getValueType",
"(",
")",
";",
"if",
"(",
"ConstantX",
")",
"{",
"if",
"(",
"(",
"IsSub",
"&&",
"CC",
"==",
"X86",
"::",
"COND_NE",
"&&",
"ConstantX",
"->",
"isNullValue",
"(",
")",
")",
"||",
"(",
"!",
"IsSub",
"&&",
"CC",
"==",
"X86",
"::",
"COND_E",
"&&",
"ConstantX",
"->",
"isAllOnesValue",
"(",
")",
")",
")",
"{",
"SDValue",
"Zero",
"=",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"ZVT",
")",
";",
"SDVTList",
"X86SubVTs",
"=",
"DAG",
".",
"getVTList",
"(",
"ZVT",
",",
"MVT",
"::",
"i32",
")",
";",
"SDValue",
"Neg",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"X86SubVTs",
",",
"Zero",
",",
"Z",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"VT",
",",
"DAG",
".",
"getTargetConstant",
"(",
"X86",
"::",
"COND_B",
",",
"DL",
",",
"MVT",
"::",
"i8",
")",
",",
"SDValue",
"(",
"Neg",
".",
"getNode",
"(",
")",
",",
"<NUM_LIT>",
")",
")",
";",
"}",
"if",
"(",
"(",
"IsSub",
"&&",
"CC",
"==",
"X86",
"::",
"COND_E",
"&&",
"ConstantX",
"->",
"isNullValue",
"(",
")",
")",
"||",
"(",
"!",
"IsSub",
"&&",
"CC",
"==",
"X86",
"::",
"COND_NE",
"&&",
"ConstantX",
"->",
"isAllOnesValue",
"(",
")",
")",
")",
"{",
"SDValue",
"One",
"=",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"ZVT",
")",
";",
"SDValue",
"Cmp1",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"MVT",
"::",
"i32",
",",
"Z",
",",
"One",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"VT",
",",
"DAG",
".",
"getTargetConstant",
"(",
"X86",
"::",
"COND_B",
",",
"DL",
",",
"MVT",
"::",
"i8",
")",
",",
"Cmp1",
")",
";",
"}",
"}",
"SDValue",
"One",
"=",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"ZVT",
")",
";",
"SDValue",
"Cmp1",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"MVT",
"::",
"i32",
",",
"Z",
",",
"One",
")",
";",
"SDVTList",
"VTs",
"=",
"DAG",
".",
"getVTList",
"(",
"VT",
",",
"MVT",
"::",
"i32",
")",
";",
"if",
"(",
"CC",
"==",
"X86",
"::",
"COND_NE",
")",
"return",
"DAG",
".",
"getNode",
"(",
"IsSub",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"VTs",
",",
"X",
",",
"DAG",
".",
"getConstant",
"(",
"-",
"<NUM_LIT>",
"ULL",
",",
"DL",
",",
"VT",
")",
",",
"Cmp1",
")",
";"
] |
LLVM | ARM | CPP | stmt_completion | CPU | 620,008 | [
"CE",
"->",
"getValue",
"(",
")",
"%",
"<NUM_LIT>",
"==",
"<NUM_LIT>",
";"
] | [
"if",
"(",
"!",
"isImm",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"const",
"MCConstantExpr",
"*",
"CE",
"=",
"dyn_cast",
"<",
"MCConstantExpr",
">",
"(",
"getImm",
"(",
")",
")",
")",
"return"
] |
GCC | i386 | MD | next_suggestion | CPU | 620,009 | [
"(",
"match_operand",
":",
"VF_128_256",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"VF_128_256",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"unspec",
":",
"VF_128_256",
"[",
"(",
"match_operand",
":",
"VF_128_256",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"VF_128_256",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"neg",
":",
"VF_128_256"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 620,010 | [
"O",
"<<",
"markup",
"(",
"<STR_LIT>",
"<imm:",
"<STR_LIT>",
")",
"<<",
"<STR_LIT>",
"#0x",
"<STR_LIT>",
";"
] | [
"unsigned",
"EncodedImm",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNum",
")",
".",
"getImm",
"(",
")",
";",
"unsigned",
"EltBits",
";",
"uint64_t",
"Val",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"EncodedImm",
",",
"EltBits",
")",
";"
] |
LLVM | SystemZ | TD | stmt_completion | CPU | 620,011 | [
"=",
"SimpleBDXLoad",
";"
] | [
"dag",
"InOperandList",
"=",
"ins",
";",
"let",
"Size",
"=",
"size",
";",
"let",
"Pattern",
"=",
"pattern",
";",
"let",
"AsmString",
"=",
"asmstr",
";",
"let",
"hasSideEffects",
"=",
"<NUM_LIT>",
";",
"let",
"mayLoad",
"=",
"<NUM_LIT>",
";",
"let",
"mayStore",
"=",
"<NUM_LIT>",
";",
"string",
"DispKey",
"=",
"<STR_LIT>",
";",
"string",
"DispSize",
"=",
"<STR_LIT>",
";",
"string",
"OpKey",
"=",
"<STR_LIT>",
";",
"string",
"OpType",
"=",
"<STR_LIT>",
";",
"string",
"MemKey",
"=",
"<STR_LIT>",
";",
"string",
"MemType",
"=",
"<STR_LIT>",
";",
"string",
"NumOpsKey",
"=",
"<STR_LIT>",
";",
"string",
"NumOpsValue",
"=",
"<STR_LIT>",
";",
"bit",
"SimpleBDXLoad",
"=",
"<NUM_LIT>",
";",
"bit",
"SimpleBDXStore",
"=",
"<NUM_LIT>",
";",
"bit",
"Has20BitOffset",
"=",
"<NUM_LIT>",
";",
"bit",
"HasIndex",
"=",
"<NUM_LIT>",
";",
"bit",
"Is128Bit",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"AccessBytes",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"CCValues",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"CompareZeroCCMask",
"=",
"<NUM_LIT>",
";",
"bit",
"CCMaskFirst",
"=",
"<NUM_LIT>",
";",
"bit",
"CCMaskLast",
"=",
"<NUM_LIT>",
";",
"bit",
"IsLogical",
"=",
"<NUM_LIT>",
";",
"bit",
"CCIfNoSignedWrap",
"=",
"<NUM_LIT>",
";",
"let",
"TSFlags",
"{",
"<NUM_LIT>",
"}"
] |
LLVM | SystemZ | CPP | next_suggestion | CPU | 620,012 | [
"HazardRec",
".",
"EmitInstruction",
"(",
"SU",
")",
";"
] | [
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"+++ Scheduling SU(",
"<STR_LIT>",
"<<",
"SU",
"->",
"NodeNum",
"<<",
"<STR_LIT>",
")\\n",
"<STR_LIT>",
";",
")",
";",
"Available",
".",
"erase",
"(",
"SU",
")",
";"
] |
LLVM | ARM | CPP | stmt_completion | CPU | 620,013 | [
"Op",
")",
"const",
"{"
] | [
"unsigned",
"getImmMinusOneOpValue",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"unsigned"
] |
GCC | aarch64 | CPP | program_repair | CPU | 620,014 | [
"<FIXS>",
"if",
"(",
"hwcap2",
"&",
"HWCAP2_FLAGM2",
")",
"<FIXE>",
"<FIXS>",
"if",
"(",
"hwcap",
"&",
"HWCAP_SM4",
")",
"<FIXE>",
"<FIXS>",
"if",
"(",
"hwcap",
"&",
"HWCAP_FPHP",
")",
"<FIXE>",
"<FIXS>",
"<FIXE>",
"<FIXS>",
"<FIXE>"
] | [
"setCPUFeature",
"(",
"FEAT_PMULL",
")",
";",
"if",
"(",
"hwcap",
"&",
"HWCAP_FLAGM",
")",
"setCPUFeature",
"(",
"FEAT_FLAGM",
")",
";",
"<BUGS>",
"if",
"(",
"hwcap2",
"&",
"HWCAP2_FLAGM2",
")",
"{",
"setCPUFeature",
"(",
"FEAT_FLAGM",
")",
";",
"<BUGE>",
"setCPUFeature",
"(",
"FEAT_FLAGM2",
")",
";",
"<BUGS>",
"}",
"if",
"(",
"hwcap",
"&",
"HWCAP_SM3",
"&&",
"hwcap",
"&",
"HWCAP_SM4",
")",
"<BUGE>",
"setCPUFeature",
"(",
"FEAT_SM4",
")",
";",
"if",
"(",
"hwcap",
"&",
"HWCAP_ASIMDDP",
")",
"setCPUFeature",
"(",
"FEAT_DOTPROD",
")",
";",
"if",
"(",
"hwcap",
"&",
"HWCAP_ASIMDFHM",
")",
"setCPUFeature",
"(",
"FEAT_FP16FML",
")",
";",
"<BUGS>",
"if",
"(",
"hwcap",
"&",
"HWCAP_FPHP",
")",
"{",
"<BUGE>",
"setCPUFeature",
"(",
"FEAT_FP16",
")",
";",
"<BUGS>",
"setCPUFeature",
"(",
"FEAT_FP",
")",
";",
"}",
"<BUGE>",
"if",
"(",
"hwcap",
"&",
"HWCAP_DIT",
")",
"setCPUFeature",
"(",
"FEAT_DIT",
")",
";",
"if",
"(",
"hwcap",
"&",
"HWCAP_ASIMDRDM",
")",
"setCPUFeature",
"(",
"FEAT_RDM",
")",
";",
"<BUGS>",
"if",
"(",
"hwcap",
"&",
"HWCAP_ILRCPC",
")",
"setCPUFeature",
"(",
"FEAT_RCPC2",
")",
";",
"<BUGE>",
"if",
"(",
"hwcap",
"&",
"HWCAP_AES",
")",
"setCPUFeature",
"(",
"FEAT_AES",
")",
";",
"if",
"(",
"hwcap",
"&",
"HWCAP_SHA1",
")"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 620,015 | [
"<STR_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"hasNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"InputType",
"="
] |
LLVM | AArch64 | CPP | code_generation | CPU | 620,016 | [
"bool",
"AArch64RegisterInfo",
"::",
"isArgumentRegister",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"MCRegister",
"Reg",
")",
"const",
"{",
"CallingConv",
"::",
"ID",
"CC",
"=",
"MF",
".",
"getFunction",
"(",
")",
".",
"getCallingConv",
"(",
")",
";",
"const",
"AArch64Subtarget",
"&",
"STI",
"=",
"MF",
".",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
";",
"bool",
"IsVarArg",
"=",
"STI",
".",
"isCallingConvWin64",
"(",
"MF",
".",
"getFunction",
"(",
")",
".",
"getCallingConv",
"(",
")",
")",
";",
"auto",
"HasReg",
"=",
"[",
"]",
"(",
"ArrayRef",
"<",
"MCRegister",
">",
"RegList",
",",
"MCRegister",
"Reg",
")",
"{",
"return",
"llvm",
"::",
"any_of",
"(",
"RegList",
",",
"[",
"Reg",
"]",
"(",
"const",
"MCRegister",
"R",
")",
"{",
"return",
"R",
"==",
"Reg",
";",
"}",
")",
";",
"}",
";",
"switch",
"(",
"CC",
")",
"{",
"default",
":",
"report_fatal_error",
"(",
"<STR_LIT>",
"Unsupported calling convention.",
"<STR_LIT>",
")",
";",
"case",
"CallingConv",
"::",
"WebKit_JS",
":",
"return",
"HasReg",
"(",
"CC_AArch64_WebKit_JS_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"GHC",
":",
"return",
"HasReg",
"(",
"CC_AArch64_GHC_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"C",
":",
"case",
"CallingConv",
"::",
"Fast",
":",
"case",
"CallingConv",
"::",
"PreserveMost",
":",
"case",
"CallingConv",
"::",
"CXX_FAST_TLS",
":",
"case",
"CallingConv",
"::",
"Swift",
":",
"case",
"CallingConv",
"::",
"SwiftTail",
":",
"case",
"CallingConv",
"::",
"Tail",
":",
"if",
"(",
"STI",
".",
"isTargetWindows",
"(",
")",
"&&",
"IsVarArg",
")",
"return",
"HasReg",
"(",
"CC_AArch64_Win64_VarArg_ArgRegs",
",",
"Reg",
")",
";",
"if",
"(",
"!",
"STI",
".",
"isTargetDarwin",
"(",
")",
")",
"{",
"switch",
"(",
"CC",
")",
"{",
"default",
":",
"return",
"HasReg",
"(",
"CC_AArch64_AAPCS_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"Swift",
":",
"case",
"CallingConv",
"::",
"SwiftTail",
":",
"return",
"HasReg",
"(",
"CC_AArch64_AAPCS_ArgRegs",
",",
"Reg",
")",
"||",
"HasReg",
"(",
"CC_AArch64_AAPCS_Swift_ArgRegs",
",",
"Reg",
")",
";",
"}",
"}",
"if",
"(",
"!",
"IsVarArg",
")",
"{",
"switch",
"(",
"CC",
")",
"{",
"default",
":",
"return",
"HasReg",
"(",
"CC_AArch64_DarwinPCS_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"Swift",
":",
"case",
"CallingConv",
"::",
"SwiftTail",
":",
"return",
"HasReg",
"(",
"CC_AArch64_DarwinPCS_ArgRegs",
",",
"Reg",
")",
"||",
"HasReg",
"(",
"CC_AArch64_DarwinPCS_Swift_ArgRegs",
",",
"Reg",
")",
";",
"}",
"}",
"if",
"(",
"STI",
".",
"isTargetILP32",
"(",
")",
")",
"return",
"HasReg",
"(",
"CC_AArch64_DarwinPCS_ILP32_VarArg_ArgRegs",
",",
"Reg",
")",
";",
"return",
"HasReg",
"(",
"CC_AArch64_DarwinPCS_VarArg_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"Win64",
":",
"if",
"(",
"IsVarArg",
")",
"HasReg",
"(",
"CC_AArch64_Win64_VarArg_ArgRegs",
",",
"Reg",
")",
";",
"return",
"HasReg",
"(",
"CC_AArch64_AAPCS_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"CFGuard_Check",
":",
"return",
"HasReg",
"(",
"CC_AArch64_Win64_CFGuard_Check_ArgRegs",
",",
"Reg",
")",
";",
"case",
"CallingConv",
"::",
"AArch64_VectorCall",
":",
"case",
"CallingConv",
"::",
"AArch64_SVE_VectorCall",
":",
"return",
"HasReg",
"(",
"CC_AArch64_AAPCS_ArgRegs",
",",
"Reg",
")",
";",
"}",
"}"
] | [
"isArgumentReg",
"-",
"Returns",
"true",
"if",
"Reg",
"can",
"be",
"used",
"as",
"an",
"argument",
"to",
"a",
"function",
"."
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 620,017 | [
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";",
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"P0",
"]",
";",
"let",
"Defs",
"=",
"[",
"P0",
",",
"PC",
"]",
";"
] |
GCC | i386 | MD | next_suggestion | CPU | 620,018 | [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] | [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
")",
")",
"<STR_LIT>",
")",
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
LLVM | X86 | TD | stmt_completion | CPU | 620,019 | [
"SKLPort6",
"]",
">",
";"
] | [
"def",
"SKLPort16",
":",
"ProcResGroup",
"<",
"[",
"SKLPort1",
","
] |
GCC | i386 | CPP | stmt_completion | CPU | 620,020 | [
"_",
"_",
"v4sf",
")",
"_",
"_",
"A",
")",
";"
] | [
"return",
"(",
"_",
"_",
"m256",
")",
"_",
"_",
"builtin_ia32_ps256_ps",
"(",
"("
] |
LLVM | ARM | TD | next_suggestion | CPU | 620,021 | [
"}"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"RdaLo",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"RdaHi",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"U",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"RdaHi",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"RdaLo",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"A",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Qm",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"horizontalReduction",
"=",
"<NUM_LIT>",
";"
] |
LLVM | ARM64 | TD | next_suggestion | CPU | 620,022 | [
"}"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"Q",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"U",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"Scalar",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"size",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opc",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rn",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rd",
";"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 620,023 | [
"BBState",
".",
"clear",
"(",
")",
";"
] | [
"BBSolved",
".",
"resize",
"(",
"MF",
".",
"getNumBlockIDs",
"(",
")",
",",
"<NUM_LIT>",
")",
";",
"while",
"(",
"<NUM_LIT>",
")",
"{",
"bool",
"MadeChange",
"=",
"false",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"I",
"=",
"MF",
".",
"begin",
"(",
")",
",",
"E",
"=",
"MF",
".",
"end",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"MadeChange",
"|=",
"processBasicBlock",
"(",
"MF",
",",
"*",
"I",
")",
";",
"if",
"(",
"!",
"MadeChange",
")",
"break",
";",
"EverMadeChange",
"=",
"true",
";",
"}"
] |
GCC | m68k | MD | stmt_completion | MPU | 620,024 | [
"<STR_LIT>",
")",
")"
] | [
"(",
"and",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"eq_attr",
"<STR_LIT>"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 620,025 | [
"}"
] | [
"S",
"->",
"getAssembler",
"(",
")",
".",
"setELFHeaderEFlags",
"(",
"ELF",
"::",
"EF_ARM_EABI_VER5",
")",
";",
"if",
"(",
"RelaxAll",
")",
"S",
"->",
"getAssembler",
"(",
")",
".",
"setRelaxAll",
"(",
"true",
")",
";",
"return",
"S",
";"
] |
GCC | nds32 | CPP | stmt_completion | CPU | 620,026 | [
"<STR_LIT>",
";"
] | [
"if",
"(",
"satisfies_constraint_Iu08",
"(",
"GEN_INT",
"(",
"sp_adjust",
")",
")",
"&&",
"NDS32_DOUBLE_WORD_ALIGN_P",
"(",
"sp_adjust",
")",
"&&",
"!",
"cfun",
"->",
"calls_alloca",
")",
"operands",
"[",
"<NUM_LIT>",
"]",
"=",
"GEN_INT",
"(",
"sp_adjust",
")",
";",
"else",
"operands",
"[",
"<NUM_LIT>",
"]",
"=",
"GEN_INT",
"(",
"<NUM_LIT>",
")",
";",
"snprintf",
"(",
"pattern",
",",
"sizeof",
"(",
"pattern",
")",
",",
"<STR_LIT>",
"pop25\\t%%0, %%1",
"<STR_LIT>",
")",
";",
"output_asm_insn",
"(",
"pattern",
",",
"operands",
")",
";",
"return",
"<STR_LIT>"
] |
LLVM | X86 | TD | next_suggestion | CPU | 620,027 | [
"let",
"ResourceCycles",
"=",
"[",
"<NUM_LIT>",
"]",
";"
] | [
"def",
"SKXWriteResGroup32",
":",
"SchedWriteRes",
"<",
"[",
"SKXPort5",
"]",
">",
"{",
"let",
"Latency",
"=",
"<NUM_LIT>",
";",
"let",
"NumMicroOps",
"=",
"<NUM_LIT>",
";"
] |
GCC | sparc | CPP | program_repair | CPU | 620,028 | [
"<FIXS>",
"enum",
"machine_mode",
"mode",
"ATTRIBUTE_UNUSED",
";",
"<FIXE>"
] | [
"intdelay_operand",
"(",
"op",
",",
"mode",
")",
"rtx",
"op",
";",
"<BUGS>",
"enum",
"machine_mode",
"mode",
";",
"<BUGE>",
"{",
"switch",
"(",
"GET_CODE",
"(",
"op",
")",
")",
"{"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 620,029 | [
"SDValue",
"E",
"=",
"b",
".",
"SRL",
"(",
"<NUM_LIT>",
"-",
"immLeft",
",",
"C",
")",
";"
] | [
"static",
"SDValue",
"PXPerformLogic",
"(",
"SDNode",
"*",
"N",
",",
"SelectionDAG",
"&",
"DAG",
",",
"TargetLowering",
"::",
"DAGCombinerInfo",
"&",
"DCI",
",",
"const",
"X86Subtarget",
"*",
"Subtarget",
")",
"{",
"MVT",
"VT",
"=",
"N",
"->",
"getSimpleValueType",
"(",
"<NUM_LIT>",
")",
";",
"SDLoc",
"dl",
"(",
"N",
")",
";",
"SDValue",
"V1",
"=",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"V2",
"=",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"SDNodeTreeBuilder",
"b",
"(",
"&",
"DAG",
",",
"dl",
")",
";",
"assert",
"(",
"(",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"OR",
")",
"||",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"AND",
")",
"||",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"XOR",
")",
")",
"&&",
"<STR_LIT>",
"PXPerformLogic only works for AND / OR / XOR",
"<STR_LIT>",
")",
";",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"OR",
"&&",
"VT",
"==",
"MVT",
"::",
"i128",
"&&",
"(",
"(",
"V1",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SHL",
"&&",
"V2",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SRL",
")",
"||",
"(",
"V1",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SRL",
"&&",
"V2",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SHL",
")",
")",
")",
"{",
"if",
"(",
"V1",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"SHL",
")",
"{",
"std",
"::",
"swap",
"(",
"V1",
",",
"V2",
")",
";",
"}",
"int",
"immLeft",
",",
"immRight",
";",
"if",
"(",
"isImmediateShiftingMask",
"(",
"V1",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"immLeft",
")",
"&&",
"isImmediateShiftingMask",
"(",
"V2",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"immRight",
")",
")",
"{",
"if",
"(",
"immLeft",
"+",
"immRight",
"==",
"<NUM_LIT>",
")",
"{",
"SDValue",
"A",
"=",
"b",
".",
"BITCAST",
"(",
"V1",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"MVT",
"::",
"v2i64",
")",
";",
"SDValue",
"B",
"=",
"b",
".",
"BITCAST",
"(",
"V2",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"MVT",
"::",
"v2i64",
")",
";",
"int",
"pool",
"[",
"]",
"=",
"{",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"}",
";",
"SDValue",
"C",
"=",
"b",
".",
"VECTOR_SHUFFLE",
"(",
"B",
",",
"A",
",",
"pool",
")",
";",
"if",
"(",
"immLeft",
"<",
"<NUM_LIT>",
")",
"{",
"SDValue",
"D",
"=",
"b",
".",
"SHL",
"(",
"immLeft",
",",
"A",
")",
";",
"SDValue",
"E",
"=",
"b",
".",
"SRL",
"(",
"<NUM_LIT>",
"-",
"immLeft",
",",
"C",
")",
";",
"SDValue",
"R",
"=",
"b",
".",
"OR",
"(",
"D",
",",
"E",
")",
";",
"return",
"b",
".",
"BITCAST",
"(",
"R",
",",
"VT",
")",
";",
"}",
"else",
"{",
"SDValue",
"D",
"=",
"b",
".",
"SHL",
"(",
"immLeft",
"-",
"<NUM_LIT>",
",",
"C",
")",
";",
"SDValue",
"E",
"=",
"b",
".",
"SRL",
"(",
"<NUM_LIT>",
"-",
"immLeft",
",",
"B",
")",
";",
"SDValue",
"R",
"=",
"b",
".",
"OR",
"(",
"D",
",",
"E",
")",
";",
"return",
"b",
".",
"BITCAST",
"(",
"R",
",",
"VT",
")",
";",
"}",
"}",
"}",
"}",
"if",
"(",
"N",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"OR",
"&&",
"VT",
"==",
"MVT",
"::",
"i256",
"&&",
"(",
"(",
"V1",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SHL",
"&&",
"V2",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SRL",
")",
"||",
"(",
"V1",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SRL",
"&&",
"V2",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SHL",
")",
")",
")",
"{",
"if",
"(",
"V1",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"SHL",
")",
"{",
"std",
"::",
"swap",
"(",
"V1",
",",
"V2",
")",
";",
"}",
"int",
"immLeft",
",",
"immRight",
";",
"if",
"(",
"isImmediateShiftingMask",
"(",
"V1",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"immLeft",
")",
"&&",
"isImmediateShiftingMask",
"(",
"V2",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"immRight",
")",
")",
"{",
"if",
"(",
"immLeft",
"+",
"immRight",
"==",
"<NUM_LIT>",
")",
"{",
"SDValue",
"A",
"=",
"b",
".",
"BITCAST",
"(",
"V1",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"MVT",
"::",
"v4i64",
")",
";",
"SDValue",
"B",
"=",
"b",
".",
"BITCAST",
"(",
"V2",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"MVT",
"::",
"v4i64",
")",
";",
"if",
"(",
"immLeft",
"<",
"<NUM_LIT>",
")",
"{",
"int",
"pool",
"[",
"]",
"=",
"{",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"}",
";",
"SDValue",
"C",
"=",
"b",
".",
"VECTOR_SHUFFLE",
"(",
"B",
",",
"A",
",",
"pool",
")",
";",
"SDValue",
"D",
"=",
"b",
".",
"SHL",
"(",
"immLeft",
",",
"A",
")",
";",
"SDValue",
"E",
"=",
"b",
".",
"SRL",
"(",
"<NUM_LIT>",
"-",
"immLeft",
",",
"C",
")",
";",
"SDValue",
"R",
"=",
"b",
".",
"OR",
"(",
"D",
",",
"E",
")",
";",
"return",
"b",
".",
"BITCAST",
"(",
"R",
",",
"VT",
")",
";",
"}",
"else",
"if",
"(",
"immLeft",
">=",
"<NUM_LIT>",
"&&",
"immLeft",
"<",
"<NUM_LIT>",
")",
"{",
"int",
"apool",
"[",
"]",
"=",
"{",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"}",
";",
"SDValue",
"NA",
"=",
"b",
".",
"VECTOR_SHUFFLE",
"(",
"B",
",",
"A",
",",
"apool",
")",
";",
"int",
"pool",
"[",
"]",
"=",
"{",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"}",
";",
"SDValue",
"C",
"=",
"b",
".",
"VECTOR_SHUFFLE",
"(",
"B",
",",
"A",
",",
"pool",
")",
";",
"SDValue",
"D",
"=",
"b",
".",
"SHL",
"(",
"immLeft",
"-",
"<NUM_LIT>",
",",
"NA",
")",
";"
] |
LLVM | JVM | CPP | stmt_completion | Virtual ISA | 620,030 | [
"Fail",
";"
] | [
"MCDisassembler",
"::",
"DecodeStatus",
"JVMDisassembler",
"::",
"getInstruction",
"(",
"MCInst",
"&",
"MI",
",",
"uint64_t",
"&",
"Size",
",",
"ArrayRef",
"<",
"uint8_t",
">",
"Bytes",
",",
"uint64_t",
",",
"raw_ostream",
"&",
"OS",
",",
"raw_ostream",
"&",
"CS",
")",
"const",
"{",
"return",
"MCDisassembler",
"::"
] |
LLVM | ARM | CPP | stmt_completion | CPU | 620,031 | [
">>",
"<NUM_LIT>",
";"
] | [
"static",
"inline",
"unsigned",
"getSORegOffset",
"(",
"unsigned",
"Op",
")",
"{",
"return",
"Op"
] |
GCC | i386 | CPP | stmt_completion | CPU | 620,032 | [
"_",
"_",
"mmask8",
")",
"-",
"<NUM_LIT>",
")",
";"
] | [
"return",
"(",
"_",
"_",
"m128i",
")",
"_",
"_",
"builtin_ia32_pmovsqw512_mask",
"(",
"(",
"_",
"_",
"v8di",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v8hi",
")",
"_",
"mm_undefined_si128",
"(",
")",
",",
"("
] |
LLVM | ARM | TD | next_suggestion | CPU | 620,033 | [
"}"
] | [
"let",
"ParserMethod",
"=",
"<STR_LIT>",
";",
"let",
"RenderMethod",
"=",
"<STR_LIT>",
";"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 620,034 | [
"if",
"(",
"STI",
".",
"hasFP16",
"(",
")",
")",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";"
] | [
"else",
"if",
"(",
"STI",
".",
"hasVFP3",
"(",
")",
")",
"ATS",
".",
"emitFPU",
"(",
"STI",
".",
"hasD16",
"(",
")",
"?",
"(",
"STI",
".",
"isFPOnlySP",
"(",
")",
"?",
"(",
"STI",
".",
"hasFP16",
"(",
")",
"?",
"ARM",
"::",
"FK_VFPV3XD_FP16",
":",
"ARM",
"::",
"FK_VFPV3XD",
")",
":",
"(",
"STI",
".",
"hasFP16",
"(",
")",
"?",
"ARM",
"::",
"FK_VFPV3_D16_FP16",
":",
"ARM",
"::",
"FK_VFPV3_D16",
")",
")",
":",
"(",
"STI",
".",
"hasFP16",
"(",
")",
"?",
"ARM",
"::",
"FK_VFPV3_FP16",
":",
"ARM",
"::",
"FK_VFPV3",
")",
")",
";",
"else",
"if",
"(",
"STI",
".",
"hasVFP2",
"(",
")",
")",
"ATS",
".",
"emitFPU",
"(",
"ARM",
"::",
"FK_VFPV2",
")",
";",
"}",
"if",
"(",
"isPositionIndependent",
"(",
")",
")",
"{",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"}",
"else",
"{",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"}",
"if",
"(",
"!",
"TM",
".",
"Options",
".",
"UnsafeFPMath",
")",
"{",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"if",
"(",
"TM",
".",
"Options",
".",
"HonorSignDependentRoundingFPMathOption",
")",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"}",
"else",
"{",
"if",
"(",
"!",
"STI",
".",
"hasVFP2",
"(",
")",
")",
"{",
"if",
"(",
"STI",
".",
"hasV7Ops",
"(",
")",
")",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"}",
"else",
"if",
"(",
"STI",
".",
"hasVFP3",
"(",
")",
")",
"{",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"}",
"}",
"if",
"(",
"TM",
".",
"Options",
".",
"NoInfsFPMath",
"&&",
"TM",
".",
"Options",
".",
"NoNaNsFPMath",
")",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"else",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"if",
"(",
"STI",
".",
"allowsUnalignedMem",
"(",
")",
")",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"else",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<NUM_LIT>",
")",
";",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"STI",
".",
"isFPOnlySP",
"(",
")",
")",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"if",
"(",
"STI",
".",
"isAAPCS_ABI",
"(",
")",
"&&",
"TM",
".",
"Options",
".",
"FloatABIType",
"==",
"FloatABI",
"::",
"Hard",
")",
"ATS",
".",
"emitAttribute",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";"
] |
LLVM | Mips | CPP | code_generation | CPU | 620,035 | [
"bool",
"MipsOs16",
"::",
"runOnModule",
"(",
"Module",
"&",
"M",
")",
"{",
"bool",
"usingMask",
"=",
"Mips32FunctionMask",
".",
"length",
"(",
")",
">",
"<NUM_LIT>",
";",
"bool",
"doneUsingMask",
"=",
"false",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Run on Module MipsOs16 \\n",
"<STR_LIT>",
"<<",
"Mips32FunctionMask",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"if",
"(",
"usingMask",
")",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"using mask \\n",
"<STR_LIT>",
"<<",
"Mips32FunctionMask",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"unsigned",
"int",
"functionIndex",
"=",
"<NUM_LIT>",
";",
"bool",
"modified",
"=",
"false",
";",
"for",
"(",
"auto",
"&",
"F",
":",
"M",
")",
"{",
"if",
"(",
"F",
".",
"isDeclaration",
"(",
")",
")",
"continue",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Working on ",
"<STR_LIT>",
"<<",
"F",
".",
"getName",
"(",
")",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"if",
"(",
"usingMask",
")",
"{",
"if",
"(",
"!",
"doneUsingMask",
")",
"{",
"if",
"(",
"functionIndex",
"==",
"Mips32FunctionMask",
".",
"length",
"(",
")",
")",
"functionIndex",
"=",
"<NUM_LIT>",
";",
"switch",
"(",
"Mips32FunctionMask",
"[",
"functionIndex",
"]",
")",
"{",
"case",
"'",
"<NUM_LIT>",
"'",
":",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"mask forced mips32: ",
"<STR_LIT>",
"<<",
"F",
".",
"getName",
"(",
")",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"F",
".",
"addFnAttr",
"(",
"<STR_LIT>",
"nomips16",
"<STR_LIT>",
")",
";",
"break",
";",
"case",
"'",
".",
"'",
":",
"doneUsingMask",
"=",
"true",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"functionIndex",
"++",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"needsFP",
"(",
"F",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"os16 forced mips32: ",
"<STR_LIT>",
"<<",
"F",
".",
"getName",
"(",
")",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"F",
".",
"addFnAttr",
"(",
"<STR_LIT>",
"nomips16",
"<STR_LIT>",
")",
";",
"}",
"else",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"os16 forced mips16: ",
"<STR_LIT>",
"<<",
"F",
".",
"getName",
"(",
")",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"F",
".",
"addFnAttr",
"(",
"<STR_LIT>",
"mips16",
"<STR_LIT>",
")",
";",
"}",
"}",
"}",
"return",
"modified",
";",
"}"
] | [
"runOnModule",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"process",
"the",
"module",
"being",
"operated",
"on",
"."
] |
LLVM | SystemZ | CPP | next_suggestion | CPU | 620,036 | [
"return",
"true",
";"
] | [
"while",
"(",
"!",
"LogicOpsWorklist",
".",
"empty",
"(",
")",
")",
"{",
"BinaryOperator",
"*",
"Op",
"=",
"LogicOpsWorklist",
".",
"back",
"(",
")",
";",
"LogicOpsWorklist",
".",
"pop_back",
"(",
")",
";",
"if",
"(",
"ConvertedInsts",
".",
"count",
"(",
"dyn_cast",
"<",
"Instruction",
">",
"(",
"Op",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"&&",
"ConvertedInsts",
".",
"count",
"(",
"dyn_cast",
"<",
"Instruction",
">",
"(",
"Op",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"&&",
"!",
"ConvertedInsts",
".",
"count",
"(",
"Op",
")",
")",
"convertLogicOp",
"(",
"*",
"Op",
")",
";",
"}",
"Module",
"&",
"M",
"=",
"*",
"F",
".",
"getParent",
"(",
")",
";",
"auto",
"&",
"Ctx",
"=",
"M",
".",
"getContext",
"(",
")",
";",
"Value",
"*",
"Zero32",
"=",
"ConstantInt",
"::",
"get",
"(",
"Type",
"::",
"getInt32Ty",
"(",
"Ctx",
")",
",",
"<NUM_LIT>",
")",
";",
"bool",
"MadeChange",
"=",
"false",
";",
"for",
"(",
"auto",
"&",
"It",
":",
"reverse",
"(",
"ConvertedInsts",
")",
")",
"{",
"Instruction",
"*",
"I",
"=",
"It",
".",
"first",
";",
"Value",
"*",
"V",
";",
"int",
"Mask",
";",
"bool",
"Worthy",
";",
"std",
"::",
"tie",
"(",
"V",
",",
"Mask",
",",
"Worthy",
")",
"=",
"It",
".",
"second",
";",
"if",
"(",
"!",
"I",
"->",
"user_empty",
"(",
")",
")",
"{",
"if",
"(",
"!",
"Worthy",
")",
"continue",
";",
"Function",
"*",
"TDCFunc",
"=",
"Intrinsic",
"::",
"getDeclaration",
"(",
"&",
"M",
",",
"Intrinsic",
"::",
"s390_tdc",
",",
"V",
"->",
"getType",
"(",
")",
")",
";",
"IRBuilder",
"<",
">",
"IRB",
"(",
"I",
")",
";",
"Value",
"*",
"MaskVal",
"=",
"ConstantInt",
"::",
"get",
"(",
"Type",
"::",
"getInt64Ty",
"(",
"Ctx",
")",
",",
"Mask",
")",
";",
"Instruction",
"*",
"TDC",
"=",
"IRB",
".",
"CreateCall",
"(",
"TDCFunc",
",",
"{",
"V",
",",
"MaskVal",
"}",
")",
";",
"Value",
"*",
"ICmp",
"=",
"IRB",
".",
"CreateICmp",
"(",
"CmpInst",
"::",
"ICMP_NE",
",",
"TDC",
",",
"Zero32",
")",
";",
"I",
"->",
"replaceAllUsesWith",
"(",
"ICmp",
")",
";",
"}",
"I",
"->",
"eraseFromParent",
"(",
")",
";",
"MadeChange",
"=",
"true",
";",
"}",
"if",
"(",
"!",
"MadeChange",
")",
"return",
"false",
";",
"for",
"(",
"auto",
"*",
"I",
":",
"PossibleJunk",
")",
"if",
"(",
"I",
"->",
"user_empty",
"(",
")",
")",
"I",
"->",
"eraseFromParent",
"(",
")",
";"
] |
GCC | alpha | MD | stmt_completion | MPU | 620,037 | [
"match_dup",
"<NUM_LIT>",
")",
")",
")"
] | [
"(",
"umax",
":",
"DI",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
")",
")",
")",
"(",
"clobber",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"leu",
":",
"DI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"("
] |
GCC | arm | CPP | next_suggestion | CPU | 620,038 | [
"return",
"size",
";"
] | [
"int",
"size",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"TARGET_32BIT",
")",
"{",
"if",
"(",
"TARGET_HARD_FLOAT_ABI",
"&&",
"TARGET_VFP",
")",
"size",
"+=",
"<NUM_LIT>",
";",
"if",
"(",
"TARGET_IWMMXT_ABI",
")",
"size",
"+=",
"<NUM_LIT>",
";",
"}"
] |
LLVM | PowerPC | CPP | next_suggestion | CPU | 620,039 | [
"}"
] | [
"static",
"unsigned",
"computeCRSaveOffset",
"(",
"const",
"PPCSubtarget",
"&",
"STI",
")",
"{",
"return",
"(",
"STI",
".",
"isAIXABI",
"(",
")",
"&&",
"!",
"STI",
".",
"isPPC64",
"(",
")",
")",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
";"
] |
GCC | rs6000 | MD | stmt_completion | CPU | 620,040 | [
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"]"
] | [
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"plus",
":",
"GPR",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"plus",
":",
"GPR",
"(",
"match_dup"
] |
GCC | d30v | CPP | code_generation | CPU | 620,041 | [
"tree",
"d30v_build_va_list",
"(",
")",
"{",
"tree",
"f_arg_ptr",
",",
"f_arg_num",
",",
"record",
",",
"type_decl",
";",
"tree",
"int_type_node",
";",
"record",
"=",
"make_lang_type",
"(",
"RECORD_TYPE",
")",
";",
"type_decl",
"=",
"build_decl",
"(",
"TYPE_DECL",
",",
"get_identifier",
"(",
"<STR_LIT>",
"__va_list_tag",
"<STR_LIT>",
")",
",",
"record",
")",
";",
"int_type_node",
"=",
"make_signed_type",
"(",
"INT_TYPE_SIZE",
")",
";",
"f_arg_ptr",
"=",
"build_decl",
"(",
"FIELD_DECL",
",",
"get_identifier",
"(",
"<STR_LIT>",
"__va_arg_ptr",
"<STR_LIT>",
")",
",",
"ptr_type_node",
")",
";",
"f_arg_num",
"=",
"build_decl",
"(",
"FIELD_DECL",
",",
"get_identifier",
"(",
"<STR_LIT>",
"__va_arg_num",
"<STR_LIT>",
")",
",",
"int_type_node",
")",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_arg_ptr",
")",
"=",
"record",
";",
"DECL_FIELD_CONTEXT",
"(",
"f_arg_num",
")",
"=",
"record",
";",
"TREE_CHAIN",
"(",
"record",
")",
"=",
"type_decl",
";",
"TYPE_NAME",
"(",
"record",
")",
"=",
"type_decl",
";",
"TYPE_FIELDS",
"(",
"record",
")",
"=",
"f_arg_ptr",
";",
"TREE_CHAIN",
"(",
"f_arg_ptr",
")",
"=",
"f_arg_num",
";",
"layout_type",
"(",
"record",
")",
";",
"return",
"build_array_type",
"(",
"record",
",",
"build_index_type",
"(",
"size_zero_node",
")",
")",
";",
"}"
] | [
"Create",
"the",
"va_list",
"data",
"type",
"."
] |
GCC | sparc | CPP | code_generation | CPU | 620,042 | [
"static",
"int",
"function_arg_slotno",
"(",
"const",
"struct",
"sparc_args",
"*",
"cum",
",",
"machine_mode",
"mode",
",",
"const_tree",
"type",
",",
"bool",
"named",
",",
"bool",
"incoming",
",",
"int",
"*",
"pregno",
",",
"int",
"*",
"ppadding",
")",
"{",
"const",
"int",
"regbase",
"=",
"incoming",
"?",
"SPARC_INCOMING_INT_ARG_FIRST",
":",
"SPARC_OUTGOING_INT_ARG_FIRST",
";",
"int",
"slotno",
"=",
"cum",
"->",
"words",
",",
"regno",
";",
"enum",
"mode_class",
"mclass",
"=",
"GET_MODE_CLASS",
"(",
"mode",
")",
";",
"*",
"pregno",
"=",
"-",
"<NUM_LIT>",
";",
"*",
"ppadding",
"=",
"-",
"<NUM_LIT>",
";",
"if",
"(",
"type",
"&&",
"TREE_ADDRESSABLE",
"(",
"type",
")",
")",
"return",
"-",
"<NUM_LIT>",
";",
"if",
"(",
"TARGET_ARCH64",
"&&",
"(",
"type",
"?",
"TYPE_ALIGN",
"(",
"type",
")",
":",
"GET_MODE_ALIGNMENT",
"(",
"mode",
")",
")",
">=",
"<NUM_LIT>",
"&&",
"(",
"slotno",
"&",
"<NUM_LIT>",
")",
"!=",
"<NUM_LIT>",
")",
"{",
"slotno",
"++",
";",
"*",
"ppadding",
"=",
"<NUM_LIT>",
";",
"}",
"else",
"*",
"ppadding",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"type",
"&&",
"VECTOR_TYPE_P",
"(",
"type",
")",
")",
"{",
"if",
"(",
"SCALAR_FLOAT_TYPE_P",
"(",
"TREE_TYPE",
"(",
"type",
")",
")",
")",
"{",
"gcc_assert",
"(",
"mode",
"==",
"BLKmode",
")",
";",
"}",
"else",
"{",
"gcc_assert",
"(",
"mode",
"!=",
"BLKmode",
")",
";",
"mclass",
"=",
"MODE_FLOAT",
";",
"}",
"}",
"switch",
"(",
"mclass",
")",
"{",
"case",
"MODE_FLOAT",
":",
"case",
"MODE_COMPLEX_FLOAT",
":",
"case",
"MODE_VECTOR_INT",
":",
"if",
"(",
"TARGET_ARCH64",
"&&",
"TARGET_FPU",
"&&",
"named",
")",
"{",
"if",
"(",
"slotno",
">=",
"SPARC_FP_ARG_MAX",
")",
"return",
"-",
"<NUM_LIT>",
";",
"regno",
"=",
"SPARC_FP_ARG_FIRST",
"+",
"slotno",
"*",
"<NUM_LIT>",
";",
"if",
"(",
"GET_MODE_SIZE",
"(",
"mode",
")",
"<=",
"<NUM_LIT>",
")",
"regno",
"++",
";",
"break",
";",
"}",
"case",
"MODE_INT",
":",
"case",
"MODE_COMPLEX_INT",
":",
"if",
"(",
"slotno",
">=",
"SPARC_INT_ARG_MAX",
")",
"return",
"-",
"<NUM_LIT>",
";",
"regno",
"=",
"regbase",
"+",
"slotno",
";",
"break",
";",
"case",
"MODE_RANDOM",
":",
"if",
"(",
"mode",
"==",
"VOIDmode",
")",
"return",
"-",
"<NUM_LIT>",
";",
"if",
"(",
"TARGET_64BIT",
"&&",
"TARGET_FPU",
"&&",
"named",
"&&",
"type",
"&&",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"RECORD_TYPE",
"||",
"VECTOR_TYPE_P",
"(",
"type",
")",
")",
")",
"{",
"if",
"(",
"slotno",
">=",
"SPARC_FP_ARG_MAX",
")",
"return",
"-",
"<NUM_LIT>",
";",
"if",
"(",
"TREE_CODE",
"(",
"type",
")",
"==",
"RECORD_TYPE",
")",
"{",
"classify_data_t",
"data",
"=",
"{",
"false",
",",
"false",
"}",
";",
"traverse_record_type",
"<",
"classify_data_t",
",",
"classify_registers",
">",
"(",
"type",
",",
"named",
",",
"&",
"data",
")",
";",
"if",
"(",
"data",
".",
"fp_regs",
")",
"{",
"if",
"(",
"slotno",
">=",
"SPARC_FP_ARG_MAX",
"-",
"<NUM_LIT>",
"&&",
"!",
"data",
".",
"fp_regs_in_first_word",
")",
"return",
"-",
"<NUM_LIT>",
";",
"}",
"else",
"{",
"if",
"(",
"slotno",
">=",
"SPARC_INT_ARG_MAX",
")",
"return",
"-",
"<NUM_LIT>",
";",
"}",
"return",
"slotno",
";",
"}",
"regno",
"=",
"SPARC_FP_ARG_FIRST",
"+",
"slotno",
"*",
"<NUM_LIT>",
";",
"}",
"else",
"{",
"if",
"(",
"slotno",
">=",
"SPARC_INT_ARG_MAX",
")",
"return",
"-",
"<NUM_LIT>",
";",
"regno",
"=",
"regbase",
"+",
"slotno",
";",
"}",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"*",
"pregno",
"=",
"regno",
";",
"return",
"slotno",
";",
"}"
] | [
"Compute",
"the",
"slot",
"number",
"to",
"pass",
"an",
"argument",
"in",
".",
"Return",
"the",
"slot",
"number",
"or",
"-1",
"if",
"passing",
"on",
"the",
"stack",
".",
"CUM",
"is",
"a",
"variable",
"of",
"type",
"CUMULATIVE_ARGS",
"which",
"gives",
"info",
"about",
"the",
"preceding",
"args",
"and",
"about",
"the",
"function",
"being",
"called",
".",
"MODE",
"is",
"the",
"argument",
"'s",
"machine",
"mode",
".",
"TYPE",
"is",
"the",
"data",
"type",
"of",
"the",
"argument",
"(",
"as",
"a",
"tree",
")",
".",
"This",
"is",
"null",
"for",
"libcalls",
"where",
"that",
"information",
"may",
"not",
"be",
"available",
".",
"NAMED",
"is",
"nonzero",
"if",
"this",
"argument",
"is",
"a",
"named",
"parameter",
"(",
"otherwise",
"it",
"is",
"an",
"extra",
"parameter",
"matching",
"an",
"ellipsis",
")",
".",
"INCOMING_P",
"is",
"zero",
"for",
"FUNCTION_ARG",
",",
"nonzero",
"for",
"FUNCTION_INCOMING_ARG",
".",
"*",
"PREGNO",
"records",
"the",
"register",
"number",
"to",
"use",
"if",
"scalar",
"type",
".",
"*",
"PPADDING",
"records",
"the",
"amount",
"of",
"padding",
"needed",
"in",
"words",
"."
] |
LLVM | Sparc | CPP | next_suggestion | CPU | 620,043 | [
"Op",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MVT",
"::",
"f32",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";"
] | [
"SDLoc",
"dl",
"(",
"Op",
")",
";",
"assert",
"(",
"Op",
".",
"getValueType",
"(",
")",
"==",
"MVT",
"::",
"i32",
")",
";"
] |
GCC | i386 | CPP | program_repair | CPU | 620,044 | [
"<FIXS>",
"machine_mode",
"mode",
";",
"<FIXE>"
] | [
"static",
"intiamcu_alignment",
"(",
"tree",
"type",
",",
"int",
"align",
")",
"{",
"<BUGS>",
"enum",
"machine_mode",
"mode",
";",
"<BUGE>",
"if",
"(",
"align",
"<NUM_LIT>",
"||",
"TYPE_USER_ALIGN",
"(",
"type",
")",
")",
"return",
"align",
";"
] |
GCC | bpf | CPP | code_generation | Virtual ISA | 620,045 | [
"static",
"void",
"bpf_output_destructor",
"(",
"rtx",
"symbol",
",",
"int",
"priority",
"ATTRIBUTE_UNUSED",
")",
"{",
"tree",
"decl",
"=",
"SYMBOL_REF_DECL",
"(",
"symbol",
")",
";",
"if",
"(",
"decl",
")",
"sorry_at",
"(",
"DECL_SOURCE_LOCATION",
"(",
"decl",
")",
",",
"<STR_LIT>",
"no destructors",
"<STR_LIT>",
")",
";",
"else",
"sorry",
"(",
"<STR_LIT>",
"no destructors",
"<STR_LIT>",
")",
";",
"}"
] | [
"Output",
"the",
"assembly",
"code",
"for",
"a",
"destructor",
".",
"Since",
"eBPF",
"does",
"n't",
"support",
"indirect",
"calls",
",",
"destructors",
"are",
"not",
"supported",
"."
] |
LLVM | J2 | CPP | stmt_completion | MPU | 620,046 | [
",",
"const",
"void",
"*",
"Decoder",
")",
"{"
] | [
"DecodeStatus",
"DecodeGPRRegisterClass",
"(",
"MCInst",
"&",
"Inst",
",",
"unsigned",
"RegNo",
",",
"uint64_t",
"Address"
] |
LLVM | Teak | CPP | program_repair | DSP | 620,047 | [
"<FIXS>",
"SDLoc",
"DL",
"(",
"N",
")",
";",
"const",
"LoadSDNode",
"*",
"ld",
"=",
"dyn_cast",
"LoadSDNode",
">",
"(",
"N",
")",
";",
"const",
"StoreSDNode",
"*",
"st",
"=",
"dyn_cast",
"StoreSDNode",
">",
"(",
"N",
")",
";",
"if",
"(",
"!",
"(",
"ld",
"&&",
"ld",
"->",
"getMemoryVT",
"(",
")",
"==",
"MVT",
"::",
"i16",
")",
"&&",
"!",
"(",
"st",
"&&",
"st",
"->",
"getMemoryVT",
"(",
")",
"==",
"MVT",
"::",
"i16",
")",
")",
"return",
"false",
";",
"<FIXE>",
"<FIXS>",
"if",
"(",
"Op",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"ADD",
"&&",
"Op",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"SUB",
")",
"return",
"false",
";",
"<FIXE>",
"<FIXS>",
"if",
"(",
"const",
"ConstantSDNode",
"*",
"rhs",
"=",
"dyn_cast",
"ConstantSDNode",
">",
"(",
"Op",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"{",
"int",
"rhsc",
"=",
"rhs",
"->",
"getSExtValue",
"(",
")",
";",
"if",
"(",
"Op",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SUB",
")",
"rhsc",
"=",
"-",
"rhsc",
";",
"if",
"(",
"rhsc",
"!=",
"<NUM_LIT>",
"&&",
"rhsc",
"!=",
"-",
"<NUM_LIT>",
")",
"return",
"false",
";",
"Base",
"=",
"Op",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"Offset",
"=",
"DAG",
".",
"getConstant",
"(",
"rhsc",
",",
"DL",
",",
"MVT",
"::",
"i16",
")",
";",
"AM",
"=",
"ISD",
"::",
"POST_INC",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"<FIXE>"
] | [
"bool",
"TeakTargetLowering",
"::",
"getPostIndexedAddressParts",
"(",
"SDNode",
"*",
"N",
",",
"SDNode",
"*",
"Op",
",",
"SDValue",
"&",
"Base",
",",
"SDValue",
"&",
"Offset",
",",
"ISD",
"::",
"MemIndexedMode",
"&",
"AM",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"<BUGS>",
"return",
"false",
";",
"<BUGE>",
"<BUGS>",
"<BUGE>",
"<BUGS>",
"<BUGE>",
"}",
"bool",
"TeakTargetLowering",
"::",
"allowsMemoryAccess",
"(",
"LLVMContext",
"&",
"Context",
",",
"const",
"DataLayout",
"&",
"DL",
",",
"EVT",
"VT",
",",
"unsigned",
"AddrSpace",
","
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 620,048 | [
"false",
";"
] | [
"if",
"(",
"IsaInfo",
"::",
"hasCodeObjectV3",
"(",
"&",
"getSTI",
"(",
")",
")",
")",
"{",
"if",
"(",
"!",
"getTargetStreamer",
"(",
")",
".",
"EmitHSAMetadataV3",
"(",
"HSAMetadataString",
")",
")",
"return",
"Error",
"(",
"getParser",
"(",
")",
".",
"getTok",
"(",
")",
".",
"getLoc",
"(",
")",
",",
"<STR_LIT>",
"invalid HSA metadata",
"<STR_LIT>",
")",
";",
"}",
"else",
"{",
"if",
"(",
"!",
"getTargetStreamer",
"(",
")",
".",
"EmitHSAMetadataV2",
"(",
"HSAMetadataString",
")",
")",
"return",
"Error",
"(",
"getParser",
"(",
")",
".",
"getTok",
"(",
")",
".",
"getLoc",
"(",
")",
",",
"<STR_LIT>",
"invalid HSA metadata",
"<STR_LIT>",
")",
";",
"}",
"return"
] |
LLVM | SystemZ | CPP | stmt_completion | CPU | 620,049 | [
"(",
"<NUM_LIT>",
")",
";"
] | [
"}",
"SmallVector",
"<",
"CCValAssign",
",",
"<NUM_LIT>",
">",
"ArgLocs",
";",
"SystemZCCState",
"ArgCCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"MF",
",",
"ArgLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"ArgCCInfo",
".",
"AnalyzeCallOperands",
"(",
"Outs",
",",
"CC_SystemZ",
")",
";",
"if",
"(",
"IsTailCall",
"&&",
"!",
"canUseSiblingCall",
"(",
"ArgCCInfo",
",",
"ArgLocs",
",",
"Outs",
")",
")",
"IsTailCall",
"=",
"false",
";",
"unsigned",
"NumBytes",
"=",
"ArgCCInfo",
".",
"getNextStackOffset",
"(",
")",
";",
"if",
"(",
"!",
"IsTailCall",
")",
"Chain",
"=",
"DAG",
".",
"getCALLSEQ_START",
"(",
"Chain",
",",
"NumBytes",
",",
"<NUM_LIT>",
",",
"DL",
")",
";",
"SmallVector",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"SDValue",
">",
",",
"<NUM_LIT>",
">",
"RegsToPass",
";",
"SmallVector",
"<",
"SDValue",
",",
"<NUM_LIT>",
">",
"MemOpChains",
";",
"SDValue",
"StackPtr",
";",
"for",
"(",
"unsigned",
"I",
"=",
"<NUM_LIT>",
",",
"E",
"=",
"ArgLocs",
".",
"size",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"CCValAssign",
"&",
"VA",
"=",
"ArgLocs",
"[",
"I",
"]",
";",
"SDValue",
"ArgValue",
"=",
"OutVals",
"[",
"I",
"]",
";",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"Indirect",
")",
"{",
"SDValue",
"SpillSlot",
"=",
"DAG",
".",
"CreateStackTemporary",
"(",
"Outs",
"[",
"I",
"]",
".",
"ArgVT",
")",
";",
"int",
"FI",
"=",
"cast",
"<",
"FrameIndexSDNode",
">",
"(",
"SpillSlot",
")",
"->",
"getIndex",
"(",
")",
";",
"MemOpChains",
".",
"push_back",
"(",
"DAG",
".",
"getStore",
"(",
"Chain",
",",
"DL",
",",
"ArgValue",
",",
"SpillSlot",
",",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"FI",
")",
")",
")",
";",
"unsigned",
"ArgIndex",
"=",
"Outs",
"[",
"I",
"]",
".",
"OrigArgIndex",
";",
"assert",
"(",
"Outs",
"[",
"I",
"]",
".",
"PartOffset",
"==",
"<NUM_LIT>",
")",
";",
"while",
"(",
"I",
"+",
"<NUM_LIT>",
"!=",
"E",
"&&",
"Outs",
"[",
"I",
"+",
"<NUM_LIT>",
"]",
".",
"OrigArgIndex",
"==",
"ArgIndex",
")",
"{",
"SDValue",
"PartValue",
"=",
"OutVals",
"[",
"I",
"+",
"<NUM_LIT>",
"]",
";",
"unsigned",
"PartOffset",
"=",
"Outs",
"[",
"I",
"+",
"<NUM_LIT>",
"]",
".",
"PartOffset",
";",
"SDValue",
"Address",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"PtrVT",
",",
"SpillSlot",
",",
"DAG",
".",
"getIntPtrConstant",
"(",
"PartOffset",
",",
"DL",
")",
")",
";",
"MemOpChains",
".",
"push_back",
"(",
"DAG",
".",
"getStore",
"(",
"Chain",
",",
"DL",
",",
"PartValue",
",",
"Address",
",",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"FI",
")",
")",
")",
";",
"++",
"I",
";",
"}",
"ArgValue",
"=",
"SpillSlot",
";",
"}",
"else",
"ArgValue",
"=",
"convertValVTToLocVT",
"(",
"DAG",
",",
"DL",
",",
"VA",
",",
"ArgValue",
")",
";",
"if",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
")",
"RegsToPass",
".",
"push_back",
"(",
"std",
"::",
"make_pair",
"(",
"VA",
".",
"getLocReg",
"(",
")",
",",
"ArgValue",
")",
")",
";",
"else",
"{",
"assert",
"(",
"VA",
".",
"isMemLoc",
"(",
")",
"&&",
"<STR_LIT>",
"Argument not register or memory",
"<STR_LIT>",
")",
";",
"if",
"(",
"!",
"StackPtr",
".",
"getNode",
"(",
")",
")",
"StackPtr",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"DL",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"PtrVT",
")",
";",
"unsigned",
"Offset",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"+",
"VA",
".",
"getLocMemOffset",
"(",
")",
";",
"if",
"(",
"VA",
".",
"getLocVT",
"(",
")",
"==",
"MVT",
"::",
"i32",
"||",
"VA",
".",
"getLocVT",
"(",
")",
"==",
"MVT",
"::",
"f32",
")",
"Offset",
"+=",
"<NUM_LIT>",
";",
"SDValue",
"Address",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"PtrVT",
",",
"StackPtr",
",",
"DAG",
".",
"getIntPtrConstant",
"(",
"Offset",
",",
"DL",
")",
")",
";",
"MemOpChains",
".",
"push_back",
"(",
"DAG",
".",
"getStore",
"(",
"Chain",
",",
"DL",
",",
"ArgValue",
",",
"Address",
",",
"MachinePointerInfo",
"(",
")",
")",
")",
";",
"}",
"}",
"if",
"(",
"!",
"MemOpChains",
".",
"empty",
"(",
")",
")",
"Chain",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TokenFactor",
",",
"DL",
",",
"MVT",
"::",
"Other",
",",
"MemOpChains",
")",
";",
"SDValue",
"Glue",
";",
"if",
"(",
"auto",
"*",
"G",
"=",
"dyn_cast",
"<",
"GlobalAddressSDNode",
">",
"(",
"Callee",
")",
")",
"{",
"Callee",
"=",
"DAG",
".",
"getTargetGlobalAddress",
"(",
"G",
"->",
"getGlobal",
"(",
")",
",",
"DL",
",",
"PtrVT",
")",
";",
"Callee",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"PtrVT",
",",
"Callee",
")",
";",
"}",
"else",
"if",
"(",
"auto",
"*",
"E",
"=",
"dyn_cast",
"<",
"ExternalSymbolSDNode",
">",
"(",
"Callee",
")",
")",
"{",
"Callee",
"=",
"DAG",
".",
"getTargetExternalSymbol",
"(",
"E",
"->",
"getSymbol",
"(",
")",
",",
"PtrVT",
")",
";",
"Callee",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"PtrVT",
",",
"Callee",
")",
";",
"}",
"else",
"if",
"(",
"IsTailCall",
")",
"{",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"DL",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"Callee",
",",
"Glue",
")",
";",
"Glue",
"=",
"Chain",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
";",
"Callee",
"=",
"DAG",
".",
"getRegister",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"Callee",
".",
"getValueType",
"(",
")",
")",
";",
"}",
"for",
"(",
"unsigned",
"I",
"=",
"<NUM_LIT>",
",",
"E",
"=",
"RegsToPass",
".",
"size",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"DL",
",",
"RegsToPass",
"[",
"I",
"]",
".",
"first",
",",
"RegsToPass",
"[",
"I",
"]",
".",
"second",
",",
"Glue",
")",
";",
"Glue",
"=",
"Chain",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
";",
"}",
"SmallVector",
"<",
"SDValue",
",",
"<NUM_LIT>",
">",
"Ops",
";",
"Ops",
".",
"push_back",
"(",
"Chain",
")",
";",
"Ops",
".",
"push_back",
"(",
"Callee",
")",
";",
"for",
"(",
"unsigned",
"I",
"=",
"<NUM_LIT>",
",",
"E",
"=",
"RegsToPass",
".",
"size",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"Ops",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"RegsToPass",
"[",
"I",
"]",
".",
"first",
",",
"RegsToPass",
"[",
"I",
"]",
".",
"second",
".",
"getValueType",
"(",
")",
")",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"Subtarget",
".",
"getRegisterInfo",
"(",
")",
";",
"const",
"uint32_t",
"*",
"Mask",
"=",
"TRI",
"->",
"getCallPreservedMask",
"(",
"MF",
",",
"CallConv",
")",
";",
"assert",
"(",
"Mask",
"&&",
"<STR_LIT>",
"Missing call preserved mask for calling convention",
"<STR_LIT>",
")",
";",
"Ops",
".",
"push_back",
"(",
"DAG",
".",
"getRegisterMask",
"(",
"Mask",
")",
")",
";",
"if",
"(",
"Glue",
".",
"getNode",
"(",
")",
")",
"Ops",
".",
"push_back",
"(",
"Glue",
")",
";",
"SDVTList",
"NodeTys",
"=",
"DAG",
".",
"getVTList",
"(",
"MVT",
"::",
"Other",
",",
"MVT",
"::",
"Glue",
")",
";",
"if",
"(",
"IsTailCall",
")",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"NodeTys",
",",
"Ops",
")",
";",
"Chain",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"NodeTys",
",",
"Ops",
")",
";",
"DAG",
".",
"addNoMergeSiteInfo",
"(",
"Chain",
".",
"getNode",
"(",
")",
",",
"CLI",
".",
"NoMerge",
")",
";",
"Glue",
"=",
"Chain",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCALLSEQ_END",
"(",
"Chain",
",",
"DAG",
".",
"getConstant",
"(",
"NumBytes",
",",
"DL",
",",
"PtrVT",
",",
"true",
")",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"PtrVT",
",",
"true",
")",
",",
"Glue",
",",
"DL",
")",
";",
"Glue",
"=",
"Chain",
".",
"getValue"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 620,050 | [
";"
] | [
"def",
"tc_9ad9998f",
":",
"InstrItinClass"
] |
LLVM | PowerPC | TD | program_repair | CPU | 620,051 | [
"<FIXS>",
"bits",
"<NUM_LIT>",
">",
"RST",
";",
"<FIXE>"
] | [
"class",
"MLS_DForm_R_SI34_RTA5_MEM",
"bits",
"<NUM_LIT>",
">",
"opcode",
",",
"dag",
"OOL",
",",
"dag",
"IOL",
",",
"string",
"asmstr",
",",
"InstrItinClass",
"itin",
",",
"list",
"dag",
">",
"pattern",
">",
":",
"PI",
"<NUM_LIT>",
",",
"opcode",
",",
"OOL",
",",
"IOL",
",",
"asmstr",
",",
"itin",
">",
"{",
"<BUGS>",
"bits",
"<NUM_LIT>",
">",
"FRS",
";",
"<BUGE>",
"bits",
"<NUM_LIT>",
">",
"D_RA",
";",
"let",
"Pattern",
"=",
"pattern",
";"
] |
GCC | rs6000 | CPP | program_repair | CPU | 620,052 | [
"<FIXS>",
"rs6000_regno_regclass",
"[",
"CA_REGNO",
"]",
"=",
"CA_REGS",
";",
"<FIXE>"
] | [
"rs6000_regno_regclass",
"[",
"MQ_REGNO",
"]",
"=",
"MQ_REGS",
";",
"rs6000_regno_regclass",
"[",
"LR_REGNO",
"]",
"=",
"LINK_REGS",
";",
"rs6000_regno_regclass",
"[",
"CTR_REGNO",
"]",
"=",
"CTR_REGS",
";",
"<BUGS>",
"rs6000_regno_regclass",
"[",
"XER_REGNO",
"]",
"=",
"XER_REGS",
";",
"<BUGE>",
"rs6000_regno_regclass",
"[",
"VRSAVE_REGNO",
"]",
"=",
"VRSAVE_REGS",
";",
"rs6000_regno_regclass",
"[",
"VSCR_REGNO",
"]",
"=",
"VRSAVE_REGS",
";",
"rs6000_regno_regclass",
"[",
"SPE_ACC_REGNO",
"]",
"=",
"SPE_ACC_REGS",
";"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 620,053 | [
"splitBlockLiveIns",
"(",
"MBB",
",",
"MI",
",",
"*",
"LoopBB",
",",
"*",
"RemainderBB",
",",
"Save",
",",
"*",
"Idx",
")",
";"
] | [
"if",
"(",
"AMDGPU",
"::",
"SReg_32RegClass",
".",
"contains",
"(",
"Idx",
"->",
"getReg",
"(",
")",
")",
")",
"{",
"if",
"(",
"Offset",
"!=",
"<NUM_LIT>",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_ADD_I32",
")",
",",
"AMDGPU",
"::",
"M0",
")",
".",
"addReg",
"(",
"Idx",
"->",
"getReg",
"(",
")",
",",
"getUndefRegState",
"(",
"Idx",
"->",
"isUndef",
"(",
")",
")",
")",
".",
"addImm",
"(",
"Offset",
")",
";",
"}",
"else",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_MOV_B32",
")",
",",
"AMDGPU",
"::",
"M0",
")",
".",
"addReg",
"(",
"Idx",
"->",
"getReg",
"(",
")",
",",
"getUndefRegState",
"(",
"Idx",
"->",
"isUndef",
"(",
")",
")",
")",
";",
"}",
"MBB",
".",
"insert",
"(",
"I",
",",
"MovRel",
")",
";",
"MI",
".",
"eraseFromParent",
"(",
")",
";",
"return",
"false",
";",
"}",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"MachineOperand",
"*",
"SaveOp",
"=",
"TII",
"->",
"getNamedOperand",
"(",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"sdst",
")",
";",
"SaveOp",
"->",
"setIsDead",
"(",
"false",
")",
";",
"unsigned",
"Save",
"=",
"SaveOp",
"->",
"getReg",
"(",
")",
";",
"assert",
"(",
"AMDGPU",
"::",
"SReg_64RegClass",
".",
"contains",
"(",
"Save",
")",
"&&",
"AMDGPU",
"::",
"VGPR_32RegClass",
".",
"contains",
"(",
"Idx",
"->",
"getReg",
"(",
")",
")",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_MOV_B64",
")",
",",
"Save",
")",
".",
"addReg",
"(",
"AMDGPU",
"::",
"EXEC",
")",
";",
"MachineBasicBlock",
"*",
"LoopBB",
"=",
"MF",
".",
"CreateMachineBasicBlock",
"(",
")",
";",
"MachineBasicBlock",
"*",
"RemainderBB",
"=",
"MF",
".",
"CreateMachineBasicBlock",
"(",
")",
";",
"MachineFunction",
"::",
"iterator",
"MBBI",
"(",
"MBB",
")",
";",
"++",
"MBBI",
";",
"MF",
".",
"insert",
"(",
"MBBI",
",",
"LoopBB",
")",
";",
"MF",
".",
"insert",
"(",
"MBBI",
",",
"RemainderBB",
")",
";",
"LoopBB",
"->",
"addSuccessor",
"(",
"LoopBB",
")",
";",
"LoopBB",
"->",
"addSuccessor",
"(",
"RemainderBB",
")",
";"
] |
LLVM | SystemZ | CPP | code_generation | CPU | 620,054 | [
"bool",
"SystemZInstrInfo",
"::",
"PredicateInstruction",
"(",
"MachineInstr",
"&",
"MI",
",",
"ArrayRef",
"<",
"MachineOperand",
">",
"Pred",
")",
"const",
"{",
"assert",
"(",
"Pred",
".",
"size",
"(",
")",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Invalid condition",
"<STR_LIT>",
")",
";",
"unsigned",
"CCValid",
"=",
"Pred",
"[",
"<NUM_LIT>",
"]",
".",
"getImm",
"(",
")",
";",
"unsigned",
"CCMask",
"=",
"Pred",
"[",
"<NUM_LIT>",
"]",
".",
"getImm",
"(",
")",
";",
"assert",
"(",
"CCMask",
">",
"<NUM_LIT>",
"&&",
"CCMask",
"<",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Invalid predicate",
"<STR_LIT>",
")",
";",
"unsigned",
"Opcode",
"=",
"MI",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"Opcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"MI",
".",
"setDesc",
"(",
"get",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"MachineInstrBuilder",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
",",
"MI",
")",
".",
"addImm",
"(",
"CCValid",
")",
".",
"addImm",
"(",
"CCMask",
")",
".",
"addReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"RegState",
"::",
"Implicit",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Opcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"||",
"Opcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"MI",
".",
"setDesc",
"(",
"get",
"(",
"Opcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"MachineInstrBuilder",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
",",
"MI",
")",
".",
"addImm",
"(",
"CCValid",
")",
".",
"addImm",
"(",
"CCMask",
")",
".",
"addReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"RegState",
"::",
"Implicit",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Opcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"MachineOperand",
"FirstOp",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"const",
"uint32_t",
"*",
"RegMask",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getRegMask",
"(",
")",
";",
"MI",
".",
"removeOperand",
"(",
"<NUM_LIT>",
")",
";",
"MI",
".",
"removeOperand",
"(",
"<NUM_LIT>",
")",
";",
"MI",
".",
"setDesc",
"(",
"get",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"MachineInstrBuilder",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
",",
"MI",
")",
".",
"addImm",
"(",
"CCValid",
")",
".",
"addImm",
"(",
"CCMask",
")",
".",
"add",
"(",
"FirstOp",
")",
".",
"addRegMask",
"(",
"RegMask",
")",
".",
"addReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"RegState",
"::",
"Implicit",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Opcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"MachineOperand",
"Target",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"const",
"uint32_t",
"*",
"RegMask",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getRegMask",
"(",
")",
";",
"MI",
".",
"removeOperand",
"(",
"<NUM_LIT>",
")",
";",
"MI",
".",
"removeOperand",
"(",
"<NUM_LIT>",
")",
";",
"MI",
".",
"setDesc",
"(",
"get",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"MachineInstrBuilder",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
",",
"MI",
")",
".",
"addImm",
"(",
"CCValid",
")",
".",
"addImm",
"(",
"CCMask",
")",
".",
"add",
"(",
"Target",
")",
".",
"addRegMask",
"(",
"RegMask",
")",
".",
"addReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"RegState",
"::",
"Implicit",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] | [
"Convert",
"the",
"instruction",
"into",
"a",
"predicated",
"instruction",
"."
] |
GCC | powerpcspe | CPP | next_suggestion | CPU | 620,055 | [
"return",
"r",
";"
] | [
"static",
"_",
"_",
"inline__",
"double",
"_",
"_",
"fmadd",
"(",
"double",
"x",
",",
"double",
"y",
",",
"double",
"z",
")",
"{",
"double",
"r",
";",
"_",
"_",
"asm__",
"(",
"<STR_LIT>",
"fmadd %0,%1,%2,%3",
"<STR_LIT>",
":",
"<STR_LIT>",
"=d",
"<STR_LIT>",
"(",
"r",
")",
":",
"<STR_LIT>",
"d",
"<STR_LIT>",
"(",
"x",
")",
",",
"<STR_LIT>",
"d",
"<STR_LIT>",
"(",
"y",
")",
",",
"<STR_LIT>",
"d",
"<STR_LIT>",
"(",
"z",
")",
")",
";"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 620,056 | [
"}"
] | [
"switch",
"(",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"Opcode",
")",
"{",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"break",
";",
"NODE_NAME_CASE",
"(",
"CALL",
")",
";",
"NODE_NAME_CASE",
"(",
"UMUL",
")",
";",
"NODE_NAME_CASE",
"(",
"BRANCH_COND",
")",
";",
"NODE_NAME_CASE",
"(",
"ENDPGM",
")",
"NODE_NAME_CASE",
"(",
"RETURN",
")",
"NODE_NAME_CASE",
"(",
"DWORDADDR",
")",
"NODE_NAME_CASE",
"(",
"FRACT",
")",
"NODE_NAME_CASE",
"(",
"CLAMP",
")",
"NODE_NAME_CASE",
"(",
"COS_HW",
")",
"NODE_NAME_CASE",
"(",
"SIN_HW",
")",
"NODE_NAME_CASE",
"(",
"FMAX_LEGACY",
")",
"NODE_NAME_CASE",
"(",
"FMIN_LEGACY",
")",
"NODE_NAME_CASE",
"(",
"FMAX3",
")",
"NODE_NAME_CASE",
"(",
"SMAX3",
")",
"NODE_NAME_CASE",
"(",
"UMAX3",
")",
"NODE_NAME_CASE",
"(",
"FMIN3",
")",
"NODE_NAME_CASE",
"(",
"SMIN3",
")",
"NODE_NAME_CASE",
"(",
"UMIN3",
")",
"NODE_NAME_CASE",
"(",
"FMED3",
")",
"NODE_NAME_CASE",
"(",
"SMED3",
")",
"NODE_NAME_CASE",
"(",
"UMED3",
")",
"NODE_NAME_CASE",
"(",
"URECIP",
")",
"NODE_NAME_CASE",
"(",
"DIV_SCALE",
")",
"NODE_NAME_CASE",
"(",
"DIV_FMAS",
")",
"NODE_NAME_CASE",
"(",
"DIV_FIXUP",
")",
"NODE_NAME_CASE",
"(",
"TRIG_PREOP",
")",
"NODE_NAME_CASE",
"(",
"RCP",
")",
"NODE_NAME_CASE",
"(",
"RSQ",
")",
"NODE_NAME_CASE",
"(",
"RSQ_LEGACY",
")",
"NODE_NAME_CASE",
"(",
"RSQ_CLAMP",
")",
"NODE_NAME_CASE",
"(",
"LDEXP",
")",
"NODE_NAME_CASE",
"(",
"FP_CLASS",
")",
"NODE_NAME_CASE",
"(",
"DOT4",
")",
"NODE_NAME_CASE",
"(",
"CARRY",
")",
"NODE_NAME_CASE",
"(",
"BORROW",
")",
"NODE_NAME_CASE",
"(",
"BFE_U32",
")",
"NODE_NAME_CASE",
"(",
"BFE_I32",
")",
"NODE_NAME_CASE",
"(",
"BFI",
")",
"NODE_NAME_CASE",
"(",
"BFM",
")",
"NODE_NAME_CASE",
"(",
"FFBH_U32",
")",
"NODE_NAME_CASE",
"(",
"MUL_U24",
")",
"NODE_NAME_CASE",
"(",
"MUL_I24",
")",
"NODE_NAME_CASE",
"(",
"MAD_U24",
")",
"NODE_NAME_CASE",
"(",
"MAD_I24",
")",
"NODE_NAME_CASE",
"(",
"TEXTURE_FETCH",
")",
"NODE_NAME_CASE",
"(",
"EXPORT",
")",
"NODE_NAME_CASE",
"(",
"CONST_ADDRESS",
")",
"NODE_NAME_CASE",
"(",
"REGISTER_LOAD",
")",
"NODE_NAME_CASE",
"(",
"REGISTER_STORE",
")",
"NODE_NAME_CASE",
"(",
"LOAD_INPUT",
")",
"NODE_NAME_CASE",
"(",
"SAMPLE",
")",
"NODE_NAME_CASE",
"(",
"SAMPLEB",
")",
"NODE_NAME_CASE",
"(",
"SAMPLED",
")",
"NODE_NAME_CASE",
"(",
"SAMPLEL",
")",
"NODE_NAME_CASE",
"(",
"CVT_F32_UBYTE0",
")",
"NODE_NAME_CASE",
"(",
"CVT_F32_UBYTE1",
")",
"NODE_NAME_CASE",
"(",
"CVT_F32_UBYTE2",
")",
"NODE_NAME_CASE",
"(",
"CVT_F32_UBYTE3",
")",
"NODE_NAME_CASE",
"(",
"BUILD_VERTICAL_VECTOR",
")",
"NODE_NAME_CASE",
"(",
"CONST_DATA_PTR",
")",
"NODE_NAME_CASE",
"(",
"PC_ADD_REL_OFFSET",
")",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"break",
";",
"NODE_NAME_CASE",
"(",
"SENDMSG",
")",
"NODE_NAME_CASE",
"(",
"INTERP_MOV",
")",
"NODE_NAME_CASE",
"(",
"INTERP_P1",
")",
"NODE_NAME_CASE",
"(",
"INTERP_P2",
")",
"NODE_NAME_CASE",
"(",
"STORE_MSKOR",
")",
"NODE_NAME_CASE",
"(",
"LOAD_CONSTANT",
")",
"NODE_NAME_CASE",
"(",
"TBUFFER_STORE_FORMAT",
")",
"NODE_NAME_CASE",
"(",
"ATOMIC_CMP_SWAP",
")",
"NODE_NAME_CASE",
"(",
"ATOMIC_INC",
")",
"NODE_NAME_CASE",
"(",
"ATOMIC_DEC",
")",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"break",
";",
"}",
"return",
"nullptr",
";"
] |
GCC | arm | MD | stmt_completion | CPU | 620,057 | [
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
] | [
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"plus",
":",
"SI",
"(",
"plus",
":",
"SI",
"("
] |
LLVM | SystemZ | CPP | next_suggestion | CPU | 620,058 | [
"}",
"else",
"if",
"(",
"RC",
"==",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{"
] | [
"if",
"(",
"RC",
"==",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
"||",
"RC",
"==",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"else",
"if",
"(",
"RC",
"==",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
"||",
"RC",
"==",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"}",
"else",
"if",
"(",
"RC",
"==",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"}",
"else",
"if",
"(",
"RC",
"==",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"}",
"else",
"if",
"(",
"RC",
"==",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 620,059 | [
"}"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"hasNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"CextOpcode",
"=",
"<STR_LIT>",
";",
"let",
"InputType",
"=",
"<STR_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentAlign",
"=",
"<NUM_LIT>",
";"
] |
GCC | sparc | CPP | stmt_completion | CPU | 620,060 | [
"B",
")",
";"
] | [
"extern",
"_",
"_",
"inline",
"long",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"_",
"vis_fpcmpugt16",
"(",
"_",
"_",
"v4hi",
"_",
"_",
"A",
",",
"_",
"_",
"v4hi",
"_",
"_",
"B",
")",
"{",
"return",
"_",
"_",
"builtin_vis_fpcmpugt16",
"(",
"_",
"_",
"A",
",",
"_",
"_"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 620,061 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rn",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"size",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"size2",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opcode",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
LLVM | Mips | TD | stmt_completion | CPU | 620,062 | [
",",
"<NUM_LIT>",
">",
";"
] | [
"class",
"PCKEV_W_ENC",
":",
"MSA_3R_FMT",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>"
] |
GCC | mips | MD | next_suggestion | CPU | 620,063 | [
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"TF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"TF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>"
] |
GCC | sparc | MD | next_suggestion | CPU | 620,064 | [
"operands",
"[",
"<NUM_LIT>",
"]",
"=",
"const0_rtx"
] | [
"{",
"operands",
"[",
"<NUM_LIT>",
"]",
"=",
"gen_compare_reg",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"if",
"(",
"GET_MODE",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"!",
"=",
"CCmode",
"&",
"&",
"GET_MODE",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"!",
"=",
"CCXmode",
")",
"FAIL"
] |
GCC | rs6000 | CPP | stmt_completion | CPU | 620,065 | [
"_",
"A",
"-",
"(",
"_",
"_",
"v16qu",
")",
"_",
"_",
"B",
")",
";"
] | [
"return",
"(",
"_",
"_",
"m128i",
")",
"(",
"(",
"_",
"_",
"v16qu",
")",
"_"
] |
GCC | arm | MD | stmt_completion | CPU | 620,066 | [
")",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"ior",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"not",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")"
] |
LLVM | Hexagon | CPP | stmt_completion | DSP | 620,067 | [
"<STR_LIT>",
")",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
";"
] | [
"return",
"(",
"F",
">>",
"<STR_LIT>",
"::"
] |
LLVM | WebAssembly | CPP | stmt_completion | Virtual ISA | 620,068 | [
")",
"return",
";"
] | [
"if",
"(",
"TargetRegisterInfo",
"::",
"virtReg2Index",
"(",
"VReg",
")",
">=",
"VRegStackified",
".",
"size",
"(",
")"
] |
LLVM | ARM | TD | next_suggestion | CPU | 620,069 | [
"}"
] | [
"def",
"c_imm",
":",
"Operand",
"<",
"i32",
">",
"{",
"let",
"PrintMethod",
"=",
"<STR_LIT>",
";",
"let",
"ParserMatchClass",
"=",
"CoprocRegAsmOperand",
";"
] |
GCC | mips | CPP | code_generation | CPU | 620,070 | [
"int",
"mips_split_const_insns",
"(",
"rtx",
"x",
")",
"{",
"unsigned",
"int",
"low",
",",
"high",
";",
"low",
"=",
"mips_const_insns",
"(",
"mips_subword",
"(",
"x",
",",
"false",
")",
")",
";",
"high",
"=",
"mips_const_insns",
"(",
"mips_subword",
"(",
"x",
",",
"true",
")",
")",
";",
"gcc_assert",
"(",
"low",
">",
"<NUM_LIT>",
"&&",
"high",
">",
"<NUM_LIT>",
")",
";",
"return",
"low",
"+",
"high",
";",
"}"
] | [
"X",
"is",
"a",
"doubleword",
"constant",
"that",
"can",
"be",
"handled",
"by",
"splitting",
"it",
"into",
"two",
"words",
"and",
"loading",
"each",
"word",
"separately",
".",
"Return",
"the",
"number",
"of",
"instructions",
"required",
"to",
"do",
"this",
",",
"assuming",
"that",
"BASE_INSN_LENGTH",
"is",
"the",
"length",
"of",
"one",
"instruction",
"."
] |
GCC | i386 | MD | stmt_completion | CPU | 620,071 | [
")"
] | [
"(",
"define_cpu_unit",
"<STR_LIT>",
"<STR_LIT>"
] |
GCC | i386 | MD | next_suggestion | CPU | 620,072 | [
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"unspec_volatile",
"[",
"(",
"match_operand",
":",
"P",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPECV_CLZERO",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | s390 | MD | next_suggestion | MPU | 620,073 | [
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"<STR_LIT>",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
LLVM | Hexagon | CPP | stmt_completion | DSP | 620,074 | [
"to_ulong",
"(",
")",
")",
";"
] | [
"MCI",
".",
"getOperand",
"(",
"MCI",
".",
"getNumOperands",
"(",
")",
"-",
"<NUM_LIT>",
")",
".",
"setImm",
"(",
"Bits",
"."
] |
LLVM | ARM64 | TD | next_suggestion | CPU | 620,075 | [
"}"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"imm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"cond",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rn",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"nzcv",
";"
] |
GCC | s390 | CPP | next_suggestion | MPU | 620,076 | [
"machine_mode",
"half_mode",
"=",
"(",
"inner_mode",
"==",
"SFmode",
"?",
"V2SFmode",
":",
"V2SImode",
")",
";"
] | [
"void",
"s390_expand_vec_init",
"(",
"rtx",
"target",
",",
"rtx",
"vals",
")",
"{",
"machine_mode",
"mode",
"=",
"GET_MODE",
"(",
"target",
")",
";",
"machine_mode",
"inner_mode",
"=",
"GET_MODE_INNER",
"(",
"mode",
")",
";",
"int",
"n_elts",
"=",
"GET_MODE_NUNITS",
"(",
"mode",
")",
";",
"bool",
"all_same",
"=",
"true",
",",
"all_regs",
"=",
"true",
",",
"all_const_int",
"=",
"true",
";",
"rtx",
"x",
";",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"n_elts",
";",
"++",
"i",
")",
"{",
"x",
"=",
"XVECEXP",
"(",
"vals",
",",
"<NUM_LIT>",
",",
"i",
")",
";",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"x",
")",
")",
"all_const_int",
"=",
"false",
";",
"if",
"(",
"i",
">",
"<NUM_LIT>",
"&&",
"!",
"rtx_equal_p",
"(",
"x",
",",
"XVECEXP",
"(",
"vals",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
")",
"all_same",
"=",
"false",
";",
"if",
"(",
"!",
"REG_P",
"(",
"x",
")",
")",
"all_regs",
"=",
"false",
";",
"}",
"if",
"(",
"all_same",
"&&",
"all_const_int",
")",
"{",
"rtx",
"vec",
"=",
"gen_rtx_CONST_VECTOR",
"(",
"mode",
",",
"XVEC",
"(",
"vals",
",",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"XVECEXP",
"(",
"vals",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
"==",
"const0_rtx",
"||",
"s390_contiguous_bitmask_vector_p",
"(",
"vec",
",",
"NULL",
",",
"NULL",
")",
"||",
"s390_bytemask_vector_p",
"(",
"vec",
",",
"NULL",
")",
")",
"{",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"target",
",",
"vec",
")",
")",
";",
"return",
";",
"}",
"}",
"if",
"(",
"all_same",
")",
"{",
"rtx",
"elem",
"=",
"XVECEXP",
"(",
"vals",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"!",
"general_operand",
"(",
"elem",
",",
"GET_MODE",
"(",
"elem",
")",
")",
")",
"elem",
"=",
"force_reg",
"(",
"inner_mode",
",",
"elem",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"target",
",",
"gen_rtx_VEC_DUPLICATE",
"(",
"mode",
",",
"elem",
")",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"all_regs",
"&&",
"REG_P",
"(",
"target",
")",
"&&",
"n_elts",
"==",
"<NUM_LIT>",
"&&",
"GET_MODE_SIZE",
"(",
"inner_mode",
")",
"==",
"<NUM_LIT>",
")",
"{",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"target",
",",
"gen_rtx_VEC_CONCAT",
"(",
"mode",
",",
"XVECEXP",
"(",
"vals",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
",",
"XVECEXP",
"(",
"vals",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"TARGET_VXE",
"&&",
"(",
"mode",
"==",
"V4SImode",
"||",
"mode",
"==",
"V4SFmode",
")",
")",
"{",
"bool",
"found",
"=",
"true",
";",
"x",
"=",
"XVECEXP",
"(",
"vals",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"memory_operand",
"(",
"x",
",",
"inner_mode",
")",
")",
"{",
"for",
"(",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"n_elts",
";",
"++",
"i",
")",
"found",
"=",
"found",
"&&",
"XVECEXP",
"(",
"vals",
",",
"<NUM_LIT>",
",",
"i",
")",
"==",
"const0_rtx",
";",
"if",
"(",
"found",
")",
"{"
] |
GCC | rs6000 | CPP | stmt_completion | CPU | 620,077 | [
"<NUM_LIT>",
")",
")",
"]",
")",
";"
] | [
"else",
"gcc_assert",
"(",
"!",
"TARGET_TOC",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
")",
"{",
"if",
"(",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"==",
"<NUM_LIT>",
")",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"%s,%s",
"<STR_LIT>",
",",
"reg_names",
"[",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"]",
",",
"reg_names",
"[",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"]",
")",
";",
"else",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"%s,%s",
"<STR_LIT>",
",",
"reg_names",
"[",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"]",
",",
"reg_names",
"[",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"]",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"==",
"CONST_INT",
")",
"fprintf",
"(",
"file",
",",
"HOST_WIDE_INT_PRINT_DEC",
"<STR_LIT>",
"(%s)",
"<STR_LIT>",
",",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
",",
"reg_names",
"[",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"]",
")",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"LO_SUM",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"&&",
"CONSTANT_P",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
")",
"{",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"lo16(",
"<STR_LIT>",
")",
";",
"output_addr_const",
"(",
"file",
",",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
";",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
")(%s)",
"<STR_LIT>",
",",
"reg_names",
"[",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"]",
")",
";",
"}",
"else",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"LO_SUM",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"&&",
"CONSTANT_P",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
")",
"{",
"output_addr_const",
"(",
"file",
",",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
";",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"@l(%s)",
"<STR_LIT>",
",",
"reg_names",
"[",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"]",
")",
";",
"}",
"else",
"if",
"(",
"toc_relative_expr_p",
"(",
"x",
",",
"false",
")",
")",
"{",
"output_addr_const",
"(",
"file",
",",
"CONST_CAST_RTX",
"(",
"tocrel_base",
")",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"LO_SUM",
")",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"@l(%s)",
"<STR_LIT>",
",",
"reg_names",
"[",
"REGNO",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"]",
")",
";",
"else",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"(%s)",
"<STR_LIT>",
",",
"reg_names",
"[",
"REGNO",
"(",
"XVECEXP",
"(",
"tocrel_base",
",",
"<NUM_LIT>",
","
] |
GCC | s390 | MD | stmt_completion | MPU | 620,078 | [
"<STR_LIT>",
"<STR_LIT>",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr"
] |
GCC | mcore | CPP | code_generation | MPU | 620,079 | [
"const",
"char",
"*",
"mcore_output_bseti",
"(",
"rtx",
"dst",
",",
"int",
"mask",
")",
"{",
"rtx",
"out_operands",
"[",
"<NUM_LIT>",
"]",
";",
"int",
"bit",
";",
"out_operands",
"[",
"<NUM_LIT>",
"]",
"=",
"dst",
";",
"for",
"(",
"bit",
"=",
"<NUM_LIT>",
";",
"bit",
"<",
"<NUM_LIT>",
";",
"bit",
"++",
")",
"{",
"if",
"(",
"(",
"mask",
"&",
"<NUM_LIT>",
")",
"==",
"<NUM_LIT>",
")",
"{",
"out_operands",
"[",
"<NUM_LIT>",
"]",
"=",
"GEN_INT",
"(",
"bit",
")",
";",
"output_asm_insn",
"(",
"<STR_LIT>",
"bseti\\t%0,%1",
"<STR_LIT>",
",",
"out_operands",
")",
";",
"}",
"mask",
">>=",
"<NUM_LIT>",
";",
"}",
"return",
"<STR_LIT>",
"<STR_LIT>",
";",
"}"
] | [
"Output",
"a",
"series",
"of",
"bseti",
"'s",
"corresponding",
"to",
"mask",
"."
] |
LLVM | X86 | CPP | next_suggestion | CPU | 620,080 | [
"}"
] | [
"I",
"->",
"setDesc",
"(",
"TII",
"->",
"get",
"(",
"Opcode",
")",
")",
";",
"if",
"(",
"Opcode",
"==",
"X86",
"::",
"UCOM_FPPr",
")",
"I",
"->",
"RemoveOperand",
"(",
"<NUM_LIT>",
")",
";",
"}",
"else",
"{",
"I",
"=",
"BuildMI",
"(",
"*",
"MBB",
",",
"++",
"I",
",",
"dl",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"ST_FPrr",
")",
")",
".",
"addReg",
"(",
"X86",
"::",
"ST0",
")",
";"
] |
LLVM | Sparc | CPP | next_suggestion | CPU | 620,081 | [
"return",
"MCAsmInfo",
"::",
"getExprForFDESymbol",
"(",
"Sym",
",",
"Encoding",
",",
"Streamer",
")",
";"
] | [
"return",
"SparcMCExpr",
"::",
"Create",
"(",
"SparcMCExpr",
"::",
"VK_Sparc_R_DISP32",
",",
"MCSymbolRefExpr",
"::",
"Create",
"(",
"Sym",
",",
"Ctx",
")",
",",
"Ctx",
")",
";",
"}"
] |
GCC | h8300 | MD | next_suggestion | MPU | 620,082 | [
"(",
"match_dup",
"<NUM_LIT>",
")",
")"
] | [
"[",
"(",
"set",
"(",
"mem",
":",
"SI",
"(",
"pre_dec",
":",
"SI",
"(",
"reg",
":",
"SI",
"SP_REG",
")",
")",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"set",
"(",
"mem",
":",
"SI",
"(",
"pre_dec",
":",
"SI",
"(",
"reg",
":",
"SI",
"SP_REG",
")",
")",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"set",
"(",
"mem",
":",
"SI",
"(",
"pre_dec",
":",
"SI",
"(",
"reg",
":",
"SI",
"SP_REG",
")",
")",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"set",
"(",
"mem",
":",
"SI",
"(",
"pre_dec",
":",
"SI",
"(",
"reg",
":",
"SI",
"SP_REG",
")",
")",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<STR_LIT>",
"[",
"(",
"parallel",
"[",
"(",
"set",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"reg",
":",
"SI",
"SP_REG",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
"(",
"set",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"reg",
":",
"SI",
"SP_REG",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 620,083 | [
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"hasNewValue",
"="
] |
LLVM | ARM | CPP | stmt_completion | CPU | 620,084 | [
")",
";"
] | [
"TargetRegistry",
"::",
"RegisterMCInstPrinter",
"(",
"*",
"T",
",",
"createARMMCInstPrinter",
")",
";",
"TargetRegistry",
"::",
"RegisterMCRelocationInfo",
"(",
"*",
"T",
",",
"createARMMCRelocationInfo",
")",
";",
"}",
"for",
"(",
"Target",
"*",
"T",
":",
"{",
"&",
"getTheARMLETarget",
"(",
")",
",",
"&",
"getTheARMBETarget",
"(",
")",
"}",
")",
"TargetRegistry",
"::",
"RegisterMCInstrAnalysis",
"(",
"*",
"T",
",",
"createARMMCInstrAnalysis",
")",
";",
"for",
"(",
"Target",
"*",
"T",
":",
"{",
"&",
"getTheThumbLETarget",
"(",
")",
",",
"&",
"getTheThumbBETarget",
"(",
")",
"}",
")",
"TargetRegistry",
"::",
"RegisterMCInstrAnalysis",
"(",
"*",
"T",
",",
"createThumbMCInstrAnalysis",
")",
";",
"for",
"(",
"Target",
"*",
"T",
":",
"{",
"&",
"getTheARMLETarget",
"(",
")",
",",
"&",
"getTheThumbLETarget",
"(",
")",
"}",
")",
"TargetRegistry",
"::",
"RegisterMCCodeEmitter",
"(",
"*",
"T",
",",
"createARMLEMCCodeEmitter",
")",
";",
"for",
"(",
"Target",
"*",
"T",
":",
"{",
"&",
"getTheARMBETarget",
"(",
")",
",",
"&",
"getTheThumbBETarget",
"(",
")",
"}",
")",
"TargetRegistry",
"::",
"RegisterMCCodeEmitter",
"(",
"*",
"T",
",",
"createARMBEMCCodeEmitter",
")",
";",
"TargetRegistry",
"::",
"RegisterMCAsmBackend",
"(",
"getTheARMLETarget",
"(",
")",
",",
"createARMLEAsmBackend",
")",
";",
"TargetRegistry",
"::",
"RegisterMCAsmBackend",
"(",
"getTheARMBETarget",
"(",
")",
",",
"createARMBEAsmBackend",
")",
";",
"TargetRegistry",
"::",
"RegisterMCAsmBackend",
"(",
"getTheThumbLETarget",
"(",
")",
",",
"createThumbLEAsmBackend",
")",
";",
"TargetRegistry",
"::",
"RegisterMCAsmBackend",
"(",
"getTheThumbBETarget",
"(",
")",
",",
"createThumbBEAsmBackend"
] |
GCC | sparc | MD | next_suggestion | CPU | 620,085 | [
"<STR_LIT>",
")"
] | [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
] |
GCC | nds32 | CPP | stmt_completion | CPU | 620,086 | [
")",
";"
] | [
"asm_fprintf",
"(",
"f",
",",
"<STR_LIT>",
"\\tmfusr\\t$r16,$pc\\n",
"<STR_LIT>",
")",
";",
"asm_fprintf",
"(",
"f",
",",
"<STR_LIT>",
"\\tlwi\\t$r15,[$r16 + 20] ",
"<STR_LIT>",
"<STR_LIT>",
"! load nested function address\\n",
"<STR_LIT>",
")",
";",
"asm_fprintf",
"(",
"f",
",",
"<STR_LIT>",
"\\tlwi\\t$r16,[$r16 + 16] ",
"<STR_LIT>",
"<STR_LIT>",
"! load chain_value\\n",
"<STR_LIT>",
")",
";",
"asm_fprintf",
"(",
"f",
",",
"<STR_LIT>",
"\\tjr\\t$r15\\n",
"<STR_LIT>",
")",
";",
"}",
"asm_fprintf",
"(",
"f",
",",
"<STR_LIT>",
"\\t! space for saving chain_value\\n",
"<STR_LIT>",
")",
";",
"assemble_aligned_integer",
"(",
"UNITS_PER_WORD",
",",
"const0_rtx",
")",
";",
"asm_fprintf",
"(",
"f",
",",
"<STR_LIT>",
"\\t! space for saving nested function address\\n",
"<STR_LIT>",
")",
";",
"assemble_aligned_integer",
"(",
"UNITS_PER_WORD",
",",
"const0_rtx"
] |
GCC | i386 | CPP | next_suggestion | CPU | 620,087 | [
"}"
] | [
"static",
"_",
"_",
"inline",
"_",
"_",
"m128i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"always_inline__",
")",
")",
"_",
"mm_unpackhi_epi64",
"(",
"_",
"_",
"m128i",
"_",
"_",
"A",
",",
"_",
"_",
"m128i",
"_",
"_",
"B",
")",
"{",
"return",
"(",
"_",
"_",
"m128i",
")",
"_",
"_",
"builtin_ia32_punpckhqdq128",
"(",
"(",
"_",
"_",
"v2di",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v2di",
")",
"_",
"_",
"B",
")",
";"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 620,088 | [
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
",",
"DL",
",",
"VT",
",",
"HOp",
",",
"DAG",
".",
"getIntPtrConstant",
"(",
"<NUM_LIT>",
",",
"DL",
")",
")",
";"
] | [
"auto",
"HOpcode",
"=",
"Op",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"FADD",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"unsigned",
"LExtIndex",
"=",
"LHS",
".",
"getConstantOperandVal",
"(",
"<NUM_LIT>",
")",
";",
"unsigned",
"RExtIndex",
"=",
"RHS",
".",
"getConstantOperandVal",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"LExtIndex",
"==",
"<NUM_LIT>",
"&&",
"RExtIndex",
"==",
"<NUM_LIT>",
"&&",
"HOpcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"std",
"::",
"swap",
"(",
"LExtIndex",
",",
"RExtIndex",
")",
";",
"if",
"(",
"LExtIndex",
"!=",
"<NUM_LIT>",
"||",
"RExtIndex",
"!=",
"<NUM_LIT>",
")",
"return",
"Op",
";",
"SDValue",
"X",
"=",
"LHS",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"EVT",
"VecVT",
"=",
"X",
".",
"getValueType",
"(",
")",
";",
"unsigned",
"BitWidth",
"=",
"VecVT",
".",
"getSizeInBits",
"(",
")",
";",
"assert",
"(",
"(",
"BitWidth",
"==",
"<NUM_LIT>",
"||",
"BitWidth",
"==",
"<NUM_LIT>",
"||",
"BitWidth",
"==",
"<NUM_LIT>",
")",
"&&",
"<STR_LIT>",
"Not expecting illegal vector widths here",
"<STR_LIT>",
")",
";",
"SDLoc",
"DL",
"(",
"Op",
")",
";",
"if",
"(",
"BitWidth",
"==",
"<NUM_LIT>",
"||",
"BitWidth",
"==",
"<NUM_LIT>",
")",
"X",
"=",
"extract128BitVector",
"(",
"X",
",",
"<NUM_LIT>",
",",
"DAG",
",",
"DL",
")",
";",
"SDValue",
"HOp",
"=",
"DAG",
".",
"getNode",
"(",
"HOpcode",
",",
"DL",
",",
"X",
".",
"getValueType",
"(",
")",
",",
"X",
",",
"X",
")",
";"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 620,089 | [
"&&",
"Inst",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
"->",
"getType",
"(",
")",
"->",
"getIntegerBitWidth",
"(",
")",
"<=",
"ConsideredSExtType",
"->",
"getIntegerBitWidth",
"(",
")",
")",
"return",
"true",
";"
] | [
"if",
"(",
"isa",
"<",
"TruncInst",
">",
"(",
"Inst",
")",
"&&",
"isa",
"<",
"SExtInst",
">",
"(",
"Inst",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"{",
"const",
"Instruction",
"*",
"Opnd",
"=",
"cast",
"<",
"Instruction",
">",
"(",
"Inst",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"Inst",
"->",
"getType",
"(",
")",
"->",
"getIntegerBitWidth",
"(",
")",
">=",
"Opnd",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
"->",
"getType",
"(",
")",
"->",
"getIntegerBitWidth",
"(",
")"
] |
GCC | rs6000 | MD | stmt_completion | CPU | 620,090 | [
")",
")"
] | [
"(",
"define_predicate",
"<STR_LIT>",
"(",
"match_code",
"<STR_LIT>"
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 620,091 | [
"return",
"<STR_LIT>",
"::",
"<STR_LIT>",
";"
] | [
"case",
"<NUM_LIT>",
":",
"case",
"<NUM_LIT>",
":",
"case",
"<NUM_LIT>",
":",
"case",
"<NUM_LIT>",
":",
"return",
"MinNumElts",
";",
"case",
"<NUM_LIT>",
":",
"return",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"case",
"<NUM_LIT>",
":",
"return",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"case",
"<NUM_LIT>",
":",
"return",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"case",
"<NUM_LIT>",
":",
"return",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"case",
"<NUM_LIT>",
":"
] |
GCC | pa | MD | program_repair | CPU | 620,092 | [
"<FIXS>",
"[",
"(",
"set",
"(",
"reg",
":",
"SI",
"<NUM_LIT>",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"set",
"(",
"reg",
":",
"SI",
"<NUM_LIT>",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"<FIXE>"
] | [
"(",
"set",
"(",
"attr",
"<STR_LIT>",
")",
"(",
"symbol_ref",
"<STR_LIT>",
")",
")",
"]",
")",
"(",
"define_expand",
"<STR_LIT>",
"<BUGS>",
"[",
"(",
"set",
"(",
"reg",
":",
"SI",
"<NUM_LIT>",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"set",
"(",
"reg",
":",
"SI",
"<NUM_LIT>",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"<BUGE>",
"(",
"parallel",
"[",
"(",
"set",
"(",
"reg",
":",
"SI",
"<NUM_LIT>",
")",
"(",
"umod",
":",
"SI",
"(",
"reg",
":",
"SI",
"<NUM_LIT>",
")",
"(",
"reg",
":",
"SI",
"<NUM_LIT>",
")",
")",
")",
"(",
"clobber",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
"(",
"clobber",
"(",
"match_dup",
"<NUM_LIT>",
")",
")"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 620,093 | [
"=",
"<NUM_LIT>",
";"
] | [
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"P1",
"]",
";",
"let",
"Defs",
"=",
"[",
"P1",
",",
"PC",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable"
] |
LLVM | WebAssembly | CPP | program_repair | Virtual ISA | 620,094 | [
"<FIXS>",
"SDValue",
"NB",
";",
"if",
"(",
"NumBytes",
")",
"{",
"NB",
"=",
"DAG",
".",
"getConstant",
"(",
"NumBytes",
",",
"DL",
",",
"PtrVT",
",",
"true",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCALLSEQ_START",
"(",
"Chain",
",",
"NB",
",",
"DL",
")",
";",
"}",
"<FIXE>"
] | [
"unsigned",
"NumBytes",
"=",
"CCInfo",
".",
"getAlignedCallFrameSize",
"(",
")",
";",
"<BUGS>",
"auto",
"NB",
"=",
"DAG",
".",
"getConstant",
"(",
"NumBytes",
",",
"DL",
",",
"PtrVT",
",",
"true",
")",
";",
"Chain",
"=",
"DAG",
".",
"getCALLSEQ_START",
"(",
"Chain",
",",
"NB",
",",
"DL",
")",
";",
"<BUGE>",
"if",
"(",
"IsVarArg",
")",
"{"
] |
GCC | rs6000 | CPP | stmt_completion | CPU | 620,095 | [
"X",
",",
"_",
"_",
"Y",
")",
";"
] | [
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"pext_u32",
"(",
"unsigned",
"int",
"_",
"_",
"X",
",",
"unsigned",
"int",
"_",
"_",
"Y",
")",
"{",
"return",
"_",
"pext_u64",
"(",
"_",
"_"
] |
LLVM | WebAssembly | CPP | program_repair | Virtual ISA | 620,096 | [
"<FIXS>",
"case",
"WebAssembly",
"::",
"OPERAND_TAG",
":",
"<FIXE>"
] | [
"case",
"WebAssembly",
"::",
"OPERAND_OFFSET64",
":",
"case",
"WebAssembly",
"::",
"OPERAND_P2ALIGN",
":",
"case",
"WebAssembly",
"::",
"OPERAND_TYPEINDEX",
":",
"<BUGS>",
"case",
"WebAssembly",
"::",
"OPERAND_EVENT",
":",
"<BUGE>",
"case",
"MCOI",
"::",
"OPERAND_IMMEDIATE",
":",
"{",
"if",
"(",
"!",
"parseLEBImmediate",
"(",
"MI",
",",
"Size",
",",
"Bytes",
",",
"false",
")",
")",
"return",
"MCDisassembler",
"::",
"Fail",
";"
] |
GCC | sh | MD | next_suggestion | CPU | 620,097 | [
"operands",
"[",
"<NUM_LIT>",
"]",
"=",
"gen_rtx_SUBREG",
"(",
"Pmode",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"<NUM_LIT>",
")"
] | [
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<STR_LIT>",
"{",
"if",
"(",
"GET_MODE",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"!",
"=",
"Pmode",
")"
] |
LLVM | Mips | TD | stmt_completion | CPU | 620,098 | [
"<NUM_LIT>",
">",
",",
"SDTCisVec",
"<",
"<NUM_LIT>",
">",
"]",
">",
";"
] | [
"def",
"SDT_MipsVecCond",
":",
"SDTypeProfile",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"[",
"SDTCisInt",
"<"
] |
LLVM | Mips | CPP | next_suggestion | CPU | 620,099 | [
"case",
"Mips",
"::",
"DROR",
":"
] | [
"case",
"Mips",
"::",
"BLTImmMacro",
":",
"case",
"Mips",
"::",
"BLEImmMacro",
":",
"case",
"Mips",
"::",
"BGEImmMacro",
":",
"case",
"Mips",
"::",
"BGTImmMacro",
":",
"case",
"Mips",
"::",
"BLTUImmMacro",
":",
"case",
"Mips",
"::",
"BLEUImmMacro",
":",
"case",
"Mips",
"::",
"BGEUImmMacro",
":",
"case",
"Mips",
"::",
"BGTUImmMacro",
":",
"case",
"Mips",
"::",
"BLTLImmMacro",
":",
"case",
"Mips",
"::",
"BLELImmMacro",
":",
"case",
"Mips",
"::",
"BGELImmMacro",
":",
"case",
"Mips",
"::",
"BGTLImmMacro",
":",
"case",
"Mips",
"::",
"BLTULImmMacro",
":",
"case",
"Mips",
"::",
"BLEULImmMacro",
":",
"case",
"Mips",
"::",
"BGEULImmMacro",
":",
"case",
"Mips",
"::",
"BGTULImmMacro",
":",
"return",
"expandCondBranches",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"SDivMacro",
":",
"case",
"Mips",
"::",
"SDivIMacro",
":",
"return",
"expandDiv",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
",",
"false",
",",
"true",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"DSDivMacro",
":",
"case",
"Mips",
"::",
"DSDivIMacro",
":",
"return",
"expandDiv",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
",",
"true",
",",
"true",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"UDivMacro",
":",
"case",
"Mips",
"::",
"UDivIMacro",
":",
"return",
"expandDiv",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
",",
"false",
",",
"false",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"DUDivMacro",
":",
"case",
"Mips",
"::",
"DUDivIMacro",
":",
"return",
"expandDiv",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
",",
"true",
",",
"false",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"PseudoTRUNC_W_S",
":",
"return",
"expandTrunc",
"(",
"Inst",
",",
"false",
",",
"false",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"PseudoTRUNC_W_D32",
":",
"return",
"expandTrunc",
"(",
"Inst",
",",
"true",
",",
"false",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"PseudoTRUNC_W_D",
":",
"return",
"expandTrunc",
"(",
"Inst",
",",
"true",
",",
"true",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"Ulh",
":",
"return",
"expandUlh",
"(",
"Inst",
",",
"true",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"Ulhu",
":",
"return",
"expandUlh",
"(",
"Inst",
",",
"false",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"Ush",
":",
"return",
"expandUsh",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"Ulw",
":",
"case",
"Mips",
"::",
"Usw",
":",
"return",
"expandUxw",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"NORImm",
":",
"case",
"Mips",
"::",
"NORImm64",
":",
"return",
"expandAliasImmediate",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"SLTImm64",
":",
"if",
"(",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
")",
")",
"{",
"Inst",
".",
"setOpcode",
"(",
"Mips",
"::",
"SLTi64",
")",
";",
"return",
"MER_NotAMacro",
";",
"}",
"return",
"expandAliasImmediate",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"SLTUImm64",
":",
"if",
"(",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
")",
")",
"{",
"Inst",
".",
"setOpcode",
"(",
"Mips",
"::",
"SLTiu64",
")",
";",
"return",
"MER_NotAMacro",
";",
"}",
"return",
"expandAliasImmediate",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"ADDi",
":",
"case",
"Mips",
"::",
"ADDi_MM",
":",
"case",
"Mips",
"::",
"ADDiu",
":",
"case",
"Mips",
"::",
"ADDiu_MM",
":",
"case",
"Mips",
"::",
"SLTi",
":",
"case",
"Mips",
"::",
"SLTi_MM",
":",
"case",
"Mips",
"::",
"SLTiu",
":",
"case",
"Mips",
"::",
"SLTiu_MM",
":",
"if",
"(",
"(",
"Inst",
".",
"getNumOperands",
"(",
")",
"==",
"<NUM_LIT>",
")",
"&&",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isReg",
"(",
")",
"&&",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isReg",
"(",
")",
"&&",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isImm",
"(",
")",
")",
"{",
"int64_t",
"ImmValue",
"=",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"ImmValue",
")",
")",
"return",
"MER_NotAMacro",
";",
"return",
"expandAliasImmediate",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"}",
"return",
"MER_NotAMacro",
";",
"case",
"Mips",
"::",
"ANDi",
":",
"case",
"Mips",
"::",
"ANDi_MM",
":",
"case",
"Mips",
"::",
"ANDi64",
":",
"case",
"Mips",
"::",
"ORi",
":",
"case",
"Mips",
"::",
"ORi_MM",
":",
"case",
"Mips",
"::",
"ORi64",
":",
"case",
"Mips",
"::",
"XORi",
":",
"case",
"Mips",
"::",
"XORi_MM",
":",
"case",
"Mips",
"::",
"XORi64",
":",
"if",
"(",
"(",
"Inst",
".",
"getNumOperands",
"(",
")",
"==",
"<NUM_LIT>",
")",
"&&",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isReg",
"(",
")",
"&&",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isReg",
"(",
")",
"&&",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isImm",
"(",
")",
")",
"{",
"int64_t",
"ImmValue",
"=",
"Inst",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"ImmValue",
")",
")",
"return",
"MER_NotAMacro",
";",
"return",
"expandAliasImmediate",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"}",
"return",
"MER_NotAMacro",
";",
"case",
"Mips",
"::",
"ROL",
":",
"case",
"Mips",
"::",
"ROR",
":",
"return",
"expandRotation",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"ROLImm",
":",
"case",
"Mips",
"::",
"RORImm",
":",
"return",
"expandRotationImm",
"(",
"Inst",
",",
"IDLoc",
",",
"Out",
",",
"STI",
")",
"?",
"MER_Fail",
":",
"MER_Success",
";",
"case",
"Mips",
"::",
"DROL",
":"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.