Compiler_Type
stringclasses 2
values | Target
stringclasses 176
values | Programming Language
stringclasses 3
values | Task
stringclasses 4
values | Target_Type
stringclasses 7
values | Idx
int64 0
636k
| Ground_Truth
listlengths 0
2.32k
| Input
listlengths 1
1.02k
|
---|---|---|---|---|---|---|---|
GCC | i386 | CPP | stmt_completion | CPU | 5,000 | [
"mm_min_pd",
"(",
"_",
"_",
"m128d",
"_",
"_",
"A",
",",
"_",
"_",
"m128d",
"_",
"_",
"B",
")",
"{"
]
| [
"static",
"_",
"_",
"inline",
"_",
"_",
"m128d",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"always_inline__",
")",
")",
"_"
]
|
LLVM | PowerPC | CPP | stmt_completion | CPU | 5,001 | [
"VSRpReg1",
")",
",",
"FrameIndex",
",",
"IsLittleEndian",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
")",
";"
]
| [
"Register",
"VSRpReg1",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
".",
"createVirtualRegister",
"(",
"RC",
")",
";",
"Register",
"DestReg",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"II",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"PPC",
"::",
"LXVP",
")",
",",
"VSRpReg0",
")",
",",
"FrameIndex",
",",
"IsLittleEndian",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
")",
";",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"II",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"PPC",
"::",
"LXVP",
")",
","
]
|
LLVM | ARM | CPP | stmt_completion | CPU | 5,002 | [
"return",
"GT",
";"
]
| [
"case",
"MI",
":",
"return",
"PL",
";",
"case",
"PL",
":",
"return",
"MI",
";",
"case",
"VS",
":",
"return",
"VC",
";",
"case",
"VC",
":",
"return",
"VS",
";",
"case",
"HI",
":",
"return",
"LS",
";",
"case",
"LS",
":",
"return",
"HI",
";",
"case",
"GE",
":",
"return",
"LT",
";",
"case",
"LT",
":",
"return",
"GE",
";",
"case",
"GT",
":",
"return",
"LE",
";",
"case",
"LE",
":"
]
|
LLVM | WebAssembly | CPP | next_suggestion | Virtual ISA | 5,003 | [
"}"
]
| [
"if",
"(",
"Info",
".",
"OperandType",
"==",
"WebAssembly",
"::",
"OPERAND_TYPEINDEX",
")",
"{",
"MCSymbol",
"*",
"Sym",
"=",
"Printer",
".",
"createTempSymbol",
"(",
"<STR_LIT>",
"typeindex",
"<STR_LIT>",
")",
";",
"SmallVector",
"<",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<NUM_LIT>",
">",
"Returns",
";",
"SmallVector",
"<",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<NUM_LIT>",
">",
"Params",
";",
"const",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
"->",
"getRegInfo",
"(",
")",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"MI",
"->",
"defs",
"(",
")",
")",
"Returns",
".",
"push_back",
"(",
"getType",
"(",
"MRI",
".",
"getRegClass",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
")",
")",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"MI",
"->",
"explicit_uses",
"(",
")",
")",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"Params",
".",
"push_back",
"(",
"getType",
"(",
"MRI",
".",
"getRegClass",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
")",
")",
";",
"if",
"(",
"WebAssembly",
"::",
"isCallIndirect",
"(",
"*",
"MI",
")",
")",
"Params",
".",
"pop_back",
"(",
")",
";",
"MCSymbolWasm",
"*",
"WasmSym",
"=",
"cast",
"<",
"MCSymbolWasm",
">",
"(",
"Sym",
")",
";",
"WasmSym",
"->",
"setReturns",
"(",
"std",
"::",
"move",
"(",
"Returns",
")",
")",
";",
"WasmSym",
"->",
"setParams",
"(",
"std",
"::",
"move",
"(",
"Params",
")",
")",
";",
"WasmSym",
"->",
"setType",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"const",
"MCExpr",
"*",
"Expr",
"=",
"MCSymbolRefExpr",
"::",
"create",
"(",
"WasmSym",
",",
"MCSymbolRefExpr",
"::",
"VK_WebAssembly_TYPEINDEX",
",",
"Ctx",
")",
";",
"MCOp",
"=",
"MCOperand",
"::",
"createExpr",
"(",
"Expr",
")",
";",
"break",
";",
"}",
"}",
"MCOp",
"=",
"MCOperand",
"::",
"createImm",
"(",
"MO",
".",
"getImm",
"(",
")",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_FPImmediate",
":",
"{",
"const",
"ConstantFP",
"*",
"Imm",
"=",
"MO",
".",
"getFPImm",
"(",
")",
";",
"if",
"(",
"Imm",
"->",
"getType",
"(",
")",
"->",
"isFloatTy",
"(",
")",
")",
"MCOp",
"=",
"MCOperand",
"::",
"createFPImm",
"(",
"Imm",
"->",
"getValueAPF",
"(",
")",
".",
"convertToFloat",
"(",
")",
")",
";",
"else",
"if",
"(",
"Imm",
"->",
"getType",
"(",
")",
"->",
"isDoubleTy",
"(",
")",
")",
"MCOp",
"=",
"MCOperand",
"::",
"createFPImm",
"(",
"Imm",
"->",
"getValueAPF",
"(",
")",
".",
"convertToDouble",
"(",
")",
")",
";",
"else",
"llvm_unreachable",
"(",
"<STR_LIT>",
"unknown floating point immediate type",
"<STR_LIT>",
")",
";",
"break",
";",
"}",
"case",
"MachineOperand",
"::",
"MO_GlobalAddress",
":",
"assert",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"<STR_LIT>",
"WebAssembly does not use target flags on GlobalAddresses",
"<STR_LIT>",
")",
";",
"MCOp",
"=",
"LowerSymbolOperand",
"(",
"GetGlobalAddressSymbol",
"(",
"MO",
")",
",",
"MO",
".",
"getOffset",
"(",
")",
",",
"MO",
".",
"getGlobal",
"(",
")",
"->",
"getValueType",
"(",
")",
"->",
"isFunctionTy",
"(",
")",
",",
"false",
")",
";",
"break",
";",
"case",
"MachineOperand",
"::",
"MO_ExternalSymbol",
":",
"assert",
"(",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
"&",
"~",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"WebAssembly uses only symbol flags on ExternalSymbols",
"<STR_LIT>",
")",
";",
"MCOp",
"=",
"LowerSymbolOperand",
"(",
"GetExternalSymbolSymbol",
"(",
"MO",
")",
",",
"<NUM_LIT>",
",",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"!=",
"<NUM_LIT>",
",",
"(",
"MO",
".",
"getTargetFlags",
"(",
")",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"!=",
"<NUM_LIT>",
")",
";",
"break",
";",
"}",
"OutMI",
".",
"addOperand",
"(",
"MCOp",
")",
";",
"}"
]
|
LLVM | ARM | TD | stmt_completion | CPU | 5,004 | [
";"
]
| [
"let",
"ParserMethod",
"=",
"<STR_LIT>",
";",
"let",
"RenderMethod",
"=",
"<STR_LIT>"
]
|
LLVM | XCore | CPP | code_generation | MPU | 5,005 | [
"void",
"XCoreTargetObjectFile",
"::",
"Initialize",
"(",
"MCContext",
"&",
"Ctx",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"{",
"TargetLoweringObjectFileELF",
"::",
"Initialize",
"(",
"Ctx",
",",
"TM",
")",
";",
"BSSSection",
"=",
"Ctx",
".",
"getELFSection",
"(",
"<STR_LIT>",
".dp.bss",
"<STR_LIT>",
",",
"ELF",
"::",
"SHT_NOBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"SHF_WRITE",
"|",
"ELF",
"::",
"XCORE_SHF_DP_SECTION",
")",
";",
"BSSSectionLarge",
"=",
"Ctx",
".",
"getELFSection",
"(",
"<STR_LIT>",
".dp.bss.large",
"<STR_LIT>",
",",
"ELF",
"::",
"SHT_NOBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"SHF_WRITE",
"|",
"ELF",
"::",
"XCORE_SHF_DP_SECTION",
")",
";",
"DataSection",
"=",
"Ctx",
".",
"getELFSection",
"(",
"<STR_LIT>",
".dp.data",
"<STR_LIT>",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"SHF_WRITE",
"|",
"ELF",
"::",
"XCORE_SHF_DP_SECTION",
")",
";",
"DataSectionLarge",
"=",
"Ctx",
".",
"getELFSection",
"(",
"<STR_LIT>",
".dp.data.large",
"<STR_LIT>",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"SHF_WRITE",
"|",
"ELF",
"::",
"XCORE_SHF_DP_SECTION",
")",
";",
"DataRelROSection",
"=",
"Ctx",
".",
"getELFSection",
"(",
"<STR_LIT>",
".dp.rodata",
"<STR_LIT>",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"SHF_WRITE",
"|",
"ELF",
"::",
"XCORE_SHF_DP_SECTION",
")",
";",
"DataRelROSectionLarge",
"=",
"Ctx",
".",
"getELFSection",
"(",
"<STR_LIT>",
".dp.rodata.large",
"<STR_LIT>",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"SHF_WRITE",
"|",
"ELF",
"::",
"XCORE_SHF_DP_SECTION",
")",
";",
"ReadOnlySection",
"=",
"Ctx",
".",
"getELFSection",
"(",
"<STR_LIT>",
".cp.rodata",
"<STR_LIT>",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"XCORE_SHF_CP_SECTION",
")",
";",
"ReadOnlySectionLarge",
"=",
"Ctx",
".",
"getELFSection",
"(",
"<STR_LIT>",
".cp.rodata.large",
"<STR_LIT>",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"XCORE_SHF_CP_SECTION",
")",
";",
"MergeableConst4Section",
"=",
"Ctx",
".",
"getELFSection",
"(",
"<STR_LIT>",
".cp.rodata.cst4",
"<STR_LIT>",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"SHF_MERGE",
"|",
"ELF",
"::",
"XCORE_SHF_CP_SECTION",
",",
"<NUM_LIT>",
")",
";",
"MergeableConst8Section",
"=",
"Ctx",
".",
"getELFSection",
"(",
"<STR_LIT>",
".cp.rodata.cst8",
"<STR_LIT>",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"SHF_MERGE",
"|",
"ELF",
"::",
"XCORE_SHF_CP_SECTION",
",",
"<NUM_LIT>",
")",
";",
"MergeableConst16Section",
"=",
"Ctx",
".",
"getELFSection",
"(",
"<STR_LIT>",
".cp.rodata.cst16",
"<STR_LIT>",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"SHF_MERGE",
"|",
"ELF",
"::",
"XCORE_SHF_CP_SECTION",
",",
"<NUM_LIT>",
")",
";",
"CStringSection",
"=",
"Ctx",
".",
"getELFSection",
"(",
"<STR_LIT>",
".cp.rodata.string",
"<STR_LIT>",
",",
"ELF",
"::",
"SHT_PROGBITS",
",",
"ELF",
"::",
"SHF_ALLOC",
"|",
"ELF",
"::",
"SHF_MERGE",
"|",
"ELF",
"::",
"SHF_STRINGS",
"|",
"ELF",
"::",
"XCORE_SHF_CP_SECTION",
")",
";",
"}"
]
| [
"This",
"method",
"must",
"be",
"called",
"before",
"any",
"actual",
"lowering",
"is",
"done",
"."
]
|
LLVM | AArch64 | TD | next_suggestion | CPU | 5,006 | [
"let",
"DecoderMethod",
"=",
"<STR_LIT>",
";"
]
| [
"return",
"(",
"(",
"(",
"uint32_t",
")",
"Imm",
")",
">",
"<NUM_LIT>",
")",
"&",
"&",
"(",
"(",
"(",
"uint32_t",
")",
"Imm",
")",
"<",
"<NUM_LIT>",
")",
";",
"}",
"]",
">",
"{",
"let",
"ParserMatchClass",
"=",
"Imm1_16Operand",
";",
"let",
"EncoderMethod",
"=",
"<STR_LIT>",
";"
]
|
LLVM | AArch64 | CPP | stmt_completion | CPU | 5,007 | [
"getPointerTy",
"(",
")",
")",
";"
]
| [
"Type",
"*",
"ArgTy",
"=",
"ArgVT",
".",
"getTypeForEVT",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"ArgListTy",
"Args",
";",
"ArgListEntry",
"Entry",
";",
"Entry",
".",
"Node",
"=",
"Arg",
";",
"Entry",
".",
"Ty",
"=",
"ArgTy",
";",
"Entry",
".",
"isSExt",
"=",
"false",
";",
"Entry",
".",
"isZExt",
"=",
"false",
";",
"Args",
".",
"push_back",
"(",
"Entry",
")",
";",
"const",
"char",
"*",
"LibcallName",
"=",
"(",
"ArgVT",
"==",
"MVT",
"::",
"f64",
")",
"?",
"<STR_LIT>",
"__sincos_stret",
"<STR_LIT>",
":",
"<STR_LIT>",
"__sincosf_stret",
"<STR_LIT>",
";",
"SDValue",
"Callee",
"=",
"DAG",
".",
"getExternalSymbol",
"(",
"LibcallName",
","
]
|
LLVM | X86 | CPP | stmt_completion | CPU | 5,008 | [
")",
"{"
]
| [
"unsigned",
"InSizeInBits",
"=",
"InVecVT",
".",
"getSizeInBits",
"(",
")",
";",
"unsigned",
"NumSubElts",
"=",
"VT",
".",
"getVectorNumElements",
"(",
")",
";",
"const",
"TargetLowering",
"&",
"TLI",
"=",
"DAG",
".",
"getTargetLoweringInfo",
"(",
")",
";",
"if",
"(",
"Subtarget",
".",
"hasAVX",
"(",
")",
"&&",
"!",
"Subtarget",
".",
"hasAVX2",
"(",
")",
"&&",
"TLI",
".",
"isTypeLegal",
"(",
"InVecVT",
")",
"&&",
"InSizeInBits",
"==",
"<NUM_LIT>",
"&&",
"InVecBC",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"AND",
")",
"{",
"auto",
"isConcatenatedNot",
"=",
"[",
"]",
"(",
"SDValue",
"V",
")",
"{",
"V",
"=",
"peekThroughBitcasts",
"(",
"V",
")",
";",
"if",
"(",
"!",
"isBitwiseNot",
"(",
"V",
")",
")",
"return",
"false",
";",
"SDValue",
"NotOp",
"=",
"V",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"return",
"peekThroughBitcasts",
"(",
"NotOp",
")",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"CONCAT_VECTORS",
";",
"}",
";",
"if",
"(",
"isConcatenatedNot",
"(",
"InVecBC",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
"||",
"isConcatenatedNot",
"(",
"InVecBC",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"{",
"SDValue",
"Concat",
"=",
"splitVectorIntBinary",
"(",
"InVecBC",
",",
"DAG",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"SDLoc",
"(",
"N",
")",
",",
"VT",
",",
"DAG",
".",
"getBitcast",
"(",
"InVecVT",
",",
"Concat",
")",
",",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"}",
"}",
"if",
"(",
"DCI",
".",
"isBeforeLegalizeOps",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"if",
"(",
"SDValue",
"V",
"=",
"narrowExtractedVectorSelect",
"(",
"N",
",",
"DAG",
")",
")",
"return",
"V",
";",
"if",
"(",
"ISD",
"::",
"isBuildVectorAllZeros",
"(",
"InVec",
".",
"getNode",
"(",
")",
")",
")",
"return",
"getZeroVector",
"(",
"VT",
",",
"Subtarget",
",",
"DAG",
",",
"SDLoc",
"(",
"N",
")",
")",
";",
"if",
"(",
"ISD",
"::",
"isBuildVectorAllOnes",
"(",
"InVec",
".",
"getNode",
"(",
")",
")",
")",
"{",
"if",
"(",
"VT",
".",
"getScalarType",
"(",
")",
"==",
"MVT",
"::",
"i1",
")",
"return",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"SDLoc",
"(",
"N",
")",
",",
"VT",
")",
";",
"return",
"getOnesVector",
"(",
"VT",
",",
"DAG",
",",
"SDLoc",
"(",
"N",
")",
")",
";",
"}",
"if",
"(",
"InVec",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"BUILD_VECTOR",
")",
"return",
"DAG",
".",
"getBuildVector",
"(",
"VT",
",",
"SDLoc",
"(",
"N",
")",
",",
"InVec",
"->",
"ops",
"(",
")",
".",
"slice",
"(",
"IdxVal",
",",
"NumSubElts",
")",
")",
";",
"if",
"(",
"VT",
".",
"getVectorElementType",
"(",
")",
"!=",
"MVT",
"::",
"i1",
"&&",
"InVec",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"INSERT_SUBVECTOR",
"&&",
"InVec",
".",
"hasOneUse",
"(",
")",
"&&",
"IdxVal",
"==",
"InVec",
".",
"getConstantOperandVal",
"(",
"<NUM_LIT>",
")",
"&&",
"InVec",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getValueSizeInBits",
"(",
")",
"<=",
"SizeInBits",
")",
"{",
"SDLoc",
"DL",
"(",
"N",
")",
";",
"SDValue",
"NewExt",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"EXTRACT_SUBVECTOR",
",",
"DL",
",",
"VT",
",",
"InVec",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"unsigned",
"NewIdxVal",
"=",
"InVec",
".",
"getConstantOperandVal",
"(",
"<NUM_LIT>",
")",
"-",
"IdxVal",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"INSERT_SUBVECTOR",
",",
"DL",
",",
"VT",
",",
"NewExt",
",",
"InVec",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"DAG",
".",
"getVectorIdxConstant",
"(",
"NewIdxVal",
",",
"DL",
")",
")",
";",
"}",
"if",
"(",
"IdxVal",
"!=",
"<NUM_LIT>",
"&&",
"(",
"InVec",
".",
"getOpcode",
"(",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"||",
"InVec",
".",
"getOpcode",
"(",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"||",
"DAG",
".",
"isSplatValue",
"(",
"InVec",
",",
"false",
")",
")",
")",
"return",
"extractSubVector",
"(",
"InVec",
",",
"<NUM_LIT>",
",",
"DAG",
",",
"SDLoc",
"(",
"N",
")",
",",
"SizeInBits",
")",
";",
"if",
"(",
"IdxVal",
"!=",
"<NUM_LIT>",
"&&",
"InVec",
".",
"getOpcode",
"(",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"cast",
"<",
"MemIntrinsicSDNode",
">",
"(",
"InVec",
")",
"->",
"getMemoryVT",
"(",
")",
"==",
"VT",
")",
"return",
"extractSubVector",
"(",
"InVec",
",",
"<NUM_LIT>",
",",
"DAG",
",",
"SDLoc",
"(",
"N",
")",
",",
"SizeInBits",
")",
";",
"if",
"(",
"(",
"InSizeInBits",
"%",
"SizeInBits",
")",
"==",
"<NUM_LIT>",
"&&",
"(",
"IdxVal",
"%",
"NumSubElts",
")",
"==",
"<NUM_LIT>",
")",
"{",
"SmallVector",
"<",
"int",
",",
"<NUM_LIT>",
">",
"ShuffleMask",
";",
"SmallVector",
"<",
"int",
",",
"<NUM_LIT>",
">",
"ScaledMask",
";",
"SmallVector",
"<",
"SDValue",
",",
"<NUM_LIT>",
">",
"ShuffleInputs",
";",
"unsigned",
"NumSubVecs",
"=",
"InSizeInBits",
"/",
"SizeInBits",
";",
"if",
"(",
"getTargetShuffleInputs",
"(",
"InVecBC",
",",
"ShuffleInputs",
",",
"ShuffleMask",
",",
"DAG",
")",
"&&",
"scaleShuffleElements",
"(",
"ShuffleMask",
",",
"NumSubVecs",
",",
"ScaledMask",
")",
")",
"{",
"unsigned",
"SubVecIdx",
"=",
"IdxVal",
"/",
"NumSubElts",
";",
"if",
"(",
"ScaledMask",
"[",
"SubVecIdx",
"]",
"==",
"SM_SentinelUndef",
")",
"return",
"DAG",
".",
"getUNDEF",
"(",
"VT",
")",
";",
"if",
"(",
"ScaledMask",
"[",
"SubVecIdx",
"]",
"==",
"SM_SentinelZero",
")",
"return",
"getZeroVector",
"(",
"VT",
",",
"Subtarget",
",",
"DAG",
",",
"SDLoc",
"(",
"N",
")",
")",
";",
"SDValue",
"Src",
"=",
"ShuffleInputs",
"[",
"ScaledMask",
"[",
"SubVecIdx",
"]",
"/",
"NumSubVecs",
"]",
";",
"if",
"(",
"Src",
".",
"getValueSizeInBits",
"(",
")",
"==",
"InSizeInBits",
")",
"{",
"unsigned",
"SrcSubVecIdx",
"=",
"ScaledMask",
"[",
"SubVecIdx",
"]",
"%",
"NumSubVecs",
";",
"unsigned",
"SrcEltIdx",
"=",
"SrcSubVecIdx",
"*",
"NumSubElts",
";",
"return",
"extractSubVector",
"(",
"DAG",
".",
"getBitcast",
"(",
"InVecVT",
",",
"Src",
")",
",",
"SrcEltIdx",
",",
"DAG",
",",
"SDLoc",
"(",
"N",
")",
",",
"SizeInBits",
")",
";",
"}",
"}",
"}",
"unsigned",
"InOpcode",
"=",
"InVec",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"InVec",
".",
"hasOneUse",
"(",
")"
]
|
GCC | arm | CPP | stmt_completion | CPU | 5,009 | [
"p",
")",
"{"
]
| [
"_",
"_",
"arm_vsubq_x_f32",
"(",
"float32x4_t",
"_",
"_",
"a",
",",
"float32x4_t",
"_",
"_",
"b",
",",
"mve_pred16_t",
"_",
"_"
]
|
LLVM | AArch64 | CPP | stmt_completion | CPU | 5,010 | [
";"
]
| [
"assert",
"(",
"Factor",
">=",
"<NUM_LIT>",
"&&",
"Factor",
"<=",
"getMaxSupportedInterleaveFactor",
"(",
")",
"&&",
"<STR_LIT>",
"Invalid interleave factor",
"<STR_LIT>",
")",
";",
"VectorType",
"*",
"VecTy",
"=",
"SVI",
"->",
"getType",
"(",
")",
";",
"assert",
"(",
"VecTy",
"->",
"getNumElements",
"(",
")",
"%",
"Factor",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Invalid interleaved store",
"<STR_LIT>",
")",
";",
"unsigned",
"LaneLen",
"=",
"VecTy",
"->",
"getNumElements",
"(",
")",
"/",
"Factor",
";",
"Type",
"*",
"EltTy",
"=",
"VecTy",
"->",
"getElementType",
"(",
")",
";",
"VectorType",
"*",
"SubVecTy",
"=",
"VectorType",
"::",
"get",
"(",
"EltTy",
",",
"LaneLen",
")",
";",
"const",
"DataLayout",
"&",
"DL",
"=",
"SI",
"->",
"getModule",
"(",
")",
"->",
"getDataLayout",
"(",
")",
";",
"if",
"(",
"!",
"Subtarget",
"->",
"hasNEON",
"(",
")",
"||",
"!",
"isLegalInterleavedAccessType",
"(",
"SubVecTy",
",",
"DL",
")",
")",
"return",
"false",
";",
"unsigned",
"NumStores",
"=",
"getNumInterleavedAccesses",
"(",
"SubVecTy",
",",
"DL",
")",
";",
"Value",
"*",
"Op0",
"=",
"SVI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"Value",
"*",
"Op1",
"=",
"SVI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"IRBuilder",
"<",
">",
"Builder",
"(",
"SI",
")",
";",
"if",
"(",
"EltTy",
"->",
"isPointerTy",
"(",
")",
")",
"{",
"Type",
"*",
"IntTy",
"=",
"DL",
".",
"getIntPtrType",
"(",
"EltTy",
")",
";",
"unsigned",
"NumOpElts",
"=",
"cast",
"<",
"VectorType",
">",
"(",
"Op0",
"->",
"getType",
"(",
")",
")",
"->",
"getNumElements",
"(",
")",
";",
"Type",
"*",
"IntVecTy",
"=",
"VectorType",
"::",
"get",
"(",
"IntTy",
",",
"NumOpElts",
")",
";",
"Op0",
"=",
"Builder",
".",
"CreatePtrToInt",
"(",
"Op0",
",",
"IntVecTy",
")",
";",
"Op1",
"=",
"Builder",
".",
"CreatePtrToInt",
"(",
"Op1",
",",
"IntVecTy",
")",
";",
"SubVecTy",
"=",
"VectorType",
"::",
"get",
"(",
"IntTy",
",",
"LaneLen",
")",
";",
"}",
"Value",
"*",
"BaseAddr",
"=",
"SI",
"->",
"getPointerOperand",
"(",
")",
";",
"if",
"(",
"NumStores",
">",
"<NUM_LIT>",
")",
"{",
"LaneLen",
"/",
"=",
"NumStores",
";",
"SubVecTy",
"=",
"VectorType",
"::",
"get",
"(",
"SubVecTy",
"->",
"getElementType",
"(",
")",
",",
"LaneLen",
")",
";",
"BaseAddr",
"=",
"Builder",
".",
"CreateBitCast",
"(",
"BaseAddr",
",",
"SubVecTy",
"->",
"getElementType",
"(",
")",
"->",
"getPointerTo",
"(",
"SI",
"->",
"getPointerAddressSpace",
"(",
")",
")",
")",
";",
"}",
"auto",
"Mask",
"=",
"SVI",
"->",
"getShuffleMask",
"(",
")",
";",
"Type",
"*",
"PtrTy",
"=",
"SubVecTy",
"->",
"getPointerTo",
"(",
"SI",
"->",
"getPointerAddressSpace",
"(",
")",
")",
";",
"Type",
"*",
"Tys",
"[",
"<NUM_LIT>",
"]",
"=",
"{",
"SubVecTy",
",",
"PtrTy",
"}",
";",
"static",
"const",
"Intrinsic",
"::",
"ID",
"StoreInts",
"[",
"<NUM_LIT>",
"]",
"=",
"{",
"Intrinsic",
"::",
"aarch64_neon_st2",
",",
"Intrinsic",
"::",
"aarch64_neon_st3",
",",
"Intrinsic",
"::",
"aarch64_neon_st4",
"}",
";",
"Function",
"*",
"StNFunc",
"=",
"Intrinsic",
"::",
"getDeclaration",
"(",
"SI",
"->",
"getModule",
"(",
")",
",",
"StoreInts",
"[",
"Factor",
"-",
"<NUM_LIT>",
"]",
",",
"Tys",
")",
";",
"for",
"(",
"unsigned",
"StoreCount",
"=",
"<NUM_LIT>",
";",
"StoreCount",
"<",
"NumStores",
";",
"++",
"StoreCount",
")",
"{",
"SmallVector",
"<",
"Value",
"*",
",",
"<NUM_LIT>",
">",
"Ops",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"Factor",
";",
"i",
"++",
")",
"{",
"unsigned",
"IdxI",
"=",
"StoreCount",
"*",
"LaneLen",
"*",
"Factor",
"+",
"i",
";",
"if",
"(",
"Mask",
"[",
"IdxI",
"]",
">=",
"<NUM_LIT>",
")",
"{",
"Ops",
".",
"push_back",
"(",
"Builder",
".",
"CreateShuffleVector",
"(",
"Op0",
",",
"Op1",
",",
"createSequentialMask",
"(",
"Mask",
"[",
"IdxI",
"]",
",",
"LaneLen",
",",
"<NUM_LIT>",
")",
")",
")",
";",
"}",
"else",
"{",
"unsigned",
"StartMask",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"unsigned",
"j",
"=",
"<NUM_LIT>",
";",
"j",
"<",
"LaneLen",
";",
"j",
"++",
")",
"{",
"unsigned",
"IdxJ",
"=",
"StoreCount",
"*",
"LaneLen",
"*",
"Factor",
"+",
"j",
";",
"if",
"(",
"Mask",
"[",
"IdxJ",
"*",
"Factor",
"+",
"IdxI",
"]",
">=",
"<NUM_LIT>",
")",
"{",
"StartMask",
"=",
"Mask",
"[",
"IdxJ",
"*",
"Factor",
"+",
"IdxI",
"]",
"-",
"IdxJ",
";",
"break",
";",
"}",
"}",
"Ops",
".",
"push_back",
"(",
"Builder",
".",
"CreateShuffleVector",
"(",
"Op0",
",",
"Op1",
",",
"createSequentialMask",
"(",
"StartMask",
",",
"LaneLen",
",",
"<NUM_LIT>",
")",
")",
")",
";",
"}",
"}",
"if",
"(",
"StoreCount",
">",
"<NUM_LIT>",
")",
"BaseAddr",
"=",
"Builder",
".",
"CreateConstGEP1_32",
"(",
"SubVecTy",
"->",
"getElementType",
"(",
")",
",",
"BaseAddr",
",",
"LaneLen",
"*",
"Factor",
")",
";",
"Ops",
".",
"push_back",
"(",
"Builder",
".",
"CreateBitCast",
"(",
"BaseAddr",
",",
"PtrTy",
")",
")",
";",
"Builder",
".",
"CreateCall",
"(",
"StNFunc",
",",
"Ops",
")",
";",
"}",
"return",
"true"
]
|
LLVM | R600 | CPP | stmt_completion | GPU | 5,011 | [
">",
"(",
")",
";"
]
| [
"AU",
".",
"addRequired",
"<",
"MachinePostDominatorTree",
">",
"(",
")",
";",
"AU",
".",
"addRequired",
"<",
"MachineLoopInfo"
]
|
LLVM | AArch64 | TD | stmt_completion | CPU | 5,012 | [
"}",
"=",
"Rn",
";"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"U",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"size",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opcode",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>"
]
|
LLVM | ARCompact | CPP | code_generation | MPU | 5,013 | [
"BitVector",
"ARCompactRegisterInfo",
"::",
"getReservedRegs",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{",
"BitVector",
"Reserved",
"(",
"getNumRegs",
"(",
")",
")",
";",
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"return",
"Reserved",
";",
"}"
]
| [
"getReservedRegs",
"-",
"Returns",
"a",
"bitset",
"indexed",
"by",
"physical",
"register",
"number",
"indicating",
"if",
"a",
"register",
"is",
"a",
"special",
"register",
"that",
"has",
"particular",
"uses",
"and",
"should",
"be",
"considered",
"unavailable",
"at",
"all",
"times",
",",
"e.g",
"."
]
|
LLVM | AArch64 | TD | stmt_completion | CPU | 5,014 | [
":",
"$",
"imm",
")",
">",
";"
]
| [
"def",
"_D",
":",
"sve_int_dup_imm_pred",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"asm",
",",
"ZPR64",
",",
"<STR_LIT>",
",",
"(",
"ins",
"ZPR64",
":",
"$",
"_Zd",
",",
"PPRAny",
":",
"$",
"Pg",
",",
"cpy_imm8_opt_lsl_i64"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 5,015 | [
"_",
"_",
"B",
")",
"{"
]
| [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m128d",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_maskz_cvtph_pd",
"(",
"_",
"_",
"mmask8",
"_",
"_",
"A",
",",
"_",
"_",
"m128h"
]
|
GCC | i386 | MD | stmt_completion | CPU | 5,016 | [
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"[",
"(",
"set",
"(",
"match_operand",
":",
"SWI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"minus",
":",
"SWI",
"(",
"match_operand",
":",
"SWI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operator",
":",
"SWI",
"<NUM_LIT>",
"<STR_LIT>",
"[",
"(",
"reg",
"FLAGS_REG",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
")",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"CC",
"FLAGS_REG",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr"
]
|
LLVM | ARM | CPP | next_suggestion | CPU | 5,017 | [
"return",
"DAG",
".",
"getStore",
"(",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"dl",
",",
"FR",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"MachinePointerInfo",
"(",
"SV",
")",
")",
";"
]
| [
"static",
"SDValue",
"LowerVASTART",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"{",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"ARMFunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"SDLoc",
"dl",
"(",
"Op",
")",
";",
"EVT",
"PtrVT",
"=",
"DAG",
".",
"getTargetLoweringInfo",
"(",
")",
".",
"getPointerTy",
"(",
"DAG",
".",
"getDataLayout",
"(",
")",
")",
";",
"SDValue",
"FR",
"=",
"DAG",
".",
"getFrameIndex",
"(",
"FuncInfo",
"->",
"getVarArgsFrameIndex",
"(",
")",
",",
"PtrVT",
")",
";",
"const",
"Value",
"*",
"SV",
"=",
"cast",
"<",
"SrcValueSDNode",
">",
"(",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
"->",
"getValue",
"(",
")",
";"
]
|
LLVM | ARM | CPP | next_suggestion | CPU | 5,018 | [
"return",
"PostRAScheduler",
"&&",
"OptLevel",
">=",
"CodeGenOpt",
"::",
"Default",
";"
]
| [
"bool",
"ARMSubtarget",
"::",
"enablePostRAScheduler",
"(",
"CodeGenOpt",
"::",
"Level",
"OptLevel",
",",
"TargetSubtargetInfo",
"::",
"AntiDepBreakMode",
"&",
"Mode",
",",
"RegClassVector",
"&",
"CriticalPathRCs",
")",
"const",
"{",
"Mode",
"=",
"TargetSubtargetInfo",
"::",
"ANTIDEP_CRITICAL",
";",
"CriticalPathRCs",
".",
"clear",
"(",
")",
";",
"CriticalPathRCs",
".",
"push_back",
"(",
"&",
"ARM",
"::",
"GPRRegClass",
")",
";"
]
|
LLVM | Hexagon | CPP | stmt_completion | DSP | 5,019 | [
";"
]
| [
"Value",
"*",
"HighA",
"=",
"StridePos",
"?",
"LA",
":",
"SA",
";",
"Value",
"*",
"CmpA",
"=",
"Builder",
".",
"CreateICmpULT",
"(",
"LowA",
",",
"HighA",
")",
";",
"Value",
"*",
"Cond",
"=",
"CmpA",
";",
"Value",
"*",
"Dist",
"=",
"Builder",
".",
"CreateSub",
"(",
"LowA",
",",
"HighA",
")",
";",
"Value",
"*",
"CmpD",
"=",
"Builder",
".",
"CreateICmpSLE",
"(",
"NumBytes",
",",
"Dist",
")",
";",
"Value",
"*",
"CmpEither",
"=",
"Builder",
".",
"CreateOr",
"(",
"Cond",
",",
"CmpD",
")",
";",
"Cond",
"=",
"CmpEither",
";",
"if",
"(",
"Threshold",
"!=",
"<NUM_LIT>",
")",
"{",
"Type",
"*",
"Ty",
"=",
"NumBytes",
"->",
"getType",
"(",
")",
";",
"Value",
"*",
"Thr",
"=",
"ConstantInt",
"::",
"get",
"(",
"Ty",
",",
"Threshold",
")",
";",
"Value",
"*",
"CmpB",
"=",
"Builder",
".",
"CreateICmpULT",
"(",
"Thr",
",",
"NumBytes",
")",
";",
"Value",
"*",
"CmpBoth",
"=",
"Builder",
".",
"CreateAnd",
"(",
"Cond",
",",
"CmpB",
")",
";",
"Cond",
"=",
"CmpBoth",
";",
"}",
"BasicBlock",
"*",
"MemmoveB",
"=",
"BasicBlock",
"::",
"Create",
"(",
"Ctx",
",",
"Header",
"->",
"getName",
"(",
")",
"+",
"<STR_LIT>",
".rtli",
"<STR_LIT>",
",",
"Func",
",",
"NewPreheader",
")",
";",
"if",
"(",
"ParentL",
")",
"ParentL",
"->",
"addBasicBlockToLoop",
"(",
"MemmoveB",
",",
"*",
"LF",
")",
";",
"Instruction",
"*",
"OldT",
"=",
"Preheader",
"->",
"getTerminator",
"(",
")",
";",
"Builder",
".",
"CreateCondBr",
"(",
"Cond",
",",
"MemmoveB",
",",
"NewPreheader",
")",
";",
"OldT",
"->",
"eraseFromParent",
"(",
")",
";",
"Preheader",
"->",
"setName",
"(",
"Preheader",
"->",
"getName",
"(",
")",
"+",
"<STR_LIT>",
".old",
"<STR_LIT>",
")",
";",
"DT",
"->",
"addNewBlock",
"(",
"MemmoveB",
",",
"Preheader",
")",
";",
"BasicBlock",
"*",
"ExitD",
"=",
"Preheader",
";",
"for",
"(",
"auto",
"PI",
"=",
"pred_begin",
"(",
"ExitB",
")",
",",
"PE",
"=",
"pred_end",
"(",
"ExitB",
")",
";",
"PI",
"!=",
"PE",
";",
"++",
"PI",
")",
"{",
"BasicBlock",
"*",
"PB",
"=",
"*",
"PI",
";",
"ExitD",
"=",
"DT",
"->",
"findNearestCommonDominator",
"(",
"ExitD",
",",
"PB",
")",
";",
"if",
"(",
"!",
"ExitD",
")",
"break",
";",
"}",
"if",
"(",
"ExitD",
"&&",
"DT",
"->",
"dominates",
"(",
"Preheader",
",",
"ExitD",
")",
")",
"{",
"DomTreeNode",
"*",
"BN",
"=",
"DT",
"->",
"getNode",
"(",
"ExitB",
")",
";",
"DomTreeNode",
"*",
"DN",
"=",
"DT",
"->",
"getNode",
"(",
"ExitD",
")",
";",
"BN",
"->",
"setIDom",
"(",
"DN",
")",
";",
"}",
"IRBuilder",
"<",
">",
"CondBuilder",
"(",
"MemmoveB",
")",
";",
"CondBuilder",
".",
"CreateBr",
"(",
"ExitB",
")",
";",
"CondBuilder",
".",
"SetInsertPoint",
"(",
"MemmoveB",
"->",
"getTerminator",
"(",
")",
")",
";",
"if",
"(",
"DestVolatile",
")",
"{",
"Type",
"*",
"Int32Ty",
"=",
"Type",
"::",
"getInt32Ty",
"(",
"Ctx",
")",
";",
"Type",
"*",
"Int32PtrTy",
"=",
"Type",
"::",
"getInt32PtrTy",
"(",
"Ctx",
")",
";",
"Type",
"*",
"VoidTy",
"=",
"Type",
"::",
"getVoidTy",
"(",
"Ctx",
")",
";",
"Module",
"*",
"M",
"=",
"Func",
"->",
"getParent",
"(",
")",
";",
"Constant",
"*",
"CF",
"=",
"M",
"->",
"getOrInsertFunction",
"(",
"HexagonVolatileMemcpyName",
",",
"VoidTy",
",",
"Int32PtrTy",
",",
"Int32PtrTy",
",",
"Int32Ty",
")",
";",
"Function",
"*",
"Fn",
"=",
"cast",
"<",
"Function",
">",
"(",
"CF",
")",
";",
"Fn",
"->",
"setLinkage",
"(",
"Function",
"::",
"ExternalLinkage",
")",
";",
"const",
"SCEV",
"*",
"OneS",
"=",
"SE",
"->",
"getConstant",
"(",
"Int32Ty",
",",
"<NUM_LIT>",
")",
";",
"const",
"SCEV",
"*",
"BECount32",
"=",
"SE",
"->",
"getTruncateOrZeroExtend",
"(",
"BECount",
",",
"Int32Ty",
")",
";",
"const",
"SCEV",
"*",
"NumWordsS",
"=",
"SE",
"->",
"getAddExpr",
"(",
"BECount32",
",",
"OneS",
",",
"SCEV",
"::",
"FlagNUW",
")",
";",
"Value",
"*",
"NumWords",
"=",
"Expander",
".",
"expandCodeFor",
"(",
"NumWordsS",
",",
"Int32Ty",
",",
"MemmoveB",
"->",
"getTerminator",
"(",
")",
")",
";",
"if",
"(",
"Instruction",
"*",
"In",
"=",
"dyn_cast",
"<",
"Instruction",
">",
"(",
"NumWords",
")",
")",
"if",
"(",
"Value",
"*",
"Simp",
"=",
"SimplifyInstruction",
"(",
"In",
",",
"{",
"*",
"DL",
",",
"TLI",
",",
"DT",
"}",
")",
")",
"NumWords",
"=",
"Simp",
";",
"Value",
"*",
"Op0",
"=",
"(",
"StoreBasePtr",
"->",
"getType",
"(",
")",
"==",
"Int32PtrTy",
")",
"?",
"StoreBasePtr",
":",
"CondBuilder",
".",
"CreateBitCast",
"(",
"StoreBasePtr",
",",
"Int32PtrTy",
")",
";",
"Value",
"*",
"Op1",
"=",
"(",
"LoadBasePtr",
"->",
"getType",
"(",
")",
"==",
"Int32PtrTy",
")",
"?",
"LoadBasePtr",
":",
"CondBuilder",
".",
"CreateBitCast",
"(",
"LoadBasePtr",
",",
"Int32PtrTy",
")",
";",
"NewCall",
"=",
"CondBuilder",
".",
"CreateCall",
"(",
"Fn",
",",
"{",
"Op0",
",",
"Op1",
",",
"NumWords",
"}",
")",
";",
"}",
"else",
"{",
"NewCall",
"=",
"CondBuilder",
".",
"CreateMemMove",
"(",
"StoreBasePtr",
",",
"SI",
"->",
"getAlignment",
"(",
")",
",",
"LoadBasePtr",
",",
"LI",
"->",
"getAlignment",
"(",
")",
",",
"NumBytes",
")",
";",
"}",
"}",
"else",
"{",
"NewCall",
"=",
"Builder",
".",
"CreateMemCpy",
"(",
"StoreBasePtr",
",",
"SI",
"->",
"getAlignment",
"(",
")",
",",
"LoadBasePtr",
",",
"LI",
"->",
"getAlignment",
"(",
")",
",",
"NumBytes",
")",
";",
"RecursivelyDeleteTriviallyDeadInstructions",
"(",
"SI",
",",
"TLI",
")",
";",
"}",
"NewCall",
"->",
"setDebugLoc",
"(",
"DLoc",
")",
";",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
" Formed ",
"<STR_LIT>",
"<<",
"(",
"Overlap",
"?",
"<STR_LIT>",
"memmove: ",
"<STR_LIT>",
":",
"<STR_LIT>",
"memcpy: ",
"<STR_LIT>",
")",
"<<",
"*",
"NewCall",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
"<<",
"<STR_LIT>",
" from load ptr=",
"<STR_LIT>",
"<<",
"*",
"LoadEv",
"<<",
"<STR_LIT>",
" at: ",
"<STR_LIT>",
"<<",
"*",
"LI",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
"<<",
"<STR_LIT>",
" from store ptr=",
"<STR_LIT>",
"<<",
"*",
"StoreEv",
"<<",
"<STR_LIT>",
" at: ",
"<STR_LIT>",
"<<",
"*",
"SI",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"return",
"true"
]
|
GCC | i386 | CPP | next_suggestion | CPU | 5,020 | [
"}"
]
| [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m128i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_maskz_srli_epi64",
"(",
"_",
"_",
"mmask8",
"_",
"_",
"U",
",",
"_",
"_",
"m128i",
"_",
"_",
"A",
",",
"const",
"int",
"_",
"_",
"imm",
")",
"{",
"return",
"(",
"_",
"_",
"m128i",
")",
"_",
"_",
"builtin_ia32_psrlqi128_mask",
"(",
"(",
"_",
"_",
"v2di",
")",
"_",
"_",
"A",
",",
"_",
"_",
"imm",
",",
"(",
"_",
"_",
"v2di",
")",
"_",
"mm_setzero_si128",
"(",
")",
",",
"(",
"_",
"_",
"mmask8",
")",
"_",
"_",
"U",
")",
";"
]
|
LLVM | X86 | CPP | program_repair | CPU | 5,021 | [
"<FIXS>",
"X86ScalarSSEf64",
"=",
"Subtarget",
"->",
"hasSSE2",
"(",
")",
";",
"X86ScalarSSEf32",
"=",
"Subtarget",
"->",
"hasSSE1",
"(",
")",
";",
"<FIXE>"
]
| [
"X86TargetLowering",
"::",
"X86TargetLowering",
"(",
"TargetMachine",
"&",
"TM",
")",
":",
"TargetLowering",
"(",
"TM",
")",
"{",
"Subtarget",
"=",
"&",
"TM",
".",
"getSubtarget",
"X86Subtarget",
">",
"(",
")",
";",
"<BUGS>",
"X86ScalarSSE",
"=",
"Subtarget",
"->",
"hasSSE2",
"(",
")",
";",
"<BUGE>",
"X86StackPtr",
"=",
"Subtarget",
"->",
"is64Bit",
"(",
")",
"?",
"X86",
"::",
"RSP",
":",
"X86",
"::",
"ESP",
";",
"RegInfo",
"=",
"TM",
".",
"getRegisterInfo",
"(",
")",
";"
]
|
LLVM | WebAssembly | CPP | next_suggestion | Virtual ISA | 5,022 | [
"getTargetStreamer",
"(",
")",
"->",
"emitImportName",
"(",
"Sym",
",",
"Name",
")",
";"
]
| [
"if",
"(",
"F",
".",
"isDeclarationForLinker",
"(",
")",
")",
"{",
"SmallVector",
"<",
"MVT",
",",
"<NUM_LIT>",
">",
"Results",
";",
"SmallVector",
"<",
"MVT",
",",
"<NUM_LIT>",
">",
"Params",
";",
"computeSignatureVTs",
"(",
"F",
".",
"getFunctionType",
"(",
")",
",",
"&",
"F",
",",
"F",
",",
"TM",
",",
"Params",
",",
"Results",
")",
";",
"auto",
"Signature",
"=",
"signatureFromMVTs",
"(",
"Results",
",",
"Params",
")",
";",
"bool",
"InvokeDetected",
"=",
"false",
";",
"auto",
"*",
"Sym",
"=",
"getMCSymbolForFunction",
"(",
"&",
"F",
",",
"WasmEnableEmException",
"||",
"WasmEnableEmSjLj",
",",
"Signature",
".",
"get",
"(",
")",
",",
"InvokeDetected",
")",
";",
"if",
"(",
"InvokeDetected",
"&&",
"!",
"InvokeSymbols",
".",
"insert",
"(",
"Sym",
")",
".",
"second",
")",
"continue",
";",
"Sym",
"->",
"setType",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"if",
"(",
"!",
"Sym",
"->",
"getSignature",
"(",
")",
")",
"{",
"Sym",
"->",
"setSignature",
"(",
"Signature",
".",
"get",
"(",
")",
")",
";",
"addSignature",
"(",
"std",
"::",
"move",
"(",
"Signature",
")",
")",
";",
"}",
"else",
"{",
"Signature",
".",
"reset",
"(",
")",
";",
"}",
"getTargetStreamer",
"(",
")",
"->",
"emitFunctionType",
"(",
"Sym",
")",
";",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"wasm-import-module",
"<STR_LIT>",
")",
")",
"{",
"StringRef",
"Name",
"=",
"F",
".",
"getFnAttribute",
"(",
"<STR_LIT>",
"wasm-import-module",
"<STR_LIT>",
")",
".",
"getValueAsString",
"(",
")",
";",
"Sym",
"->",
"setImportModule",
"(",
"storeName",
"(",
"Name",
")",
")",
";",
"getTargetStreamer",
"(",
")",
"->",
"emitImportModule",
"(",
"Sym",
",",
"Name",
")",
";",
"}",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"wasm-import-name",
"<STR_LIT>",
")",
")",
"{",
"StringRef",
"Name",
"=",
"InvokeDetected",
"?",
"Sym",
"->",
"getName",
"(",
")",
":",
"F",
".",
"getFnAttribute",
"(",
"<STR_LIT>",
"wasm-import-name",
"<STR_LIT>",
")",
".",
"getValueAsString",
"(",
")",
";",
"Sym",
"->",
"setImportName",
"(",
"storeName",
"(",
"Name",
")",
")",
";"
]
|
LLVM | PowerPC | TD | stmt_completion | CPU | 5,023 | [
"BCDCTN_rec",
",",
"VMUL10CUQ",
",",
"VMUL10UQ",
",",
"XSXSIGQP",
")",
">",
";"
]
| [
"def",
":",
"InstRW",
"<",
"[",
"P10W_DX_5C",
",",
"P10W_DISP_ANY",
",",
"P10DX_Read",
"]",
",",
"(",
"instrs"
]
|
LLVM | ARM | CPP | stmt_completion | CPU | 5,024 | [
"(",
"*",
"CurrentReg",
")",
")",
"++",
"CurrentReg",
";"
]
| [
"while",
"(",
"CurrentReg",
"!=",
"OrderEnd",
"&&",
"!",
"EnabledRegs",
".",
"count"
]
|
GCC | csky | CPP | next_suggestion | CPU | 5,025 | [
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"\\taddi\\tsp, sp, 4\\n",
"<STR_LIT>",
")",
";"
]
| [
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"\\tlrw\\t%s, %ld\\n",
"<STR_LIT>",
",",
"reg1",
",",
"(",
"long",
")",
"vcall_offset",
")",
";",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"\\taddu\\t%s, %s, %s\\n",
"<STR_LIT>",
",",
"reg0",
",",
"reg0",
",",
"reg1",
")",
";",
"}",
"else",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"\\t%s\\t%s, %s, %ld\\n",
"<STR_LIT>",
",",
"(",
"vcall_offset",
">",
"<NUM_LIT>",
"?",
"<STR_LIT>",
"addi",
"<STR_LIT>",
":",
"<STR_LIT>",
"subi",
"<STR_LIT>",
")",
",",
"reg0",
",",
"reg0",
",",
"(",
"long",
")",
"(",
"vcall_offset",
">",
"<NUM_LIT>",
"?",
"vcall_offset",
":",
"-",
"vcall_offset",
")",
")",
";",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"\\tld.w\\t%s, (%s, 0)\\n",
"<STR_LIT>",
",",
"reg0",
",",
"reg0",
")",
";",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"\\taddu\\t%s, %s, %s\\n",
"<STR_LIT>",
",",
"thiz",
",",
"thiz",
",",
"reg0",
")",
";",
"}",
"if",
"(",
"CSKY_TARGET_ARCH",
"(",
"CK801",
")",
")",
"{",
"if",
"(",
"vcall_offset",
">",
"maxoff",
"||",
"vcall_offset",
"<",
"-",
"maxoff",
")",
"{",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"\\tld.w\\tl0, (sp, 0)\\n",
"<STR_LIT>",
")",
";",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"\\tld.w\\tl1, (sp, 4)\\n",
"<STR_LIT>",
")",
";",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"\\taddi\\t sp, sp, 8\\n",
"<STR_LIT>",
")",
";",
"}",
"else",
"if",
"(",
"delta",
">",
"maxoff",
"||",
"delta",
"<",
"-",
"maxoff",
")",
"{",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"\\tld.w\\tl0, (sp, 0)\\n",
"<STR_LIT>",
")",
";"
]
|
LLVM | X86 | CPP | next_suggestion | CPU | 5,026 | [
"if",
"(",
"F",
".",
"hasStructRetAttr",
"(",
")",
"&&",
"CC",
"!=",
"CallingConv",
"::",
"Swift",
")",
"{"
]
| [
"unsigned",
"SrcReg",
"=",
"Reg",
"+",
"VA",
".",
"getValNo",
"(",
")",
";",
"EVT",
"SrcVT",
"=",
"TLI",
".",
"getValueType",
"(",
"DL",
",",
"RV",
"->",
"getType",
"(",
")",
")",
";",
"EVT",
"DstVT",
"=",
"VA",
".",
"getValVT",
"(",
")",
";",
"if",
"(",
"SrcVT",
"!=",
"DstVT",
")",
"{",
"if",
"(",
"SrcVT",
"!=",
"MVT",
"::",
"i1",
"&&",
"SrcVT",
"!=",
"MVT",
"::",
"i8",
"&&",
"SrcVT",
"!=",
"MVT",
"::",
"i16",
")",
"return",
"false",
";",
"if",
"(",
"!",
"Outs",
"[",
"<NUM_LIT>",
"]",
".",
"Flags",
".",
"isZExt",
"(",
")",
"&&",
"!",
"Outs",
"[",
"<NUM_LIT>",
"]",
".",
"Flags",
".",
"isSExt",
"(",
")",
")",
"return",
"false",
";",
"assert",
"(",
"DstVT",
"==",
"MVT",
"::",
"i32",
"&&",
"<STR_LIT>",
"X86 should always ext to i32",
"<STR_LIT>",
")",
";",
"if",
"(",
"SrcVT",
"==",
"MVT",
"::",
"i1",
")",
"{",
"if",
"(",
"Outs",
"[",
"<NUM_LIT>",
"]",
".",
"Flags",
".",
"isSExt",
"(",
")",
")",
"return",
"false",
";",
"SrcReg",
"=",
"fastEmitZExtFromI1",
"(",
"MVT",
"::",
"i8",
",",
"SrcReg",
",",
"false",
")",
";",
"SrcVT",
"=",
"MVT",
"::",
"i8",
";",
"}",
"unsigned",
"Op",
"=",
"Outs",
"[",
"<NUM_LIT>",
"]",
".",
"Flags",
".",
"isZExt",
"(",
")",
"?",
"ISD",
"::",
"ZERO_EXTEND",
":",
"ISD",
"::",
"SIGN_EXTEND",
";",
"SrcReg",
"=",
"fastEmit_r",
"(",
"SrcVT",
".",
"getSimpleVT",
"(",
")",
",",
"DstVT",
".",
"getSimpleVT",
"(",
")",
",",
"Op",
",",
"SrcReg",
",",
"false",
")",
";",
"}",
"unsigned",
"DstReg",
"=",
"VA",
".",
"getLocReg",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"SrcRC",
"=",
"MRI",
".",
"getRegClass",
"(",
"SrcReg",
")",
";",
"if",
"(",
"!",
"SrcRC",
"->",
"contains",
"(",
"DstReg",
")",
")",
"return",
"false",
";",
"BuildMI",
"(",
"*",
"FuncInfo",
".",
"MBB",
",",
"FuncInfo",
".",
"InsertPt",
",",
"DbgLoc",
",",
"TII",
".",
"get",
"(",
"TargetOpcode",
"::",
"COPY",
")",
",",
"DstReg",
")",
".",
"addReg",
"(",
"SrcReg",
")",
";",
"RetRegs",
".",
"push_back",
"(",
"VA",
".",
"getLocReg",
"(",
")",
")",
";",
"}"
]
|
LLVM | ARM | TD | next_suggestion | CPU | 5,027 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"CRd",
";"
]
| [
"bits",
"<",
"<NUM_LIT>",
">",
"cop",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"CRd",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"Dbit",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"load",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"addr",
";"
]
|
LLVM | Mips | CPP | stmt_completion | CPU | 5,028 | [
"SrcReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"FMOV_D32",
";"
]
| [
"Opc",
"=",
"isMicroMips",
"?",
"Mips",
"::",
"MFHI16_MM",
":",
"Mips",
"::",
"MFHI",
";",
"SrcReg",
"=",
"<NUM_LIT>",
";",
"}",
"else",
"if",
"(",
"Mips",
"::",
"LO32RegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
"{",
"Opc",
"=",
"isMicroMips",
"?",
"Mips",
"::",
"MFLO16_MM",
":",
"Mips",
"::",
"MFLO",
";",
"SrcReg",
"=",
"<NUM_LIT>",
";",
"}",
"else",
"if",
"(",
"Mips",
"::",
"HI32DSPRegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"MFHI_DSP",
";",
"else",
"if",
"(",
"Mips",
"::",
"LO32DSPRegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"MFLO_DSP",
";",
"else",
"if",
"(",
"Mips",
"::",
"DSPCCRegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Mips",
"::",
"RDDSP",
")",
",",
"DestReg",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
"<<",
"<NUM_LIT>",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"RegState",
"::",
"Implicit",
"|",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"Mips",
"::",
"MSACtrlRegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"CFCMSA",
";",
"}",
"else",
"if",
"(",
"Mips",
"::",
"GPR32RegClass",
".",
"contains",
"(",
"SrcReg",
")",
")",
"{",
"if",
"(",
"Mips",
"::",
"CCRRegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"CTC1",
";",
"else",
"if",
"(",
"Mips",
"::",
"FGR32RegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"MTC1",
";",
"else",
"if",
"(",
"Mips",
"::",
"HI32RegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"MTHI",
",",
"DestReg",
"=",
"<NUM_LIT>",
";",
"else",
"if",
"(",
"Mips",
"::",
"LO32RegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"MTLO",
",",
"DestReg",
"=",
"<NUM_LIT>",
";",
"else",
"if",
"(",
"Mips",
"::",
"HI32DSPRegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"MTHI_DSP",
";",
"else",
"if",
"(",
"Mips",
"::",
"LO32DSPRegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"MTLO_DSP",
";",
"else",
"if",
"(",
"Mips",
"::",
"DSPCCRegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Mips",
"::",
"WRDSP",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
"<<",
"<NUM_LIT>",
")",
".",
"addReg",
"(",
"DestReg",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"Mips",
"::",
"MSACtrlRegClass",
".",
"contains",
"(",
"DestReg",
")",
")",
"{",
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"Mips",
"::",
"CTCMSA",
")",
")",
".",
"addReg",
"(",
"DestReg",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"KillSrc",
")",
")",
";",
"return",
";",
"}",
"}",
"else",
"if",
"(",
"Mips",
"::",
"FGR32RegClass",
".",
"contains",
"(",
"DestReg",
",",
"SrcReg",
")",
")",
"Opc",
"=",
"Mips",
"::",
"FMOV_S",
";",
"else",
"if",
"(",
"Mips",
"::",
"AFGR64RegClass",
".",
"contains",
"(",
"DestReg",
","
]
|
LLVM | WebAssembly | CPP | code_generation | Virtual ISA | 5,029 | [
"bool",
"WebAssemblyLowerBrUnless",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"********** Lowering br_unless **********\\n",
"<STR_LIT>",
"<STR_LIT>",
"********** Function: ",
"<STR_LIT>",
"<<",
"MF",
".",
"getName",
"(",
")",
"<<",
"'",
"\\n",
"'",
")",
";",
"auto",
"&",
"MFI",
"=",
"*",
"MF",
".",
"getInfo",
"<",
"WebAssemblyFunctionInfo",
">",
"(",
")",
";",
"const",
"auto",
"&",
"TII",
"=",
"*",
"MF",
".",
"getSubtarget",
"<",
"WebAssemblySubtarget",
">",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"auto",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"for",
"(",
"auto",
"&",
"MBB",
":",
"MF",
")",
"{",
"for",
"(",
"auto",
"MII",
"=",
"MBB",
".",
"begin",
"(",
")",
";",
"MII",
"!=",
"MBB",
".",
"end",
"(",
")",
";",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"&",
"*",
"MII",
"++",
";",
"if",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
"!=",
"WebAssembly",
"::",
"BR_UNLESS",
")",
"continue",
";",
"unsigned",
"Cond",
"=",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"bool",
"Inverted",
"=",
"false",
";",
"if",
"(",
"MFI",
".",
"isVRegStackified",
"(",
"Cond",
")",
")",
"{",
"assert",
"(",
"MRI",
".",
"hasOneDef",
"(",
"Cond",
")",
")",
";",
"MachineInstr",
"*",
"Def",
"=",
"MRI",
".",
"getVRegDef",
"(",
"Cond",
")",
";",
"switch",
"(",
"Def",
"->",
"getOpcode",
"(",
")",
")",
"{",
"using",
"namespace",
"WebAssembly",
";",
"case",
"EQ_I32",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"NE_I32",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"NE_I32",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"EQ_I32",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"GT_S_I32",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"LE_S_I32",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"GE_S_I32",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"LT_S_I32",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"LT_S_I32",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"GE_S_I32",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"LE_S_I32",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"GT_S_I32",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"GT_U_I32",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"LE_U_I32",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"GE_U_I32",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"LT_U_I32",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"LT_U_I32",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"GE_U_I32",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"LE_U_I32",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"GT_U_I32",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"EQ_I64",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"NE_I64",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"NE_I64",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"EQ_I64",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"GT_S_I64",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"LE_S_I64",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"GE_S_I64",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"LT_S_I64",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"LT_S_I64",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"GE_S_I64",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"LE_S_I64",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"GT_S_I64",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"GT_U_I64",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"LE_U_I64",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"GE_U_I64",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"LT_U_I64",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"LT_U_I64",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"GE_U_I64",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"LE_U_I64",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"GT_U_I64",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"EQ_F32",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"NE_F32",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"NE_F32",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"EQ_F32",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"EQ_F64",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"NE_F64",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"case",
"NE_F64",
":",
"Def",
"->",
"setDesc",
"(",
"TII",
".",
"get",
"(",
"EQ_F64",
")",
")",
";",
"Inverted",
"=",
"true",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"}",
"if",
"(",
"!",
"Inverted",
")",
"{",
"unsigned",
"ZeroReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"WebAssembly",
"::",
"I32RegClass",
")",
";",
"MFI",
".",
"stackifyVReg",
"(",
"ZeroReg",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"WebAssembly",
"::",
"CONST_I32",
")",
",",
"ZeroReg",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
";",
"unsigned",
"Tmp",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"WebAssembly",
"::",
"I32RegClass",
")",
";",
"MFI",
".",
"stackifyVReg",
"(",
"Tmp",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"WebAssembly",
"::",
"EQ_I32",
")",
",",
"Tmp",
")",
".",
"addReg",
"(",
"Cond",
")",
".",
"addReg",
"(",
"ZeroReg",
")",
";",
"Cond",
"=",
"Tmp",
";",
"Inverted",
"=",
"true",
";",
"}",
"assert",
"(",
"Inverted",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"MI",
"->",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"WebAssembly",
"::",
"BR_IF",
")",
")",
".",
"addReg",
"(",
"Cond",
")",
".",
"addOperand",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"}",
"return",
"true",
";",
"}"
]
| [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
]
|
GCC | s390 | MD | next_suggestion | MPU | 5,030 | [
"(",
"match_test",
"<STR_LIT>",
")",
")",
")"
]
| [
"(",
"define_constraint",
"<STR_LIT>",
"<STR_LIT>",
"(",
"and",
"(",
"match_code",
"<STR_LIT>",
")"
]
|
GCC | c6x | MD | next_suggestion | VLIW | 5,031 | [
"<STR_LIT>"
]
| [
"[",
"(",
"unspec",
"[",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mult",
":",
"DI",
"(",
"zero_extend",
":",
"DI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"sign_extend",
":",
"DI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"UNSPEC_REAL_MULT",
")",
"]"
]
|
GCC | arm | CPP | stmt_completion | CPU | 5,032 | [
";"
]
| [
"gcc_assert",
"(",
"(",
"GET_MODE",
"(",
"op0",
")",
"==",
"mode0",
"||",
"GET_MODE",
"(",
"op0",
")",
"==",
"VOIDmode",
")",
"&&",
"(",
"GET_MODE",
"(",
"op1",
")",
"==",
"mode1",
"||",
"GET_MODE",
"(",
"op1",
")",
"==",
"VOIDmode",
")",
"&&",
"(",
"GET_MODE",
"(",
"op2",
")",
"==",
"mode2",
"||",
"GET_MODE",
"(",
"op2",
")",
"==",
"VOIDmode",
")",
")",
";",
"if",
"(",
"!",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"<NUM_LIT>",
"]",
".",
"predicate",
")",
"(",
"op0",
",",
"mode0",
")",
")",
"op0",
"=",
"copy_to_mode_reg",
"(",
"mode0",
",",
"op0",
")",
";",
"if",
"(",
"!",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"<NUM_LIT>",
"]",
".",
"predicate",
")",
"(",
"op1",
",",
"mode1",
")",
")",
"op1",
"=",
"copy_to_mode_reg",
"(",
"mode1",
",",
"op1",
")",
";",
"if",
"(",
"!",
"(",
"*",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"<NUM_LIT>",
"]",
".",
"predicate",
")",
"(",
"op2",
",",
"mode2",
")",
")",
"op2",
"=",
"copy_to_mode_reg",
"(",
"mode2",
",",
"op2",
")",
";",
"pat",
"=",
"GEN_FCN",
"(",
"icode",
")",
"(",
"target",
",",
"op0",
",",
"op1",
",",
"op2",
")",
";",
"if",
"(",
"!",
"pat",
")",
"return",
"<NUM_LIT>",
";",
"emit_insn",
"(",
"pat",
")",
";",
"return",
"target"
]
|
GCC | sh | CPP | stmt_completion | CPU | 5,033 | [
"XVECEXP",
"(",
"PATTERN",
"(",
"insn",
")",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";"
]
| [
"while",
"(",
"(",
"insn",
"=",
"NEXT_INSN",
"(",
"insn",
")",
")",
")",
"{",
"if",
"(",
"GET_CODE",
"(",
"insn",
")",
"==",
"CODE_LABEL",
"||",
"GET_CODE",
"(",
"insn",
")",
"==",
"JUMP_INSN",
")",
"break",
";",
"if",
"(",
"!",
"INSN_P",
"(",
"insn",
")",
")",
"continue",
";",
"if",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"insn",
")",
")",
"==",
"SEQUENCE",
")",
"insn",
"="
]
|
GCC | aarch64 | CPP | stmt_completion | CPU | 5,034 | [
"_",
"b",
",",
"_",
"_",
"c",
")",
";"
]
| [
"return",
"_",
"_",
"builtin_aarch64_sqrdmlshv4si",
"(",
"_",
"_",
"a",
",",
"_"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 5,035 | [
"let",
"isRestrictNoSlot1Store",
"=",
"<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",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";",
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | Hexagon | TD | stmt_completion | DSP | 5,036 | [
"<NUM_LIT>",
";"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"Defs",
"=",
"[",
"LC1",
",",
"SA1",
"]",
";",
"let",
"isExtendable",
"="
]
|
LLVM | AArch64 | CPP | program_repair | CPU | 5,037 | [
"<FIXS>",
"DAG",
".",
"getConstant",
"(",
"CnstVal",
",",
"dl",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"<FIXE>"
]
| [
"VT",
".",
"getSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
")",
"{",
"CnstVal",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"CnstVal",
")",
";",
"SDValue",
"Mov",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MVT",
"::",
"v2f64",
",",
"<BUGS>",
"DAG",
".",
"getConstant",
"(",
"CnstVal",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"<BUGE>",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VT",
",",
"Mov",
")",
";",
"}"
]
|
GCC | rs6000 | MD | next_suggestion | CPU | 5,038 | [
"(",
"unspec",
":",
"SFDF",
"[",
"(",
"match_operand",
":",
"SFDF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SFDF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
GCC | i386 | MD | next_suggestion | CPU | 5,039 | [
"<STR_LIT>",
")"
]
| [
"(",
"match_operand",
":",
"V2DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"parallel",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
")",
")",
")",
"]",
"<STR_LIT>"
]
|
GCC | rs6000 | MD | next_suggestion | CPU | 5,040 | [
"<STR_LIT>",
")"
]
| [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
]
|
GCC | aarch64 | MD | stmt_completion | CPU | 5,041 | [
")",
")"
]
| [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>"
]
|
GCC | tilepro | MD | next_suggestion | VLIW | 5,042 | [
"DONE"
]
| [
"[",
"(",
"set",
"(",
"match_operand",
":",
"VEC",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"VEC",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<STR_LIT>",
"{",
"tilepro_expand_movmisalign",
"(",
"<",
"MODE",
">",
"mode",
",",
"operands",
")"
]
|
LLVM | SystemZ | TD | next_suggestion | CPU | 5,043 | [
"}"
]
| [
"bits",
"<",
"<NUM_LIT>",
">",
"BD2",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"R3",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"op",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"RBD1",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"R3",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"RBD1",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"BD2",
";"
]
|
GCC | frv | MD | next_suggestion | VLIW | 5,044 | [
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
]
| [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"CC_FP",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"CC_FP",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
LLVM | AArch64 | TD | next_suggestion | CPU | 5,045 | [
"let",
"MIOperandInfo",
"=",
"(",
"ops",
"GPR32",
",",
"arith_extend64",
")",
";"
]
| [
"class",
"arith_extended_reg32to64",
"<",
"ValueType",
"Ty",
">",
":",
"Operand",
"<",
"Ty",
">",
",",
"ComplexPattern",
"<",
"Ty",
",",
"<NUM_LIT>",
",",
"<STR_LIT>",
",",
"[",
"]",
">",
"{",
"let",
"PrintMethod",
"=",
"<STR_LIT>",
";"
]
|
LLVM | SystemZ | TD | next_suggestion | CPU | 5,046 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"M3",
";"
]
| [
"bits",
"<",
"<NUM_LIT>",
">",
"BD2",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"op",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"R1",
";"
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 5,047 | [
",",
"AllowModify",
")",
";"
]
| [
"bool",
"SIInstrInfo",
"::",
"analyzeBranch",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"*",
"&",
"TBB",
",",
"MachineBasicBlock",
"*",
"&",
"FBB",
",",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
",",
"bool",
"AllowModify",
")",
"const",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
".",
"getFirstTerminator",
"(",
")",
";",
"if",
"(",
"I",
"==",
"MBB",
".",
"end",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"I",
"->",
"getOpcode",
"(",
")",
"!=",
"AMDGPU",
"::",
"SI_MASK_BRANCH",
")",
"return",
"analyzeBranchImpl",
"(",
"MBB",
",",
"I",
",",
"TBB",
",",
"FBB",
",",
"Cond"
]
|
GCC | h8300 | CPP | code_generation | MPU | 5,048 | [
"int",
"h8300_tiny_data_p",
"(",
"tree",
"decl",
")",
"{",
"tree",
"a",
";",
"if",
"(",
"TREE_CODE",
"(",
"decl",
")",
"!=",
"VAR_DECL",
")",
"return",
"<NUM_LIT>",
";",
"a",
"=",
"lookup_attribute",
"(",
"<STR_LIT>",
"tiny_data",
"<STR_LIT>",
",",
"DECL_ATTRIBUTES",
"(",
"decl",
")",
")",
";",
"return",
"a",
"!=",
"NULL_TREE",
";",
"}"
]
| [
"Return",
"nonzero",
"if",
"DECL",
"is",
"a",
"variable",
"that",
"'s",
"in",
"the",
"tiny",
"data",
"area",
"."
]
|
LLVM | LoongArch | CPP | next_suggestion | CPU | 5,049 | [
"switch",
"(",
"MO",
".",
"getType",
"(",
")",
")",
"{"
]
| [
"if",
"(",
"ExtraCode",
"&&",
"ExtraCode",
"[",
"<NUM_LIT>",
"]",
")",
"{",
"if",
"(",
"ExtraCode",
"[",
"<NUM_LIT>",
"]",
"!=",
"<NUM_LIT>",
")",
"return",
"true",
";",
"switch",
"(",
"ExtraCode",
"[",
"<NUM_LIT>",
"]",
")",
"{",
"default",
":",
"return",
"true",
";",
"case",
"'",
"z",
"'",
":",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
"&&",
"MO",
".",
"getImm",
"(",
")",
"==",
"<NUM_LIT>",
")",
"{",
"OS",
"<<",
"'",
"$",
"'",
"<<",
"LoongArchInstPrinter",
"::",
"getRegisterName",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"break",
";",
"case",
"'",
"w",
"'",
":",
"if",
"(",
"MO",
".",
"getReg",
"(",
")",
".",
"id",
"(",
")",
">=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"MO",
".",
"getReg",
"(",
")",
".",
"id",
"(",
")",
"<=",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"break",
";",
"return",
"true",
";",
"case",
"'",
"u",
"'",
":",
"if",
"(",
"MO",
".",
"getReg",
"(",
")",
".",
"id",
"(",
")",
">=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"MO",
".",
"getReg",
"(",
")",
".",
"id",
"(",
")",
"<=",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"break",
";",
"return",
"true",
";",
"}",
"}"
]
|
GCC | aarch64 | CPP | stmt_completion | CPU | 5,050 | [
"_",
"_",
"a",
";"
]
| [
"return",
"(",
"int16x4_t",
")"
]
|
LLVM | X86 | CPP | next_suggestion | CPU | 5,051 | [
"}"
]
| [
"MachineBasicBlock",
"*",
"continueMBB",
"=",
"MF",
"->",
"CreateMachineBasicBlock",
"(",
"LLVM_BB",
")",
";",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
"->",
"getRegInfo",
"(",
")",
";",
"const",
"TargetRegisterClass",
"*",
"AddrRegClass",
"=",
"getRegClassFor",
"(",
"Is64Bit",
"?",
"MVT",
"::",
"i64",
":",
"MVT",
"::",
"i32",
")",
";",
"unsigned",
"mallocPtrVReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"AddrRegClass",
")",
",",
"bumpSPPtrVReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"AddrRegClass",
")",
",",
"tmpSPVReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"AddrRegClass",
")",
",",
"SPLimitVReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"AddrRegClass",
")",
",",
"sizeVReg",
"=",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
",",
"physSPReg",
"=",
"Is64Bit",
"?",
"X86",
"::",
"RSP",
":",
"X86",
"::",
"ESP",
";",
"MachineFunction",
"::",
"iterator",
"MBBIter",
"=",
"BB",
";",
"++",
"MBBIter",
";",
"MF",
"->",
"insert",
"(",
"MBBIter",
",",
"bumpMBB",
")",
";",
"MF",
"->",
"insert",
"(",
"MBBIter",
",",
"mallocMBB",
")",
";",
"MF",
"->",
"insert",
"(",
"MBBIter",
",",
"continueMBB",
")",
";",
"continueMBB",
"->",
"splice",
"(",
"continueMBB",
"->",
"begin",
"(",
")",
",",
"BB",
",",
"std",
"::",
"next",
"(",
"MachineBasicBlock",
"::",
"iterator",
"(",
"MI",
")",
")",
",",
"BB",
"->",
"end",
"(",
")",
")",
";",
"continueMBB",
"->",
"transferSuccessorsAndUpdatePHIs",
"(",
"BB",
")",
";",
"BuildMI",
"(",
"BB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"TargetOpcode",
"::",
"COPY",
")",
",",
"tmpSPVReg",
")",
".",
"addReg",
"(",
"physSPReg",
")",
";",
"BuildMI",
"(",
"BB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"Is64Bit",
"?",
"X86",
"::",
"SUB64rr",
":",
"X86",
"::",
"SUB32rr",
")",
",",
"SPLimitVReg",
")",
".",
"addReg",
"(",
"tmpSPVReg",
")",
".",
"addReg",
"(",
"sizeVReg",
")",
";",
"BuildMI",
"(",
"BB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"Is64Bit",
"?",
"X86",
"::",
"CMP64mr",
":",
"X86",
"::",
"CMP32mr",
")",
")",
".",
"addReg",
"(",
"<NUM_LIT>",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
".",
"addReg",
"(",
"<NUM_LIT>",
")",
".",
"addImm",
"(",
"TlsOffset",
")",
".",
"addReg",
"(",
"TlsReg",
")",
".",
"addReg",
"(",
"SPLimitVReg",
")",
";",
"BuildMI",
"(",
"BB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"JG_4",
")",
")",
".",
"addMBB",
"(",
"mallocMBB",
")",
";",
"BuildMI",
"(",
"bumpMBB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"TargetOpcode",
"::",
"COPY",
")",
",",
"physSPReg",
")",
".",
"addReg",
"(",
"SPLimitVReg",
")",
";",
"BuildMI",
"(",
"bumpMBB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"TargetOpcode",
"::",
"COPY",
")",
",",
"bumpSPPtrVReg",
")",
".",
"addReg",
"(",
"SPLimitVReg",
")",
";",
"BuildMI",
"(",
"bumpMBB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"JMP_4",
")",
")",
".",
"addMBB",
"(",
"continueMBB",
")",
";",
"const",
"uint32_t",
"*",
"RegMask",
"=",
"MF",
"->",
"getTarget",
"(",
")",
".",
"getSubtargetImpl",
"(",
")",
"->",
"getRegisterInfo",
"(",
")",
"->",
"getCallPreservedMask",
"(",
"CallingConv",
"::",
"C",
")",
";",
"if",
"(",
"Is64Bit",
")",
"{",
"BuildMI",
"(",
"mallocMBB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"MOV64rr",
")",
",",
"X86",
"::",
"RDI",
")",
".",
"addReg",
"(",
"sizeVReg",
")",
";",
"BuildMI",
"(",
"mallocMBB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"CALL64pcrel32",
")",
")",
".",
"addExternalSymbol",
"(",
"<STR_LIT>",
"__morestack_allocate_stack_space",
"<STR_LIT>",
")",
".",
"addRegMask",
"(",
"RegMask",
")",
".",
"addReg",
"(",
"X86",
"::",
"RDI",
",",
"RegState",
"::",
"Implicit",
")",
".",
"addReg",
"(",
"X86",
"::",
"RAX",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";",
"}",
"else",
"{",
"BuildMI",
"(",
"mallocMBB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"SUB32ri",
")",
",",
"physSPReg",
")",
".",
"addReg",
"(",
"physSPReg",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
";",
"BuildMI",
"(",
"mallocMBB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"PUSH32r",
")",
")",
".",
"addReg",
"(",
"sizeVReg",
")",
";",
"BuildMI",
"(",
"mallocMBB",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"X86",
"::",
"CALLpcrel32",
")",
")",
".",
"addExternalSymbol",
"(",
"<STR_LIT>",
"__morestack_allocate_stack_space",
"<STR_LIT>",
")",
".",
"addRegMask",
"(",
"RegMask",
")",
".",
"addReg",
"(",
"X86",
"::",
"EAX",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";"
]
|
GCC | mcore | MD | next_suggestion | MPU | 5,052 | [
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
]
| [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"reg",
":",
"CC",
"<NUM_LIT>",
")",
"(",
"ne",
":",
"CC",
"(",
"lshiftrt",
":",
"SI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>"
]
|
GCC | i386 | MD | next_suggestion | CPU | 5,053 | [
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"(",
"match_operand",
":",
"<",
"avx512fmaskmode",
">",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
LLVM | AMDGPU | CPP | code_generation | GPU | 5,054 | [
"bool",
"R600InstrInfo",
"::",
"FindSwizzleForVectorSlot",
"(",
"const",
"std",
"::",
"vector",
"<",
"std",
"::",
"vector",
"<",
"std",
"::",
"pair",
"<",
"int",
",",
"unsigned",
">>",
">",
"&",
"IGSrcs",
",",
"std",
"::",
"vector",
"<",
"R600InstrInfo",
"::",
"BankSwizzle",
">",
"&",
"SwzCandidate",
",",
"const",
"std",
"::",
"vector",
"<",
"std",
"::",
"pair",
"<",
"int",
",",
"unsigned",
">>",
"&",
"TransSrcs",
",",
"R600InstrInfo",
"::",
"BankSwizzle",
"TransSwz",
")",
"const",
"{",
"unsigned",
"ValidUpTo",
"=",
"<NUM_LIT>",
";",
"do",
"{",
"ValidUpTo",
"=",
"isLegalUpTo",
"(",
"IGSrcs",
",",
"SwzCandidate",
",",
"TransSrcs",
",",
"TransSwz",
")",
";",
"if",
"(",
"ValidUpTo",
"==",
"IGSrcs",
".",
"size",
"(",
")",
")",
"return",
"true",
";",
"}",
"while",
"(",
"NextPossibleSolution",
"(",
"SwzCandidate",
",",
"ValidUpTo",
")",
")",
";",
"return",
"false",
";",
"}"
]
| [
"Enumerate",
"all",
"possible",
"Swizzle",
"sequence",
"to",
"find",
"one",
"that",
"can",
"meet",
"all",
"read",
"port",
"requirements",
"."
]
|
LLVM | ARM | CPP | next_suggestion | CPU | 5,055 | [
"return",
"Val",
";"
]
| [
"bool",
"J2",
"=",
"(",
"Val",
"&",
"<NUM_LIT>",
")",
";",
"if",
"(",
"I",
"^",
"J1",
")",
"Val",
"&=",
"~",
"<NUM_LIT>",
";",
"else",
"Val",
"|=",
"<NUM_LIT>",
";",
"if",
"(",
"I",
"^",
"J2",
")",
"Val",
"&=",
"~",
"<NUM_LIT>",
";",
"else",
"Val",
"|=",
"<NUM_LIT>",
";"
]
|
GCC | i386 | MD | next_suggestion | CPU | 5,056 | [
"}",
")"
]
| [
"(",
"match_operand",
":",
"VI8F_256",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"VI8F_256",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"VI8F_256",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
")",
"]",
"<STR_LIT>",
"{",
"int",
"mask",
"=",
"INTVAL",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"emit_insn",
"(",
"gen_avx512dq_shuf_",
"<",
"shuffletype",
">",
"<NUM_LIT>",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"GEN_INT",
"(",
"(",
"(",
"mask",
">",
">",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
")",
"*",
"<NUM_LIT>",
"+",
"<NUM_LIT>",
")",
",",
"GEN_INT",
"(",
"(",
"(",
"mask",
">",
">",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
")",
"*",
"<NUM_LIT>",
"+",
"<NUM_LIT>",
")",
",",
"GEN_INT",
"(",
"(",
"(",
"mask",
">",
">",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
")",
"*",
"<NUM_LIT>",
"+",
"<NUM_LIT>",
")",
",",
"GEN_INT",
"(",
"(",
"(",
"mask",
">",
">",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
")",
"*",
"<NUM_LIT>",
"+",
"<NUM_LIT>",
")",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
")",
"DONE"
]
|
LLVM | AMDGPU | CPP | program_repair | GPU | 5,057 | [
"<FIXS>",
"MachineBasicBlock",
"::",
"iterator",
"I",
"(",
"&",
"MI",
")",
";",
"<FIXE>",
"<FIXS>",
"unsigned",
"Idx",
"=",
"TII",
"->",
"getNamedOperand",
"(",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"idx",
")",
"->",
"getReg",
"(",
")",
";",
"<FIXE>"
]
| [
"bool",
"SILowerControlFlow",
"::",
"loadM0",
"(",
"MachineInstr",
"&",
"MI",
",",
"MachineInstr",
"*",
"MovRel",
",",
"int",
"Offset",
")",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
";",
"DebugLoc",
"DL",
"=",
"MI",
".",
"getDebugLoc",
"(",
")",
";",
"<BUGS>",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MI",
";",
"<BUGE>",
"<BUGS>",
"unsigned",
"Idx",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"<BUGE>",
"if",
"(",
"AMDGPU",
"::",
"SReg_32RegClass",
".",
"contains",
"(",
"Idx",
")",
")",
"{",
"if",
"(",
"Offset",
")",
"{"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 5,058 | [
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"P0",
"]",
";",
"let",
"Defs",
"=",
"[",
"P0",
",",
"PC",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | X86 | CPP | code_generation | CPU | 5,059 | [
"const",
"MCFixupKindInfo",
"&",
"getFixupKindInfo",
"(",
"MCFixupKind",
"Kind",
")",
"const",
"{",
"const",
"static",
"MCFixupKindInfo",
"Infos",
"[",
"]",
"=",
"{",
"{",
"<STR_LIT>",
"reloc_pcrel_4byte",
"<STR_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"*",
"<NUM_LIT>",
"}",
",",
"{",
"<STR_LIT>",
"reloc_pcrel_1byte",
"<STR_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"*",
"<NUM_LIT>",
"}",
",",
"{",
"<STR_LIT>",
"reloc_riprel_4byte",
"<STR_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"*",
"<NUM_LIT>",
"}",
"}",
";",
"if",
"(",
"Kind",
"<",
"FirstTargetFixupKind",
")",
"return",
"MCCodeEmitter",
"::",
"getFixupKindInfo",
"(",
"Kind",
")",
";",
"assert",
"(",
"unsigned",
"(",
"Kind",
"-",
"FirstTargetFixupKind",
")",
"<",
"getNumFixupKinds",
"(",
")",
"&&",
"<STR_LIT>",
"Invalid kind!",
"<STR_LIT>",
")",
";",
"return",
"Infos",
"[",
"Kind",
"-",
"FirstTargetFixupKind",
"]",
";",
"}"
]
| [
"Get",
"information",
"on",
"a",
"fixup",
"kind",
"."
]
|
GCC | alpha | MD | next_suggestion | MPU | 5,060 | [
"<STR_LIT>"
]
| [
"[",
"(",
"parallel",
"[",
"(",
"call",
"(",
"mem",
":",
"DI",
"(",
"match_operand",
"<NUM_LIT>",
")",
")",
"(",
"match_operand",
"<NUM_LIT>",
")",
")",
"(",
"use",
"(",
"reg",
":",
"DI",
"<NUM_LIT>",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"DI",
"<NUM_LIT>",
")",
")",
"]",
")",
"]"
]
|
GCC | sh | MD | stmt_completion | CPU | 5,061 | [
"(",
"const_int",
"<NUM_LIT>",
")",
")"
]
| [
"(",
"label_ref",
"(",
"match_operand",
"<NUM_LIT>",
")",
")",
"(",
"pc",
")",
")",
")",
"]",
"<STR_LIT>",
"{",
"return",
"output_branch",
"(",
"sh_eval_treg_value",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
",",
"insn",
",",
"operands",
")",
"}",
"<STR_LIT>",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
"{",
"/",
"*",
"Try",
"to",
"canonicalize",
"the",
"branch",
"condition",
"if",
"it",
"is",
"not",
"one",
"of",
":",
"(",
"ne",
"(",
"reg",
":",
"SI",
"T_REG",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"eq",
"(",
"reg",
":",
"SI",
"T_REG",
")"
]
|
GCC | h8300 | CPP | stmt_completion | MPU | 5,062 | [
"onlyjump_p",
"(",
"i2",
")",
")",
";"
]
| [
"return",
"(",
"INSN_P",
"(",
"i1",
")",
"&&",
"rtx_equal_p",
"(",
"PATTERN",
"(",
"i1",
")",
",",
"PATTERN",
"(",
"i3",
")",
")",
"&&",
"any_condjump_p",
"(",
"i2",
")",
"&&"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 5,063 | [
"_",
"B",
",",
"(",
"_",
"_",
"v32qi",
")",
"_",
"_",
"W",
",",
"(",
"_",
"_",
"mmask32",
")",
"_",
"_",
"M",
")",
";"
]
| [
"return",
"(",
"_",
"_",
"m256i",
")",
"_",
"_",
"builtin_ia32_pmaxub256_mask",
"(",
"(",
"_",
"_",
"v32qi",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v32qi",
")",
"_"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 5,064 | [
")",
")",
"_",
"mm512_reduce_add_ph",
"(",
"_",
"_",
"m512h",
"_",
"_",
"A",
")",
"{"
]
| [
"extern",
"_",
"_",
"inline",
"_",
"Float16",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__"
]
|
GCC | aarch64 | CPP | next_suggestion | CPU | 5,065 | [
"if",
"(",
"!",
"possible_target",
"||",
"GET_MODE",
"(",
"possible_target",
")",
"!=",
"target_mode",
")",
"possible_target",
"=",
"gen_reg_rtx",
"(",
"target_mode",
")",
";"
]
| [
"rtx",
"function_expander",
"::",
"get_reg_target",
"(",
")",
"{",
"machine_mode",
"target_mode",
"=",
"result_mode",
"(",
")",
";"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 5,066 | [
"let",
"opExtentAlign",
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"P0",
"]",
";",
"let",
"Defs",
"=",
"[",
"P0",
",",
"PC",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";"
]
|
GCC | mips | CPP | next_suggestion | CPU | 5,067 | [
"}"
]
| [
"if",
"(",
"cache",
"==",
"NULL_TREE",
")",
"cache",
"=",
"build_pointer_type",
"(",
"build_qualified_type",
"(",
"void_type_node",
",",
"TYPE_QUAL_CONST",
"|",
"TYPE_QUAL_VOLATILE",
")",
")",
";",
"return",
"cache",
";"
]
|
LLVM | AArch64 | CPP | next_suggestion | CPU | 5,068 | [
"O",
"<<",
"getRegisterName",
"(",
"RegOp",
".",
"getReg",
"(",
")",
")",
";"
]
| [
"void",
"AArch64InstPrinter",
"::",
"printMatrixTile",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"unsigned",
"OpNum",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"const",
"MCOperand",
"&",
"RegOp",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNum",
")",
";",
"assert",
"(",
"RegOp",
".",
"isReg",
"(",
")",
"&&",
"<STR_LIT>",
"Unexpected operand type!",
"<STR_LIT>",
")",
";"
]
|
GCC | arm | CPP | stmt_completion | CPU | 5,069 | [
"a",
")",
"{"
]
| [
"vcvt_f32_bf16",
"(",
"bfloat16x4_t",
"_",
"_"
]
|
GCC | mips | MD | stmt_completion | CPU | 5,070 | [
"<STR_LIT>",
"<STR_LIT>",
")",
"]"
]
| [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"V2HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"unspec",
":",
"V2HI",
"[",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>"
]
|
LLVM | Mips | CPP | stmt_completion | CPU | 5,071 | [
"<NUM_LIT>",
";"
]
| [
"intptr_t",
"ResultPtr",
"=",
"(",
"intptr_t",
")",
"MR",
"->",
"getResultPointer",
"(",
")",
";",
"switch",
"(",
"(",
"Mips",
"::",
"RelocationType",
")",
"MR",
"->",
"getRelocationType",
"(",
")",
")",
"{",
"case",
"Mips",
"::",
"reloc_mips_branch",
":",
"ResultPtr",
"=",
"(",
"(",
"(",
"ResultPtr",
"-",
"(",
"intptr_t",
")",
"RelocPos",
")",
"-",
"<NUM_LIT>",
")",
">>",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
";",
"*",
"(",
"(",
"unsigned",
"*",
")",
"RelocPos",
")",
"|=",
"(",
"unsigned",
")",
"ResultPtr",
";",
"break",
";",
"case",
"Mips",
"::",
"reloc_mips_26",
":",
"ResultPtr",
"=",
"(",
"ResultPtr",
"&",
"<NUM_LIT>",
")",
">>",
"<NUM_LIT>",
";",
"*",
"(",
"(",
"unsigned",
"*",
")",
"RelocPos",
")",
"|=",
"(",
"unsigned",
")",
"ResultPtr",
";",
"break",
";",
"case",
"Mips",
"::",
"reloc_mips_hi",
":",
"ResultPtr",
"=",
"ResultPtr",
">>",
"<NUM_LIT>",
";",
"if",
"(",
"(",
"(",
"(",
"intptr_t",
")",
"(",
"MR",
"->",
"getResultPointer",
"(",
")",
")",
"&",
"<NUM_LIT>",
")",
">>",
"<NUM_LIT>",
")",
"==",
"<NUM_LIT>",
")",
"{",
"ResultPtr",
"+=",
"<NUM_LIT>",
";",
"}",
"*",
"(",
"(",
"unsigned",
"*",
")",
"RelocPos",
")",
"|=",
"(",
"unsigned",
")",
"ResultPtr",
";",
"break",
";",
"case",
"Mips",
"::",
"reloc_mips_lo",
":",
"ResultPtr",
"=",
"ResultPtr",
"&"
]
|
LLVM | Hexagon | TD | stmt_completion | DSP | 5,072 | [
"=",
"<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",
"addrMode",
"=",
"BaseImmOffset",
";",
"let",
"accessSize",
"=",
"WordAccess",
";",
"let",
"mayLoad",
"=",
"<NUM_LIT>",
";",
"let",
"isRestrictNoSlot1Store",
"=",
"<NUM_LIT>",
";",
"let",
"mayStore",
"=",
"<NUM_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentAlign"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 5,073 | [
"let",
"isCodeGenOnly",
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isPredicable",
"=",
"<NUM_LIT>",
";",
"let",
"isPseudo",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | AMDGPU | CPP | program_repair | GPU | 5,074 | [
"<FIXS>",
"if",
"(",
"F",
".",
"getCallingConv",
"(",
")",
"!=",
"CallingConv",
"::",
"AMDGPU_KERNEL",
"&&",
"F",
".",
"getCallingConv",
"(",
")",
"!=",
"CallingConv",
"::",
"SPIR_KERNEL",
")",
"<FIXE>",
"<FIXS>",
"unsigned",
"MaxKernArgAlign",
";",
"HSACodeProps",
".",
"mKernargSegmentSize",
"=",
"STM",
".",
"getKernArgSegmentSize",
"(",
"F",
",",
"MaxKernArgAlign",
")",
";",
"<FIXE>",
"<FIXS>",
"HSACodeProps",
".",
"mKernargSegmentAlign",
"=",
"std",
"::",
"max",
"(",
"MaxKernArgAlign",
",",
"<NUM_LIT>",
"u",
")",
";",
"<FIXE>"
]
| [
"const",
"Function",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"<BUGS>",
"if",
"(",
"F",
".",
"getCallingConv",
"(",
")",
"!=",
"CallingConv",
"::",
"AMDGPU_KERNEL",
")",
"<BUGE>",
"return",
"HSACodeProps",
";",
"<BUGS>",
"HSACodeProps",
".",
"mKernargSegmentSize",
"=",
"STM",
".",
"getKernArgSegmentSize",
"(",
"F",
",",
"MFI",
".",
"getExplicitKernArgSize",
"(",
")",
")",
";",
"<BUGE>",
"HSACodeProps",
".",
"mGroupSegmentFixedSize",
"=",
"ProgramInfo",
".",
"LDSSize",
";",
"HSACodeProps",
".",
"mPrivateSegmentFixedSize",
"=",
"ProgramInfo",
".",
"ScratchSize",
";",
"<BUGS>",
"HSACodeProps",
".",
"mKernargSegmentAlign",
"=",
"std",
"::",
"max",
"(",
"uint32_t",
"(",
"<NUM_LIT>",
")",
",",
"MFI",
".",
"getMaxKernArgAlign",
"(",
")",
")",
";",
"<BUGE>",
"HSACodeProps",
".",
"mWavefrontSize",
"=",
"STM",
".",
"getWavefrontSize",
"(",
")",
";",
"HSACodeProps",
".",
"mNumSGPRs",
"=",
"ProgramInfo",
".",
"NumSGPR",
";",
"HSACodeProps",
".",
"mNumVGPRs",
"=",
"ProgramInfo",
".",
"NumVGPR",
";"
]
|
LLVM | VE | TD | stmt_completion | CPU | 5,075 | [
")",
",",
"i64",
":",
"$",
"sz",
",",
"v256f64",
":",
"$",
"vx",
",",
"i32",
":",
"$",
"vl",
")",
">",
";"
]
| [
"def",
":",
"Pat",
"<",
"(",
"int_ve_vl_vstu2d_vssl",
"v256f64",
":",
"$",
"vx",
",",
"simm7",
":",
"$",
"I",
",",
"i64",
":",
"$",
"sz",
",",
"i32",
":",
"$",
"vl",
")",
",",
"(",
"VSTU2Dirvl",
"(",
"LO7",
"$",
"I"
]
|
LLVM | SystemZ | CPP | stmt_completion | CPU | 5,076 | [
")",
";"
]
| [
"if",
"(",
"(",
"Index",
"==",
"<NUM_LIT>",
"&&",
"Op0",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SCALAR_TO_VECTOR",
")",
"||",
"Op0",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"BUILD_VECTOR",
")",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"VT",
",",
"Op0",
".",
"getOperand",
"(",
"Index",
")",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"VT",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"DAG",
".",
"getTargetConstant",
"(",
"Index",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"}",
"GeneralShuffle",
"GS",
"(",
"VT",
")",
";",
"for",
"(",
"unsigned",
"I",
"=",
"<NUM_LIT>",
";",
"I",
"<",
"NumElements",
";",
"++",
"I",
")",
"{",
"int",
"Elt",
"=",
"VSN",
"->",
"getMaskElt",
"(",
"I",
")",
";",
"if",
"(",
"Elt",
"<",
"<NUM_LIT>",
")",
"GS",
".",
"addUndef",
"(",
")",
";",
"else",
"if",
"(",
"!",
"GS",
".",
"add",
"(",
"Op",
".",
"getOperand",
"(",
"unsigned",
"(",
"Elt",
")",
"/",
"NumElements",
")",
",",
"unsigned",
"(",
"Elt",
")",
"%",
"NumElements",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"}",
"return",
"GS",
".",
"getNode",
"(",
"DAG",
",",
"SDLoc",
"(",
"VSN",
")"
]
|
GCC | sh | CPP | stmt_completion | CPU | 5,077 | [
"arg",
".",
"promoted_size_in_bytes",
"(",
")",
",",
"UNITS_PER_WORD",
")",
")",
")",
";"
]
| [
"if",
"(",
"!",
"(",
"(",
"TARGET_SH4",
"||",
"TARGET_SH2A",
")",
"||",
"ca",
"->",
"renesas_abi",
")",
"||",
"sh_pass_in_reg_p",
"(",
"*",
"ca",
",",
"arg",
".",
"mode",
",",
"arg",
".",
"type",
")",
")",
"(",
"ca",
"->",
"arg_count",
"[",
"(",
"int",
")",
"get_sh_arg_class",
"(",
"arg",
".",
"mode",
")",
"]",
"=",
"(",
"sh_round_reg",
"(",
"*",
"ca",
",",
"arg",
".",
"mode",
")",
"+",
"CEIL",
"("
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 5,078 | [
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";",
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | AArch64 | TD | next_suggestion | CPU | 5,079 | [
"let",
"ParserMatchClass",
"=",
"LogicalVecShifterOperand",
";"
]
| [
"def",
"logical_vec_shift",
":",
"Operand",
"<",
"i32",
">",
"{",
"let",
"PrintMethod",
"=",
"<STR_LIT>",
";",
"let",
"EncoderMethod",
"=",
"<STR_LIT>",
";"
]
|
LLVM | R600 | CPP | next_suggestion | GPU | 5,080 | [
"}"
]
| [
"const",
"AMDGPUSubtarget",
"&",
"ST",
"=",
"TM",
"->",
"getSubtarget",
"<",
"AMDGPUSubtarget",
">",
"(",
")",
";",
"addPass",
"(",
"createFlattenCFGPass",
"(",
")",
")",
";",
"if",
"(",
"ST",
".",
"getGeneration",
"(",
")",
">",
"AMDGPUSubtarget",
"::",
"NORTHERN_ISLANDS",
")",
"{",
"addPass",
"(",
"createSITypeRewriter",
"(",
")",
")",
";",
"addPass",
"(",
"createStructurizeCFGPass",
"(",
")",
")",
";",
"addPass",
"(",
"createSIAnnotateControlFlowPass",
"(",
")",
")",
";",
"}",
"else",
"{",
"addPass",
"(",
"createR600TextureIntrinsicsReplacer",
"(",
")",
")",
";",
"}",
"return",
"false",
";"
]
|
GCC | c6x | MD | next_suggestion | VLIW | 5,081 | [
"<STR_LIT>",
")"
]
| [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_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>",
")",
")",
")",
")"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 5,082 | [
"v8di",
")",
"_",
"_",
"O",
",",
"_",
"_",
"M",
")",
";"
]
| [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m512i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm512_mask_broadcast_i64x4",
"(",
"_",
"_",
"m512i",
"_",
"_",
"O",
",",
"_",
"_",
"mmask8",
"_",
"_",
"M",
",",
"_",
"_",
"m256i",
"_",
"_",
"A",
")",
"{",
"return",
"(",
"_",
"_",
"m512i",
")",
"_",
"_",
"builtin_ia32_broadcasti64x4_512",
"(",
"(",
"_",
"_",
"v4di",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_"
]
|
LLVM | LC2200 | CPP | next_suggestion | CPU | 5,083 | [
"StartLoc",
"=",
"Operand",
".",
"getStartLoc",
"(",
")",
";"
]
| [
"bool",
"LC2200AsmParser",
"::",
"ParseRegister",
"(",
"unsigned",
"&",
"RegNo",
",",
"SMLoc",
"&",
"StartLoc",
",",
"SMLoc",
"&",
"EndLoc",
")",
"{",
"SmallVector",
"<",
"std",
"::",
"unique_ptr",
"<",
"MCParsedAsmOperand",
">",
",",
"<NUM_LIT>",
">",
"Operands",
";",
"if",
"(",
"ParseRegister",
"(",
"RegNo",
",",
"Operands",
")",
")",
"return",
"true",
";",
"LC2200Operand",
"&",
"Operand",
"=",
"static_cast",
"<",
"LC2200Operand",
"&",
">",
"(",
"*",
"Operands",
".",
"front",
"(",
")",
")",
";"
]
|
LLVM | ARM64 | TD | stmt_completion | CPU | 5,084 | [
"}",
"=",
"<NUM_LIT>",
";"
]
| [
"class",
"BaseSystemI",
"<",
"bit",
"L",
",",
"dag",
"oops",
",",
"dag",
"iops",
",",
"string",
"asm",
",",
"string",
"operands",
">",
":",
"I",
"<",
"oops",
",",
"iops",
",",
"asm",
",",
"operands",
",",
"<STR_LIT>",
",",
"[",
"]",
">",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>"
]
|
LLVM | AArch64 | TD | stmt_completion | CPU | 5,085 | [
";"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"s",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Pg",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Pd",
";",
"let",
"Defs",
"=",
"!",
"if",
"(",
"!",
"eq",
"(",
"s",
",",
"<NUM_LIT>",
")",
",",
"[",
"NZCV",
"]",
",",
"[",
"]",
")",
";",
"let",
"Uses",
"=",
"[",
"FFR",
"]"
]
|
LLVM | Hexagon | TD | stmt_completion | DSP | 5,086 | [
";"
]
| [
"def",
"J4_cmpeqn1_fp0_jump_t",
":",
"HInst",
"<",
"(",
"outs",
")",
",",
"(",
"ins",
"GeneralSubRegs",
":",
"$",
"Rs16",
",",
"n1Const",
":",
"$",
"n1",
",",
"b30_2Imm",
":",
"$",
"Ii",
")",
",",
"<STR_LIT>",
",",
"tc_3d495a39",
",",
"TypeCJ",
">",
",",
"Enc_14640c",
",",
"PredRel",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedFalse",
"=",
"<NUM_LIT>",
";",
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";",
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"P0",
"]",
";",
"let",
"Defs",
"=",
"[",
"P0",
",",
"PC",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>"
]
|
GCC | c6x | MD | next_suggestion | VLIW | 5,087 | [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
GCC | mips | MD | stmt_completion | CPU | 5,088 | [
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"(",
"define_bypass",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"define_bypass",
"<NUM_LIT>",
"<STR_LIT>"
]
|
GCC | m68hc11 | MD | program_repair | MPU | 5,089 | [
"<FIXS>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"<FIXE>",
"<FIXS>",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
")",
"]",
"<FIXE>"
]
| [
"(",
"define_insn",
"<STR_LIT>",
"<BUGS>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"<BUGE>",
"(",
"match_operator",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"[",
"(",
"zero_extend",
":",
"SI",
"<BUGS>",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
")",
"]",
"<BUGE>",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
GCC | visium | MD | stmt_completion | Virtual ISA | 5,090 | [
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
")"
]
| [
"(",
"mult",
":",
"DI",
"(",
"any_extend",
":",
"DI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"any_extend",
":",
"DI",
"(",
"match_operand",
":"
]
|
LLVM | CSKY | CPP | stmt_completion | CPU | 5,091 | [
"false",
";"
]
| [
"case",
"MachineOperand",
"::",
"MO_Immediate",
":",
"OS",
"<<",
"MO",
".",
"getImm",
"(",
")",
";",
"return",
"false",
";",
"case",
"MachineOperand",
"::",
"MO_Register",
":",
"if",
"(",
"MO",
".",
"getReg",
"(",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"return",
"false",
";",
"OS",
"<<",
"CSKYInstPrinter",
"::",
"getRegisterName",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
";",
"return",
"false",
";",
"case",
"MachineOperand",
"::",
"MO_GlobalAddress",
":",
"PrintSymbolOperand",
"(",
"MO",
",",
"OS",
")",
";",
"return",
"false",
";",
"case",
"MachineOperand",
"::",
"MO_BlockAddress",
":",
"{",
"MCSymbol",
"*",
"Sym",
"=",
"GetBlockAddressSymbol",
"(",
"MO",
".",
"getBlockAddress",
"(",
")",
")",
";",
"Sym",
"->",
"print",
"(",
"OS",
",",
"MAI",
")",
";",
"return"
]
|
LLVM | R600 | CPP | code_generation | GPU | 5,092 | [
"bool",
"R600InstrInfo",
"::",
"expandPostRAPseudo",
"(",
"MachineBasicBlock",
"::",
"iterator",
"MI",
")",
"const",
"{",
"switch",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"AMDGPUInstrInfo",
"::",
"expandPostRAPseudo",
"(",
"MI",
")",
";",
"case",
"AMDGPU",
"::",
"R600_EXTRACT_ELT_V2",
":",
"case",
"AMDGPU",
"::",
"R600_EXTRACT_ELT_V4",
":",
"buildIndirectRead",
"(",
"MI",
"->",
"getParent",
"(",
")",
",",
"MI",
",",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
",",
"RI",
".",
"getHWRegIndex",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
",",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
",",
"RI",
".",
"getHWRegChan",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"AMDGPU",
"::",
"R600_INSERT_ELT_V2",
":",
"case",
"AMDGPU",
"::",
"R600_INSERT_ELT_V4",
":",
"buildIndirectWrite",
"(",
"MI",
"->",
"getParent",
"(",
")",
",",
"MI",
",",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
",",
"RI",
".",
"getHWRegIndex",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
",",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
",",
"RI",
".",
"getHWRegChan",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
")",
";",
"break",
";",
"}",
"MI",
"->",
"eraseFromParent",
"(",
")",
";",
"return",
"true",
";",
"}"
]
| [
"This",
"function",
"is",
"called",
"for",
"all",
"pseudo",
"instructions",
"that",
"remain",
"after",
"register",
"allocation",
"."
]
|
GCC | loongarch | CPP | stmt_completion | CPU | 5,093 | [
"sizeof",
"(",
"args",
")",
")",
";"
]
| [
"static",
"bool",
"loongarch_return_in_memory",
"(",
"const_tree",
"type",
",",
"const_tree",
"fndecl",
"ATTRIBUTE_UNUSED",
")",
"{",
"CUMULATIVE_ARGS",
"args",
";",
"cumulative_args_t",
"cum",
"=",
"pack_cumulative_args",
"(",
"&",
"args",
")",
";",
"memset",
"(",
"&",
"args",
",",
"<NUM_LIT>",
","
]
|
LLVM | TPC | CPP | stmt_completion | Virtual ISA | 5,094 | [
"=",
"Val",
";"
]
| [
"auto",
"Res",
"=",
"std",
"::",
"make_unique",
"<",
"TPCOperand",
">",
"(",
"OpKind",
"::",
"MovDGAll",
",",
"StartLoc",
",",
"EndLoc",
")",
";",
"Res",
"->",
"MovDGAll",
".",
"Val"
]
|
GCC | cris | MD | program_repair | MPU | 5,095 | [
"<FIXS>",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"CC",
"CRIS_CC0_REGNUM",
")",
")",
"]",
"<FIXE>"
]
| [
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"ashift",
":",
"SI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"<BUGS>",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
")",
"]",
"<BUGE>",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
]
|
GCC | ia64 | MD | next_suggestion | CPU | 5,096 | [
"rtx",
"q",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")"
]
| [
"(",
"define_expand",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"XF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"div",
":",
"XF",
"(",
"match_operand",
":",
"XF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"XF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"{",
"rtx",
"q_res",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")",
"rtx",
"a",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")",
"rtx",
"b",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")",
"rtx",
"y",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")",
"rtx",
"e",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")",
"rtx",
"y1",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")",
"rtx",
"e1",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")",
"rtx",
"q1",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")",
"rtx",
"y2",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")",
"rtx",
"e2",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")",
"rtx",
"y3",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")",
"rtx",
"e3",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")",
"rtx",
"e4",
"=",
"gen_reg_rtx",
"(",
"RFmode",
")"
]
|
GCC | s390 | MD | stmt_completion | MPU | 5,097 | [
"<STR_LIT>",
")"
]
| [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>"
]
|
LLVM | WebAssembly | CPP | stmt_completion | Virtual ISA | 5,098 | [
")",
";"
]
| [
"assert",
"(",
"Ty",
"->",
"isFPOrFPVectorTy",
"(",
")",
"&&",
"<STR_LIT>",
"Ty must be floating point",
"<STR_LIT>"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 5,099 | [
"_",
"_",
"P",
"=",
"_",
"_",
"A",
";"
]
| [
"extern",
"_",
"_",
"inline",
"void",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_store_ph",
"(",
"void",
"*",
"_",
"_",
"P",
",",
"_",
"_",
"m128h",
"_",
"_",
"A",
")",
"{",
"*",
"(",
"_",
"_",
"m128h",
"*",
")"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.