Compiler_Type
stringclasses 2
values | Target
stringclasses 176
values | Programming Language
stringclasses 3
values | Task
stringclasses 4
values | Target_Type
stringclasses 7
values | Idx
int64 0
636k
| Ground_Truth
listlengths 0
2.32k
| Input
listlengths 1
1.02k
|
---|---|---|---|---|---|---|---|
LLVM | XCore | CPP | stmt_completion | MPU | 6,900 | [
",",
"RemainingAdj",
")",
";"
]
| [
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"SpillList",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"assert",
"(",
"SpillList",
"[",
"i",
"]",
".",
"Offset",
"%",
"<NUM_LIT>",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Misaligned stack offset",
"<STR_LIT>",
")",
";",
"assert",
"(",
"SpillList",
"[",
"i",
"]",
".",
"Offset",
"<=",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Unexpected positive stack offset",
"<STR_LIT>",
")",
";",
"int",
"OffsetFromTop",
"=",
"-",
"SpillList",
"[",
"i",
"]",
".",
"Offset",
"/",
"<NUM_LIT>",
";",
"IfNeededLDAWSP",
"(",
"MBB",
",",
"MBBI",
",",
"dl",
",",
"TII",
",",
"OffsetFromTop"
]
|
LLVM | TPC | TD | next_suggestion | Virtual ISA | 6,901 | [
"let",
"Constraints",
"=",
"<STR_LIT>",
";"
]
| [
"let",
"Dest",
"=",
"dest",
";",
"let",
"SrcA",
"=",
"op1",
";",
"let",
"SrcB",
"=",
"op2",
";",
"let",
"OperandType",
"=",
"optype",
";",
"let",
"Switches",
"=",
"funcId",
";",
"let",
"VectorPred",
"=",
"!",
"eq",
"(",
"!",
"cast",
"<",
"string",
">",
"(",
"Pred",
")",
",",
"<STR_LIT>",
")",
";",
"let",
"PredAddress",
"=",
"pred",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"PredPolarity",
"=",
"pred",
"{",
"<NUM_LIT>",
"}",
";"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 6,902 | [
"m512",
"_",
"_",
"A",
",",
"int",
"_",
"_",
"B",
",",
"const",
"int",
"_",
"_",
"R",
")",
"{"
]
| [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m512",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm512_reduce_round_ps",
"(",
"_",
"_"
]
|
GCC | m32c | CPP | stmt_completion | MPU | 6,903 | [
")",
";"
]
| [
"if",
"(",
"from",
"==",
"AP_REGNO",
")",
"{",
"if",
"(",
"TARGET_A16",
")",
"ofs",
"+=",
"<NUM_LIT>",
";",
"else",
"ofs",
"+=",
"<NUM_LIT>",
";",
"}",
"if",
"(",
"to",
"==",
"SP_REGNO",
")",
"{",
"ofs",
"+=",
"m32c_pushm_popm",
"(",
"PP_justcount"
]
|
LLVM | Hexagon | TD | stmt_completion | DSP | 6,904 | [
"=",
"<STR_LIT>",
";"
]
| [
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"addrMode",
"=",
"PostInc",
";",
"let",
"accessSize",
"=",
"HalfWordAccess",
";",
"let",
"mayLoad",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"CS",
"]",
";",
"let",
"Constraints"
]
|
LLVM | AArch64 | TD | next_suggestion | CPU | 6,905 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"offset",
";"
]
| [
"bits",
"<",
"<NUM_LIT>",
">",
"offset",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opc",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"V",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"L",
";"
]
|
LLVM | Cpu0 | CPP | code_generation | CPU | 6,906 | [
"const",
"char",
"*",
"Cpu0AsmPrinter",
"::",
"getCurrentABIString",
"(",
")",
"const",
"{",
"switch",
"(",
"Subtarget",
"->",
"getTargetABI",
"(",
")",
")",
"{",
"case",
"Cpu0Subtarget",
"::",
"O32",
":",
"return",
"<STR_LIT>",
"abi32",
"<STR_LIT>",
";",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unknown Cpu0 ABI",
"<STR_LIT>",
")",
";",
";",
"}",
"}"
]
| [
"Emit",
"Set",
"directives",
"."
]
|
LLVM | X86 | CPP | next_suggestion | CPU | 6,907 | [
"StoredVal",
"=",
"DAG",
".",
"getBitcast",
"(",
"CastVT",
",",
"StoredVal",
")",
";"
]
| [
"if",
"(",
"St",
"->",
"isTruncatingStore",
"(",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"MVT",
"StoreVT",
"=",
"StoredVal",
".",
"getSimpleValueType",
"(",
")",
";",
"assert",
"(",
"StoreVT",
".",
"isVector",
"(",
")",
"&&",
"StoreVT",
".",
"getSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Unexpected VT",
"<STR_LIT>",
")",
";",
"if",
"(",
"DAG",
".",
"getTargetLoweringInfo",
"(",
")",
".",
"getTypeAction",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"StoreVT",
")",
"!=",
"TargetLowering",
"::",
"TypeWidenVector",
")",
"return",
"SDValue",
"(",
")",
";",
"MVT",
"WideVT",
"=",
"MVT",
"::",
"getVectorVT",
"(",
"StoreVT",
".",
"getVectorElementType",
"(",
")",
",",
"StoreVT",
".",
"getVectorNumElements",
"(",
")",
"*",
"<NUM_LIT>",
")",
";",
"StoredVal",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"CONCAT_VECTORS",
",",
"dl",
",",
"WideVT",
",",
"StoredVal",
",",
"DAG",
".",
"getUNDEF",
"(",
"StoreVT",
")",
")",
";",
"MVT",
"StVT",
"=",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"StoreVT",
".",
"isInteger",
"(",
")",
"?",
"MVT",
"::",
"i64",
":",
"MVT",
"::",
"f64",
";",
"MVT",
"CastVT",
"=",
"MVT",
"::",
"getVectorVT",
"(",
"StVT",
",",
"<NUM_LIT>",
")",
";"
]
|
LLVM | MBlaze | CPP | program_repair | MPU | 6,908 | [
"<FIXS>",
"for",
"(",
"unsigned",
"aop",
"=",
"<NUM_LIT>",
";",
"aop",
"aend",
";",
"++",
"aop",
")",
"{",
"<FIXE>",
"<FIXS>",
"const",
"unsigned",
"mend",
"=",
"getLastRealOperand",
"(",
"m",
")",
";",
"for",
"(",
"unsigned",
"mop",
"=",
"<NUM_LIT>",
";",
"mop",
"mend",
";",
"++",
"mop",
")",
"{",
"<FIXE>"
]
| [
"bool",
"a_is_memory",
"=",
"desc",
".",
"mayLoad",
"(",
")",
"||",
"desc",
".",
"mayStore",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"m",
"=",
"a",
";",
"for",
"(",
"++",
"m",
";",
"m",
"!=",
"b",
";",
"++",
"m",
")",
"{",
"<BUGS>",
"for",
"(",
"unsigned",
"aop",
"=",
"<NUM_LIT>",
",",
"aend",
"=",
"a",
"->",
"getNumOperands",
"(",
")",
";",
"aop",
"aend",
";",
"++",
"aop",
")",
"{",
"<BUGE>",
"bool",
"aop_is_reg",
"=",
"a",
"->",
"getOperand",
"(",
"aop",
")",
".",
"isReg",
"(",
")",
";",
"if",
"(",
"!",
"aop_is_reg",
")",
"continue",
";",
"bool",
"aop_is_def",
"=",
"a",
"->",
"getOperand",
"(",
"aop",
")",
".",
"isDef",
"(",
")",
";",
"unsigned",
"aop_reg",
"=",
"a",
"->",
"getOperand",
"(",
"aop",
")",
".",
"getReg",
"(",
")",
";",
"<BUGS>",
"for",
"(",
"unsigned",
"mop",
"=",
"<NUM_LIT>",
",",
"mend",
"=",
"m",
"->",
"getNumOperands",
"(",
")",
";",
"mop",
"mend",
";",
"++",
"mop",
")",
"{",
"<BUGE>",
"bool",
"mop_is_reg",
"=",
"m",
"->",
"getOperand",
"(",
"mop",
")",
".",
"isReg",
"(",
")",
";",
"if",
"(",
"!",
"mop_is_reg",
")",
"continue",
";"
]
|
LLVM | Mips | CPP | stmt_completion | CPU | 6,909 | [
",",
"CPU",
",",
"FS",
",",
"isLittle",
",",
"this",
")",
";"
]
| [
"Attribute",
"CPUAttr",
"=",
"FnAttrs",
".",
"getAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"<STR_LIT>",
"target-cpu",
"<STR_LIT>",
")",
";",
"Attribute",
"FSAttr",
"=",
"FnAttrs",
".",
"getAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"<STR_LIT>",
"target-features",
"<STR_LIT>",
")",
";",
"std",
"::",
"string",
"CPU",
"=",
"!",
"CPUAttr",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"None",
")",
"?",
"CPUAttr",
".",
"getValueAsString",
"(",
")",
".",
"str",
"(",
")",
":",
"TargetCPU",
";",
"std",
"::",
"string",
"FS",
"=",
"!",
"FSAttr",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"None",
")",
"?",
"FSAttr",
".",
"getValueAsString",
"(",
")",
".",
"str",
"(",
")",
":",
"TargetFS",
";",
"bool",
"hasMips16Attr",
"=",
"!",
"FnAttrs",
".",
"getAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"<STR_LIT>",
"mips16",
"<STR_LIT>",
")",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"None",
")",
";",
"bool",
"hasNoMips16Attr",
"=",
"!",
"FnAttrs",
".",
"getAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"<STR_LIT>",
"nomips16",
"<STR_LIT>",
")",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"None",
")",
";",
"Attribute",
"SFAttr",
"=",
"FnAttrs",
".",
"getAttribute",
"(",
"AttributeSet",
"::",
"FunctionIndex",
",",
"<STR_LIT>",
"use-soft-float",
"<STR_LIT>",
")",
";",
"bool",
"softFloat",
"=",
"!",
"SFAttr",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"None",
")",
"?",
"SFAttr",
".",
"getValueAsString",
"(",
")",
"==",
"<STR_LIT>",
"true",
"<STR_LIT>",
":",
"Options",
".",
"UseSoftFloat",
";",
"if",
"(",
"hasMips16Attr",
")",
"FS",
"+=",
"FS",
".",
"empty",
"(",
")",
"?",
"<STR_LIT>",
"+mips16",
"<STR_LIT>",
":",
"<STR_LIT>",
",+mips16",
"<STR_LIT>",
";",
"else",
"if",
"(",
"hasNoMips16Attr",
")",
"FS",
"+=",
"FS",
".",
"empty",
"(",
")",
"?",
"<STR_LIT>",
"-mips16",
"<STR_LIT>",
":",
"<STR_LIT>",
",-mips16",
"<STR_LIT>",
";",
"auto",
"&",
"I",
"=",
"SubtargetMap",
"[",
"CPU",
"+",
"FS",
"+",
"(",
"softFloat",
"?",
"<STR_LIT>",
"use-soft-float=true",
"<STR_LIT>",
":",
"<STR_LIT>",
"use-soft-float=false",
"<STR_LIT>",
")",
"]",
";",
"if",
"(",
"!",
"I",
")",
"{",
"resetTargetOptions",
"(",
"F",
")",
";",
"I",
"=",
"llvm",
"::",
"make_unique",
"<",
"MipsSubtarget",
">",
"(",
"TargetTriple"
]
|
LLVM | AMDGPU | CPP | next_suggestion | GPU | 6,910 | [
"}"
]
| [
"}",
"if",
"(",
"!",
"AndExecMI",
")",
"return",
"false",
";",
"SlotIndex",
"StartIdx",
"=",
"LIS",
"->",
"getInstructionIndex",
"(",
"SaveExecMI",
")",
";",
"SlotIndex",
"EndIdx",
"=",
"LIS",
"->",
"getInstructionIndex",
"(",
"*",
"AndExecMI",
")",
";",
"for",
"(",
"MCRegUnitIterator",
"UI",
"(",
"ExecReg",
",",
"TRI",
")",
";",
"UI",
".",
"isValid",
"(",
")",
";",
"++",
"UI",
")",
"{",
"LiveRange",
"&",
"RegUnit",
"=",
"LIS",
"->",
"getRegUnit",
"(",
"*",
"UI",
")",
";",
"if",
"(",
"RegUnit",
".",
"find",
"(",
"StartIdx",
")",
"!=",
"std",
"::",
"prev",
"(",
"RegUnit",
".",
"find",
"(",
"EndIdx",
")",
")",
")",
"return",
"false",
";",
"}",
"LIS",
"->",
"removeInterval",
"(",
"SavedExecReg",
")",
";",
"LIS",
"->",
"removeInterval",
"(",
"DstReg",
")",
";",
"SaveExecMI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"setReg",
"(",
"DstReg",
")",
";",
"LIS",
"->",
"RemoveMachineInstrFromMaps",
"(",
"*",
"AndExecMI",
")",
";",
"AndExecMI",
"->",
"eraseFromParent",
"(",
")",
";",
"LIS",
"->",
"createAndComputeVirtRegInterval",
"(",
"DstReg",
")",
";",
"return",
"true",
";"
]
|
LLVM | X86 | CPP | next_suggestion | CPU | 6,911 | [
"MVT",
"MaskVT",
"=",
"MVT",
"::",
"getVectorVT",
"(",
"MVT",
"::",
"i64",
",",
"VT",
".",
"getSizeInBits",
"(",
")",
"/",
"<NUM_LIT>",
")",
";"
]
| [
"MVT",
"EltVT",
"=",
"VT",
".",
"getVectorElementType",
"(",
")",
";",
"SDValue",
"Zero",
"=",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"EltVT",
")",
";",
"SDValue",
"AllOnes",
"=",
"DAG",
".",
"getAllOnesConstant",
"(",
"DL",
",",
"EltVT",
")",
";",
"SmallVector",
"<",
"SDValue",
",",
"<NUM_LIT>",
">",
"MaskOps",
";",
"for",
"(",
"int",
"i",
"=",
"<NUM_LIT>",
",",
"Size",
"=",
"Mask",
".",
"size",
"(",
")",
";",
"i",
"<",
"Size",
";",
"++",
"i",
")",
"{",
"if",
"(",
"Mask",
"[",
"i",
"]",
">=",
"<NUM_LIT>",
"&&",
"Mask",
"[",
"i",
"]",
"!=",
"i",
"&&",
"Mask",
"[",
"i",
"]",
"!=",
"i",
"+",
"Size",
")",
"return",
"SDValue",
"(",
")",
";",
"MaskOps",
".",
"push_back",
"(",
"Mask",
"[",
"i",
"]",
"<",
"Size",
"?",
"AllOnes",
":",
"Zero",
")",
";",
"}",
"SDValue",
"V1Mask",
"=",
"DAG",
".",
"getBuildVector",
"(",
"VT",
",",
"DL",
",",
"MaskOps",
")",
";",
"V1",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AND",
",",
"DL",
",",
"VT",
",",
"V1",
",",
"V1Mask",
")",
";"
]
|
GCC | arm | MD | stmt_completion | CPU | 6,912 | [
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"(",
"and",
"(",
"eq_attr"
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 6,913 | [
")",
")",
"{"
]
| [
"MachineInstr",
"*",
"Copy",
"=",
"BuildMI",
"(",
"*",
"BB",
",",
"&",
"I",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"TargetOpcode",
"::",
"COPY",
")",
",",
"I",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
".",
"addReg",
"(",
"I",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
",",
"<NUM_LIT>",
",",
"SubReg",
")",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"Copy",
"->",
"operands",
"("
]
|
LLVM | Mips | TD | stmt_completion | CPU | 6,914 | [
"=",
"[",
"RA",
"]",
";"
]
| [
"class",
"BEQZALC_DESC",
":",
"CMP_CBR_RT_Z_DESC_BASE",
"<",
"<STR_LIT>",
",",
"brtarget",
",",
"GPR32Opnd",
">",
"{",
"list",
"<",
"Register",
">",
"Defs"
]
|
LLVM | PowerPC | CPP | next_suggestion | CPU | 6,915 | [
"}"
]
| [
"case",
"PPC",
"::",
"QVSTFDX",
":",
"case",
"PPC",
"::",
"QVSTFSXs",
":",
"case",
"PPC",
"::",
"QVSTFDXb",
":",
"case",
"PPC",
"::",
"SPILL_VRSAVE",
":",
"case",
"PPC",
"::",
"SPILLTOVSR_ST",
":",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isImm",
"(",
")",
"&&",
"!",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isFI",
"(",
")",
")",
"{",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"}",
"break",
";"
]
|
LLVM | ARM | CPP | stmt_completion | CPU | 6,916 | [
"SplitRetInfos",
";"
]
| [
"auto",
"&",
"MF",
"=",
"MIRBuilder",
".",
"getMF",
"(",
")",
";",
"const",
"auto",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"auto",
"DL",
"=",
"MF",
".",
"getDataLayout",
"(",
")",
";",
"auto",
"&",
"TLI",
"=",
"*",
"getTLI",
"<",
"ARMTargetLowering",
">",
"(",
")",
";",
"if",
"(",
"!",
"isSupportedType",
"(",
"DL",
",",
"TLI",
",",
"Val",
"->",
"getType",
"(",
")",
")",
")",
"return",
"false",
";",
"ArgInfo",
"OrigRetInfo",
"(",
"VRegs",
",",
"Val",
"->",
"getType",
"(",
")",
")",
";",
"setArgFlags",
"(",
"OrigRetInfo",
",",
"AttributeList",
"::",
"ReturnIndex",
",",
"DL",
",",
"F",
")",
";",
"SmallVector",
"<",
"ArgInfo",
",",
"<NUM_LIT>",
">"
]
|
LLVM | MCS51 | CPP | next_suggestion | MPU | 6,917 | [
"}",
"else",
"{"
]
| [
"Diagnostic",
"+=",
"<STR_LIT>",
" (expected an integer in the range ",
"<STR_LIT>",
"+",
"std",
"::",
"to_string",
"(",
"Min",
")",
"+",
"<STR_LIT>",
" to ",
"<STR_LIT>",
"+",
"std",
"::",
"to_string",
"(",
"Max",
")",
"+",
"<STR_LIT>",
")",
"<STR_LIT>",
";",
"if",
"(",
"Ctx",
")",
"{",
"Ctx",
"->",
"reportFatalError",
"(",
"Fixup",
".",
"getLoc",
"(",
")",
",",
"Diagnostic",
")",
";"
]
|
LLVM | X86 | CPP | program_repair | CPU | 6,918 | [
"<FIXS>",
"BuildMI",
"(",
"BB",
",",
"X86",
"::",
"FLDr32",
",",
"<NUM_LIT>",
")",
".",
"addReg",
"(",
"getReg",
"(",
"rv",
")",
")",
";",
"<FIXE>",
"<FIXS>",
"BuildMI",
"(",
"BB",
",",
"X86",
"::",
"FLDr64",
",",
"<NUM_LIT>",
")",
".",
"addReg",
"(",
"getReg",
"(",
"rv",
")",
")",
";",
"<FIXE>"
]
| [
"case",
"cFloat",
":",
"<BUGS>",
"BuildMI",
"(",
"BB",
",",
"X86",
"::",
"FLDr4",
",",
"<NUM_LIT>",
")",
".",
"addReg",
"(",
"getReg",
"(",
"rv",
")",
")",
";",
"<BUGE>",
"break",
";",
"case",
"cDouble",
":",
"<BUGS>",
"BuildMI",
"(",
"BB",
",",
"X86",
"::",
"FLDr8",
",",
"<NUM_LIT>",
")",
".",
"addReg",
"(",
"getReg",
"(",
"rv",
")",
")",
";",
"<BUGE>",
"break",
";",
"case",
"cLong",
":"
]
|
GCC | mips | MD | program_repair | CPU | 6,919 | [
"<FIXS>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<FIXE>"
]
| [
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"(",
"define_insn",
"<STR_LIT>",
"<BUGS>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<BUGE>",
"<STR_LIT>"
]
|
LLVM | X86 | TD | next_suggestion | CPU | 6,920 | [
"let",
"ResourceCycles",
"=",
"[",
"<NUM_LIT>",
"]",
";"
]
| [
"let",
"Latency",
"=",
"<NUM_LIT>",
";",
"let",
"NumMicroOps",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | AMDGPU | CPP | program_repair | GPU | 6,921 | [
"<FIXS>",
"SelectionDAG",
"&",
"DAG",
"=",
"DCI",
".",
"DAG",
";",
"if",
"(",
"N0",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"OR",
"&&",
"!",
"DAG",
".",
"haveNoCommonBitsSet",
"(",
"N0",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"N0",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"<FIXE>"
]
| [
"if",
"(",
"!",
"CAdd",
")",
"return",
"SDValue",
"(",
")",
";",
"<BUGS>",
"<BUGE>",
"APInt",
"Offset",
"=",
"CAdd",
"->",
"getAPIntValue",
"(",
")",
"<<",
"CN1",
"->",
"getAPIntValue",
"(",
")",
";",
"Type",
"*",
"Ty",
"=",
"MemVT",
".",
"getTypeForEVT",
"(",
"*",
"DCI",
".",
"DAG",
".",
"getContext",
"(",
")",
")",
";"
]
|
LLVM | ARM | CPP | next_suggestion | CPU | 6,922 | [
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"-> ",
"<STR_LIT>",
";",
"R",
".",
"AccIntAdd",
"->",
"dump",
"(",
")",
";"
]
| [
"if",
"(",
"!",
"IsReduction",
")",
"continue",
";",
"Instruction",
"*",
"Acc",
"=",
"dyn_cast",
"<",
"Instruction",
">",
"(",
"Phi",
".",
"getIncomingValueForBlock",
"(",
"Latch",
")",
")",
";",
"if",
"(",
"!",
"Acc",
")",
"continue",
";",
"Reductions",
".",
"push_back",
"(",
"Reduction",
"(",
"&",
"Phi",
",",
"Acc",
")",
")",
";",
"}",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"\\nAccumulating integer additions (reductions) found:\\n",
"<STR_LIT>",
";",
"for",
"(",
"auto",
"&",
"R",
":",
"Reductions",
")",
"{",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"- ",
"<STR_LIT>",
";",
"R",
".",
"Phi",
"->",
"dump",
"(",
")",
";"
]
|
LLVM | ARM | CPP | stmt_completion | CPU | 6,923 | [
"*",
"pSection",
")",
"{"
]
| [
"void",
"setTextSection",
"(",
"LDSection"
]
|
GCC | i386 | CPP | next_suggestion | CPU | 6,924 | [
"}"
]
| [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m128d",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_maskz_fmsub_sd",
"(",
"_",
"_",
"mmask8",
"_",
"_",
"U",
",",
"_",
"_",
"m128d",
"_",
"_",
"W",
",",
"_",
"_",
"m128d",
"_",
"_",
"A",
",",
"_",
"_",
"m128d",
"_",
"_",
"B",
")",
"{",
"return",
"(",
"_",
"_",
"m128d",
")",
"_",
"_",
"builtin_ia32_vfmaddsd3_maskz",
"(",
"(",
"_",
"_",
"v2df",
")",
"_",
"_",
"W",
",",
"(",
"_",
"_",
"v2df",
")",
"_",
"_",
"A",
",",
"-",
"(",
"_",
"_",
"v2df",
")",
"_",
"_",
"B",
",",
"(",
"_",
"_",
"mmask8",
")",
"_",
"_",
"U",
",",
"_",
"MM_FROUND_CUR_DIRECTION",
")",
";"
]
|
LLVM | AArch64 | CPP | next_suggestion | CPU | 6,925 | [
"assert",
"(",
"!",
"Res",
"&&",
"<STR_LIT>",
"Call operand has unhandled type",
"<STR_LIT>",
")",
";"
]
| [
"MVT",
"ArgVT",
"=",
"Outs",
"[",
"i",
"]",
".",
"VT",
";",
"ISD",
"::",
"ArgFlagsTy",
"ArgFlags",
"=",
"Outs",
"[",
"i",
"]",
".",
"Flags",
";",
"bool",
"UseVarArgCC",
"=",
"false",
";",
"if",
"(",
"IsVarArg",
")",
"{",
"if",
"(",
"IsCalleeWin64",
")",
"{",
"UseVarArgCC",
"=",
"true",
";",
"}",
"else",
"{",
"UseVarArgCC",
"=",
"!",
"Outs",
"[",
"i",
"]",
".",
"IsFixed",
";",
"}",
"}",
"if",
"(",
"!",
"UseVarArgCC",
")",
"{",
"EVT",
"ActualVT",
"=",
"TLI",
".",
"getValueType",
"(",
"DAG",
".",
"getDataLayout",
"(",
")",
",",
"CLI",
".",
"Args",
"[",
"Outs",
"[",
"i",
"]",
".",
"OrigArgIndex",
"]",
".",
"Ty",
",",
"true",
")",
";",
"MVT",
"ActualMVT",
"=",
"ActualVT",
".",
"isSimple",
"(",
")",
"?",
"ActualVT",
".",
"getSimpleVT",
"(",
")",
":",
"ArgVT",
";",
"if",
"(",
"ActualMVT",
"==",
"MVT",
"::",
"i1",
"||",
"ActualMVT",
"==",
"MVT",
"::",
"i8",
")",
"ArgVT",
"=",
"MVT",
"::",
"i8",
";",
"else",
"if",
"(",
"ActualMVT",
"==",
"MVT",
"::",
"i16",
")",
"ArgVT",
"=",
"MVT",
"::",
"i16",
";",
"}",
"CCAssignFn",
"*",
"AssignFn",
"=",
"TLI",
".",
"CCAssignFnForCall",
"(",
"CalleeCC",
",",
"UseVarArgCC",
")",
";",
"bool",
"Res",
"=",
"AssignFn",
"(",
"i",
",",
"ArgVT",
",",
"ArgVT",
",",
"CCValAssign",
"::",
"Full",
",",
"ArgFlags",
",",
"CCInfo",
")",
";"
]
|
GCC | i386 | MD | next_suggestion | CPU | 6,926 | [
"DONE"
]
| [
"(",
"if_then_else",
":",
"V_256",
"(",
"match_operator",
"<NUM_LIT>",
"<STR_LIT>",
"[",
"(",
"match_operand",
":",
"VI_256",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"VI_256",
"<NUM_LIT>",
"<STR_LIT>",
")",
"]",
")",
"(",
"match_operand",
":",
"V_256",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"V_256",
"<NUM_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"{",
"bool",
"ok",
"=",
"ix86_expand_int_vcond",
"(",
"operands",
")",
"gcc_assert",
"(",
"ok",
")"
]
|
LLVM | PIC16 | CPP | stmt_completion | MPU | 6,927 | [
"BB",
".",
"end",
"(",
")",
";",
"++",
"I",
")",
"{"
]
| [
"for",
"(",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"BB",
".",
"begin",
"(",
")",
";",
"I",
"!="
]
|
GCC | arm | CPP | next_suggestion | CPU | 6,928 | [
"if",
"(",
"elementwidth",
")",
"*",
"elementwidth",
"=",
"tmpwidth",
";"
]
| [
"if",
"(",
"retval",
"==",
"-",
"<NUM_LIT>",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"modconst",
")",
"*",
"modconst",
"=",
"tmpconst",
";"
]
|
LLVM | Hexagon | CPP | code_generation | DSP | 6,929 | [
"bool",
"HexagonInstrInfo",
"::",
"isValidOffset",
"(",
"unsigned",
"Opcode",
",",
"int",
"Offset",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
",",
"bool",
"Extend",
")",
"const",
"{",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"Hexagon",
"::",
"PS_vstorerq_ai",
":",
"case",
"Hexagon",
"::",
"PS_vstorerv_ai",
":",
"case",
"Hexagon",
"::",
"PS_vstorerw_ai",
":",
"case",
"Hexagon",
"::",
"PS_vstorerw_nt_ai",
":",
"case",
"Hexagon",
"::",
"PS_vloadrq_ai",
":",
"case",
"Hexagon",
"::",
"PS_vloadrv_ai",
":",
"case",
"Hexagon",
"::",
"PS_vloadrw_ai",
":",
"case",
"Hexagon",
"::",
"PS_vloadrw_nt_ai",
":",
"case",
"Hexagon",
"::",
"V6_vL32b_ai",
":",
"case",
"Hexagon",
"::",
"V6_vS32b_ai",
":",
"case",
"Hexagon",
"::",
"V6_vS32b_qpred_ai",
":",
"case",
"Hexagon",
"::",
"V6_vS32b_nqpred_ai",
":",
"case",
"Hexagon",
"::",
"V6_vL32b_nt_ai",
":",
"case",
"Hexagon",
"::",
"V6_vS32b_nt_ai",
":",
"case",
"Hexagon",
"::",
"V6_vL32Ub_ai",
":",
"case",
"Hexagon",
"::",
"V6_vS32Ub_ai",
":",
"case",
"Hexagon",
"::",
"V6_vgathermh_pseudo",
":",
"case",
"Hexagon",
"::",
"V6_vgathermw_pseudo",
":",
"case",
"Hexagon",
"::",
"V6_vgathermhw_pseudo",
":",
"case",
"Hexagon",
"::",
"V6_vgathermhq_pseudo",
":",
"case",
"Hexagon",
"::",
"V6_vgathermwq_pseudo",
":",
"case",
"Hexagon",
"::",
"V6_vgathermhwq_pseudo",
":",
"{",
"unsigned",
"VectorSize",
"=",
"TRI",
"->",
"getSpillSize",
"(",
"Hexagon",
"::",
"HvxVRRegClass",
")",
";",
"assert",
"(",
"isPowerOf2_32",
"(",
"VectorSize",
")",
")",
";",
"if",
"(",
"Offset",
"&",
"(",
"VectorSize",
"-",
"<NUM_LIT>",
")",
")",
"return",
"false",
";",
"return",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"Offset",
">>",
"Log2_32",
"(",
"VectorSize",
")",
")",
";",
"}",
"case",
"Hexagon",
"::",
"J2_loop0i",
":",
"case",
"Hexagon",
"::",
"J2_loop1i",
":",
"return",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
";",
"case",
"Hexagon",
"::",
"S4_storeirb_io",
":",
"case",
"Hexagon",
"::",
"S4_storeirbt_io",
":",
"case",
"Hexagon",
"::",
"S4_storeirbf_io",
":",
"return",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
";",
"case",
"Hexagon",
"::",
"S4_storeirh_io",
":",
"case",
"Hexagon",
"::",
"S4_storeirht_io",
":",
"case",
"Hexagon",
"::",
"S4_storeirhf_io",
":",
"return",
"isShiftedUInt",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
";",
"case",
"Hexagon",
"::",
"S4_storeiri_io",
":",
"case",
"Hexagon",
"::",
"S4_storeirit_io",
":",
"case",
"Hexagon",
"::",
"S4_storeirif_io",
":",
"return",
"isShiftedUInt",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
";",
"case",
"Hexagon",
"::",
"A4_cmpbeqi",
":",
"return",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
";",
"case",
"Hexagon",
"::",
"A4_cmpbgti",
":",
"return",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
";",
"}",
"if",
"(",
"Extend",
")",
"return",
"true",
";",
"switch",
"(",
"Opcode",
")",
"{",
"case",
"Hexagon",
"::",
"L2_loadri_io",
":",
"case",
"Hexagon",
"::",
"S2_storeri_io",
":",
"return",
"(",
"Offset",
">=",
"Hexagon_MEMW_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_MEMW_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"L2_loadrd_io",
":",
"case",
"Hexagon",
"::",
"S2_storerd_io",
":",
"return",
"(",
"Offset",
">=",
"Hexagon_MEMD_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_MEMD_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"L2_loadrh_io",
":",
"case",
"Hexagon",
"::",
"L2_loadruh_io",
":",
"case",
"Hexagon",
"::",
"S2_storerh_io",
":",
"case",
"Hexagon",
"::",
"S2_storerf_io",
":",
"return",
"(",
"Offset",
">=",
"Hexagon_MEMH_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_MEMH_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"L2_loadrb_io",
":",
"case",
"Hexagon",
"::",
"L2_loadrub_io",
":",
"case",
"Hexagon",
"::",
"S2_storerb_io",
":",
"return",
"(",
"Offset",
">=",
"Hexagon_MEMB_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_MEMB_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"A2_addi",
":",
"return",
"(",
"Offset",
">=",
"Hexagon_ADDI_OFFSET_MIN",
")",
"&&",
"(",
"Offset",
"<=",
"Hexagon_ADDI_OFFSET_MAX",
")",
";",
"case",
"Hexagon",
"::",
"L4_iadd_memopw_io",
":",
"case",
"Hexagon",
"::",
"L4_isub_memopw_io",
":",
"case",
"Hexagon",
"::",
"L4_add_memopw_io",
":",
"case",
"Hexagon",
"::",
"L4_sub_memopw_io",
":",
"case",
"Hexagon",
"::",
"L4_iand_memopw_io",
":",
"case",
"Hexagon",
"::",
"L4_ior_memopw_io",
":",
"case",
"Hexagon",
"::",
"L4_and_memopw_io",
":",
"case",
"Hexagon",
"::",
"L4_or_memopw_io",
":",
"return",
"(",
"<NUM_LIT>",
"<=",
"Offset",
"&&",
"Offset",
"<=",
"<NUM_LIT>",
")",
";",
"case",
"Hexagon",
"::",
"L4_iadd_memoph_io",
":",
"case",
"Hexagon",
"::",
"L4_isub_memoph_io",
":",
"case",
"Hexagon",
"::",
"L4_add_memoph_io",
":",
"case",
"Hexagon",
"::",
"L4_sub_memoph_io",
":",
"case",
"Hexagon",
"::",
"L4_iand_memoph_io",
":",
"case",
"Hexagon",
"::",
"L4_ior_memoph_io",
":",
"case",
"Hexagon",
"::",
"L4_and_memoph_io",
":",
"case",
"Hexagon",
"::",
"L4_or_memoph_io",
":",
"return",
"(",
"<NUM_LIT>",
"<=",
"Offset",
"&&",
"Offset",
"<=",
"<NUM_LIT>",
")",
";",
"case",
"Hexagon",
"::",
"L4_iadd_memopb_io",
":",
"case",
"Hexagon",
"::",
"L4_isub_memopb_io",
":",
"case",
"Hexagon",
"::",
"L4_add_memopb_io",
":",
"case",
"Hexagon",
"::",
"L4_sub_memopb_io",
":",
"case",
"Hexagon",
"::",
"L4_iand_memopb_io",
":",
"case",
"Hexagon",
"::",
"L4_ior_memopb_io",
":",
"case",
"Hexagon",
"::",
"L4_and_memopb_io",
":",
"case",
"Hexagon",
"::",
"L4_or_memopb_io",
":",
"return",
"(",
"<NUM_LIT>",
"<=",
"Offset",
"&&",
"Offset",
"<=",
"<NUM_LIT>",
")",
";",
"case",
"Hexagon",
"::",
"STriw_pred",
":",
"case",
"Hexagon",
"::",
"LDriw_pred",
":",
"case",
"Hexagon",
"::",
"STriw_ctr",
":",
"case",
"Hexagon",
"::",
"LDriw_ctr",
":",
"return",
"true",
";",
"case",
"Hexagon",
"::",
"PS_fi",
":",
"case",
"Hexagon",
"::",
"PS_fia",
":",
"case",
"Hexagon",
"::",
"INLINEASM",
":",
"return",
"true",
";",
"case",
"Hexagon",
"::",
"L2_ploadrbt_io",
":",
"case",
"Hexagon",
"::",
"L2_ploadrbf_io",
":",
"case",
"Hexagon",
"::",
"L2_ploadrubt_io",
":",
"case",
"Hexagon",
"::",
"L2_ploadrubf_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerbt_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerbf_io",
":",
"return",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
";",
"case",
"Hexagon",
"::",
"L2_ploadrht_io",
":",
"case",
"Hexagon",
"::",
"L2_ploadrhf_io",
":",
"case",
"Hexagon",
"::",
"L2_ploadruht_io",
":",
"case",
"Hexagon",
"::",
"L2_ploadruhf_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerht_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerhf_io",
":",
"return",
"isShiftedUInt",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
";",
"case",
"Hexagon",
"::",
"L2_ploadrit_io",
":",
"case",
"Hexagon",
"::",
"L2_ploadrif_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerit_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerif_io",
":",
"return",
"isShiftedUInt",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
";",
"case",
"Hexagon",
"::",
"L2_ploadrdt_io",
":",
"case",
"Hexagon",
"::",
"L2_ploadrdf_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerdt_io",
":",
"case",
"Hexagon",
"::",
"S2_pstorerdf_io",
":",
"return",
"isShiftedUInt",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
";",
"case",
"Hexagon",
"::",
"L2_loadbsw2_io",
":",
"case",
"Hexagon",
"::",
"L2_loadbzw2_io",
":",
"return",
"isShiftedInt",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
";",
"case",
"Hexagon",
"::",
"L2_loadbsw4_io",
":",
"case",
"Hexagon",
"::",
"L2_loadbzw4_io",
":",
"return",
"isShiftedInt",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
";",
"}",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Failed Opcode is : ",
"<STR_LIT>",
"<<",
"Opcode",
"<<",
"<STR_LIT>",
" (",
"<STR_LIT>",
"<<",
"getName",
"(",
"Opcode",
")",
"<<",
"<STR_LIT>",
")\\n",
"<STR_LIT>",
";",
"llvm_unreachable",
"(",
"<STR_LIT>",
"No offset range is defined for this opcode. ",
"<STR_LIT>",
"<STR_LIT>",
"Please define it in the above switch statement!",
"<STR_LIT>",
")",
";",
"}"
]
| [
"Test",
"the",
"validity",
"of",
"offset",
"."
]
|
LLVM | AMDGPU | CPP | program_repair | GPU | 6,930 | [
"<FIXS>",
"SmallVector",
"const",
"ValueMapping",
"*",
",",
"<NUM_LIT>",
">",
"OpdsMapping",
"(",
"<NUM_LIT>",
")",
";",
"<FIXE>"
]
| [
"const",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"MachineRegisterInfo",
"&",
"MRI",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"<BUGS>",
"SmallVector",
"const",
"ValueMapping",
"*",
",",
"<NUM_LIT>",
">",
"OpdsMapping",
"(",
"MI",
".",
"getNumOperands",
"(",
")",
")",
";",
"<BUGE>",
"unsigned",
"Size",
"=",
"getSizeInBits",
"(",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
",",
"MRI",
",",
"*",
"TRI",
")",
";",
"LLT",
"LoadTy",
"=",
"MRI",
".",
"getType",
"(",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
";",
"Register",
"PtrReg",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";"
]
|
GCC | ia64 | MD | stmt_completion | CPU | 6,931 | [
")",
")",
")"
]
| [
"(",
"and",
"(",
"match_code",
"<STR_LIT>",
")",
"(",
"match_test",
"<STR_LIT>"
]
|
LLVM | Hexagon | CPP | stmt_completion | DSP | 6,932 | [
"HST",
".",
"getInstrInfo",
"(",
")",
";"
]
| [
"auto",
"&",
"HFI",
"=",
"*",
"HST",
".",
"getFrameLowering",
"(",
")",
";",
"if",
"(",
"!",
"HFI",
".",
"needsAligna",
"(",
"*",
"MF",
")",
")",
"return",
";",
"MachineFrameInfo",
"*",
"MFI",
"=",
"MF",
"->",
"getFrameInfo",
"(",
")",
";",
"MachineBasicBlock",
"*",
"EntryBB",
"=",
"&",
"MF",
"->",
"front",
"(",
")",
";",
"unsigned",
"AR",
"=",
"FuncInfo",
"->",
"CreateReg",
"(",
"MVT",
"::",
"i32",
")",
";",
"unsigned",
"MaxA",
"=",
"MFI",
"->",
"getMaxAlignment",
"(",
")",
";",
"auto",
"&",
"HII",
"=",
"*"
]
|
GCC | avr | MD | next_suggestion | MPU | 6,933 | [
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"[",
"(",
"set",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"plus",
":",
"HI",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"zero_extend",
":",
"HI",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>"
]
|
GCC | i386 | CPP | next_suggestion | CPU | 6,934 | [
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"!=",
"nelt",
";",
"i",
"++",
")",
"d",
"->",
"perm",
"[",
"i",
"]",
"=",
"(",
"d",
"->",
"perm",
"[",
"i",
"]",
"+",
"nelt",
")",
"%",
"(",
"<NUM_LIT>",
"*",
"nelt",
")",
";"
]
| [
"static",
"void",
"ix86_vec_perm_index_canon",
"(",
"struct",
"expand_vec_perm_d",
"*",
"d",
")",
"{",
"unsigned",
"nelt",
"=",
"d",
"->",
"nelt",
";",
"if",
"(",
"d",
"->",
"perm",
"[",
"<NUM_LIT>",
"]",
"<",
"nelt",
")",
"return",
";"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 6,935 | [
"op1",
")",
";"
]
| [
"rtx",
"op0",
"=",
"expand_expr",
"(",
"arg0",
",",
"NULL_RTX",
",",
"VOIDmode",
",",
"<NUM_LIT>",
")",
";",
"rtx",
"op1",
"=",
"expand_expr",
"(",
"arg1",
",",
"NULL_RTX",
",",
"VOIDmode",
",",
"<NUM_LIT>",
")",
";",
"enum",
"machine_mode",
"mode0",
"=",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"<NUM_LIT>",
"]",
".",
"mode",
";",
"enum",
"machine_mode",
"mode1",
"=",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"<NUM_LIT>",
"]",
".",
"mode",
";",
"if",
"(",
"VECTOR_MODE_P",
"(",
"mode1",
")",
")",
"op1",
"=",
"safe_vector_operand",
"(",
"op1",
",",
"mode1",
")",
";",
"op0",
"=",
"gen_rtx_MEM",
"(",
"mode0",
",",
"copy_to_mode_reg",
"(",
"Pmode",
",",
"op0",
")",
")",
";",
"op1",
"=",
"copy_to_mode_reg",
"(",
"mode1",
","
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 6,936 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
| [
"def",
"A2_vraddub",
":",
"HInst",
"<",
"(",
"outs",
"DoubleRegs",
":",
"$",
"Rdd32",
")",
",",
"(",
"ins",
"DoubleRegs",
":",
"$",
"Rss32",
",",
"DoubleRegs",
":",
"$",
"Rtt32",
")",
",",
"<STR_LIT>",
",",
"tc_bafaade3",
",",
"TypeM",
">",
",",
"Enc_a56825",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
|
GCC | s390 | MD | next_suggestion | MPU | 6,937 | [
"(",
"set",
"(",
"match_operand",
":",
"<",
"tointvec",
">",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"(",
"compare",
":",
"CCVFHE",
"(",
"match_operand",
":",
"VF_HW",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"VF_HW",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")"
]
|
LLVM | Hexagon | TD | stmt_completion | DSP | 6,938 | [
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"isCompare",
"=",
"<NUM_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentAlign"
]
|
GCC | alpha | MD | stmt_completion | MPU | 6,939 | [
")",
")"
]
| [
"(",
"define_predicate",
"<STR_LIT>",
"(",
"and",
"(",
"match_code",
"<STR_LIT>",
")",
"(",
"match_test",
"<STR_LIT>",
")"
]
|
LLVM | PowerPC | CPP | code_generation | CPU | 6,940 | [
"bool",
"PPCInstrInfo",
"::",
"ClobbersPredicate",
"(",
"MachineInstr",
"&",
"MI",
",",
"std",
"::",
"vector",
"<",
"MachineOperand",
">",
"&",
"Pred",
",",
"bool",
"SkipDead",
")",
"const",
"{",
"const",
"TargetRegisterClass",
"*",
"RCs",
"[",
"]",
"=",
"{",
"&",
"PPC",
"::",
"CRRCRegClass",
",",
"&",
"PPC",
"::",
"CRBITRCRegClass",
",",
"&",
"PPC",
"::",
"CTRRCRegClass",
",",
"&",
"PPC",
"::",
"CTRRC8RegClass",
"}",
";",
"bool",
"Found",
"=",
"false",
";",
"for",
"(",
"const",
"MachineOperand",
"&",
"MO",
":",
"MI",
".",
"operands",
"(",
")",
")",
"{",
"for",
"(",
"unsigned",
"c",
"=",
"<NUM_LIT>",
";",
"c",
"<",
"array_lengthof",
"(",
"RCs",
")",
"&&",
"!",
"Found",
";",
"++",
"c",
")",
"{",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"RCs",
"[",
"c",
"]",
";",
"if",
"(",
"MO",
".",
"isReg",
"(",
")",
")",
"{",
"if",
"(",
"MO",
".",
"isDef",
"(",
")",
"&&",
"RC",
"->",
"contains",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
")",
"{",
"Pred",
".",
"push_back",
"(",
"MO",
")",
";",
"Found",
"=",
"true",
";",
"}",
"}",
"else",
"if",
"(",
"MO",
".",
"isRegMask",
"(",
")",
")",
"{",
"for",
"(",
"TargetRegisterClass",
"::",
"iterator",
"I",
"=",
"RC",
"->",
"begin",
"(",
")",
",",
"IE",
"=",
"RC",
"->",
"end",
"(",
")",
";",
"I",
"!=",
"IE",
";",
"++",
"I",
")",
"if",
"(",
"MO",
".",
"clobbersPhysReg",
"(",
"*",
"I",
")",
")",
"{",
"Pred",
".",
"push_back",
"(",
"MO",
")",
";",
"Found",
"=",
"true",
";",
"}",
"}",
"}",
"}",
"return",
"Found",
";",
"}"
]
| [
"If",
"the",
"specified",
"instruction",
"defines",
"any",
"predicate",
"or",
"condition",
"code",
"register",
"(",
"s",
")",
"used",
"for",
"predication",
",",
"returns",
"true",
"as",
"well",
"as",
"the",
"definition",
"predicate",
"(",
"s",
")",
"by",
"reference",
"."
]
|
GCC | rs6000 | MD | next_suggestion | CPU | 6,941 | [
"(",
"if_then_else",
"(",
"ne",
"(",
"symbol_ref",
"<STR_LIT>",
")",
"(",
"symbol_ref",
"<STR_LIT>",
")",
")"
]
| [
"(",
"high",
":",
"TLSmode",
"(",
"unspec",
":",
"TLSmode",
"[",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
"]",
"UNSPEC_TLSGOTDTPREL",
")",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"lo_sum",
":",
"TLSmode",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"unspec",
":",
"TLSmode",
"[",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
"]",
"UNSPEC_TLSGOTDTPREL",
")",
")",
")",
"]",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"attr",
"<STR_LIT>",
")"
]
|
GCC | spu | MD | stmt_completion | MPU | 6,942 | [
")",
")",
"]",
")",
"]"
]
| [
"(",
"use",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"use",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>"
]
|
LLVM | Hexagon | CPP | next_suggestion | DSP | 6,943 | [
"ISel",
".",
"ReplaceNode",
"(",
"InpN",
",",
"OutN",
")",
";"
]
| [
"MVT",
"HalfTy",
"=",
"MVT",
"::",
"getVectorVT",
"(",
"OpTy",
".",
"getVectorElementType",
"(",
")",
",",
"OpTy",
".",
"getVectorNumElements",
"(",
")",
"/",
"<NUM_LIT>",
")",
";",
"unsigned",
"Sub",
"=",
"(",
"Part",
"==",
"OpRef",
"::",
"LoHalf",
")",
"?",
"Hexagon",
"::",
"vsub_lo",
":",
"Hexagon",
"::",
"vsub_hi",
";",
"Op",
"=",
"DAG",
".",
"getTargetExtractSubreg",
"(",
"Sub",
",",
"dl",
",",
"HalfTy",
",",
"Op",
")",
";",
"}",
"}",
"Ops",
".",
"push_back",
"(",
"Op",
")",
";",
"}",
"assert",
"(",
"Node",
".",
"Ty",
"!=",
"MVT",
"::",
"Other",
")",
";",
"SDNode",
"*",
"ResN",
"=",
"(",
"Node",
".",
"Opc",
"==",
"TargetOpcode",
"::",
"COPY",
")",
"?",
"Ops",
".",
"front",
"(",
")",
".",
"getNode",
"(",
")",
":",
"DAG",
".",
"getMachineNode",
"(",
"Node",
".",
"Opc",
",",
"dl",
",",
"Node",
".",
"Ty",
",",
"Ops",
")",
";",
"Output",
".",
"push_back",
"(",
"SDValue",
"(",
"ResN",
",",
"<NUM_LIT>",
")",
")",
";",
"}",
"SDNode",
"*",
"OutN",
"=",
"Output",
".",
"back",
"(",
")",
".",
"getNode",
"(",
")",
";",
"SDNode",
"*",
"InpN",
"=",
"Results",
".",
"InpNode",
";",
"DEBUG_WITH_TYPE",
"(",
"<STR_LIT>",
"isel",
"<STR_LIT>",
",",
"{",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Generated node:\\n",
"<STR_LIT>",
";",
"OutN",
"->",
"dumpr",
"(",
"&",
"DAG",
")",
";",
"}",
")",
";"
]
|
LLVM | Mips | CPP | code_generation | CPU | 6,944 | [
"MipsSubtarget",
"::",
"MipsSubtarget",
"(",
"const",
"std",
"::",
"string",
"&",
"TT",
",",
"const",
"std",
"::",
"string",
"&",
"CPU",
",",
"const",
"std",
"::",
"string",
"&",
"FS",
",",
"bool",
"little",
",",
"Reloc",
"::",
"Model",
"_",
"RM",
",",
"MipsTargetMachine",
"*",
"_",
"TM",
")",
":",
"MipsGenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"MipsArchVersion",
"(",
"Mips32",
")",
",",
"MipsABI",
"(",
"UnknownABI",
")",
",",
"IsLittle",
"(",
"little",
")",
",",
"IsSingleFloat",
"(",
"false",
")",
",",
"IsFP64bit",
"(",
"false",
")",
",",
"IsNaN2008bit",
"(",
"false",
")",
",",
"IsGP64bit",
"(",
"false",
")",
",",
"HasVFPU",
"(",
"false",
")",
",",
"HasCnMips",
"(",
"false",
")",
",",
"IsLinux",
"(",
"true",
")",
",",
"HasMips3_32",
"(",
"false",
")",
",",
"HasMips3_32r2",
"(",
"false",
")",
",",
"HasMips4_32",
"(",
"false",
")",
",",
"HasMips4_32r2",
"(",
"false",
")",
",",
"HasMips5_32r2",
"(",
"false",
")",
",",
"InMips16Mode",
"(",
"false",
")",
",",
"InMips16HardFloat",
"(",
"Mips16HardFloat",
")",
",",
"InMicroMipsMode",
"(",
"false",
")",
",",
"HasDSP",
"(",
"false",
")",
",",
"HasDSPR2",
"(",
"false",
")",
",",
"AllowMixed16_32",
"(",
"Mixed16_32",
"|",
"Mips_Os16",
")",
",",
"Os16",
"(",
"Mips_Os16",
")",
",",
"HasMSA",
"(",
"false",
")",
",",
"RM",
"(",
"_",
"RM",
")",
",",
"OverrideMode",
"(",
"NoOverride",
")",
",",
"TM",
"(",
"_",
"TM",
")",
",",
"TargetTriple",
"(",
"TT",
")",
"{",
"std",
"::",
"string",
"CPUName",
"=",
"CPU",
";",
"CPUName",
"=",
"selectMipsCPU",
"(",
"TT",
",",
"CPUName",
")",
";",
"ParseSubtargetFeatures",
"(",
"CPUName",
",",
"FS",
")",
";",
"if",
"(",
"InMips16Mode",
"&&",
"!",
"TM",
"->",
"Options",
".",
"UseSoftFloat",
")",
"{",
"TM",
"->",
"Options",
".",
"UseSoftFloat",
"=",
"true",
";",
"TM",
"->",
"Options",
".",
"FloatABIType",
"=",
"FloatABI",
"::",
"Soft",
";",
"InMips16HardFloat",
"=",
"true",
";",
"}",
"PreviousInMips16Mode",
"=",
"InMips16Mode",
";",
"InstrItins",
"=",
"getInstrItineraryForCPU",
"(",
"CPUName",
")",
";",
"if",
"(",
"MipsArchVersion",
"==",
"Mips1",
")",
"report_fatal_error",
"(",
"<STR_LIT>",
"Code generation for MIPS-I is not implemented",
"<STR_LIT>",
",",
"false",
")",
";",
"if",
"(",
"MipsArchVersion",
"==",
"Mips2",
")",
"report_fatal_error",
"(",
"<STR_LIT>",
"Code generation for MIPS-II is not implemented",
"<STR_LIT>",
",",
"false",
")",
";",
"if",
"(",
"MipsArchVersion",
"==",
"Mips3",
")",
"report_fatal_error",
"(",
"<STR_LIT>",
"Code generation for MIPS-III is not implemented",
"<STR_LIT>",
",",
"false",
")",
";",
"if",
"(",
"MipsArchVersion",
"==",
"Mips5",
")",
"report_fatal_error",
"(",
"<STR_LIT>",
"Code generation for MIPS-V is not implemented",
"<STR_LIT>",
",",
"false",
")",
";",
"assert",
"(",
"MipsABI",
"!=",
"UnknownABI",
")",
";",
"assert",
"(",
"(",
"(",
"(",
"getFeatureBits",
"(",
")",
"&",
"Mips",
"::",
"FeatureO32",
")",
"!=",
"<NUM_LIT>",
")",
"+",
"(",
"(",
"getFeatureBits",
"(",
")",
"&",
"Mips",
"::",
"FeatureEABI",
")",
"!=",
"<NUM_LIT>",
")",
"+",
"(",
"(",
"getFeatureBits",
"(",
")",
"&",
"Mips",
"::",
"FeatureN32",
")",
"!=",
"<NUM_LIT>",
")",
"+",
"(",
"(",
"getFeatureBits",
"(",
")",
"&",
"Mips",
"::",
"FeatureN64",
")",
"!=",
"<NUM_LIT>",
")",
")",
"==",
"<NUM_LIT>",
")",
";",
"assert",
"(",
"(",
"(",
"!",
"isGP64bit",
"(",
")",
"&&",
"(",
"isABI_O32",
"(",
")",
"||",
"isABI_EABI",
"(",
")",
")",
")",
"||",
"(",
"isGP64bit",
"(",
")",
"&&",
"(",
"isABI_N32",
"(",
")",
"||",
"isABI_N64",
"(",
")",
")",
")",
")",
"&&",
"<STR_LIT>",
"Invalid Arch & ABI pair.",
"<STR_LIT>",
")",
";",
"if",
"(",
"hasMSA",
"(",
")",
"&&",
"!",
"isFP64bit",
"(",
")",
")",
"report_fatal_error",
"(",
"<STR_LIT>",
"MSA requires a 64-bit FPU register file (FR=1 mode). ",
"<STR_LIT>",
"<STR_LIT>",
"See -mattr=+fp64.",
"<STR_LIT>",
",",
"false",
")",
";",
"if",
"(",
"hasMips32r6",
"(",
")",
")",
"{",
"StringRef",
"ISA",
"=",
"hasMips64r6",
"(",
")",
"?",
"<STR_LIT>",
"MIPS64r6",
"<STR_LIT>",
":",
"<STR_LIT>",
"MIPS32r6",
"<STR_LIT>",
";",
"assert",
"(",
"isFP64bit",
"(",
")",
")",
";",
"assert",
"(",
"isNaN2008",
"(",
")",
")",
";",
"if",
"(",
"hasDSP",
"(",
")",
")",
"report_fatal_error",
"(",
"ISA",
"+",
"<STR_LIT>",
" is not compatible with the DSP ASE",
"<STR_LIT>",
",",
"false",
")",
";",
"}",
"if",
"(",
"TT",
".",
"find",
"(",
"<STR_LIT>",
"linux",
"<STR_LIT>",
")",
"==",
"std",
"::",
"string",
"::",
"npos",
")",
"IsLinux",
"=",
"false",
";",
"UseSmallSection",
"=",
"!",
"IsLinux",
"&&",
"(",
"RM",
"==",
"Reloc",
"::",
"Static",
")",
";",
"}"
]
| [
"This",
"constructor",
"initializes",
"the",
"data",
"members",
"to",
"match",
"that",
"of",
"the",
"specified",
"triple",
"."
]
|
GCC | m68hc11 | CPP | program_repair | MPU | 6,945 | [
"<FIXS>",
"fprintf",
"(",
"file",
",",
"<STR_LIT>",
"%u,+",
"<STR_LIT>",
",",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"addr",
")",
")",
")",
";",
"<FIXE>"
]
| [
"case",
"PRE_INC",
":",
"if",
"(",
"TARGET_M6812",
")",
"{",
"<BUGS>",
"asm_fprintf",
"(",
"file",
",",
"<STR_LIT>",
"%u,+",
"<STR_LIT>",
",",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"addr",
")",
")",
")",
";",
"<BUGE>",
"asm_print_register",
"(",
"file",
",",
"REGNO",
"(",
"XEXP",
"(",
"base",
",",
"<NUM_LIT>",
")",
")",
")",
";",
"}",
"else"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 6,946 | [
"_",
"B",
",",
"(",
"_",
"_",
"v8di",
")",
"_",
"_",
"W",
",",
"(",
"_",
"_",
"mmask8",
")",
"_",
"_",
"U",
")",
";"
]
| [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m512i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm512_mask_or_epi64",
"(",
"_",
"_",
"m512i",
"_",
"_",
"W",
",",
"_",
"_",
"mmask8",
"_",
"_",
"U",
",",
"_",
"_",
"m512i",
"_",
"_",
"A",
",",
"_",
"_",
"m512i",
"_",
"_",
"B",
")",
"{",
"return",
"(",
"_",
"_",
"m512i",
")",
"_",
"_",
"builtin_ia32_porq512_mask",
"(",
"(",
"_",
"_",
"v8di",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v8di",
")",
"_"
]
|
GCC | s390 | MD | next_suggestion | MPU | 6,947 | [
"(",
"match_operand",
":",
"FP",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")"
]
| [
"[",
"(",
"set",
"(",
"match_operand",
":",
"FP",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"minus",
":",
"FP",
"(",
"match_operand",
":",
"FP",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
LLVM | X86 | TD | program_repair | CPU | 6,948 | [
"<FIXS>",
"(",
"OpNodeInt",
"(",
"_SrcRC",
".",
"ScalarIntMemFrags",
"addr",
":",
"$",
"src",
")",
")",
")",
"]",
">",
",",
"<FIXE>"
]
| [
"(",
"ins",
"_SrcRC",
".",
"IntScalarMemOp",
":",
"$",
"src",
")",
",",
"!",
"strconcat",
"(",
"asm",
",",
"<STR_LIT>",
")",
",",
"[",
"(",
"set",
"_DstRC",
".",
"RC",
":",
"$",
"dst",
",",
"<BUGS>",
"(",
"OpNodeInt",
"(",
"_SrcRC",
".",
"VT",
"_SrcRC",
".",
"ScalarIntMemCPat",
":",
"$",
"src",
")",
")",
")",
"]",
">",
",",
"<BUGE>",
"EVEX",
",",
"VEX_LIG",
",",
"Sched",
"[",
"sched",
".",
"Folded",
",",
"sched",
".",
"ReadAfterFold",
"]",
">",
",",
"SIMD_EXC",
";",
"}"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 6,949 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
|
GCC | i386 | CPP | program_repair | CPU | 6,950 | [
"<FIXS>",
"rtx",
"t",
"=",
"gen_reg_rtx",
"(",
"V4SFmode",
")",
";",
"ix86_expand_vector_set",
"(",
"false",
",",
"t",
",",
"gen_lowpart",
"(",
"SFmode",
",",
"val",
")",
",",
"elt",
")",
";",
"emit_move_insn",
"(",
"target",
",",
"gen_lowpart",
"(",
"mode",
",",
"t",
")",
")",
";",
"<FIXE>"
]
| [
"else",
"{",
"<BUGS>",
"ix86_expand_vector_set",
"(",
"false",
",",
"gen_lowpart",
"(",
"V4SFmode",
",",
"target",
")",
",",
"gen_lowpart",
"(",
"SFmode",
",",
"val",
")",
",",
"elt",
")",
";",
"<BUGE>",
"}",
"return",
";"
]
|
LLVM | ARM64 | TD | stmt_completion | CPU | 6,951 | [
";"
]
| [
"def",
"Xi",
":",
"BaseCondSetFlagsImm",
"<",
"op",
",",
"GPR64",
",",
"asm",
">",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>"
]
|
GCC | arm | MD | next_suggestion | CPU | 6,952 | [
"<STR_LIT>"
]
| [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"reg",
":",
"SI",
"VFPCC_REGNUM",
")",
"(",
"unspec_volatile",
":",
"SI",
"[",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"VUNSPEC_SET_FPSCR_NZCVQC",
")",
")",
"]"
]
|
LLVM | Hexagon | TD | stmt_completion | DSP | 6,953 | [
"=",
"<NUM_LIT>",
";"
]
| [
"def",
"J4_cmpgti_tp0_jump_t",
":",
"HInst",
"<",
"(",
"outs",
")",
",",
"(",
"ins",
"GeneralSubRegs",
":",
"$",
"Rs16",
",",
"u5_0Imm",
":",
"$",
"II",
",",
"b30_2Imm",
":",
"$",
"Ii",
")",
",",
"<STR_LIT>",
",",
"tc_3d495a39",
",",
"TypeCJ",
">",
",",
"Enc_14d27a",
",",
"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"
]
|
LLVM | AArch64 | CPP | stmt_completion | CPU | 6,954 | [
"(",
"Val",
")",
")",
";"
]
| [
"static",
"DecodeStatus",
"DecodeSImm8OptLslByte",
"(",
"llvm",
"::",
"MCInst",
"&",
"Inst",
",",
"unsigned",
"Imm",
",",
"uint64_t",
"Addr",
",",
"const",
"void",
"*",
"Decoder",
")",
"{",
"signed",
"Val",
"=",
"(",
"int8_t",
")",
"Imm",
";",
"if",
"(",
"Imm",
"&",
"<NUM_LIT>",
")",
"return",
"Fail",
";",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm"
]
|
GCC | i386 | MD | next_suggestion | CPU | 6,955 | [
"(",
"parallel",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
")",
")"
]
| [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"reg",
":",
"CCFP",
"FLAGS_REG",
")",
"(",
"compare",
":",
"CCFP",
"(",
"vec_select",
":",
"MODEF",
"(",
"match_operand",
":",
"<",
"ssevecmode",
">",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
LLVM | CAHP | CPP | stmt_completion | CPU | 6,956 | [
":"
]
| [
"case",
"ISD",
"::",
"BR_CC",
":",
"return",
"LowerBR_CC",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"GlobalAddress",
":",
"return",
"LowerGlobalAddress",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"SELECT",
":",
"return",
"LowerSELECT",
"(",
"Op",
",",
"DAG",
")",
";",
"case",
"ISD",
"::",
"FRAMEADDR"
]
|
GCC | nds32 | MD | stmt_completion | CPU | 6,957 | [
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"(",
"and",
"("
]
|
LLVM | AArch64 | TD | stmt_completion | CPU | 6,958 | [
"V128",
":",
"$",
"Rn",
")",
",",
"(",
"v16i8",
"V128",
":",
"$",
"Rm",
")",
")",
")",
"]",
">",
";"
]
| [
"def",
"v16i8",
":",
"BaseSIMDThreeSameVectorPseudo",
"<",
"V128",
",",
"[",
"(",
"set",
"(",
"v16i8",
"V128",
":",
"$",
"dst",
")",
",",
"(",
"OpNode",
"(",
"v16i8",
"V128",
":",
"$",
"Rd",
")",
",",
"(",
"v16i8"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 6,959 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Ps",
";"
]
| [
"let",
"IClass",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | WebAssembly | CPP | stmt_completion | Virtual ISA | 6,960 | [
"<STR_LIT>",
")",
";"
]
| [
"llvm_unreachable",
"(",
"<STR_LIT>",
"ParseRegister is not implemented."
]
|
LLVM | WebAssembly | CPP | stmt_completion | Virtual ISA | 6,961 | [
";"
]
| [
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Found `main` function with incorrect type: ",
"<STR_LIT>",
"<<",
"*",
"F",
".",
"getFunctionType",
"(",
")",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"Value",
"*",
"Args",
"[",
"]",
"=",
"{",
"UndefValue",
"::",
"get",
"(",
"MainArgTys",
"[",
"<NUM_LIT>",
"]",
")",
",",
"UndefValue",
"::",
"get",
"(",
"MainArgTys",
"[",
"<NUM_LIT>",
"]",
")",
"}",
";",
"Value",
"*",
"Casted",
"=",
"ConstantExpr",
"::",
"getBitCast",
"(",
"Main",
",",
"PointerType",
"::",
"get",
"(",
"MainTy",
",",
"<NUM_LIT>",
")",
")",
";",
"CallMain",
"=",
"CallInst",
"::",
"Create",
"(",
"Casted",
",",
"Args",
",",
"<STR_LIT>",
"call_main",
"<STR_LIT>",
")",
";",
"Use",
"*",
"UseMain",
"=",
"&",
"CallMain",
"->",
"getOperandUse",
"(",
"<NUM_LIT>",
")",
";",
"Uses",
".",
"push_back",
"(",
"std",
"::",
"make_pair",
"(",
"UseMain",
",",
"&",
"F",
")",
")",
";",
"}",
"}",
"}",
"DenseMap",
"<",
"std",
"::",
"pair",
"<",
"Function",
"*",
",",
"FunctionType",
"*",
">",
",",
"Function",
"*",
">",
"Wrappers",
";",
"for",
"(",
"auto",
"&",
"UseFunc",
":",
"Uses",
")",
"{",
"Use",
"*",
"U",
"=",
"UseFunc",
".",
"first",
";",
"Function",
"*",
"F",
"=",
"UseFunc",
".",
"second",
";",
"PointerType",
"*",
"PTy",
"=",
"cast",
"<",
"PointerType",
">",
"(",
"U",
"->",
"get",
"(",
")",
"->",
"getType",
"(",
")",
")",
";",
"FunctionType",
"*",
"Ty",
"=",
"dyn_cast",
"<",
"FunctionType",
">",
"(",
"PTy",
"->",
"getElementType",
"(",
")",
")",
";",
"if",
"(",
"!",
"Ty",
")",
"continue",
";",
"auto",
"Pair",
"=",
"Wrappers",
".",
"insert",
"(",
"std",
"::",
"make_pair",
"(",
"std",
"::",
"make_pair",
"(",
"F",
",",
"Ty",
")",
",",
"nullptr",
")",
")",
";",
"if",
"(",
"Pair",
".",
"second",
")",
"Pair",
".",
"first",
"->",
"second",
"=",
"CreateWrapper",
"(",
"F",
",",
"Ty",
")",
";",
"Function",
"*",
"Wrapper",
"=",
"Pair",
".",
"first",
"->",
"second",
";",
"if",
"(",
"!",
"Wrapper",
")",
"continue",
";",
"if",
"(",
"isa",
"<",
"Constant",
">",
"(",
"U",
"->",
"get",
"(",
")",
")",
")",
"U",
"->",
"get",
"(",
")",
"->",
"replaceAllUsesWith",
"(",
"Wrapper",
")",
";",
"else",
"U",
"->",
"set",
"(",
"Wrapper",
")",
";",
"}",
"if",
"(",
"CallMain",
")",
"{",
"Main",
"->",
"setName",
"(",
"<STR_LIT>",
"__original_main",
"<STR_LIT>",
")",
";",
"Function",
"*",
"MainWrapper",
"=",
"cast",
"<",
"Function",
">",
"(",
"CallMain",
"->",
"getCalledValue",
"(",
")",
"->",
"stripPointerCasts",
"(",
")",
")",
";",
"MainWrapper",
"->",
"setName",
"(",
"<STR_LIT>",
"main",
"<STR_LIT>",
")",
";",
"MainWrapper",
"->",
"setLinkage",
"(",
"Main",
"->",
"getLinkage",
"(",
")",
")",
";",
"MainWrapper",
"->",
"setVisibility",
"(",
"Main",
"->",
"getVisibility",
"(",
")",
")",
";",
"Main",
"->",
"setLinkage",
"(",
"Function",
"::",
"PrivateLinkage",
")",
";",
"Main",
"->",
"setVisibility",
"(",
"Function",
"::",
"DefaultVisibility",
")",
";",
"delete",
"CallMain",
";",
"}",
"return",
"true"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 6,962 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Ii",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
]
| [
"class",
"Enc_78cbf0",
":",
"OpcodeHexagon",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"Ii",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Ii",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Ii",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Ii",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
]
|
GCC | m68k | CPP | program_repair | MPU | 6,963 | [
"<FIXS>",
"&&",
"!",
"(",
"flag_pic",
"&&",
"ireg",
"==",
"pic_offset_table_rtx",
")",
")",
"<FIXE>"
]
| [
"ireg",
"=",
"reg2",
";",
"}",
"if",
"(",
"ireg",
"!=",
"<NUM_LIT>",
"&&",
"breg",
"==",
"<NUM_LIT>",
"&&",
"GET_CODE",
"(",
"addr",
")",
"==",
"LABEL_REF",
"<BUGS>",
"&&",
"!",
"(",
"flag_pic",
"&&",
"ireg",
"==",
"pic_offset_table_rtx",
")",
")",
"<BUGE>",
"{",
"int",
"scale",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"GET_CODE",
"(",
"ireg",
")",
"==",
"MULT",
")"
]
|
GCC | i386 | CPP | program_repair | CPU | 6,964 | [
"<FIXS>",
"bitmap_clear",
"(",
"data",
"->",
"ready_try_change",
")",
";",
"<FIXE>"
]
| [
"n_ready",
",",
"<NUM_LIT>",
")",
";",
"data",
"->",
"ready_try_change_size",
"=",
"n_ready",
";",
"}",
"<BUGS>",
"sbitmap_zero",
"(",
"data",
"->",
"ready_try_change",
")",
";",
"<BUGE>"
]
|
LLVM | Mips | TD | next_suggestion | CPU | 6,965 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"rt",
";"
]
| [
"bits",
"<",
"<NUM_LIT>",
">",
"offset",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Inst",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"op",
";"
]
|
GCC | aarch64 | CPP | stmt_completion | CPU | 6,966 | [
"true",
";"
]
| [
"if",
"(",
"aarch64_vfp_is_call_or_return_candidate",
"(",
"TYPE_MODE",
"(",
"valtype",
")",
",",
"valtype",
",",
"&",
"dummy_mode",
",",
"&",
"dummy_int",
",",
"NULL",
")",
")",
"return",
"false",
";",
"return"
]
|
LLVM | Lanai | CPP | stmt_completion | CPU | 6,967 | [
"Op",
")",
")",
";"
]
| [
"std",
"::",
"unique_ptr",
"<",
"LanaiOperand",
">",
"Op",
"=",
"parseRegister",
"(",
")",
";",
"if",
"(",
"!",
"Op",
")",
"Op",
"=",
"parseImmediate",
"(",
")",
";",
"if",
"(",
"!",
"Op",
")",
"{",
"Error",
"(",
"Parser",
".",
"getTok",
"(",
")",
".",
"getLoc",
"(",
")",
",",
"<STR_LIT>",
"Unknown operand",
"<STR_LIT>",
")",
";",
"Parser",
".",
"eatToEndOfStatement",
"(",
")",
";",
"return",
"MatchOperand_ParseFail",
";",
"}",
"Operands",
"->",
"push_back",
"(",
"std",
"::",
"move",
"("
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 6,968 | [
"const",
"{"
]
| [
"bool",
"isVISrc_64V2FP32",
"(",
")"
]
|
GCC | i386 | CPP | code_generation | CPU | 6,969 | [
"static",
"unsigned",
"HOST_WIDE_INT",
"ix86_memmodel_check",
"(",
"unsigned",
"HOST_WIDE_INT",
"val",
")",
"{",
"enum",
"memmodel",
"model",
"=",
"memmodel_from_int",
"(",
"val",
")",
";",
"bool",
"strong",
";",
"if",
"(",
"val",
"&",
"~",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"(",
"IX86_HLE_ACQUIRE",
"|",
"IX86_HLE_RELEASE",
"|",
"MEMMODEL_MASK",
")",
"||",
"(",
"(",
"val",
"&",
"IX86_HLE_ACQUIRE",
")",
"&&",
"(",
"val",
"&",
"IX86_HLE_RELEASE",
")",
")",
")",
"{",
"warning",
"(",
"OPT_Winvalid_memory_model",
",",
"<STR_LIT>",
"unknown architecture specific memory model",
"<STR_LIT>",
")",
";",
"return",
"MEMMODEL_SEQ_CST",
";",
"}",
"strong",
"=",
"(",
"is_mm_acq_rel",
"(",
"model",
")",
"||",
"is_mm_seq_cst",
"(",
"model",
")",
")",
";",
"if",
"(",
"val",
"&",
"IX86_HLE_ACQUIRE",
"&&",
"!",
"(",
"is_mm_acquire",
"(",
"model",
")",
"||",
"strong",
")",
")",
"{",
"warning",
"(",
"OPT_Winvalid_memory_model",
",",
"<STR_LIT>",
"%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger ",
"<STR_LIT>",
"<STR_LIT>",
"memory model",
"<STR_LIT>",
")",
";",
"return",
"MEMMODEL_SEQ_CST",
"|",
"IX86_HLE_ACQUIRE",
";",
"}",
"if",
"(",
"val",
"&",
"IX86_HLE_RELEASE",
"&&",
"!",
"(",
"is_mm_release",
"(",
"model",
")",
"||",
"strong",
")",
")",
"{",
"warning",
"(",
"OPT_Winvalid_memory_model",
",",
"<STR_LIT>",
"%<HLE_RELEASE%> not used with %<RELEASE%> or stronger ",
"<STR_LIT>",
"<STR_LIT>",
"memory model",
"<STR_LIT>",
")",
";",
"return",
"MEMMODEL_SEQ_CST",
"|",
"IX86_HLE_RELEASE",
";",
"}",
"return",
"val",
";",
"}"
]
| [
"Validate",
"target",
"specific",
"memory",
"model",
"bits",
"in",
"VAL",
"."
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 6,970 | [
"}"
]
| [
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";",
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Defs",
"=",
"[",
"PC",
"]",
";",
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";"
]
|
LLVM | TPC | CPP | stmt_completion | Virtual ISA | 6,971 | [
"false",
";"
]
| [
"if",
"(",
"Sw",
"!=",
"TPCII",
"::",
"SW_MDG_TYPE_SINGLE",
")",
"return",
"false",
";",
"*",
"pSrcG",
"=",
"(",
"Sw",
"&",
"TPCII",
"::",
"SW_SRC_DUAL_GROUP",
")",
">>",
"TPCII",
"::",
"SW_SRC_DUAL_GROUP_SHIFT",
";",
"*",
"pDstG",
"=",
"(",
"Sw",
"&",
"TPCII",
"::",
"SW_DST_DUAL_GROUP",
")",
">>",
"TPCII",
"::",
"SW_DST_DUAL_GROUP_SHIFT",
";",
"return",
"true",
";",
"}",
"return"
]
|
LLVM | X86 | CPP | next_suggestion | CPU | 6,972 | [
"if",
"(",
"IsBlendSupported",
")",
"if",
"(",
"SDValue",
"Blend",
"=",
"lowerVectorShuffleAsBlend",
"(",
"DL",
",",
"MVT",
"::",
"v4i32",
",",
"V1",
",",
"V2",
",",
"Mask",
",",
"Subtarget",
",",
"DAG",
")",
")",
"return",
"Blend",
";"
]
| [
"const",
"int",
"UnpackHiMask",
"[",
"]",
"=",
"{",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"}",
";",
"if",
"(",
"isShuffleEquivalent",
"(",
"V1",
",",
"V2",
",",
"Mask",
",",
"{",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"}",
")",
")",
"Mask",
"=",
"UnpackLoMask",
";",
"else",
"if",
"(",
"isShuffleEquivalent",
"(",
"V1",
",",
"V2",
",",
"Mask",
",",
"{",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"}",
")",
")",
"Mask",
"=",
"UnpackHiMask",
";",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"MVT",
"::",
"v4i32",
",",
"V1",
",",
"getV4X86ShuffleImm8ForMask",
"(",
"Mask",
",",
"DL",
",",
"DAG",
")",
")",
";",
"}",
"if",
"(",
"SDValue",
"Shift",
"=",
"lowerVectorShuffleAsShift",
"(",
"DL",
",",
"MVT",
"::",
"v4i32",
",",
"V1",
",",
"V2",
",",
"Mask",
",",
"Subtarget",
",",
"DAG",
")",
")",
"return",
"Shift",
";",
"if",
"(",
"NumV2Elements",
"==",
"<NUM_LIT>",
")",
"if",
"(",
"SDValue",
"V",
"=",
"lowerVectorShuffleAsElementInsertion",
"(",
"DL",
",",
"MVT",
"::",
"v4i32",
",",
"V1",
",",
"V2",
",",
"Mask",
",",
"Subtarget",
",",
"DAG",
")",
")",
"return",
"V",
";",
"bool",
"IsBlendSupported",
"=",
"Subtarget",
".",
"hasSSE41",
"(",
")",
";"
]
|
LLVM | Kudeyar | CPP | stmt_completion | CPU | 6,973 | [
"BA",
",",
"getPointerTy",
"(",
")",
")",
";"
]
| [
"const",
"BlockAddress",
"*",
"BA",
"=",
"cast",
"<",
"BlockAddressSDNode",
">",
"(",
"Op",
")",
"->",
"getBlockAddress",
"(",
")",
";",
"SDValue",
"Result",
"=",
"DAG",
".",
"getTargetBlockAddress",
"("
]
|
LLVM | PowerPC | CPP | next_suggestion | CPU | 6,974 | [
"static",
"const",
"SpillSlot",
"Offsets64",
"[",
"]",
"=",
"{"
]
| [
"}",
"static",
"const",
"SpillSlot",
"Offsets",
"[",
"]",
"=",
"{",
"{",
"PPC",
"::",
"F31",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F30",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F29",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F28",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F27",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F26",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F25",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F24",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F23",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F22",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F21",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F20",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F19",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F18",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F17",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F16",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F15",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"F14",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R31",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R30",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R29",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R28",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R27",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R26",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R25",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R24",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R23",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R22",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R21",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R20",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R19",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R18",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R17",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R16",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R15",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"R14",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"CR2",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"VRSAVE",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"V31",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"V30",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"V29",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"V28",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"V27",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"V26",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"V25",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"V24",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"V23",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"V22",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"V21",
",",
"-",
"<NUM_LIT>",
"}",
",",
"{",
"PPC",
"::",
"V20",
",",
"-",
"<NUM_LIT>",
"}",
"}",
";"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 6,975 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Pd4",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
]
| [
"bits",
"<",
"<NUM_LIT>",
">",
"Rss32",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rss32",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Pd4",
";"
]
|
LLVM | ARM | TD | next_suggestion | CPU | 6,976 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"size",
";"
]
| [
"bits",
"<",
"<NUM_LIT>",
">",
"Qd",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"Qd",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | ARM | TD | stmt_completion | CPU | 6,977 | [
",",
"shr_imm64",
",",
"OpcodeStr",
",",
"!",
"strconcat",
"(",
"Dt",
",",
"<STR_LIT>",
")",
",",
"v1i64",
",",
"OpNode",
">",
";"
]
| [
"def",
"v1i64",
":",
"N2VDSh",
"<",
"op24",
",",
"op23",
",",
"op11_8",
",",
"<NUM_LIT>",
",",
"op4",
",",
"N2RegVShRFrm",
",",
"itin"
]
|
LLVM | TPC | TD | stmt_completion | Virtual ISA | 6,978 | [
">",
"pred",
";"
]
| [
"class",
"SpuInst_MovFromHWReg",
"<",
"bits",
"<",
"<NUM_LIT>",
">",
"opc",
",",
"RegisterClass",
"Rdst",
",",
"RegisterClass",
"Rsrc",
",",
"string",
"asmstr",
">",
":",
"ScalarInstBase",
"<",
"opc",
",",
"asmstr",
">",
"{",
"let",
"OutOperandList",
"=",
"(",
"outs",
"Rdst",
":",
"$",
"dest",
")",
";",
"let",
"InOperandList",
"=",
"(",
"ins",
"Rsrc",
":",
"$",
"src",
",",
"SwitchSet",
":",
"$",
"sw",
",",
"Rdst",
":",
"$",
"income",
",",
"SPred",
":",
"$",
"pred",
")",
";",
"let",
"Itinerary",
"=",
"IIC_ScalarOp",
";",
"let",
"isNotUsedInDisasm",
"=",
"!",
"if",
"(",
"!",
"eq",
"(",
"!",
"cast",
"<",
"string",
">",
"(",
"Rdst",
")",
",",
"<STR_LIT>",
")",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"dest",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"src",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"sw",
";",
"bits",
"<",
"<NUM_LIT>"
]
|
LLVM | Hexagon | CPP | program_repair | DSP | 6,979 | [
"<FIXS>",
"#",
"include",
"<STR_LIT>",
"HexagonSubtarget.h",
"<STR_LIT>",
"<FIXE>",
"<FIXS>",
"#",
"include",
"<STR_LIT>",
"llvm/CodeGen/MachineFunction.h",
"<STR_LIT>",
"#",
"include",
"memory",
">",
"<FIXE>",
"<FIXS>",
"const",
"HexagonSubtarget",
"*",
"Subtarget",
"=",
"nullptr",
";",
"<FIXE>"
]
| [
"#",
"define",
"LLVM_LIB_TARGET_HEXAGON_HEXAGONASMPRINTER_H",
"#",
"include",
"<STR_LIT>",
"Hexagon.h",
"<STR_LIT>",
"<BUGS>",
"#",
"include",
"<STR_LIT>",
"HexagonTargetMachine.h",
"<STR_LIT>",
"<BUGE>",
"#",
"include",
"<STR_LIT>",
"llvm/CodeGen/AsmPrinter.h",
"<STR_LIT>",
"<BUGS>",
"#",
"include",
"<STR_LIT>",
"llvm/Support/Compiler.h",
"<STR_LIT>",
"#",
"include",
"<STR_LIT>",
"llvm/Support/raw_ostream.h",
"<STR_LIT>",
"<BUGE>",
"namespace",
"llvm",
"{",
"class",
"HexagonAsmPrinter",
":",
"public",
"AsmPrinter",
"{",
"<BUGS>",
"const",
"HexagonSubtarget",
"*",
"Subtarget",
";",
"<BUGE>",
"public",
":",
"explicit",
"HexagonAsmPrinter",
"(",
"TargetMachine",
"&",
"TM",
","
]
|
LLVM | ARM64 | TD | stmt_completion | CPU | 6,980 | [
"(",
"baseOpc",
",",
"<STR_LIT>",
")",
")",
"V64",
":",
"$",
"Rn",
")",
",",
"hsub",
")",
",",
"(",
"i64",
"<NUM_LIT>",
")",
")",
")",
">",
";"
]
| [
"def",
":",
"Pat",
"<",
"(",
"i32",
"(",
"intOp",
"(",
"v4i16",
"V64",
":",
"$",
"Rn",
")",
")",
")",
",",
"(",
"i32",
"(",
"SMOVvi16to32",
"(",
"INSERT_SUBREG",
"(",
"v16i8",
"(",
"IMPLICIT_DEF",
")",
")",
",",
"(",
"!",
"cast",
"<",
"Instruction",
">",
"(",
"!",
"strconcat"
]
|
LLVM | X86 | TD | stmt_completion | CPU | 6,981 | [
"<NUM_LIT>",
",",
"<NUM_LIT>",
"]",
";"
]
| [
"let",
"NumMicroOps",
"=",
"<NUM_LIT>",
";",
"let",
"ResourceCycles",
"=",
"["
]
|
LLVM | AArch64 | CPP | next_suggestion | CPU | 6,982 | [
"O",
"<<",
"<STR_LIT>",
"#0x",
"<STR_LIT>",
";"
]
| [
"void",
"AArch64InstPrinter",
"::",
"printLogicalImm32",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"unsigned",
"OpNum",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"uint64_t",
"Val",
"=",
"MI",
"->",
"getOperand",
"(",
"OpNum",
")",
".",
"getImm",
"(",
")",
";"
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 6,983 | [
"CTLZ_ZERO_UNDEF",
";"
]
| [
"return",
"Opc",
"==",
"ISD",
"::",
"CTLZ",
"||",
"Opc",
"==",
"ISD",
"::"
]
|
LLVM | AMDGPU | CPP | stmt_completion | GPU | 6,984 | [
"(",
")",
";"
]
| [
"AU",
".",
"addRequired",
"<",
"TargetPassConfig",
">"
]
|
LLVM | NMX | CPP | next_suggestion | VLIW | 6,985 | [
"}"
]
| [
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"SignExtend32",
"<",
"<NUM_LIT>",
">",
"(",
"Insn",
")",
")",
")",
";",
"return",
"MCDisassembler",
"::",
"Success",
";"
]
|
GCC | i386 | CPP | stmt_completion | CPU | 6,986 | [
"(",
")",
",",
"(",
"_",
"_",
"mmask8",
")",
"_",
"_",
"U",
")",
";"
]
| [
"return",
"(",
"_",
"_",
"m256i",
")",
"_",
"_",
"builtin_ia32_pmaddwd256_mask",
"(",
"(",
"_",
"_",
"v16hi",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v16hi",
")",
"_",
"_",
"B",
",",
"(",
"_",
"_",
"v8si",
")",
"_",
"mm256_setzero_si256"
]
|
GCC | ia64 | MD | next_suggestion | CPU | 6,987 | [
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"(",
"match_operand",
":",
"TI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
"{",
"ia64_split_tmode_move",
"(",
"operands",
")",
"DONE",
"}"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 6,988 | [
"let",
"opExtentAlign",
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"CextOpcode",
"=",
"<STR_LIT>",
";",
"let",
"InputType",
"=",
"<STR_LIT>",
";",
"let",
"isCompare",
"=",
"<NUM_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";"
]
|
GCC | rs6000 | MD | next_suggestion | CPU | 6,989 | [
"(",
"match_operand",
":",
"SFDF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]"
]
| [
"(",
"ge",
"(",
"match_operand",
":",
"SFDF2",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"SFDF2",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"match_operand",
":",
"SFDF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 6,990 | [
"}"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rxx32",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Pe4",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Pe4",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
]
|
LLVM | ARM | TD | stmt_completion | CPU | 6,991 | [
";"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"addr",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"addr",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"addr",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"DecoderMethod",
"=",
"<STR_LIT>"
]
|
GCC | pdp10 | MD | stmt_completion | MPU | 6,992 | [
")",
")",
"]"
]
| [
"(",
"plus",
":",
"DI",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
]
|
GCC | i386 | MD | stmt_completion | CPU | 6,993 | [
"<STR_LIT>",
"<STR_LIT>",
")"
]
| [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr"
]
|
GCC | visium | MD | program_repair | Virtual ISA | 6,994 | [
"<FIXS>",
"<STR_LIT>",
"<FIXE>"
]
| [
"(",
"sign_extend",
":",
"DI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"<BUGS>",
"<STR_LIT>",
"<BUGE>",
"[",
"(",
"parallel",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"CC",
"R_FLAGS",
")",
")",
"]",
")",
"(",
"parallel",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")"
]
|
GCC | gcn | MD | stmt_completion | GPU | 6,995 | [
")",
")"
]
| [
"(",
"use",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<STR_LIT>",
"{",
"emit_insn",
"(",
"gen_gcn_wavefront_barrier",
"("
]
|
LLVM | Hexagon | TD | next_suggestion | DSP | 6,996 | [
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";",
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax1",
"=",
"<NUM_LIT>",
";",
"let",
"cofRelax2",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"P1",
"]",
";",
"let",
"Defs",
"=",
"[",
"P1",
",",
"PC",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";"
]
|
LLVM | X86 | CPP | stmt_completion | CPU | 6,997 | [
"Don't know how to lower!",
"<STR_LIT>",
")",
";"
]
| [
"unsigned",
"SSECC",
"=",
"translateX86FSETCC",
"(",
"SetCCOpcode",
",",
"Op0",
",",
"Op1",
")",
";",
"unsigned",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"if",
"(",
"Subtarget",
"->",
"hasAVX512",
"(",
")",
"&&",
"VT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"i1",
")",
"{",
"assert",
"(",
"VT",
".",
"getVectorNumElements",
"(",
")",
"<=",
"<NUM_LIT>",
")",
";",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"}",
"if",
"(",
"SSECC",
"==",
"<NUM_LIT>",
")",
"{",
"unsigned",
"CC0",
",",
"CC1",
";",
"unsigned",
"CombineOpc",
";",
"if",
"(",
"SetCCOpcode",
"==",
"ISD",
"::",
"SETUEQ",
")",
"{",
"CC0",
"=",
"<NUM_LIT>",
";",
"CC1",
"=",
"<NUM_LIT>",
";",
"CombineOpc",
"=",
"ISD",
"::",
"OR",
";",
"}",
"else",
"{",
"assert",
"(",
"SetCCOpcode",
"==",
"ISD",
"::",
"SETONE",
")",
";",
"CC0",
"=",
"<NUM_LIT>",
";",
"CC1",
"=",
"<NUM_LIT>",
";",
"CombineOpc",
"=",
"ISD",
"::",
"AND",
";",
"}",
"SDValue",
"Cmp0",
"=",
"DAG",
".",
"getNode",
"(",
"Opc",
",",
"dl",
",",
"VT",
",",
"Op0",
",",
"Op1",
",",
"DAG",
".",
"getConstant",
"(",
"CC0",
",",
"dl",
",",
"MVT",
"::",
"i8",
")",
")",
";",
"SDValue",
"Cmp1",
"=",
"DAG",
".",
"getNode",
"(",
"Opc",
",",
"dl",
",",
"VT",
",",
"Op0",
",",
"Op1",
",",
"DAG",
".",
"getConstant",
"(",
"CC1",
",",
"dl",
",",
"MVT",
"::",
"i8",
")",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"CombineOpc",
",",
"dl",
",",
"VT",
",",
"Cmp0",
",",
"Cmp1",
")",
";",
"}",
"return",
"DAG",
".",
"getNode",
"(",
"Opc",
",",
"dl",
",",
"VT",
",",
"Op0",
",",
"Op1",
",",
"DAG",
".",
"getConstant",
"(",
"SSECC",
",",
"dl",
",",
"MVT",
"::",
"i8",
")",
")",
";",
"}",
"if",
"(",
"VT",
".",
"is256BitVector",
"(",
")",
"&&",
"!",
"Subtarget",
"->",
"hasInt256",
"(",
")",
")",
"return",
"Lower256IntVSETCC",
"(",
"Op",
",",
"DAG",
")",
";",
"EVT",
"OpVT",
"=",
"Op1",
".",
"getValueType",
"(",
")",
";",
"if",
"(",
"OpVT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"i1",
")",
"return",
"LowerBoolVSETCC_AVX512",
"(",
"Op",
",",
"DAG",
")",
";",
"bool",
"MaskResult",
"=",
"(",
"VT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"i1",
")",
";",
"if",
"(",
"Subtarget",
"->",
"hasAVX512",
"(",
")",
")",
"{",
"if",
"(",
"Op1",
".",
"getValueType",
"(",
")",
".",
"is512BitVector",
"(",
")",
"||",
"(",
"Subtarget",
"->",
"hasBWI",
"(",
")",
"&&",
"Subtarget",
"->",
"hasVLX",
"(",
")",
")",
"||",
"(",
"MaskResult",
"&&",
"OpVT",
".",
"getVectorElementType",
"(",
")",
".",
"getSizeInBits",
"(",
")",
">=",
"<NUM_LIT>",
")",
")",
"return",
"LowerIntVSETCC_AVX512",
"(",
"Op",
",",
"DAG",
",",
"Subtarget",
")",
";",
"if",
"(",
"MaskResult",
"&&",
"(",
"OpVT",
".",
"getVectorElementType",
"(",
")",
".",
"getSizeInBits",
"(",
")",
"<",
"<NUM_LIT>",
"&&",
"OpVT",
".",
"getVectorElementType",
"(",
")",
".",
"getSizeInBits",
"(",
")",
">=",
"<NUM_LIT>",
")",
")",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TRUNCATE",
",",
"dl",
",",
"VT",
",",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SETCC",
",",
"dl",
",",
"OpVT",
",",
"Op0",
",",
"Op1",
",",
"CC",
")",
")",
";",
"}",
"unsigned",
"Opc",
";",
"bool",
"Swap",
"=",
"false",
",",
"Invert",
"=",
"false",
",",
"FlipSigns",
"=",
"false",
",",
"MinMax",
"=",
"false",
";",
"bool",
"Subus",
"=",
"false",
";",
"switch",
"(",
"SetCCOpcode",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unexpected SETCC condition",
"<STR_LIT>",
")",
";",
"case",
"ISD",
"::",
"SETNE",
":",
"Invert",
"=",
"true",
";",
"case",
"ISD",
"::",
"SETEQ",
":",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"ISD",
"::",
"SETLT",
":",
"Swap",
"=",
"true",
";",
"case",
"ISD",
"::",
"SETGT",
":",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"ISD",
"::",
"SETGE",
":",
"Swap",
"=",
"true",
";",
"case",
"ISD",
"::",
"SETLE",
":",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"Invert",
"=",
"true",
";",
"break",
";",
"case",
"ISD",
"::",
"SETULT",
":",
"Swap",
"=",
"true",
";",
"case",
"ISD",
"::",
"SETUGT",
":",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"FlipSigns",
"=",
"true",
";",
"break",
";",
"case",
"ISD",
"::",
"SETUGE",
":",
"Swap",
"=",
"true",
";",
"case",
"ISD",
"::",
"SETULE",
":",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"FlipSigns",
"=",
"true",
";",
"Invert",
"=",
"true",
";",
"break",
";",
"}",
"MVT",
"VET",
"=",
"VT",
".",
"getVectorElementType",
"(",
")",
";",
"bool",
"hasMinMax",
"=",
"(",
"Subtarget",
"->",
"hasSSE41",
"(",
")",
"&&",
"(",
"VET",
">=",
"MVT",
"::",
"i8",
"&&",
"VET",
"<=",
"MVT",
"::",
"i32",
")",
")",
"||",
"(",
"Subtarget",
"->",
"hasSSE2",
"(",
")",
"&&",
"(",
"VET",
"==",
"MVT",
"::",
"i8",
")",
")",
";",
"if",
"(",
"hasMinMax",
")",
"{",
"switch",
"(",
"SetCCOpcode",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"SETULE",
":",
"Opc",
"=",
"ISD",
"::",
"UMIN",
";",
"MinMax",
"=",
"true",
";",
"break",
";",
"case",
"ISD",
"::",
"SETUGE",
":",
"Opc",
"=",
"ISD",
"::",
"UMAX",
";",
"MinMax",
"=",
"true",
";",
"break",
";",
"}",
"if",
"(",
"MinMax",
")",
"{",
"Swap",
"=",
"false",
";",
"Invert",
"=",
"false",
";",
"FlipSigns",
"=",
"false",
";",
"}",
"}",
"bool",
"hasSubus",
"=",
"Subtarget",
"->",
"hasSSE2",
"(",
")",
"&&",
"(",
"VET",
"==",
"MVT",
"::",
"i8",
"||",
"VET",
"==",
"MVT",
"::",
"i16",
")",
";",
"if",
"(",
"!",
"MinMax",
"&&",
"hasSubus",
")",
"{",
"switch",
"(",
"SetCCOpcode",
")",
"{",
"default",
":",
"break",
";",
"case",
"ISD",
"::",
"SETULT",
":",
"{",
"if",
"(",
"Subtarget",
"->",
"hasAVX",
"(",
")",
")",
"break",
";",
"SDValue",
"ULEOp1",
"=",
"ChangeVSETULTtoVSETULE",
"(",
"dl",
",",
"Op1",
",",
"DAG",
")",
";",
"if",
"(",
"ULEOp1",
".",
"getNode",
"(",
")",
")",
"{",
"Op1",
"=",
"ULEOp1",
";",
"Subus",
"=",
"true",
";",
"Invert",
"=",
"false",
";",
"Swap",
"=",
"false",
";",
"}",
"break",
";",
"}",
"case",
"ISD",
"::",
"SETUGE",
":",
"Subus",
"=",
"true",
";",
"Invert",
"=",
"false",
";",
"Swap",
"=",
"true",
";",
"break",
";",
"case",
"ISD",
"::",
"SETULE",
":",
"Subus",
"=",
"true",
";",
"Invert",
"=",
"false",
";",
"Swap",
"=",
"false",
";",
"break",
";",
"}",
"if",
"(",
"Subus",
")",
"{",
"Opc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"FlipSigns",
"=",
"false",
";",
"}",
"}",
"if",
"(",
"Swap",
")",
"std",
"::",
"swap",
"(",
"Op0",
",",
"Op1",
")",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"v2i64",
")",
"{",
"if",
"(",
"Opc",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"!",
"Subtarget",
"->",
"hasSSE42",
"(",
")",
")",
"{",
"assert",
"(",
"Subtarget",
"->",
"hasSSE2",
"(",
")",
"&&",
"<STR_LIT>"
]
|
LLVM | ARM | TD | stmt_completion | CPU | 6,998 | [
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
]
| [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"val",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-"
]
|
LLVM | AAP | CPP | code_generation | MPU | 6,999 | [
"unsigned",
"AAPInstrInfo",
"::",
"isStoreToStackSlot",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"int",
"&",
"FrameIndex",
")",
"const",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"default",
":",
"return",
"<NUM_LIT>",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"break",
";",
"}",
"if",
"(",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isFI",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"isImm",
"(",
")",
"&&",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
"==",
"<NUM_LIT>",
")",
"{",
"FrameIndex",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getIndex",
"(",
")",
";",
"return",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"}",
"return",
"<NUM_LIT>",
";",
"}"
]
| [
"isStoreToStackSlot",
"-",
"If",
"the",
"specified",
"machine",
"instruction",
"is",
"a",
"direct",
"store",
"to",
"a",
"stack",
"slot",
",",
"return",
"the",
"virtual",
"or",
"physical",
"register",
"number",
"of",
"the",
"source",
"reg",
"along",
"with",
"the",
"FrameIndex",
"of",
"the",
"loaded",
"stack",
"slot",
"."
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.