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
|
TMS320C64X
|
CPP
|
stmt_completion
|
VLIW
| 10,800 |
[
";"
] |
[
"std",
"::",
"pair",
"<",
"int",
",",
"int",
">",
"opcnt",
"=",
"countOperandSides",
"(",
"MI",
",",
"MRI",
")",
";",
"if",
"(",
"opcnt",
".",
"second",
">",
"opcnt",
".",
"first",
")",
"{",
"return",
"ClusterPriority",
"(",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"}",
"else",
"{",
"return",
"ClusterPriority",
"(",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")"
] |
LLVM
|
AMDGPU
|
CPP
|
program_repair
|
GPU
| 10,801 |
[
"<FIXS>",
"AllocaTy",
"->",
"getNumElements",
"(",
")",
">",
"<NUM_LIT>",
"||",
"AllocaTy",
"->",
"getNumElements",
"(",
")",
"<NUM_LIT>",
")",
"{",
"<FIXE>"
] |
[
"if",
"(",
"!",
"AllocaTy",
"||",
"AllocaTy",
"->",
"getElementType",
"(",
")",
"->",
"isVectorTy",
"(",
")",
"||",
"<BUGS>",
"AllocaTy",
"->",
"getNumElements",
"(",
")",
">",
"<NUM_LIT>",
")",
"{",
"<BUGE>",
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
" Cannot convert type to vector\\n",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}"
] |
GCC
|
arm
|
CPP
|
stmt_completion
|
CPU
| 10,802 |
[
"_",
"b",
")",
"{"
] |
[
"_",
"_",
"qsub8",
"(",
"int8x4_t",
"_",
"_",
"a",
",",
"int8x4_t",
"_"
] |
GCC
|
arm
|
MD
|
next_suggestion
|
CPU
| 10,803 |
[
"(",
"clobber",
"(",
"reg",
":",
"CC",
"CC_REGNUM",
")",
")",
"]"
] |
[
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")"
] |
LLVM
|
Mips
|
CPP
|
next_suggestion
|
CPU
| 10,804 |
[
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"PtrVT",
",",
"ThreadPointer",
",",
"Offset",
")",
";"
] |
[
"lowerGlobalTLSAddress",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"GlobalAddressSDNode",
"*",
"GA",
"=",
"cast",
"<",
"GlobalAddressSDNode",
">",
"(",
"Op",
")",
";",
"SDLoc",
"DL",
"(",
"GA",
")",
";",
"const",
"GlobalValue",
"*",
"GV",
"=",
"GA",
"->",
"getGlobal",
"(",
")",
";",
"EVT",
"PtrVT",
"=",
"getPointerTy",
"(",
")",
";",
"TLSModel",
"::",
"Model",
"model",
"=",
"getTargetMachine",
"(",
")",
".",
"getTLSModel",
"(",
"GV",
")",
";",
"if",
"(",
"model",
"==",
"TLSModel",
"::",
"GeneralDynamic",
"||",
"model",
"==",
"TLSModel",
"::",
"LocalDynamic",
")",
"{",
"unsigned",
"Flag",
"=",
"(",
"model",
"==",
"TLSModel",
"::",
"LocalDynamic",
")",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"SDValue",
"TGA",
"=",
"DAG",
".",
"getTargetGlobalAddress",
"(",
"GV",
",",
"DL",
",",
"PtrVT",
",",
"<NUM_LIT>",
",",
"Flag",
")",
";",
"SDValue",
"Argument",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"PtrVT",
",",
"getGlobalReg",
"(",
"DAG",
",",
"PtrVT",
")",
",",
"TGA",
")",
";",
"unsigned",
"PtrSize",
"=",
"PtrVT",
".",
"getSizeInBits",
"(",
")",
";",
"IntegerType",
"*",
"PtrTy",
"=",
"Type",
"::",
"getIntNTy",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"PtrSize",
")",
";",
"SDValue",
"TlsGetAddr",
"=",
"DAG",
".",
"getExternalSymbol",
"(",
"<STR_LIT>",
"__tls_get_addr",
"<STR_LIT>",
",",
"PtrVT",
")",
";",
"ArgListTy",
"Args",
";",
"ArgListEntry",
"Entry",
";",
"Entry",
".",
"Node",
"=",
"Argument",
";",
"Entry",
".",
"Ty",
"=",
"PtrTy",
";",
"Args",
".",
"push_back",
"(",
"Entry",
")",
";",
"TargetLowering",
"::",
"CallLoweringInfo",
"CLI",
"(",
"DAG",
")",
";",
"CLI",
".",
"setDebugLoc",
"(",
"DL",
")",
".",
"setChain",
"(",
"DAG",
".",
"getEntryNode",
"(",
")",
")",
".",
"setCallee",
"(",
"CallingConv",
"::",
"C",
",",
"PtrTy",
",",
"TlsGetAddr",
",",
"std",
"::",
"move",
"(",
"Args",
")",
",",
"<NUM_LIT>",
")",
";",
"std",
"::",
"pair",
"<",
"SDValue",
",",
"SDValue",
">",
"CallResult",
"=",
"LowerCallTo",
"(",
"CLI",
")",
";",
"SDValue",
"Ret",
"=",
"CallResult",
".",
"first",
";",
"if",
"(",
"model",
"!=",
"TLSModel",
"::",
"LocalDynamic",
")",
"return",
"Ret",
";",
"SDValue",
"TGAHi",
"=",
"DAG",
".",
"getTargetGlobalAddress",
"(",
"GV",
",",
"DL",
",",
"PtrVT",
",",
"<NUM_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"SDValue",
"Hi",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"PtrVT",
",",
"TGAHi",
")",
";",
"SDValue",
"TGALo",
"=",
"DAG",
".",
"getTargetGlobalAddress",
"(",
"GV",
",",
"DL",
",",
"PtrVT",
",",
"<NUM_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"SDValue",
"Lo",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"PtrVT",
",",
"TGALo",
")",
";",
"SDValue",
"Add",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"PtrVT",
",",
"Hi",
",",
"Ret",
")",
";",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"PtrVT",
",",
"Add",
",",
"Lo",
")",
";",
"}",
"SDValue",
"Offset",
";",
"if",
"(",
"model",
"==",
"TLSModel",
"::",
"InitialExec",
")",
"{",
"SDValue",
"TGA",
"=",
"DAG",
".",
"getTargetGlobalAddress",
"(",
"GV",
",",
"DL",
",",
"PtrVT",
",",
"<NUM_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"TGA",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"PtrVT",
",",
"getGlobalReg",
"(",
"DAG",
",",
"PtrVT",
")",
",",
"TGA",
")",
";",
"Offset",
"=",
"DAG",
".",
"getLoad",
"(",
"PtrVT",
",",
"DL",
",",
"DAG",
".",
"getEntryNode",
"(",
")",
",",
"TGA",
",",
"MachinePointerInfo",
"(",
")",
",",
"false",
",",
"false",
",",
"false",
",",
"<NUM_LIT>",
")",
";",
"}",
"else",
"{",
"assert",
"(",
"model",
"==",
"TLSModel",
"::",
"LocalExec",
")",
";",
"SDValue",
"TGAHi",
"=",
"DAG",
".",
"getTargetGlobalAddress",
"(",
"GV",
",",
"DL",
",",
"PtrVT",
",",
"<NUM_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"SDValue",
"TGALo",
"=",
"DAG",
".",
"getTargetGlobalAddress",
"(",
"GV",
",",
"DL",
",",
"PtrVT",
",",
"<NUM_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"SDValue",
"Hi",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"PtrVT",
",",
"TGAHi",
")",
";",
"SDValue",
"Lo",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"PtrVT",
",",
"TGALo",
")",
";",
"Offset",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"PtrVT",
",",
"Hi",
",",
"Lo",
")",
";",
"}",
"SDValue",
"ThreadPointer",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"PtrVT",
")",
";"
] |
GCC
|
s390
|
MD
|
stmt_completion
|
MPU
| 10,805 |
[
"<STR_LIT>",
"<STR_LIT>",
")"
] |
[
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr"
] |
LLVM
|
ARM
|
CPP
|
program_repair
|
CPU
| 10,806 |
[
"<FIXS>",
"!",
"isZeroVector",
"(",
"PassThru",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
")",
"<FIXE>"
] |
[
"SDValue",
"Combo",
"=",
"NewLoad",
";",
"if",
"(",
"!",
"PassThru",
".",
"isUndef",
"(",
")",
"&&",
"(",
"PassThru",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"BITCAST",
"||",
"<BUGS>",
"!",
"IsZero",
"(",
"PassThru",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
")",
"<BUGE>",
"Combo",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"VSELECT",
",",
"dl",
",",
"VT",
",",
"Mask",
",",
"NewLoad",
",",
"PassThru",
")",
";",
"return",
"DAG",
".",
"getMergeValues",
"(",
"{",
"Combo",
",",
"NewLoad",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
"}",
",",
"dl",
")",
";",
"}"
] |
LLVM
|
AArch64
|
CPP
|
next_suggestion
|
CPU
| 10,807 |
[
"}"
] |
[
"void",
"AArch64TargetWinCOFFStreamer",
"::",
"emitARM64WinCFINop",
"(",
")",
"{",
"emitARM64WinUnwindCode",
"(",
"Win64EH",
"::",
"UOP_Nop",
",",
"-",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";"
] |
GCC
|
arm
|
CPP
|
program_repair
|
CPU
| 10,808 |
[
"<FIXS>",
"if",
"(",
"can_ldrd",
")",
"<FIXE>"
] |
[
"case",
"PRE_DEC",
":",
"if",
"(",
"emit",
")",
"{",
"<BUGS>",
"if",
"(",
"TARGET_LDRD",
")",
"<BUGE>",
"output_asm_insn",
"(",
"<STR_LIT>",
"ldrd%?\\t%0, [%m1, #-8]!",
"<STR_LIT>",
",",
"operands",
")",
";",
"elseoutput_asm_insn",
"(",
"<STR_LIT>",
"ldmdb%?\\t%m1!, %M0",
"<STR_LIT>",
",",
"operands",
")",
";"
] |
LLVM
|
SPIRV
|
CPP
|
next_suggestion
|
Virtual ISA
| 10,809 |
[
"}"
] |
[
"if",
"(",
"NegateOpcode",
"!=",
"<NUM_LIT>",
")",
"{",
"Register",
"TmpReg",
"=",
"MRI",
"->",
"createVirtualRegister",
"(",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"Result",
"|=",
"selectUnOpWithSrc",
"(",
"TmpReg",
",",
"ResType",
",",
"I",
",",
"ValueReg",
",",
"NegateOpcode",
")",
";",
"ValueReg",
"=",
"TmpReg",
";",
"}",
"Result",
"|=",
"BuildMI",
"(",
"*",
"I",
".",
"getParent",
"(",
")",
",",
"I",
",",
"I",
".",
"getDebugLoc",
"(",
")",
",",
"TII",
".",
"get",
"(",
"NewOpcode",
")",
")",
".",
"addDef",
"(",
"ResVReg",
")",
".",
"addUse",
"(",
"GR",
".",
"getSPIRVTypeID",
"(",
"ResType",
")",
")",
".",
"addUse",
"(",
"Ptr",
")",
".",
"addUse",
"(",
"ScopeReg",
")",
".",
"addUse",
"(",
"MemSemReg",
")",
".",
"addUse",
"(",
"ValueReg",
")",
".",
"constrainAllUses",
"(",
"TII",
",",
"TRI",
",",
"RBI",
")",
";",
"return",
"Result",
";"
] |
LLVM
|
Hexagon
|
TD
|
next_suggestion
|
DSP
| 10,810 |
[
"let",
"isCompare",
"=",
"<NUM_LIT>",
";"
] |
[
"def",
"A4_cmpbgti",
":",
"HInst",
"<",
"(",
"outs",
"PredRegs",
":",
"$",
"Pd4",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rs32",
",",
"s8_0Imm",
":",
"$",
"Ii",
")",
",",
"<STR_LIT>",
",",
"tc_643b4717",
",",
"TypeALU64",
">",
",",
"Enc_08d755",
",",
"ImmRegRel",
"{",
"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",
"CextOpcode",
"=",
"<STR_LIT>",
";",
"let",
"InputType",
"=",
"<STR_LIT>",
";"
] |
LLVM
|
CJG
|
CPP
|
stmt_completion
|
CPU
| 10,811 |
[
"PIC_",
":",
"Reloc",
"::",
"Static",
";"
] |
[
"if",
"(",
"!",
"RM",
".",
"hasValue",
"(",
")",
")",
"return",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
"?",
"Reloc",
"::"
] |
GCC
|
i386
|
MD
|
next_suggestion
|
CPU
| 10,812 |
[
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
] |
[
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
LLVM
|
AArch64
|
TD
|
next_suggestion
|
CPU
| 10,813 |
[
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Zm",
";"
] |
[
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"sz",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opc",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Pg",
";"
] |
LLVM
|
X86
|
CPP
|
next_suggestion
|
CPU
| 10,814 |
[
"llvm_unreachable",
"(",
"<STR_LIT>",
"impossible",
"<STR_LIT>",
")",
";"
] |
[
"static",
"bool",
"isFuncletReturnInstr",
"(",
"MachineInstr",
"&",
"MI",
")",
"{",
"switch",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
"{",
"case",
"X86",
"::",
"CATCHRET",
":",
"case",
"X86",
"::",
"CLEANUPRET",
":",
"return",
"true",
";",
"default",
":",
"return",
"false",
";",
"}"
] |
LLVM
|
AArch64
|
TD
|
next_suggestion
|
CPU
| 10,815 |
[
"}"
] |
[
"class",
"BranchReg",
"<",
"bits",
"<",
"<NUM_LIT>",
">",
"opc",
",",
"string",
"asm",
",",
"list",
"<",
"dag",
">",
"pattern",
">",
":",
"BaseBranchReg",
"<",
"opc",
",",
"(",
"outs",
")",
",",
"(",
"ins",
"GPR64",
":",
"$",
"Rn",
")",
",",
"asm",
",",
"<STR_LIT>",
",",
"pattern",
">",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"Rn",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rn",
";"
] |
LLVM
|
Hexagon
|
TD
|
next_suggestion
|
DSP
| 10,816 |
[
"let",
"opExtentAlign",
"=",
"<NUM_LIT>",
";"
] |
[
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isPredicable",
"=",
"<NUM_LIT>",
";",
"let",
"hasSideEffects",
"=",
"<NUM_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";"
] |
LLVM
|
AMDGPU
|
CPP
|
stmt_completion
|
GPU
| 10,817 |
[
")",
".",
"getImm",
"(",
")",
")",
"==",
"<NUM_LIT>",
")",
"return",
"true",
";"
] |
[
"if",
"(",
"SIInstrInfo",
"::",
"isVALU",
"(",
"MI",
")",
")",
"{",
"if",
"(",
"TII",
"->",
"getNamedOperand",
"(",
"MI",
",",
"AMDGPU",
"::",
"OpName",
"::",
"sdst",
")",
")",
"return",
"true",
";",
"for",
"(",
"auto",
"MO",
":",
"MI",
".",
"implicit_operands",
"(",
")",
")",
"if",
"(",
"MO",
".",
"isDef",
"(",
")",
"&&",
"TRI",
"->",
"isSGPRClass",
"(",
"TRI",
"->",
"getPhysRegBaseClass",
"(",
"MO",
".",
"getReg",
"(",
")",
")",
")",
")",
"return",
"true",
";",
"}",
"if",
"(",
"MI",
".",
"getOpcode",
"(",
")",
"==",
"AMDGPU",
"::",
"S_WAITCNT_DEPCTR",
"&&",
"AMDGPU",
"::",
"DepCtr",
"::",
"decodeFieldSaSdst",
"(",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>"
] |
LLVM
|
AArch64
|
TD
|
stmt_completion
|
CPU
| 10,818 |
[
"<STR_LIT>",
";"
] |
[
"def",
"sme_elm_idx0_7",
":",
"Operand",
"<",
"i64",
">",
",",
"ImmLeaf",
"<",
"i64",
",",
"[",
"{",
"return",
"(",
"(",
"uint64_t",
")",
"Imm",
")",
"<",
"=",
"<NUM_LIT>",
";",
"}",
"]",
">",
"{",
"let",
"ParserMatchClass",
"=",
"Imm0_7Operand",
";",
"let",
"PrintMethod",
"="
] |
GCC
|
ia64
|
CPP
|
program_repair
|
CPU
| 10,819 |
[
"<FIXS>",
"int",
"needed",
"=",
"group_barrier_needed_p",
"(",
"insn",
")",
";",
"gcc_assert",
"(",
"!",
"needed",
")",
";",
"<FIXE>"
] |
[
"memcpy",
"(",
"prev_cycle_state",
",",
"curr_state",
",",
"dfa_state_size",
")",
";",
"if",
"(",
"reload_completed",
")",
"{",
"<BUGS>",
"if",
"(",
"group_barrier_needed_p",
"(",
"insn",
")",
")",
"abort",
"(",
")",
";",
"<BUGE>",
"if",
"(",
"GET_CODE",
"(",
"insn",
")",
"==",
"CALL_INSN",
")",
"init_insn_group_barriers",
"(",
")",
";",
"stops_p",
"[",
"INSN_UID",
"(",
"insn",
")",
"]",
"=",
"stop_before_p",
";"
] |
LLVM
|
M68k
|
CPP
|
stmt_completion
|
MPU
| 10,820 |
[
")",
";"
] |
[
"if",
"(",
"Cond",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SETCC",
")",
"{",
"if",
"(",
"cast",
"<",
"CondCodeSDNode",
">",
"(",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
"->",
"get",
"(",
")",
"==",
"ISD",
"::",
"SETEQ",
"&&",
"isNullConstant",
"(",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
"&&",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getResNo",
"(",
")",
"==",
"<NUM_LIT>",
"&&",
"(",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SADDO",
"||",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"UADDO",
"||",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"SSUBO",
"||",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"USUBO",
")",
")",
"{",
"Inverted",
"=",
"true",
";",
"Cond",
"=",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"}",
"else",
"{",
"if",
"(",
"SDValue",
"NewCond",
"=",
"LowerSETCC",
"(",
"Cond",
",",
"DAG",
")",
")",
"Cond",
"=",
"NewCond",
";",
"}",
"}",
"if",
"(",
"Cond",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"AND",
"&&",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOpcode",
"(",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"isOneConstant",
"(",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"Cond",
"=",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"unsigned",
"CondOpcode",
"=",
"Cond",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"CondOpcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"||",
"CondOpcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"CC",
"=",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"Cmp",
"=",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"unsigned",
"Opc",
"=",
"Cmp",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"isM68kLogicalCmp",
"(",
"Cmp",
")",
"||",
"Opc",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"Cond",
"=",
"Cmp",
";",
"AddTest",
"=",
"false",
";",
"}",
"else",
"{",
"switch",
"(",
"CC",
"->",
"getAsZExtVal",
"(",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"M68k",
"::",
"COND_VS",
":",
"case",
"M68k",
"::",
"COND_CS",
":",
"Cond",
"=",
"Cond",
".",
"getNode",
"(",
")",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"AddTest",
"=",
"false",
";",
"break",
";",
"}",
"}",
"}",
"CondOpcode",
"=",
"Cond",
".",
"getOpcode",
"(",
")",
";",
"if",
"(",
"isOverflowArithmetic",
"(",
"CondOpcode",
")",
")",
"{",
"SDValue",
"Result",
";",
"unsigned",
"CCode",
";",
"lowerOverflowArithmetic",
"(",
"Cond",
",",
"DAG",
",",
"Result",
",",
"Cond",
",",
"CCode",
")",
";",
"if",
"(",
"Inverted",
")",
"CCode",
"=",
"M68k",
"::",
"GetOppositeBranchCondition",
"(",
"(",
"M68k",
"::",
"CondCode",
")",
"CCode",
")",
";",
"CC",
"=",
"DAG",
".",
"getConstant",
"(",
"CCode",
",",
"DL",
",",
"MVT",
"::",
"i8",
")",
";",
"AddTest",
"=",
"false",
";",
"}",
"else",
"{",
"unsigned",
"CondOpc",
";",
"if",
"(",
"Cond",
".",
"hasOneUse",
"(",
")",
"&&",
"isAndOrOfSetCCs",
"(",
"Cond",
",",
"CondOpc",
")",
")",
"{",
"SDValue",
"Cmp",
"=",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"CondOpc",
"==",
"ISD",
"::",
"OR",
")",
"{",
"if",
"(",
"Cmp",
"==",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
"&&",
"isM68kLogicalCmp",
"(",
"Cmp",
")",
")",
"{",
"CC",
"=",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"Chain",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Chain",
",",
"Dest",
",",
"CC",
",",
"Cmp",
")",
";",
"CC",
"=",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"Cond",
"=",
"Cmp",
";",
"AddTest",
"=",
"false",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"Cmp",
"==",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
"&&",
"isM68kLogicalCmp",
"(",
"Cmp",
")",
"&&",
"Op",
".",
"getNode",
"(",
")",
"->",
"hasOneUse",
"(",
")",
")",
"{",
"M68k",
"::",
"CondCode",
"CCode",
"=",
"(",
"M68k",
"::",
"CondCode",
")",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getConstantOperandVal",
"(",
"<NUM_LIT>",
")",
";",
"CCode",
"=",
"M68k",
"::",
"GetOppositeBranchCondition",
"(",
"CCode",
")",
";",
"CC",
"=",
"DAG",
".",
"getConstant",
"(",
"CCode",
",",
"DL",
",",
"MVT",
"::",
"i8",
")",
";",
"SDNode",
"*",
"User",
"=",
"*",
"Op",
".",
"getNode",
"(",
")",
"->",
"use_begin",
"(",
")",
";",
"if",
"(",
"User",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"BR",
")",
"{",
"SDValue",
"FalseBB",
"=",
"User",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"SDNode",
"*",
"NewBR",
"=",
"DAG",
".",
"UpdateNodeOperands",
"(",
"User",
",",
"User",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Dest",
")",
";",
"assert",
"(",
"NewBR",
"==",
"User",
")",
";",
"(",
"void",
")",
"NewBR",
";",
"Dest",
"=",
"FalseBB",
";",
"Chain",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"DL",
",",
"Op",
".",
"getValueType",
"(",
")",
",",
"Chain",
",",
"Dest",
",",
"CC",
",",
"Cmp",
")",
";",
"M68k",
"::",
"CondCode",
"CCode",
"=",
"(",
"M68k",
"::",
"CondCode",
")",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getConstantOperandVal",
"(",
"<NUM_LIT>",
")",
";",
"CCode",
"=",
"M68k",
"::",
"GetOppositeBranchCondition",
"(",
"CCode",
")",
";",
"CC",
"=",
"DAG",
".",
"getConstant",
"(",
"CCode",
",",
"DL",
",",
"MVT",
"::",
"i8",
")",
";",
"Cond",
"=",
"Cmp",
";",
"AddTest",
"=",
"false",
";",
"}",
"}",
"}",
"}",
"else",
"if",
"(",
"Cond",
".",
"hasOneUse",
"(",
")",
"&&",
"isXor1OfSetCC",
"(",
"Cond",
")",
")",
"{",
"M68k",
"::",
"CondCode",
"CCode",
"=",
"(",
"M68k",
"::",
"CondCode",
")",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getConstantOperandVal",
"(",
"<NUM_LIT>",
")",
";",
"CCode",
"=",
"M68k",
"::",
"GetOppositeBranchCondition",
"(",
"CCode",
")",
";",
"CC",
"=",
"DAG",
".",
"getConstant",
"(",
"CCode",
",",
"DL",
",",
"MVT",
"::",
"i8",
")",
";",
"Cond",
"=",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"AddTest",
"=",
"false",
";",
"}",
"}",
"if",
"(",
"AddTest",
")",
"{",
"if",
"(",
"isTruncWithZeroHighBitsInput",
"(",
"Cond",
",",
"DAG",
")",
")",
"Cond",
"=",
"Cond",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"Cond",
".",
"hasOneUse",
"(",
")",
")",
"{",
"if",
"(",
"SDValue",
"NewSetCC",
"=",
"LowerToBTST",
"(",
"Cond",
",",
"ISD",
"::",
"SETNE",
",",
"DL",
",",
"DAG",
")",
")",
"{",
"CC",
"=",
"NewSetCC",
".",
"getOperand",
"(",
"<NUM_LIT>"
] |
LLVM
|
PowerPC
|
CPP
|
code_generation
|
CPU
| 10,821 |
[
"bool",
"PPCAsmParser",
"::",
"MatchAndEmitInstruction",
"(",
"SMLoc",
"IDLoc",
",",
"unsigned",
"&",
"Opcode",
",",
"SmallVectorImpl",
"<",
"MCParsedAsmOperand",
"*",
">",
"&",
"Operands",
",",
"MCStreamer",
"&",
"Out",
",",
"unsigned",
"&",
"ErrorInfo",
",",
"bool",
"MatchingInlineAsm",
")",
"{",
"MCInst",
"Inst",
";",
"switch",
"(",
"MatchInstructionImpl",
"(",
"Operands",
",",
"Inst",
",",
"ErrorInfo",
",",
"MatchingInlineAsm",
")",
")",
"{",
"default",
":",
"break",
";",
"case",
"Match_Success",
":",
"ProcessInstruction",
"(",
"Inst",
",",
"Operands",
")",
";",
"Inst",
".",
"setLoc",
"(",
"IDLoc",
")",
";",
"Out",
".",
"EmitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"return",
"false",
";",
"case",
"Match_MissingFeature",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"<STR_LIT>",
"instruction use requires an option to be enabled",
"<STR_LIT>",
")",
";",
"case",
"Match_MnemonicFail",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"<STR_LIT>",
"unrecognized instruction mnemonic",
"<STR_LIT>",
")",
";",
"case",
"Match_InvalidOperand",
":",
"{",
"SMLoc",
"ErrorLoc",
"=",
"IDLoc",
";",
"if",
"(",
"ErrorInfo",
"!=",
"~",
"<NUM_LIT>",
"U",
")",
"{",
"if",
"(",
"ErrorInfo",
">=",
"Operands",
".",
"size",
"(",
")",
")",
"return",
"Error",
"(",
"IDLoc",
",",
"<STR_LIT>",
"too few operands for instruction",
"<STR_LIT>",
")",
";",
"ErrorLoc",
"=",
"(",
"(",
"PPCOperand",
"*",
")",
"Operands",
"[",
"ErrorInfo",
"]",
")",
"->",
"getStartLoc",
"(",
")",
";",
"if",
"(",
"ErrorLoc",
"==",
"SMLoc",
"(",
")",
")",
"ErrorLoc",
"=",
"IDLoc",
";",
"}",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"invalid operand for instruction",
"<STR_LIT>",
")",
";",
"}",
"}",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Implement any new match types added!",
"<STR_LIT>",
")",
";",
"}"
] |
[
"MatchAndEmitInstruction",
"-",
"Recognize",
"a",
"series",
"of",
"operands",
"of",
"a",
"parsed",
"instruction",
"as",
"an",
"actual",
"MCInst",
"and",
"emit",
"it",
"to",
"the",
"specified",
"MCStreamer",
"."
] |
LLVM
|
CSKY
|
CPP
|
next_suggestion
|
CPU
| 10,822 |
[
"}"
] |
[
"LLVM_EXTERNAL_VISIBILITY",
"void",
"LLVMInitializeCSKYAsmPrinter",
"(",
")",
"{",
"RegisterAsmPrinter",
"<",
"CSKYAsmPrinter",
">",
"X",
"(",
"getTheCSKYTarget",
"(",
")",
")",
";"
] |
LLVM
|
AArch64
|
TD
|
stmt_completion
|
CPU
| 10,823 |
[
"v8i16",
"V128",
":",
"$",
"Rd",
")",
",",
"(",
"IntOp",
"(",
"v8i8",
"V64",
":",
"$",
"Rn",
")",
",",
"(",
"v8i8",
"V64",
":",
"$",
"Rm",
")",
")",
")",
"]",
">",
";"
] |
[
"def",
"v8i8",
":",
"BaseSIMDDifferentThreeVector",
"<",
"U",
",",
"<NUM_LIT>",
",",
"opc",
",",
"V128",
",",
"V64",
",",
"V64",
",",
"asm",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"[",
"(",
"set",
"("
] |
LLVM
|
SystemZ
|
TD
|
next_suggestion
|
CPU
| 10,824 |
[
"}"
] |
[
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"V2",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"M3",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"M4",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"V2",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"op",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] |
GCC
|
powerpcspe
|
CPP
|
next_suggestion
|
CPU
| 10,825 |
[
"set_flags",
"&=",
"~",
"rs6000_opt_masks",
"[",
"j",
"]",
".",
"mask",
";"
] |
[
"for",
"(",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"ARRAY_SIZE",
"(",
"flags",
")",
";",
"i",
"++",
")",
"{",
"HOST_WIDE_INT",
"no_flag",
"=",
"flags",
"[",
"i",
"]",
".",
"no_flag",
";",
"if",
"(",
"(",
"rs6000_isa_flags",
"&",
"no_flag",
")",
"==",
"<NUM_LIT>",
"&&",
"(",
"rs6000_isa_flags_explicit",
"&",
"no_flag",
")",
"!=",
"<NUM_LIT>",
")",
"{",
"HOST_WIDE_INT",
"dep_flags",
"=",
"flags",
"[",
"i",
"]",
".",
"dep_flags",
";",
"HOST_WIDE_INT",
"set_flags",
"=",
"(",
"rs6000_isa_flags_explicit",
"&",
"rs6000_isa_flags",
"&",
"dep_flags",
")",
";",
"if",
"(",
"set_flags",
")",
"{",
"for",
"(",
"j",
"=",
"<NUM_LIT>",
";",
"j",
"<",
"ARRAY_SIZE",
"(",
"rs6000_opt_masks",
")",
";",
"j",
"++",
")",
"if",
"(",
"(",
"set_flags",
"&",
"rs6000_opt_masks",
"[",
"j",
"]",
".",
"mask",
")",
"!=",
"<NUM_LIT>",
")",
"{"
] |
LLVM
|
X86
|
CPP
|
next_suggestion
|
CPU
| 10,826 |
[
"break",
";"
] |
[
"case",
"X86",
"::",
"LD_Fp80m",
":",
"case",
"X86",
"::",
"MMX_MOVD64rm",
":",
"case",
"X86",
"::",
"MMX_MOVQ64rm",
":",
"return",
"false",
";",
"}",
"EVT",
"VT",
"=",
"Load1",
"->",
"getValueType",
"(",
"<NUM_LIT>",
")",
";",
"switch",
"(",
"VT",
".",
"getSimpleVT",
"(",
")",
".",
"SimpleTy",
")",
"{",
"default",
":",
"if",
"(",
"Subtarget",
".",
"is64Bit",
"(",
")",
")",
"{",
"if",
"(",
"NumLoads",
">=",
"<NUM_LIT>",
")",
"return",
"false",
";",
"}",
"else",
"if",
"(",
"NumLoads",
")",
"{",
"return",
"false",
";",
"}"
] |
LLVM
|
AArch64
|
TD
|
next_suggestion
|
CPU
| 10,827 |
[
"}"
] |
[
"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>",
"-",
"<NUM_LIT>",
"}",
"=",
"opc",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"extend",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"extend",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rn",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rt",
";"
] |
GCC
|
sparc
|
MD
|
next_suggestion
|
CPU
| 10,828 |
[
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
[
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"unspec",
":",
"SI",
"[",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
LLVM
|
X86
|
CPP
|
next_suggestion
|
CPU
| 10,829 |
[
"int",
"EgressCutCost",
"=",
"<NUM_LIT>",
",",
"IngressCutCost",
"=",
"<NUM_LIT>",
";"
] |
[
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Cutting edges...\\n",
"<STR_LIT>",
")",
";",
"EdgeSet",
"CutEdges",
"{",
"*",
"Graph",
"}",
";",
"DenseMap",
"<",
"const",
"Node",
"*",
",",
"SmallVector",
"<",
"const",
"Edge",
"*",
",",
"<NUM_LIT>",
">>",
"IngressEdgeMap",
";",
"for",
"(",
"const",
"Edge",
"&",
"E",
":",
"Graph",
"->",
"edges",
"(",
")",
")",
"if",
"(",
"MachineGadgetGraph",
"::",
"isCFGEdge",
"(",
"E",
")",
")",
"IngressEdgeMap",
"[",
"E",
".",
"getDest",
"(",
")",
"]",
".",
"push_back",
"(",
"&",
"E",
")",
";",
"for",
"(",
"const",
"Node",
"&",
"N",
":",
"Graph",
"->",
"nodes",
"(",
")",
")",
"{",
"for",
"(",
"const",
"Edge",
"&",
"E",
":",
"N",
".",
"edges",
"(",
")",
")",
"{",
"if",
"(",
"!",
"MachineGadgetGraph",
"::",
"isGadgetEdge",
"(",
"E",
")",
")",
"continue",
";",
"SmallVector",
"<",
"const",
"Edge",
"*",
",",
"<NUM_LIT>",
">",
"EgressEdges",
";",
"SmallVector",
"<",
"const",
"Edge",
"*",
",",
"<NUM_LIT>",
">",
"&",
"IngressEdges",
"=",
"IngressEdgeMap",
"[",
"E",
".",
"getDest",
"(",
")",
"]",
";",
"for",
"(",
"const",
"Edge",
"&",
"EgressEdge",
":",
"N",
".",
"edges",
"(",
")",
")",
"if",
"(",
"MachineGadgetGraph",
"::",
"isCFGEdge",
"(",
"EgressEdge",
")",
")",
"EgressEdges",
".",
"push_back",
"(",
"&",
"EgressEdge",
")",
";"
] |
LLVM
|
PowerPC
|
CPP
|
stmt_completion
|
CPU
| 10,830 |
[
")",
";"
] |
[
"static",
"bool",
"hasNonRISpills",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"PPCFunctionInfo",
"*",
"FuncInfo",
"=",
"MF",
".",
"getInfo",
"<",
"PPCFunctionInfo",
">",
"(",
")",
";",
"return",
"FuncInfo",
"->",
"hasNonRISpills",
"("
] |
LLVM
|
ARM
|
CPP
|
next_suggestion
|
CPU
| 10,831 |
[
"}"
] |
[
"unsigned",
"FirstLoc",
"=",
"~",
"<NUM_LIT>",
"U",
";",
"unsigned",
"LastLoc",
"=",
"<NUM_LIT>",
";",
"MachineInstr",
"*",
"FirstOp",
"=",
"<NUM_LIT>",
";",
"MachineInstr",
"*",
"LastOp",
"=",
"<NUM_LIT>",
";",
"int",
"LastOffset",
"=",
"<NUM_LIT>",
";",
"unsigned",
"LastOpcode",
"=",
"<NUM_LIT>",
";",
"unsigned",
"LastBytes",
"=",
"<NUM_LIT>",
";",
"unsigned",
"NumMove",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"int",
"i",
"=",
"Ops",
".",
"size",
"(",
")",
"-",
"<NUM_LIT>",
";",
"i",
">=",
"<NUM_LIT>",
";",
"--",
"i",
")",
"{",
"MachineInstr",
"*",
"Op",
"=",
"Ops",
"[",
"i",
"]",
";",
"unsigned",
"Loc",
"=",
"MI2LocMap",
"[",
"Op",
"]",
";",
"if",
"(",
"Loc",
"<=",
"FirstLoc",
")",
"{",
"FirstLoc",
"=",
"Loc",
";",
"FirstOp",
"=",
"Op",
";",
"}",
"if",
"(",
"Loc",
">=",
"LastLoc",
")",
"{",
"LastLoc",
"=",
"Loc",
";",
"LastOp",
"=",
"Op",
";",
"}",
"unsigned",
"Opcode",
"=",
"Op",
"->",
"getOpcode",
"(",
")",
";",
"if",
"(",
"LastOpcode",
"&&",
"Opcode",
"!=",
"LastOpcode",
")",
"break",
";",
"int",
"Offset",
"=",
"getMemoryOpOffset",
"(",
"Op",
")",
";",
"unsigned",
"Bytes",
"=",
"getLSMultipleTransferSize",
"(",
"Op",
")",
";",
"if",
"(",
"LastBytes",
")",
"{",
"if",
"(",
"Bytes",
"!=",
"LastBytes",
"||",
"Offset",
"!=",
"(",
"LastOffset",
"+",
"(",
"int",
")",
"Bytes",
")",
")",
"break",
";",
"}",
"LastOffset",
"=",
"Offset",
";",
"LastBytes",
"=",
"Bytes",
";",
"LastOpcode",
"=",
"Opcode",
";",
"if",
"(",
"++",
"NumMove",
"==",
"<NUM_LIT>",
")",
"break",
";",
"}",
"if",
"(",
"NumMove",
"<=",
"<NUM_LIT>",
")",
"Ops",
".",
"pop_back",
"(",
")",
";",
"else",
"{",
"SmallPtrSet",
"<",
"MachineInstr",
"*",
",",
"<NUM_LIT>",
">",
"MemOps",
";",
"SmallSet",
"<",
"unsigned",
",",
"<NUM_LIT>",
">",
"MemRegs",
";",
"for",
"(",
"int",
"i",
"=",
"NumMove",
"-",
"<NUM_LIT>",
";",
"i",
">=",
"<NUM_LIT>",
";",
"--",
"i",
")",
"{",
"MemOps",
".",
"insert",
"(",
"Ops",
"[",
"i",
"]",
")",
";",
"MemRegs",
".",
"insert",
"(",
"Ops",
"[",
"i",
"]",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
";",
"}",
"bool",
"DoMove",
"=",
"(",
"LastLoc",
"-",
"FirstLoc",
")",
"<=",
"NumMove",
"*",
"<NUM_LIT>",
";",
"if",
"(",
"DoMove",
")",
"DoMove",
"=",
"IsSafeAndProfitableToMove",
"(",
"isLd",
",",
"Base",
",",
"FirstOp",
",",
"LastOp",
",",
"MemOps",
",",
"MemRegs",
",",
"TRI",
")",
";",
"if",
"(",
"!",
"DoMove",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"!=",
"NumMove",
";",
"++",
"i",
")",
"Ops",
".",
"pop_back",
"(",
")",
";",
"}",
"else",
"{",
"MachineBasicBlock",
"::",
"iterator",
"InsertPos",
"=",
"isLd",
"?",
"FirstOp",
":",
"LastOp",
";",
"while",
"(",
"InsertPos",
"!=",
"MBB",
"->",
"end",
"(",
")",
"&&",
"MemOps",
".",
"count",
"(",
"InsertPos",
")",
")",
"++",
"InsertPos",
";",
"MachineInstr",
"*",
"Op0",
"=",
"Ops",
".",
"back",
"(",
")",
";",
"MachineInstr",
"*",
"Op1",
"=",
"Ops",
"[",
"Ops",
".",
"size",
"(",
")",
"-",
"<NUM_LIT>",
"]",
";",
"unsigned",
"EvenReg",
"=",
"<NUM_LIT>",
",",
"OddReg",
"=",
"<NUM_LIT>",
";",
"unsigned",
"BaseReg",
"=",
"<NUM_LIT>",
",",
"OffReg",
"=",
"<NUM_LIT>",
",",
"PredReg",
"=",
"<NUM_LIT>",
";",
"<STR_LIT>",
"::",
"<STR_LIT>",
"Pred",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"bool",
"isT2",
"=",
"false",
";",
"unsigned",
"NewOpc",
"=",
"<NUM_LIT>",
";",
"int",
"Offset",
"=",
"<NUM_LIT>",
";",
"DebugLoc",
"dl",
";",
"if",
"(",
"NumMove",
"==",
"<NUM_LIT>",
"&&",
"CanFormLdStDWord",
"(",
"Op0",
",",
"Op1",
",",
"dl",
",",
"NewOpc",
",",
"EvenReg",
",",
"OddReg",
",",
"BaseReg",
",",
"OffReg",
",",
"Offset",
",",
"PredReg",
",",
"Pred",
",",
"isT2",
")",
")",
"{",
"Ops",
".",
"pop_back",
"(",
")",
";",
"Ops",
".",
"pop_back",
"(",
")",
";",
"if",
"(",
"isLd",
")",
"{",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"*",
"MBB",
",",
"InsertPos",
",",
"dl",
",",
"TII",
"->",
"get",
"(",
"NewOpc",
")",
")",
".",
"addReg",
"(",
"EvenReg",
",",
"RegState",
"::",
"Define",
")",
".",
"addReg",
"(",
"OddReg",
",",
"RegState",
"::",
"Define",
")",
".",
"addReg",
"(",
"BaseReg",
")",
";",
"if",
"(",
"!",
"isT2",
")",
"MIB",
".",
"addReg",
"(",
"OffReg",
")",
";",
"MIB",
".",
"addImm",
"(",
"Offset",
")",
".",
"addImm",
"(",
"Pred",
")",
".",
"addReg",
"(",
"PredReg",
")",
";",
"++",
"NumLDRDFormed",
";",
"}",
"else",
"{",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"*",
"MBB",
",",
"InsertPos",
",",
"dl",
",",
"TII",
"->",
"get",
"(",
"NewOpc",
")",
")",
".",
"addReg",
"(",
"EvenReg",
")",
".",
"addReg",
"(",
"OddReg",
")",
".",
"addReg",
"(",
"BaseReg",
")",
";",
"if",
"(",
"!",
"isT2",
")",
"MIB",
".",
"addReg",
"(",
"OffReg",
")",
";",
"MIB",
".",
"addImm",
"(",
"Offset",
")",
".",
"addImm",
"(",
"Pred",
")",
".",
"addReg",
"(",
"PredReg",
")",
";",
"++",
"NumSTRDFormed",
";",
"}",
"MBB",
"->",
"erase",
"(",
"Op0",
")",
";",
"MBB",
"->",
"erase",
"(",
"Op1",
")",
";",
"MRI",
"->",
"setRegAllocationHint",
"(",
"EvenReg",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"OddReg",
")",
";",
"MRI",
"->",
"setRegAllocationHint",
"(",
"OddReg",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"EvenReg",
")",
";",
"}",
"else",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"!=",
"NumMove",
";",
"++",
"i",
")",
"{",
"MachineInstr",
"*",
"Op",
"=",
"Ops",
".",
"back",
"(",
")",
";",
"Ops",
".",
"pop_back",
"(",
")",
";",
"MBB",
"->",
"splice",
"(",
"InsertPos",
",",
"MBB",
",",
"Op",
")",
";",
"}"
] |
LLVM
|
WebAssembly
|
CPP
|
stmt_completion
|
Virtual ISA
| 10,832 |
[
";"
] |
[
"if",
"(",
"!",
"Stack",
".",
"empty",
"(",
")",
")",
"{",
"return",
"typeError",
"(",
"ErrorLoc",
",",
"std",
"::",
"to_string",
"(",
"Stack",
".",
"size",
"(",
")",
")",
"+",
"<STR_LIT>",
" superfluous return values",
"<STR_LIT>",
")",
";",
"}",
"Unreachable",
"=",
"true",
";",
"return",
"false"
] |
LLVM
|
CSKY
|
TD
|
stmt_completion
|
CPU
| 10,833 |
[
"num",
">",
";"
] |
[
"class",
"nimm",
"<",
"int",
"num",
">",
":",
"Operand",
"<",
"i32",
">",
",",
"ImmLeaf",
"<",
"i32",
",",
"<STR_LIT>",
"#",
"num",
"#",
"<STR_LIT>",
",",
"nimm_XFORM",
">",
"{",
"let",
"ParserMatchClass",
"=",
"UImmAsmOperand",
"<"
] |
LLVM
|
Hexagon
|
TD
|
next_suggestion
|
DSP
| 10,834 |
[
"}"
] |
[
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"addrMode",
"=",
"BaseImmOffset",
";",
"let",
"accessSize",
"=",
"HalfWordAccess",
";",
"let",
"mayLoad",
"=",
"<NUM_LIT>",
";",
"let",
"CextOpcode",
"=",
"<STR_LIT>",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isPredicable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentAlign",
"=",
"<NUM_LIT>",
";"
] |
LLVM
|
Hexagon
|
TD
|
next_suggestion
|
DSP
| 10,835 |
[
"let",
"Defs",
"=",
"[",
"USR_OVF",
"]",
";"
] |
[
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"hasNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"prefersSlot3",
"=",
"<NUM_LIT>",
";"
] |
GCC
|
arm
|
CPP
|
stmt_completion
|
CPU
| 10,836 |
[
"_",
"a",
",",
"_",
"_",
"b",
")",
";"
] |
[
"vqrshlq_s64",
"(",
"int64x2_t",
"_",
"_",
"a",
",",
"int64x2_t",
"_",
"_",
"b",
")",
"{",
"return",
"(",
"int64x2_t",
")",
"_",
"_",
"builtin_neon_vqrshlsv2di",
"(",
"_"
] |
LLVM
|
X86
|
CPP
|
next_suggestion
|
CPU
| 10,837 |
[
"DemandedElts",
".",
"setAllBits",
"(",
")",
";"
] |
[
"static",
"APInt",
"getExtractedDemandedElts",
"(",
"SDNode",
"*",
"N",
")",
"{",
"MVT",
"VT",
"=",
"N",
"->",
"getSimpleValueType",
"(",
"<NUM_LIT>",
")",
";",
"unsigned",
"NumElts",
"=",
"VT",
".",
"getVectorNumElements",
"(",
")",
";",
"APInt",
"DemandedElts",
"=",
"APInt",
"::",
"getZero",
"(",
"NumElts",
")",
";",
"for",
"(",
"SDNode",
"*",
"User",
":",
"N",
"->",
"uses",
"(",
")",
")",
"{",
"switch",
"(",
"User",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"case",
"ISD",
"::",
"EXTRACT_VECTOR_ELT",
":",
"if",
"(",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"User",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"{"
] |
GCC
|
aarch64
|
MD
|
stmt_completion
|
CPU
| 10,838 |
[
"UNSPEC_BDEP",
"UNSPEC_BEXT",
"UNSPEC_BGRP",
"]",
")"
] |
[
"(",
"define_int_iterator",
"SVE2_INT_BITPERM",
"["
] |
LLVM
|
AMDGPU
|
CPP
|
stmt_completion
|
GPU
| 10,839 |
[
")",
"&",
"<NUM_LIT>",
")",
";"
] |
[
"O",
"<<",
"formatDec",
"(",
"MI",
"->",
"getOperand",
"(",
"OpNo",
")",
".",
"getImm",
"("
] |
GCC
|
arm
|
CPP
|
next_suggestion
|
CPU
| 10,840 |
[
"}"
] |
[
"vreinterpretq_p8_bf16",
"(",
"bfloat16x8_t",
"_",
"_",
"a",
")",
"{",
"return",
"(",
"poly8x16_t",
")",
"_",
"_",
"a",
";"
] |
LLVM
|
ARM
|
CPP
|
code_generation
|
CPU
| 10,841 |
[
"bool",
"Thumb1InstrInfo",
"::",
"restoreCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MBB",
".",
"getParent",
"(",
")",
";",
"ARMFunctionInfo",
"*",
"AFI",
"=",
"MF",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"false",
";",
"bool",
"isVarArg",
"=",
"AFI",
"->",
"getVarArgsRegSaveSize",
"(",
")",
">",
"<NUM_LIT>",
";",
"DebugLoc",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MF",
",",
"DL",
",",
"get",
"(",
"ARM",
"::",
"tPOP",
")",
")",
";",
"AddDefaultPred",
"(",
"MIB",
")",
";",
"MIB",
".",
"addReg",
"(",
"<NUM_LIT>",
")",
";",
"bool",
"NumRegs",
"=",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"CSI",
".",
"size",
"(",
")",
";",
"i",
"!=",
"<NUM_LIT>",
";",
"--",
"i",
")",
"{",
"unsigned",
"Reg",
"=",
"CSI",
"[",
"i",
"-",
"<NUM_LIT>",
"]",
".",
"getReg",
"(",
")",
";",
"if",
"(",
"Reg",
"==",
"ARM",
"::",
"LR",
")",
"{",
"if",
"(",
"isVarArg",
")",
"continue",
";",
"Reg",
"=",
"ARM",
"::",
"PC",
";",
"(",
"*",
"MIB",
")",
".",
"setDesc",
"(",
"get",
"(",
"ARM",
"::",
"tPOP_RET",
")",
")",
";",
"MI",
"=",
"MBB",
".",
"erase",
"(",
"MI",
")",
";",
"}",
"MIB",
".",
"addReg",
"(",
"Reg",
",",
"getDefRegState",
"(",
"true",
")",
")",
";",
"NumRegs",
"=",
"true",
";",
"}",
"if",
"(",
"NumRegs",
")",
"MBB",
".",
"insert",
"(",
"MI",
",",
"&",
"*",
"MIB",
")",
";",
"return",
"true",
";",
"}"
] |
[
"restoreCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"restore",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"load",
"instructions",
"via",
"loadRegToStackSlot",
"(",
")",
"."
] |
LLVM
|
TPC
|
TD
|
next_suggestion
|
Virtual ISA
| 10,842 |
[
"}"
] |
[
"let",
"Pattern",
"=",
"pattern",
";",
"let",
"Itinerary",
"=",
"IIC_StoreScalLocal",
";",
"let",
"mayStore",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"addr",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"value",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"sw",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"pred",
";",
"let",
"SrcA",
"=",
"addr",
";",
"let",
"SrcB",
"=",
"sw",
";",
"let",
"SrcExtra",
"=",
"value",
";",
"let",
"PredAddress",
"=",
"pred",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"VectorPred",
"=",
"<NUM_LIT>",
";",
"let",
"PredPolarity",
"=",
"pred",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"OutOfSlotData",
"=",
"<NUM_LIT>",
";"
] |
LLVM
|
SPIRV
|
CPP
|
stmt_completion
|
Virtual ISA
| 10,843 |
[
",",
"Mul",
",",
"{",
"<NUM_LIT>",
"}",
")",
";"
] |
[
"IRBuilder",
"<",
">",
"IRB",
"(",
"EntryBB",
")",
";",
"Value",
"*",
"Mul",
"=",
"IRB",
".",
"CreateNUWMul",
"(",
"UMulFunc",
"->",
"getArg",
"(",
"<NUM_LIT>",
")",
",",
"UMulFunc",
"->",
"getArg",
"(",
"<NUM_LIT>",
")",
")",
";",
"Value",
"*",
"Div",
"=",
"IRB",
".",
"CreateUDiv",
"(",
"Mul",
",",
"UMulFunc",
"->",
"getArg",
"(",
"<NUM_LIT>",
")",
")",
";",
"Value",
"*",
"Overflow",
"=",
"IRB",
".",
"CreateICmpNE",
"(",
"UMulFunc",
"->",
"getArg",
"(",
"<NUM_LIT>",
")",
",",
"Div",
")",
";",
"Type",
"*",
"StructTy",
"=",
"UMulFunc",
"->",
"getReturnType",
"(",
")",
";",
"Value",
"*",
"Agg",
"=",
"IRB",
".",
"CreateInsertValue",
"(",
"PoisonValue",
"::",
"get",
"(",
"StructTy",
")"
] |
GCC
|
rs6000
|
CPP
|
program_repair
|
CPU
| 10,844 |
[
"<FIXS>",
"addressing",
".",
"If",
"we",
"allow",
"scalars",
"into",
"Altivec",
"registers",
",",
"<FIXE>"
] |
[
"addr_mask",
"|=",
"RELOAD_REG_INDEXED",
";",
"if",
"(",
"TARGET_UPDATE"
] |
LLVM
|
Hexagon
|
TD
|
next_suggestion
|
DSP
| 10,845 |
[
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
[
"def",
"J2_callt",
":",
"HInst",
"<",
"(",
"outs",
")",
",",
"(",
"ins",
"PredRegs",
":",
"$",
"Pu4",
",",
"a30_2Imm",
":",
"$",
"Ii",
")",
",",
"<STR_LIT>",
",",
"tc_1d81e60e",
",",
"TypeJ",
">",
",",
"Enc_daea09",
",",
"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>",
";"
] |
LLVM
|
AMDGPU
|
CPP
|
stmt_completion
|
GPU
| 10,846 |
[
",",
"int",
"VTSplitIdx",
")",
"{"
] |
[
"if",
"(",
"Info",
"->",
"hasImplicitBufferPtr",
"(",
")",
")",
"{",
"Register",
"ImplicitBufferPtrReg",
"=",
"Info",
"->",
"addImplicitBufferPtr",
"(",
"*",
"TRI",
")",
";",
"MF",
".",
"addLiveIn",
"(",
"ImplicitBufferPtrReg",
",",
"&",
"AMDGPU",
"::",
"SGPR_64RegClass",
")",
";",
"CCInfo",
".",
"AllocateReg",
"(",
"ImplicitBufferPtrReg",
")",
";",
"}",
"SmallVector",
"<",
"ArgInfo",
",",
"<NUM_LIT>",
">",
"SplitArgs",
";",
"unsigned",
"Idx",
"=",
"<NUM_LIT>",
";",
"unsigned",
"PSInputNum",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"auto",
"&",
"Arg",
":",
"F",
".",
"args",
"(",
")",
")",
"{",
"if",
"(",
"DL",
".",
"getTypeStoreSize",
"(",
"Arg",
".",
"getType",
"(",
")",
")",
"==",
"<NUM_LIT>",
")",
"continue",
";",
"const",
"bool",
"InReg",
"=",
"Arg",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"InReg",
")",
";",
"if",
"(",
"!",
"IsShader",
"&&",
"InReg",
")",
"return",
"false",
";",
"if",
"(",
"Arg",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"SwiftSelf",
")",
"||",
"Arg",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"SwiftError",
")",
"||",
"Arg",
".",
"hasAttribute",
"(",
"Attribute",
"::",
"Nest",
")",
")",
"return",
"false",
";",
"if",
"(",
"CC",
"==",
"CallingConv",
"::",
"AMDGPU_PS",
"&&",
"!",
"InReg",
"&&",
"PSInputNum",
"<=",
"<NUM_LIT>",
")",
"{",
"const",
"bool",
"ArgUsed",
"=",
"!",
"Arg",
".",
"use_empty",
"(",
")",
";",
"bool",
"SkipArg",
"=",
"!",
"ArgUsed",
"&&",
"!",
"Info",
"->",
"isPSInputAllocated",
"(",
"PSInputNum",
")",
";",
"if",
"(",
"!",
"SkipArg",
")",
"{",
"Info",
"->",
"markPSInputAllocated",
"(",
"PSInputNum",
")",
";",
"if",
"(",
"ArgUsed",
")",
"Info",
"->",
"markPSInputEnabled",
"(",
"PSInputNum",
")",
";",
"}",
"++",
"PSInputNum",
";",
"if",
"(",
"SkipArg",
")",
"{",
"for",
"(",
"int",
"I",
"=",
"<NUM_LIT>",
",",
"E",
"=",
"VRegs",
"[",
"Idx",
"]",
".",
"size",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"MIRBuilder",
".",
"buildUndef",
"(",
"VRegs",
"[",
"Idx",
"]",
"[",
"I",
"]",
")",
";",
"++",
"Idx",
";",
"continue",
";",
"}",
"}",
"ArgInfo",
"OrigArg",
"(",
"VRegs",
"[",
"Idx",
"]",
",",
"Arg",
".",
"getType",
"(",
")",
")",
";",
"setArgFlags",
"(",
"OrigArg",
",",
"Idx",
"+",
"AttributeList",
"::",
"FirstArgIndex",
",",
"DL",
",",
"F",
")",
";",
"splitToValueTypes",
"(",
"OrigArg",
",",
"SplitArgs",
",",
"DL",
",",
"MRI",
",",
"CC",
",",
"[",
"&",
"]",
"(",
"ArrayRef",
"<",
"Register",
">",
"Regs",
",",
"LLT",
"LLTy",
",",
"LLT",
"PartLLT"
] |
LLVM
|
ARM64
|
TD
|
next_suggestion
|
CPU
| 10,847 |
[
"let",
"DecoderMethod",
"=",
"<STR_LIT>",
";"
] |
[
"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",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"offset",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"dst2",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"base",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"dst",
";"
] |
LLVM
|
X86
|
CPP
|
next_suggestion
|
CPU
| 10,848 |
[
"S",
"->",
"getAssembler",
"(",
")",
".",
"setRelaxAll",
"(",
"RelaxAll",
")",
";"
] |
[
"MCStreamer",
"*",
"llvm",
"::",
"createX86WinCOFFStreamer",
"(",
"MCContext",
"&",
"C",
",",
"MCAsmBackend",
"&",
"AB",
",",
"raw_pwrite_stream",
"&",
"OS",
",",
"MCCodeEmitter",
"*",
"CE",
",",
"bool",
"RelaxAll",
",",
"bool",
"IncrementalLinkerCompatible",
")",
"{",
"X86WinCOFFStreamer",
"*",
"S",
"=",
"new",
"X86WinCOFFStreamer",
"(",
"C",
",",
"AB",
",",
"CE",
",",
"OS",
")",
";"
] |
LLVM
|
AMDGPU
|
CPP
|
stmt_completion
|
GPU
| 10,849 |
[
"getScheduledUnits",
"(",
")",
";"
] |
[
"DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"First phase: Fast scheduling for Reg Liveness\\n",
"<STR_LIT>",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"DAGSize",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"SIScheduleBlock",
"*",
"Block",
"=",
"CurrentBlocks",
"[",
"i",
"]",
";",
"Block",
"->",
"fastSchedule",
"(",
")",
";",
"}",
"MachineBasicBlock",
"::",
"iterator",
"CurrentTopFastSched",
"=",
"DAG",
"->",
"getCurrentTop",
"(",
")",
";",
"std",
"::",
"vector",
"<",
"MachineBasicBlock",
"::",
"iterator",
">",
"PosOld",
";",
"std",
"::",
"vector",
"<",
"MachineBasicBlock",
"::",
"iterator",
">",
"PosNew",
";",
"PosOld",
".",
"reserve",
"(",
"DAG",
"->",
"SUnits",
".",
"size",
"(",
")",
")",
";",
"PosNew",
".",
"reserve",
"(",
"DAG",
"->",
"SUnits",
".",
"size",
"(",
")",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"DAGSize",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"int",
"BlockIndice",
"=",
"TopDownIndex2Block",
"[",
"i",
"]",
";",
"SIScheduleBlock",
"*",
"Block",
"=",
"CurrentBlocks",
"[",
"BlockIndice",
"]",
";",
"std",
"::",
"vector",
"<",
"SUnit",
"*",
">",
"SUs",
"=",
"Block",
"->",
"getScheduledUnits",
"(",
")",
";",
"for",
"(",
"SUnit",
"*",
"SU",
":",
"SUs",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"SU",
"->",
"getInstr",
"(",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"Pos",
"=",
"MI",
";",
"PosOld",
".",
"push_back",
"(",
"Pos",
")",
";",
"if",
"(",
"&",
"*",
"CurrentTopFastSched",
"==",
"MI",
")",
"{",
"PosNew",
".",
"push_back",
"(",
"Pos",
")",
";",
"CurrentTopFastSched",
"=",
"nextIfDebug",
"(",
"++",
"CurrentTopFastSched",
",",
"DAG",
"->",
"getCurrentBottom",
"(",
")",
")",
";",
"}",
"else",
"{",
"DAG",
"->",
"getBB",
"(",
")",
"->",
"splice",
"(",
"CurrentTopFastSched",
",",
"DAG",
"->",
"getBB",
"(",
")",
",",
"MI",
")",
";",
"DAG",
"->",
"getLIS",
"(",
")",
"->",
"handleMove",
"(",
"*",
"MI",
",",
"true",
")",
";",
"PosNew",
".",
"push_back",
"(",
"CurrentTopFastSched",
")",
";",
"}",
"}",
"}",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"DAGSize",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"SIScheduleBlock",
"*",
"Block",
"=",
"CurrentBlocks",
"[",
"i",
"]",
";",
"std",
"::",
"vector",
"<",
"SUnit",
"*",
">",
"SUs",
"=",
"Block",
"->"
] |
LLVM
|
ARM
|
CPP
|
stmt_completion
|
CPU
| 10,850 |
[
")",
")",
";"
] |
[
"ValueList",
"RHS",
";",
"if",
"(",
"IsNarrowSequence",
"<",
"<NUM_LIT>",
">",
"(",
"MulOp0",
",",
"LHS",
")",
"&&",
"IsNarrowSequence",
"<",
"<NUM_LIT>",
">",
"(",
"MulOp1",
",",
"RHS",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"OK, found narrow mul: ",
"<STR_LIT>",
";",
"Mul",
"->",
"dump",
"(",
")",
")",
";",
"Candidates",
".",
"push_back",
"(",
"make_unique",
"<",
"BinOpChain",
">",
"(",
"Mul",
",",
"LHS",
",",
"RHS"
] |
GCC
|
mips
|
MD
|
stmt_completion
|
CPU
| 10,851 |
[
")"
] |
[
"(",
"define_bypass",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
"<STR_LIT>"
] |
GCC
|
arm
|
CPP
|
stmt_completion
|
CPU
| 10,852 |
[
"FUNCTION_DECL",
"&&",
"target_pure_code",
")",
"flags",
"|=",
"SECTION_ARM_PURECODE",
";"
] |
[
"if",
"(",
"decl",
"&&",
"TREE_CODE",
"(",
"decl",
")",
"=="
] |
LLVM
|
WDC65816
|
CPP
|
stmt_completion
|
MPU
| 10,853 |
[
")",
"const",
"{"
] |
[
"bool",
"is64Bit",
"("
] |
LLVM
|
ARM
|
CPP
|
stmt_completion
|
CPU
| 10,854 |
[
"<STR_LIT>",
")",
";"
] |
[
"Binary",
"|=",
"(",
"IsThumb",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"II",
"->",
"getPredicate",
"(",
"&",
"MI",
")",
")",
"<<",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"unsigned",
"RegT",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"RegT",
"=",
"getARMRegisterNumbering",
"(",
"RegT",
")",
";",
"Binary",
"|=",
"(",
"RegT",
"<<",
"<STR_LIT>",
"::"
] |
GCC
|
visium
|
MD
|
stmt_completion
|
Virtual ISA
| 10,855 |
[
")",
")",
"]"
] |
[
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"plus",
":",
"SI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC
|
i386
|
MD
|
stmt_completion
|
CPU
| 10,856 |
[
"<STR_LIT>",
"<STR_LIT>",
")"
] |
[
"(",
"and",
"(",
"eq_attr"
] |
GCC
|
aarch64
|
CPP
|
stmt_completion
|
CPU
| 10,857 |
[
"i",
")",
";"
] |
[
"for",
"(",
"int",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"NUM_MACHINE_MODES",
";",
"++",
"i",
")",
"{",
"machine_mode",
"mode",
"=",
"(",
"machine_mode",
")",
"i",
";",
"unsigned",
"int",
"vec_flags",
"=",
"aarch64_classify_vector_mode",
"(",
"mode",
")",
";",
"if",
"(",
"vec_flags",
"&",
"VEC_ANY_SVE",
")",
"bitmap_set_bit",
"(",
"modes",
","
] |
LLVM
|
TPC
|
TD
|
stmt_completion
|
Virtual ISA
| 10,858 |
[
"$",
"pred",
")",
";"
] |
[
"class",
"SpuInstJmpR",
"<",
"bits",
"<",
"<NUM_LIT>",
">",
"opc",
",",
"string",
"asmstr",
",",
"list",
"<",
"dag",
">",
"pattern",
"=",
"[",
"]",
">",
":",
"ScalarInstBase",
"<",
"opc",
",",
"asmstr",
">",
"{",
"let",
"OutOperandList",
"=",
"(",
"outs",
")",
";",
"let",
"InOperandList",
"=",
"(",
"ins",
"SRF",
":",
"$",
"target",
",",
"SPred",
":"
] |
LLVM
|
Mips
|
CPP
|
stmt_completion
|
CPU
| 10,859 |
[
"(",
")",
";"
] |
[
"if",
"(",
"IDVal",
"==",
"<STR_LIT>",
".dword",
"<STR_LIT>",
")",
"{",
"parseDataDirective",
"(",
"<NUM_LIT>",
",",
"DirectiveID",
".",
"getLoc",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"<STR_LIT>",
".ent",
"<STR_LIT>",
")",
"{",
"StringRef",
"SymbolName",
";",
"if",
"(",
"Parser",
".",
"parseIdentifier",
"(",
"SymbolName",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected identifier after .ent",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"Comma",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"unexpected token, expected end of statement",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"Parser",
".",
"Lex",
"(",
")",
";",
"const",
"MCExpr",
"*",
"DummyNumber",
";",
"int64_t",
"DummyNumberVal",
";",
"if",
"(",
"Parser",
".",
"parseExpression",
"(",
"DummyNumber",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected number after comma",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"DummyNumber",
"->",
"evaluateAsAbsolute",
"(",
"DummyNumberVal",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected an absolute expression after comma",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"unexpected token, expected end of statement",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"MCSymbol",
"*",
"Sym",
"=",
"getContext",
"(",
")",
".",
"getOrCreateSymbol",
"(",
"SymbolName",
")",
";",
"getTargetStreamer",
"(",
")",
".",
"emitDirectiveEnt",
"(",
"*",
"Sym",
")",
";",
"CurrentFn",
"=",
"Sym",
";",
"IsCpRestoreSet",
"=",
"false",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"<STR_LIT>",
".end",
"<STR_LIT>",
")",
"{",
"StringRef",
"SymbolName",
";",
"if",
"(",
"Parser",
".",
"parseIdentifier",
"(",
"SymbolName",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected identifier after .end",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"unexpected token, expected end of statement",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"CurrentFn",
"==",
"nullptr",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
".end used without .ent",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"(",
"SymbolName",
"!=",
"CurrentFn",
"->",
"getName",
"(",
")",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
".end symbol does not match .ent symbol",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"getTargetStreamer",
"(",
")",
".",
"emitDirectiveEnd",
"(",
"SymbolName",
")",
";",
"CurrentFn",
"=",
"nullptr",
";",
"IsCpRestoreSet",
"=",
"false",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"<STR_LIT>",
".frame",
"<STR_LIT>",
")",
"{",
"SmallVector",
"<",
"std",
"::",
"unique_ptr",
"<",
"MCParsedAsmOperand",
">",
",",
"<NUM_LIT>",
">",
"TmpReg",
";",
"OperandMatchResultTy",
"ResTy",
"=",
"parseAnyRegister",
"(",
"TmpReg",
")",
";",
"if",
"(",
"ResTy",
"==",
"MatchOperand_NoMatch",
"||",
"ResTy",
"==",
"MatchOperand_ParseFail",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected stack register",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"MipsOperand",
"&",
"StackRegOpnd",
"=",
"static_cast",
"<",
"MipsOperand",
"&",
">",
"(",
"*",
"TmpReg",
"[",
"<NUM_LIT>",
"]",
")",
";",
"if",
"(",
"!",
"StackRegOpnd",
".",
"isGPRAsmReg",
"(",
")",
")",
"{",
"reportParseError",
"(",
"StackRegOpnd",
".",
"getStartLoc",
"(",
")",
",",
"<STR_LIT>",
"expected general purpose register",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"unsigned",
"StackReg",
"=",
"StackRegOpnd",
".",
"getGPR32Reg",
"(",
")",
";",
"if",
"(",
"Parser",
".",
"getTok",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Comma",
")",
")",
"Parser",
".",
"Lex",
"(",
")",
";",
"else",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"unexpected token, expected comma",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"const",
"MCExpr",
"*",
"FrameSize",
";",
"int64_t",
"FrameSizeVal",
";",
"if",
"(",
"Parser",
".",
"parseExpression",
"(",
"FrameSize",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected frame size value",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"FrameSize",
"->",
"evaluateAsAbsolute",
"(",
"FrameSizeVal",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"frame size not an absolute expression",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"Parser",
".",
"getTok",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Comma",
")",
")",
"Parser",
".",
"Lex",
"(",
")",
";",
"else",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"unexpected token, expected comma",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"TmpReg",
".",
"clear"
] |
LLVM
|
Hexagon
|
TD
|
stmt_completion
|
DSP
| 10,860 |
[
"=",
"<NUM_LIT>",
";"
] |
[
"def",
"L4_isub_memoph_io",
":",
"HInst",
"<",
"(",
"outs",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rs32",
",",
"u31_1Imm",
":",
"$",
"Ii",
",",
"u5_0Imm",
":",
"$",
"II",
")",
",",
"<STR_LIT>",
",",
"tc_096199d3",
",",
"TypeV4LDST",
">",
",",
"Enc_e66a97",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}"
] |
LLVM
|
Hexagon
|
TD
|
next_suggestion
|
DSP
| 10,861 |
[
"}"
] |
[
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isCall",
"=",
"<NUM_LIT>",
";",
"let",
"prefersSlot3",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"=",
"[",
"R29",
"]",
";",
"let",
"Defs",
"=",
"[",
"PC",
",",
"R31",
"]",
";",
"let",
"hasSideEffects",
"=",
"<NUM_LIT>",
";",
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";"
] |
LLVM
|
ARM
|
TD
|
stmt_completion
|
CPU
| 10,862 |
[
"$",
"Vn",
",",
"DPR",
":",
"$",
"Vm",
")",
",",
"N3RegFrm",
",",
"itin",
",",
"OpcodeStr",
",",
"Dt",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"[",
"(",
"set",
"QPR",
":",
"$",
"Vd",
",",
"(",
"OpNode",
"(",
"TyQ",
"QPR",
":",
"$",
"src1",
")",
",",
"(",
"TyQ",
"(",
"MulOp",
"(",
"TyD",
"DPR",
":",
"$",
"Vn",
")",
",",
"(",
"TyD",
"DPR",
":",
"$",
"Vm",
")",
")",
")",
")",
")",
"]",
">",
";"
] |
[
"class",
"N3VLMulOp",
"<",
"bit",
"op24",
",",
"bit",
"op23",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"op21_20",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"op11_8",
",",
"bit",
"op4",
",",
"InstrItinClass",
"itin",
",",
"string",
"OpcodeStr",
",",
"string",
"Dt",
",",
"ValueType",
"TyQ",
",",
"ValueType",
"TyD",
",",
"SDNode",
"MulOp",
",",
"SDNode",
"OpNode",
">",
":",
"N3V",
"<",
"op24",
",",
"op23",
",",
"op21_20",
",",
"op11_8",
",",
"<NUM_LIT>",
",",
"op4",
",",
"(",
"outs",
"QPR",
":",
"$",
"Vd",
")",
",",
"(",
"ins",
"QPR",
":",
"$",
"src1",
",",
"DPR",
":"
] |
LLVM
|
R600
|
TD
|
next_suggestion
|
GPU
| 10,863 |
[
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"slc",
";"
] |
[
"bits",
"<",
"<NUM_LIT>",
">",
"idxen",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"glc",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"addr64",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"lds",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"vaddr",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"vdata",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"srsrc",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"slc",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"tfe",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"soffset",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"offset",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"offen",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"idxen",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"glc",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"addr64",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"lds",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"op",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"vaddr",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"vdata",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"srsrc",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] |
LLVM
|
Hexagon
|
TD
|
stmt_completion
|
DSP
| 10,864 |
[
"-",
"<NUM_LIT>",
"}",
";"
] |
[
"bits",
"<",
"<NUM_LIT>",
">",
"Ii",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Ii",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Pv4",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Pv4",
"{",
"<NUM_LIT>"
] |
LLVM
|
AMDGPU
|
CPP
|
stmt_completion
|
GPU
| 10,865 |
[
"STI",
")",
"const",
"{"
] |
[
"virtual",
"unsigned",
"getSOPPBrEncoding",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"unsigned",
"OpNo",
",",
"SmallVectorImpl",
"<",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&"
] |
LLVM
|
R600
|
CPP
|
stmt_completion
|
GPU
| 10,866 |
[
"f32",
",",
"Custom",
")",
";"
] |
[
"addRegisterClass",
"(",
"MVT",
"::",
"i64",
",",
"&",
"AMDGPU",
"::",
"SReg_64RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"v16i8",
",",
"&",
"AMDGPU",
"::",
"SReg_128RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"v32i8",
",",
"&",
"AMDGPU",
"::",
"SReg_256RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"v64i8",
",",
"&",
"AMDGPU",
"::",
"SReg_512RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"i32",
",",
"&",
"AMDGPU",
"::",
"VReg_32RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"f32",
",",
"&",
"AMDGPU",
"::",
"VReg_32RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"v1i32",
",",
"&",
"AMDGPU",
"::",
"VReg_32RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"v2i32",
",",
"&",
"AMDGPU",
"::",
"VReg_64RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"v2f32",
",",
"&",
"AMDGPU",
"::",
"VReg_64RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"v4i32",
",",
"&",
"AMDGPU",
"::",
"VReg_128RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"v4f32",
",",
"&",
"AMDGPU",
"::",
"VReg_128RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"v8i32",
",",
"&",
"AMDGPU",
"::",
"VReg_256RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"v8f32",
",",
"&",
"AMDGPU",
"::",
"VReg_256RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"v16i32",
",",
"&",
"AMDGPU",
"::",
"VReg_512RegClass",
")",
";",
"addRegisterClass",
"(",
"MVT",
"::",
"v16f32",
",",
"&",
"AMDGPU",
"::",
"VReg_512RegClass",
")",
";",
"computeRegisterProperties",
"(",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"VECTOR_SHUFFLE",
",",
"MVT",
"::",
"v8i32",
",",
"Expand",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"VECTOR_SHUFFLE",
",",
"MVT",
"::",
"v8f32",
",",
"Expand",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"VECTOR_SHUFFLE",
",",
"MVT",
"::",
"v16i32",
",",
"Expand",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"VECTOR_SHUFFLE",
",",
"MVT",
"::",
"v16f32",
",",
"Expand",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"i64",
",",
"Legal",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"i32",
",",
"Legal",
")",
";",
"setOperationAction",
"(",
"ISD",
"::",
"SELECT_CC",
",",
"MVT",
"::"
] |
LLVM
|
R600
|
CPP
|
program_repair
|
GPU
| 10,867 |
[
"<FIXS>",
"printRegOperand",
"(",
"Op",
".",
"getReg",
"(",
")",
",",
"O",
",",
"MRI",
")",
";",
"<FIXE>"
] |
[
"break",
";",
"default",
":",
"<BUGS>",
"printRegOperand",
"(",
"Op",
".",
"getReg",
"(",
")",
",",
"O",
")",
";",
"<BUGE>",
"break",
";",
"}",
"}",
"else",
"if",
"(",
"Op",
".",
"isImm",
"(",
")",
")",
"{"
] |
LLVM
|
X86
|
TD
|
stmt_completion
|
CPU
| 10,868 |
[
"src",
")",
",",
"<NUM_LIT>",
">",
";"
] |
[
"def",
":",
"InstAlias",
"<",
"<STR_LIT>",
",",
"(",
"MOVDQArr_REV",
"VR128",
":",
"$",
"dst",
",",
"VR128",
":",
"$"
] |
GCC
|
arm
|
CPP
|
stmt_completion
|
CPU
| 10,869 |
[
",",
"_",
"_",
"p",
")",
";"
] |
[
"_",
"_",
"arm_vstrwq_scatter_base_p_u32",
"(",
"uint32x4_t",
"_",
"_",
"addr",
",",
"const",
"int",
"_",
"_",
"offset",
",",
"uint32x4_t",
"_",
"_",
"value",
",",
"mve_pred16_t",
"_",
"_",
"p",
")",
"{",
"_",
"_",
"builtin_mve_vstrwq_scatter_base_p_uv4si",
"(",
"_",
"_",
"addr",
",",
"_",
"_",
"offset",
",",
"_",
"_",
"value"
] |
LLVM
|
SystemZ
|
CPP
|
next_suggestion
|
CPU
| 10,870 |
[
"MachineOperand",
"Target",
"(",
"Branch",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";"
] |
[
"MachineInstr",
"*",
"Branch",
"=",
"CCUsers",
"[",
"<NUM_LIT>",
"]",
";",
"if",
"(",
"Branch",
"->",
"getOpcode",
"(",
")",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"||",
"Branch",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"||",
"Branch",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"return",
"false",
";",
"unsigned",
"SrcReg",
"=",
"getCompareSourceReg",
"(",
"Compare",
")",
";",
"MachineBasicBlock",
"::",
"iterator",
"MBBI",
"=",
"Compare",
",",
"MBBE",
"=",
"Branch",
";",
"for",
"(",
"++",
"MBBI",
";",
"MBBI",
"!=",
"MBBE",
";",
"++",
"MBBI",
")",
"if",
"(",
"getRegReferences",
"(",
"*",
"MBBI",
",",
"SrcReg",
")",
")",
"return",
"false",
";"
] |
LLVM
|
Sparc
|
TD
|
stmt_completion
|
CPU
| 10,871 |
[
"<STR_LIT>",
",",
"[",
"(",
"set",
"FPRegs",
":",
"$",
"rd",
",",
"(",
"SPftoi",
"DFPRegs",
":",
"$",
"rs2",
")",
")",
"]",
",",
"IIC_fpu_fast_instr",
">",
";"
] |
[
"def",
"FDTOI",
":",
"F3_3u",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"(",
"outs",
"FPRegs",
":",
"$",
"rd",
")",
",",
"(",
"ins",
"DFPRegs",
":",
"$",
"rs2",
")",
","
] |
LLVM
|
X86
|
CPP
|
next_suggestion
|
CPU
| 10,872 |
[
"if",
"(",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"Imm",
")",
")",
"return",
"X86",
"::",
"MOV64ri32",
";"
] |
[
"static",
"unsigned",
"getMOVriOpcode",
"(",
"bool",
"Use64BitReg",
",",
"int64_t",
"Imm",
")",
"{",
"if",
"(",
"Use64BitReg",
")",
"{",
"if",
"(",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"Imm",
")",
")",
"return",
"X86",
"::",
"MOV32ri64",
";"
] |
GCC
|
visium
|
CPP
|
next_suggestion
|
Virtual ISA
| 10,873 |
[
"return",
"(",
"templ",
"&&",
"templ",
"[",
"<NUM_LIT>",
"]",
"==",
"'",
"\\0",
"'",
")",
";"
] |
[
"else",
"if",
"(",
"asm_noperands",
"(",
"body",
")",
">=",
"<NUM_LIT>",
")",
"templ",
"=",
"decode_asm_operands",
"(",
"body",
",",
"NULL",
",",
"NULL",
",",
"NULL",
",",
"NULL",
",",
"NULL",
")",
";",
"else",
"templ",
"=",
"NULL",
";"
] |
LLVM
|
Hexagon
|
TD
|
stmt_completion
|
DSP
| 10,874 |
[
"DoubleRegs",
",",
"<NUM_LIT>",
",",
"s11_2Ext",
">",
";"
] |
[
"def",
"L2_loadbsw4_io",
":",
"T_load_io",
"<",
"<STR_LIT>",
","
] |
LLVM
|
X86
|
CPP
|
program_repair
|
CPU
| 10,875 |
[
"<FIXS>",
"assert",
"(",
"RegVT",
".",
"isVector",
"(",
")",
"&&",
"<STR_LIT>",
"We only custom lower vector loads.",
"<STR_LIT>",
")",
";",
"<FIXE>",
"<FIXS>",
"<STR_LIT>",
"We only custom lower integer vector loads.",
"<STR_LIT>",
")",
";",
"<FIXE>",
"<FIXS>",
"if",
"(",
"RegVT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"i1",
")",
"{",
"<FIXE>"
] |
[
"static",
"SDValue",
"LowerLoad",
"(",
"SDValue",
"Op",
",",
"const",
"X86Subtarget",
"&",
"Subtarget",
",",
"SelectionDAG",
"&",
"DAG",
")",
"{",
"MVT",
"RegVT",
"=",
"Op",
".",
"getSimpleValueType",
"(",
")",
";",
"<BUGS>",
"assert",
"(",
"RegVT",
".",
"isVector",
"(",
")",
"&&",
"<STR_LIT>",
"We only custom lower vector sext loads.",
"<STR_LIT>",
")",
";",
"<BUGE>",
"assert",
"(",
"RegVT",
".",
"isInteger",
"(",
")",
"&&",
"<BUGS>",
"<STR_LIT>",
"We only custom lower integer vector sext loads.",
"<STR_LIT>",
")",
";",
"<BUGE>",
"LoadSDNode",
"*",
"Ld",
"=",
"cast",
"LoadSDNode",
">",
"(",
"Op",
".",
"getNode",
"(",
")",
")",
";",
"SDLoc",
"dl",
"(",
"Ld",
")",
";",
"EVT",
"MemVT",
"=",
"Ld",
"->",
"getMemoryVT",
"(",
")",
";",
"<BUGS>",
"if",
"(",
"RegVT",
".",
"isVector",
"(",
")",
"&&",
"RegVT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"i1",
")",
"{",
"<BUGE>",
"assert",
"(",
"EVT",
"(",
"RegVT",
")",
"==",
"MemVT",
"&&",
"<STR_LIT>",
"Expected non-extending load",
"<STR_LIT>",
")",
";",
"assert",
"(",
"RegVT",
".",
"getVectorNumElements",
"(",
")",
"<=",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Unexpected VT",
"<STR_LIT>",
")",
";",
"assert",
"(",
"Subtarget",
".",
"hasAVX512",
"(",
")",
"&&",
"!",
"Subtarget",
".",
"hasDQI",
"(",
")",
"&&"
] |
GCC
|
i386
|
CPP
|
next_suggestion
|
CPU
| 10,876 |
[
"}"
] |
[
"extern",
"_",
"_",
"inline",
"_",
"_",
"m128d",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_nmsub_pd",
"(",
"_",
"_",
"m128d",
"_",
"_",
"A",
",",
"_",
"_",
"m128d",
"_",
"_",
"B",
",",
"_",
"_",
"m128d",
"_",
"_",
"C",
")",
"{",
"return",
"(",
"_",
"_",
"m128d",
")",
"_",
"_",
"builtin_ia32_vfmaddpd",
"(",
"-",
"(",
"_",
"_",
"v2df",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v2df",
")",
"_",
"_",
"B",
",",
"-",
"(",
"_",
"_",
"v2df",
")",
"_",
"_",
"C",
")",
";"
] |
LLVM
|
AArch64
|
CPP
|
stmt_completion
|
CPU
| 10,877 |
[
"(",
"MBBI",
")",
")",
";"
] |
[
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unexpected callee-save save/restore opcode!",
"<STR_LIT>",
")",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"NewOpc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"NewOpc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"NewOpc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"NewIsUnscaled",
"=",
"true",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"NewOpc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"NewIsUnscaled",
"=",
"true",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"NewOpc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"NewOpc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"NewOpc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"NewIsUnscaled",
"=",
"true",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"NewOpc",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"NewIsUnscaled",
"=",
"true",
";",
"break",
";",
"}",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"NewOpc",
")",
")",
";",
"MIB",
".",
"addReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"RegState",
"::",
"Define",
")",
";",
"unsigned",
"OpndIdx",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"unsigned",
"OpndEnd",
"=",
"MBBI",
"->",
"getNumOperands",
"(",
")",
"-",
"<NUM_LIT>",
";",
"OpndIdx",
"<",
"OpndEnd",
";",
"++",
"OpndIdx",
")",
"MIB",
".",
"add",
"(",
"MBBI",
"->",
"getOperand",
"(",
"OpndIdx",
")",
")",
";",
"assert",
"(",
"MBBI",
"->",
"getOperand",
"(",
"OpndIdx",
")",
".",
"getImm",
"(",
")",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Unexpected immediate offset in first/last callee-save save/restore ",
"<STR_LIT>",
"<STR_LIT>",
"instruction!",
"<STR_LIT>",
")",
";",
"assert",
"(",
"MBBI",
"->",
"getOperand",
"(",
"OpndIdx",
"-",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"<STR_LIT>",
"Unexpected base register in callee-save save/restore instruction!",
"<STR_LIT>",
")",
";",
"assert",
"(",
"CSStackSizeInc",
"%",
"<NUM_LIT>",
"==",
"<NUM_LIT>",
")",
";",
"int64_t",
"CSStackSizeIncImm",
"=",
"CSStackSizeInc",
";",
"if",
"(",
"!",
"NewIsUnscaled",
")",
"CSStackSizeIncImm",
"/",
"=",
"<NUM_LIT>",
";",
"MIB",
".",
"addImm",
"(",
"CSStackSizeIncImm",
")",
";",
"MIB",
".",
"setMIFlags",
"(",
"MBBI",
"->",
"getFlags",
"(",
")",
")",
";",
"MIB",
".",
"setMemRefs",
"(",
"MBBI",
"->",
"memoperands_begin",
"(",
")",
",",
"MBBI",
"->",
"memoperands_end",
"(",
")",
")",
";",
"return",
"std",
"::",
"prev",
"(",
"MBB",
".",
"erase"
] |
LLVM
|
Hexagon
|
TD
|
stmt_completion
|
DSP
| 10,878 |
[
"[",
"USR",
"]",
";"
] |
[
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isFP",
"=",
"<NUM_LIT>",
";",
"let",
"Uses",
"="
] |
LLVM
|
Cpu0
|
CPP
|
next_suggestion
|
CPU
| 10,879 |
[
"CreateMCInst",
"(",
"St",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"GPReg",
",",
"BaseReg",
",",
"MCOperand",
"::",
"createImm",
"(",
"Offset",
")",
")",
";"
] |
[
"MCOperand",
"SPReg",
"=",
"MCOperand",
"::",
"createReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
",",
"BaseReg",
"=",
"SPReg",
";",
"MCOperand",
"GPReg",
"=",
"MCOperand",
"::",
"createReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"MCOperand",
"ZEROReg",
"=",
"MCOperand",
"::",
"createReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"if",
"(",
"!",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
")",
"{",
"unsigned",
"Hi",
"=",
"(",
"(",
"Offset",
"+",
"<NUM_LIT>",
")",
">>",
"<NUM_LIT>",
")",
"&",
"<NUM_LIT>",
";",
"Offset",
"&=",
"<NUM_LIT>",
";",
"MCOperand",
"ATReg",
"=",
"MCOperand",
"::",
"createReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"BaseReg",
"=",
"ATReg",
";",
"MCInsts",
".",
"resize",
"(",
"<NUM_LIT>",
")",
";",
"CreateMCInst",
"(",
"MCInsts",
"[",
"<NUM_LIT>",
"]",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"ATReg",
",",
"ZEROReg",
",",
"MCOperand",
"::",
"createImm",
"(",
"Hi",
")",
")",
";",
"CreateMCInst",
"(",
"MCInsts",
"[",
"<NUM_LIT>",
"]",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"ATReg",
",",
"ATReg",
",",
"SPReg",
")",
";",
"}",
"MCInst",
"St",
";"
] |
GCC
|
arm
|
CPP
|
program_repair
|
CPU
| 10,880 |
[
"<FIXS>",
"target_option_default_node",
"=",
"target_option_current_node",
"=",
"build_target_option_node",
"(",
"&",
"global_options",
")",
";",
"<FIXE>"
] |
[
"arm_option_check_internal",
"(",
"&",
"global_options",
")",
";",
"arm_option_params_internal",
"(",
")",
";",
"<BUGS>",
"cl_target_option_save",
"(",
"TREE_TARGET_OPTION",
"(",
"target_option_default_node",
")",
",",
"&",
"global_options",
")",
";",
"<BUGE>",
"arm_add_gc_roots",
"(",
")",
";"
] |
GCC
|
sh
|
MD
|
next_suggestion
|
CPU
| 10,881 |
[
"(",
"const_string",
"<STR_LIT>",
")",
")",
")"
] |
[
"<STR_LIT>",
"[",
"(",
"set",
"(",
"attr",
"<STR_LIT>",
")",
"(",
"cond",
"[",
"(",
"eq",
"(",
"symbol_ref",
"<STR_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"eq",
"(",
"symbol_ref",
"<STR_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"eq",
"(",
"symbol_ref",
"<STR_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"eq",
"(",
"symbol_ref",
"<STR_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"]"
] |
LLVM
|
CJG
|
CPP
|
code_generation
|
CPU
| 10,882 |
[
"bool",
"CJGInstrInfo",
"::",
"reverseBranchCondition",
"(",
"SmallVectorImpl",
"<",
"MachineOperand",
">",
"&",
"Cond",
")",
"const",
"{",
"assert",
"(",
"Cond",
".",
"size",
"(",
")",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Invalid Xbranch condition!",
"<STR_LIT>",
")",
";",
"<STR_LIT>",
"::",
"<STR_LIT>",
"CC",
"=",
"static_cast",
"<",
"<STR_LIT>",
"::",
"<STR_LIT>",
">",
"(",
"Cond",
"[",
"<NUM_LIT>",
"]",
".",
"getImm",
"(",
")",
")",
";",
"switch",
"(",
"CC",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Invalid branch condition!",
"<STR_LIT>",
")",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"CC",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"CC",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"CC",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"CC",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"CC",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"CC",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"CC",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"CC",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"CC",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"CC",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"break",
";",
"}",
"Cond",
"[",
"<NUM_LIT>",
"]",
".",
"setImm",
"(",
"CC",
")",
";",
"return",
"false",
";",
"}"
] |
[
"Reverses",
"the",
"branch",
"condition",
"of",
"the",
"specified",
"condition",
"list",
",",
"returning",
"false",
"on",
"success",
"and",
"true",
"if",
"it",
"can",
"not",
"be",
"reversed",
"."
] |
LLVM
|
X86
|
CPP
|
stmt_completion
|
CPU
| 10,883 |
[
"O",
")",
";"
] |
[
"void",
"printanymem",
"(",
"const",
"MCInst",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"raw_ostream",
"&",
"O",
")",
"{",
"printMemReference",
"(",
"MI",
",",
"OpNo",
","
] |
LLVM
|
ARM
|
TD
|
program_repair
|
CPU
| 10,884 |
[
"<FIXS>",
"InstrStage",
"<NUM_LIT>",
",",
"[",
"A9_AGU",
"]",
">",
",",
"<FIXE>"
] |
[
"InstrStage",
"<NUM_LIT>",
",",
"[",
"A9_DRegsVFP",
"]",
",",
"<NUM_LIT>",
",",
"Reserved",
">",
",",
"InstrStage",
"<NUM_LIT>",
",",
"[",
"A9_Pipe1",
"]",
",",
"<NUM_LIT>",
">",
",",
"<BUGS>",
"InstrStage",
"<NUM_LIT>",
",",
"[",
"A9_LSPipe",
"]",
">",
",",
"<BUGE>",
"InstrStage",
"<NUM_LIT>",
",",
"[",
"A9_NPipe",
"]",
">",
"]",
",",
"[",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"]",
">",
","
] |
LLVM
|
VE
|
TD
|
stmt_completion
|
CPU
| 10,885 |
[
",",
"v256f64",
":",
"$",
"pt",
")",
">",
";"
] |
[
"def",
":",
"Pat",
"<",
"(",
"int_ve_vl_vmaxswsx_vvvvl",
"v256f64",
":",
"$",
"vy",
",",
"v256f64",
":",
"$",
"vz",
",",
"v256f64",
":",
"$",
"pt",
",",
"i32",
":",
"$",
"vl",
")",
",",
"(",
"VMAXSWSXvvl_v",
"v256f64",
":",
"$",
"vy",
",",
"v256f64",
":",
"$",
"vz",
",",
"i32",
":",
"$",
"vl"
] |
LLVM
|
AArch64
|
TD
|
stmt_completion
|
CPU
| 10,886 |
[
"=",
"<NUM_LIT>",
";"
] |
[
"let",
"Uses",
"=",
"[",
"NZCV",
"]",
";",
"let",
"Defs",
"=",
"[",
"NZCV",
"]",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rn",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rm",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"nzcv",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"cond",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"op",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"cond",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rn",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}"
] |
GCC
|
mips
|
MD
|
stmt_completion
|
CPU
| 10,887 |
[
"<STR_LIT>",
")",
"]",
")"
] |
[
"(",
"define_code_attr",
"su",
"[",
"(",
"sign_extend",
"<STR_LIT>",
")",
"(",
"zero_extend"
] |
LLVM
|
Hexagon
|
TD
|
next_suggestion
|
DSP
| 10,888 |
[
"let",
"Uses",
"=",
"[",
"P0",
"]",
";"
] |
[
"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>",
";"
] |
GCC
|
gcn
|
CPP
|
next_suggestion
|
GPU
| 10,889 |
[
"TREE_THIS_VOLATILE",
"(",
"ref_out",
")",
"=",
"<NUM_LIT>",
";"
] |
[
"lock_bb",
"=",
"locked_edge",
"->",
"src",
";",
"*",
"gsi",
"=",
"gsi_for_stmt",
"(",
"gsi_stmt",
"(",
"*",
"gsi",
")",
")",
";",
"locked_edge",
"->",
"flags",
"^=",
"EDGE_TRUE_VALUE",
"|",
"EDGE_FALLTHRU",
";",
"locked_edge",
"->",
"probability",
"=",
"profile_probability",
"::",
"even",
"(",
")",
";",
"edge",
"loop_edge",
"=",
"make_edge",
"(",
"lock_bb",
",",
"lock_bb",
",",
"EDGE_FALSE_VALUE",
")",
";",
"loop_edge",
"->",
"probability",
"=",
"profile_probability",
"::",
"even",
"(",
")",
";",
"set_immediate_dominator",
"(",
"CDI_DOMINATORS",
",",
"lock_bb",
",",
"entry_bb",
")",
";",
"set_immediate_dominator",
"(",
"CDI_DOMINATORS",
",",
"update_bb",
",",
"lock_bb",
")",
";",
"loop",
"*",
"lock_loop",
"=",
"alloc_loop",
"(",
")",
";",
"lock_loop",
"->",
"header",
"=",
"lock_bb",
";",
"lock_loop",
"->",
"latch",
"=",
"lock_bb",
";",
"lock_loop",
"->",
"nb_iterations_estimate",
"=",
"<NUM_LIT>",
";",
"lock_loop",
"->",
"any_estimate",
"=",
"true",
";",
"add_loop",
"(",
"lock_loop",
",",
"entry_bb",
"->",
"loop_father",
")",
";",
"gimple_seq",
"red_seq",
"=",
"NULL",
";",
"tree",
"acc_in",
"=",
"make_ssa_name",
"(",
"var_type",
")",
";",
"tree",
"ref_in",
"=",
"build_simple_mem_ref",
"(",
"ptr",
")",
";",
"TREE_THIS_VOLATILE",
"(",
"ref_in",
")",
"=",
"<NUM_LIT>",
";",
"gimplify_assign",
"(",
"acc_in",
",",
"ref_in",
",",
"&",
"red_seq",
")",
";",
"tree",
"acc_out",
"=",
"make_ssa_name",
"(",
"var_type",
")",
";",
"tree",
"update_expr",
"=",
"fold_build2",
"(",
"op",
",",
"var_type",
",",
"ref_in",
",",
"var",
")",
";",
"gimplify_assign",
"(",
"acc_out",
",",
"update_expr",
",",
"&",
"red_seq",
")",
";",
"tree",
"ref_out",
"=",
"build_simple_mem_ref",
"(",
"ptr",
")",
";"
] |
GCC
|
h8300
|
MD
|
next_suggestion
|
MPU
| 10,890 |
[
"(",
"set",
"(",
"cc0",
")",
"(",
"compare",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")"
] |
[
"(",
"set",
"(",
"cc0",
")",
"(",
"compare",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"pc",
")",
"(",
"if_then_else",
"(",
"le",
"(",
"cc0",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"label_ref",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
"(",
"pc",
")",
")",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"parallel",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_op_dup",
"<NUM_LIT>",
"[",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
")",
")",
"(",
"clobber",
"(",
"scratch",
":",
"QI",
")",
")",
"]",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"plus",
":",
"QI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")"
] |
GCC
|
rs6000
|
MD
|
next_suggestion
|
CPU
| 10,891 |
[
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
] |
[
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
LLVM
|
Mips
|
CPP
|
stmt_completion
|
CPU
| 10,892 |
[
";"
] |
[
"void",
"MipsTargetELFStreamer",
"::",
"emitDirectiveOptionPic0",
"(",
")",
"{",
"MCAssembler",
"&",
"MCA",
"=",
"getStreamer",
"(",
")",
".",
"getAssembler",
"(",
")",
";",
"unsigned",
"Flags",
"=",
"MCA",
".",
"getELFHeaderEFlags",
"(",
")",
";",
"Pic",
"=",
"false"
] |
GCC
|
sparc
|
CPP
|
program_repair
|
CPU
| 10,893 |
[
"<FIXS>",
"else",
"<FIXE>"
] |
[
"sparc_mode_class",
"[",
"i",
"]",
"=",
"<NUM_LIT>",
"<<",
"(",
"int",
")",
"T_MODE",
";",
"else",
"if",
"(",
"GET_MODE_SIZE",
"(",
"i",
")",
"==",
"<NUM_LIT>",
")",
"sparc_mode_class",
"[",
"i",
"]",
"=",
"<NUM_LIT>",
"<<",
"(",
"int",
")",
"O_MODE",
";",
"<BUGS>",
"else",
"<BUGE>",
"sparc_mode_class",
"[",
"i",
"]",
"=",
"<NUM_LIT>",
";",
"break",
";",
"case",
"MODE_VECTOR_INT",
":"
] |
LLVM
|
ARM
|
CPP
|
next_suggestion
|
CPU
| 10,894 |
[
"}"
] |
[
"unsigned",
"CondBit0",
"=",
"Firstcond",
"&",
"<NUM_LIT>",
";",
"unsigned",
"NumTZ",
"=",
"countTrailingZeros",
"<",
"uint8_t",
">",
"(",
"Mask",
")",
";",
"unsigned",
"char",
"CCBits",
"=",
"static_cast",
"<",
"unsigned",
"char",
">",
"(",
"Firstcond",
"&",
"<NUM_LIT>",
")",
";",
"assert",
"(",
"NumTZ",
"<=",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Invalid IT mask!",
"<STR_LIT>",
")",
";",
"for",
"(",
"unsigned",
"Pos",
"=",
"NumTZ",
"+",
"<NUM_LIT>",
";",
"Pos",
"<=",
"<NUM_LIT>",
";",
"++",
"Pos",
")",
"{",
"bool",
"T",
"=",
"(",
"(",
"Mask",
">>",
"Pos",
")",
"&",
"<NUM_LIT>",
")",
"==",
"CondBit0",
";",
"if",
"(",
"T",
")",
"ITStates",
".",
"push_back",
"(",
"CCBits",
")",
";",
"else",
"ITStates",
".",
"push_back",
"(",
"CCBits",
"^",
"<NUM_LIT>",
")",
";",
"}",
"ITStates",
".",
"push_back",
"(",
"CCBits",
")",
";"
] |
LLVM
|
SystemZ
|
CPP
|
program_repair
|
CPU
| 10,895 |
[
"<FIXS>",
"bool",
"expandRxSBG",
"(",
"RxSBGOperands",
"&",
"RxSBG",
")",
";",
"<FIXE>"
] |
[
"bool",
"detectOrAndInsertion",
"(",
"SDValue",
"&",
"Op",
",",
"uint64_t",
"InsertMask",
")",
";",
"<BUGS>",
"bool",
"expandRISBG",
"(",
"RISBGOperands",
"&",
"Ops",
")",
";",
"<BUGE>",
"SDValue",
"getUNDEF64",
"(",
"SDLoc",
"DL",
")",
";"
] |
GCC
|
aarch64
|
CPP
|
code_generation
|
CPU
| 10,896 |
[
"tree",
"resolve",
"(",
"function_resolver",
"&",
"r",
")",
"const",
"override",
"{",
"unsigned",
"int",
"i",
",",
"nargs",
";",
"type_suffix_index",
"type",
";",
"if",
"(",
"!",
"r",
".",
"check_gp_argument",
"(",
"<NUM_LIT>",
",",
"i",
",",
"nargs",
")",
"||",
"(",
"type",
"=",
"r",
".",
"infer_vector_type",
"(",
"i",
")",
")",
"==",
"NUM_TYPE_SUFFIXES",
")",
"return",
"error_mark_node",
";",
"if",
"(",
"type",
"==",
"TYPE_SUFFIX_b",
")",
"return",
"r",
".",
"resolve_to",
"(",
"r",
".",
"mode_suffix_id",
",",
"type",
")",
";",
"if",
"(",
"type_suffixes",
"[",
"type",
"]",
".",
"integer_p",
"&&",
"type_suffixes",
"[",
"type",
"]",
".",
"element_bits",
"<",
"<NUM_LIT>",
")",
"{",
"type_suffix_index",
"wide_suffix",
"=",
"find_type_suffix",
"(",
"type_suffixes",
"[",
"type",
"]",
".",
"tclass",
",",
"type_suffixes",
"[",
"type",
"]",
".",
"element_bits",
"*",
"<NUM_LIT>",
")",
";",
"if",
"(",
"tree",
"res",
"=",
"r",
".",
"lookup_form",
"(",
"r",
".",
"mode_suffix_id",
",",
"wide_suffix",
")",
")",
"return",
"res",
";",
"}",
"return",
"r",
".",
"report_no_such_form",
"(",
"type",
")",
";",
"}"
] |
[
"If",
"the",
"call",
"is",
"erroneous",
",",
"report",
"an",
"appropriate",
"error",
"and",
"return",
"error_mark_node",
".",
"Otherwise",
",",
"if",
"the",
"function",
"is",
"overloaded",
",",
"return",
"the",
"decl",
"of",
"the",
"non-overloaded",
"function",
".",
"Return",
"NULL_TREE",
"otherwise",
",",
"indicating",
"that",
"the",
"call",
"should",
"be",
"processed",
"in",
"the",
"normal",
"way",
"."
] |
GCC
|
avr
|
MD
|
program_repair
|
MPU
| 10,897 |
[
"<FIXS>",
"(",
"define_insn_and_split",
"<STR_LIT>",
"<FIXE>",
"<FIXS>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<FIXE>",
"<FIXS>",
"(",
"define_insn_and_split",
"<STR_LIT>",
"<FIXE>",
"<FIXS>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<FIXE>"
] |
[
"TA",
"UTAQI",
"HI",
"SI",
"DI",
"]",
")",
"<BUGS>",
"(",
"define_insn",
"<STR_LIT>",
"<BUGE>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"FIXED_A",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"fract_convert",
":",
"FIXED_A",
"(",
"match_operand",
":",
"FIXED_B",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"{",
"return",
"avr_out_fract",
"(",
"insn",
",",
"operands",
",",
"true",
",",
"NULL",
")",
"}",
"<BUGS>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<BUGE>",
"<BUGS>",
"(",
"define_insn",
"<STR_LIT>",
"<BUGE>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"FIXED_A",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"unsigned_fract_convert",
":",
"FIXED_A",
"(",
"match_operand",
":",
"FIXED_B",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"{",
"return",
"avr_out_fract",
"(",
"insn",
",",
"operands",
",",
"false",
",",
"NULL",
")",
"}",
"<BUGS>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<BUGE>"
] |
LLVM
|
AMDGPU
|
CPP
|
stmt_completion
|
GPU
| 10,898 |
[
"AMDGPU_PS",
":"
] |
[
"case",
"CallingConv",
"::",
"AMDGPU_VS",
":",
"case",
"CallingConv",
"::",
"AMDGPU_LS",
":",
"case",
"CallingConv",
"::",
"AMDGPU_HS",
":",
"case",
"CallingConv",
"::",
"AMDGPU_ES",
":",
"case",
"CallingConv",
"::",
"AMDGPU_GS",
":",
"case",
"CallingConv",
"::"
] |
LLVM
|
AMDGPU
|
CPP
|
program_repair
|
GPU
| 10,899 |
[
"<FIXS>",
"UP",
".",
"MaxCount",
"=",
"std",
"::",
"numeric_limits",
"unsigned",
">",
"::",
"max",
"(",
")",
";",
"<FIXE>"
] |
[
"void",
"AMDGPUTTIImpl",
"::",
"getUnrollingPreferences",
"(",
"Loop",
"*",
"L",
",",
"ScalarEvolution",
"&",
"SE",
",",
"TTI",
"::",
"UnrollingPreferences",
"&",
"UP",
")",
"{",
"UP",
".",
"Threshold",
"=",
"<NUM_LIT>",
";",
"<BUGS>",
"UP",
".",
"MaxCount",
"=",
"UINT_MAX",
";",
"<BUGE>",
"UP",
".",
"Partial",
"=",
"true",
";"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.