Compiler_Type
stringclasses
2 values
Target
stringclasses
176 values
Programming Language
stringclasses
3 values
Task
stringclasses
4 values
Target_Type
stringclasses
7 values
Idx
int64
0
636k
Ground_Truth
sequencelengths
0
2.32k
Input
sequencelengths
1
1.02k
LLVM
WebAssembly
CPP
next_suggestion
Virtual ISA
0
[ "}" ]
[ "void", "Block", "::", "AddBranchTo", "(", "Block", "*", "Target", ",", "const", "char", "*", "Condition", ",", "const", "char", "*", "Code", ")", "{", "assert", "(", "!", "contains", "(", "BranchesOut", ",", "Target", ")", "&&", "<STR_LIT>", "cannot add more than one branch to the same target", "<STR_LIT>", ")", ";", "BranchesOut", "[", "Target", "]", "=", "make_unique", "<", "Branch", ">", "(", "Condition", ",", "Code", ")", ";" ]
GCC
i386
CPP
stmt_completion
CPU
1
[ "_", "_", "mmask16", ")", "_", "_", "U", ")", ";" ]
[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_cvtepi8_epi32", "(", "_", "_", "mmask16", "_", "_", "U", ",", "_", "_", "m128i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_pmovsxbd512_mask", "(", "(", "_", "_", "v16qi", ")", "_", "_", "A", ",", "(", "_", "_", "v16si", ")", "_", "mm512_setzero_si512", "(", ")", ",", "(" ]
LLVM
PowerPC
TD
stmt_completion
CPU
2
[ "(", "PPCvecinsert", "v4i32", ":", "$", "XTi", ",", "v4i32", ":", "$", "XB", ",", "imm32SExt16", ":", "$", "UIM", ")", ")", "]", ">", ",", "RegConstraint", "<", "<STR_LIT>", ">", ",", "NoEncode", "<", "<STR_LIT>", ">", ";" ]
[ "def", "XXINSERTW", ":", "XX2_RD6_UIM5_RS6", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "vsrc", ":", "$", "XT", ")", ",", "(", "ins", "vsrc", ":", "$", "XTi", ",", "vsrc", ":", "$", "XB", ",", "u4imm", ":", "$", "UIM", ")", ",", "<STR_LIT>", ",", "IIC_VecFP", ",", "[", "(", "set", "v4i32", ":", "$", "XT", "," ]
LLVM
AArch64
CPP
next_suggestion
CPU
3
[ "assert", "(", "NumBytes", "<=", "FulleSizeInBytes", "&&", "<STR_LIT>", "Invalid fixup size!", "<STR_LIT>", ")", ";" ]
[ "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Target", ",", "Value", ",", "Ctx", ",", "TheTriple", ",", "IsResolved", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid fixup offset!", "<STR_LIT>", ")", ";", "unsigned", "FulleSizeInBytes", "=", "getFixupKindContainereSizeInBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "FulleSizeInBytes", "==", "<NUM_LIT>", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ")", ";", "}", "}", "else", "{", "assert", "(", "(", "Offset", "+", "FulleSizeInBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid fixup size!", "<STR_LIT>", ")", ";" ]
LLVM
AArch64
TD
next_suggestion
CPU
4
[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "target", ";" ]
[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "NZCV", "]", ";", "bits", "<", "<NUM_LIT>", ">", "cond", ";", "bits", "<", "<NUM_LIT>", ">", "target", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]
LLVM
AMDGPU
CPP
next_suggestion
GPU
5
[ "if", "(", "!", "Info", "->", "isEntryFunction", "(", ")", "&&", "FI", ".", "hasValue", "(", ")", ")", "MIB", ".", "addReg", "(", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ";" ]
[ "const", "MachineInstr", "*", "LHSDef", "=", "MRI", "->", "getVRegDef", "(", "LHS", ".", "getReg", "(", ")", ")", ";", "const", "MachineInstr", "*", "RHSDef", "=", "MRI", "->", "getVRegDef", "(", "RHS", ".", "getReg", "(", ")", ")", ";", "if", "(", "LHSDef", "&&", "RHSDef", ")", "{", "int64_t", "PossibleOffset", "=", "RHSDef", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getCImm", "(", ")", "->", "getSExtValue", "(", ")", ";", "if", "(", "SIInstrInfo", "::", "isLegalMUBUFImmOffset", "(", "PossibleOffset", ")", "&&", "(", "!", "STI", ".", "privateMemoryResourceIsRangeChecked", "(", ")", "||", "KnownBits", "->", "signBitIsZero", "(", "LHS", ".", "getReg", "(", ")", ")", ")", ")", "{", "if", "(", "LHSDef", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "G_FRAME_INDEX", ")", "FI", "=", "LHSDef", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "else", "VAddr", "=", "LHS", ".", "getReg", "(", ")", ";", "Offset", "=", "PossibleOffset", ";", "}", "}", "}", "else", "if", "(", "RootDef", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "G_FRAME_INDEX", ")", "{", "FI", "=", "RootDef", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "}", "}", "return", "{", "{", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "MIB", ".", "addReg", "(", "Info", "->", "getScratchRSrcReg", "(", ")", ")", ";", "}", ",", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "if", "(", "FI", ".", "hasValue", "(", ")", ")", "MIB", ".", "addFrameIndex", "(", "FI", ".", "getValue", "(", ")", ")", ";", "else", "MIB", ".", "addReg", "(", "VAddr", ")", ";", "}", ",", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{" ]
GCC
iq2000
CPP
code_generation
CPU
6
[ "static", "section", "*", "iq2000_select_rtx_section", "(", "machine_mode", "mode", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "return", "mergeable_constant_section", "(", "mode", ",", "align", ",", "<NUM_LIT>", ")", ";", "}" ]
[ "Choose", "the", "section", "to", "use", "for", "the", "constant", "rtx", "expression", "X", "that", "has", "mode", "MODE", "." ]
GCC
aarch64
CPP
next_suggestion
CPU
7
[ "}" ]
[ "static", "tree", "add_attribute", "(", "const", "char", "*", "name", ",", "tree", "attrs", ")", "{", "return", "tree_cons", "(", "get_identifier", "(", "name", ")", ",", "NULL_TREE", ",", "attrs", ")", ";" ]
LLVM
SystemZ
TD
next_suggestion
CPU
8
[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V2", "{", "<NUM_LIT>", "}", ";" ]
[ "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "V1", ";", "bits", "<", "<NUM_LIT>", ">", "V2", ";", "bits", "<", "<NUM_LIT>", ">", "M3", ";", "bits", "<", "<NUM_LIT>", ">", "M4", ";", "bits", "<", "<NUM_LIT>", ">", "M5", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "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>", "}", "=", "M5", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "m4or", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "M4", "{", "<NUM_LIT>", "}", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "m4or", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "M4", "{", "<NUM_LIT>", "}", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "m4or", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "M4", "{", "<NUM_LIT>", "}", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "m4or", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "M4", "{", "<NUM_LIT>", "}", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "M3", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "}", ";" ]
GCC
sh
MD
program_repair
CPU
9
[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>", "<FIXS>", "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>", "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>", "<FIXS>", "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>" ]
[ "}", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "div", ":", "SI", "(", "reg", ":", "SI", "R4_REG", ")", "(", "reg", ":", "SI", "R5_REG", ")", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "PR_REG", ")", ")", "(", "clobber", "(", "reg", ":", "DF", "DR0_REG", ")", ")", "(", "clobber", "(", "reg", ":", "DF", "DR2_REG", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "FPSCR_STAT_REG", ")", ")", "<BUGS>", "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "use", "(", "reg", ":", "SI", "FPSCR_MODES_REG", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "div", ":", "SI", "(", "reg", ":", "SI", "R4_REG", ")", "(", "reg", ":", "SI", "R5_REG", ")", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "PR_REG", ")", ")", "(", "clobber", "(", "reg", ":", "DF", "DR0_REG", ")", ")", "(", "clobber", "(", "reg", ":", "DF", "DR2_REG", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "R2_REG", ")", ")", "<BUGS>", "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]
LLVM
X86
TD
stmt_completion
CPU
10
[ ":", "$", "ptr", ")", ")", ">", ";" ]
[ "def", "extloadi64i32", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "ptr", ")", ",", "(", "i64", "(", "extloadi32", "node" ]
LLVM
AMDGPU
CPP
stmt_completion
GPU
11
[ ":", "<NUM_LIT>", ";" ]
[ "auto", "Arg", "=", "ArgInfo", ".", "getPreloadedValue", "(", "Value", ")", ".", "first", ";", "return", "Arg", "?", "Arg", "->", "getRegister", "(", ")" ]
GCC
i386
MD
next_suggestion
CPU
12
[ "<STR_LIT>", ")" ]
[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")" ]
LLVM
AArch64
TD
next_suggestion
CPU
13
[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zd", ";" ]
[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz8_64", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zn", ";" ]
GCC
i386
MD
program_repair
CPU
14
[ "<FIXS>", "(", "V2DI", "<STR_LIT>", ")", "(", "V4DI", "<STR_LIT>", ")", "(", "V8DI", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]
[ "[", "(", "V16QI", "<STR_LIT>", ")", "(", "V32QI", "<STR_LIT>", ")", "(", "V8HI", "<STR_LIT>", ")", "(", "V16HI", "<STR_LIT>", ")", "(", "V4SI", "<STR_LIT>", ")", "(", "V8SI", "<STR_LIT>", ")", "(", "V16SI", "<STR_LIT>", ")", "<BUGS>", "(", "V2DI", "<STR_LIT>", ")", "(", "V4DI", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_mode_attr", "avx_avx2", "[", "(", "V4SF", "<STR_LIT>", ")", "(", "V2DF", "<STR_LIT>", ")" ]
LLVM
AArch64
CPP
stmt_completion
CPU
15
[ ")", ";" ]
[ "if", "(", "Value", "&", "<NUM_LIT>", ")", "Ctx", ".", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "fixup must be 16-byte aligned", "<STR_LIT>", ")", ";", "return", "Value", ">>", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "AArch64MCExpr", "::", "VariantKind", "RefKind", "=", "static_cast", "<", "AArch64MCExpr", "::", "VariantKind", ">", "(", "Target", ".", "getRefKind", "(", ")", ")", ";", "if", "(", "AArch64MCExpr", "::", "getSymbolLoc", "(", "RefKind", ")", "!=", "AArch64MCExpr", "::", "VK_ABS", "&&", "AArch64MCExpr", "::", "getSymbolLoc", "(", "RefKind", ")", "!=", "AArch64MCExpr", "::", "VK_SABS", ")", "{", "Ctx", ".", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "relocation for a thread-local variable points to an ", "<STR_LIT>", "<STR_LIT>", "absolute symbol", "<STR_LIT>", ")", ";", "return", "Value", ";", "}", "if", "(", "!", "IsResolved", ")", "{", "Ctx", ".", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "unresolved movw fixup not yet ", "<STR_LIT>", "<STR_LIT>", "implemented", "<STR_LIT>", ")", ";", "return", "Value", ";", "}", "if", "(", "AArch64MCExpr", "::", "getSymbolLoc", "(", "RefKind", ")", "==", "AArch64MCExpr", "::", "VK_SABS", ")", "{", "switch", "(", "AArch64MCExpr", "::", "getAddressFrag", "(", "RefKind", ")", ")", "{", "case", "AArch64MCExpr", "::", "VK_G0", ":", "break", ";", "case", "AArch64MCExpr", "::", "VK_G1", ":", "SignedValue", "=", "SignedValue", ">>", "<NUM_LIT>", ";", "break", ";", "case", "AArch64MCExpr", "::", "VK_G2", ":", "SignedValue", "=", "SignedValue", ">>", "<NUM_LIT>", ";", "break", ";", "case", "AArch64MCExpr", "::", "VK_G3", ":", "SignedValue", "=", "SignedValue", ">>", "<NUM_LIT>", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Variant kind doesn't correspond to fixup", "<STR_LIT>", ")", ";", "}", "}", "else", "{", "switch", "(", "AArch64MCExpr", "::", "getAddressFrag", "(", "RefKind", ")", ")", "{", "case", "AArch64MCExpr", "::", "VK_G0", ":", "break", ";", "case", "AArch64MCExpr", "::", "VK_G1", ":", "Value", "=", "Value", ">>", "<NUM_LIT>", ";", "break", ";", "case", "AArch64MCExpr", "::", "VK_G2", ":", "Value", "=", "Value", ">>", "<NUM_LIT>", ";", "break", ";", "case", "AArch64MCExpr", "::", "VK_G3", ":", "Value", "=", "Value", ">>", "<NUM_LIT>", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Variant kind doesn't correspond to fixup", "<STR_LIT>", ")", ";", "}", "}", "if", "(", "RefKind", "&", "AArch64MCExpr", "::", "VK_NC", ")", "{", "Value", "&=", "<NUM_LIT>", ";", "}", "else", "if", "(", "AArch64MCExpr", "::", "getSymbolLoc", "(", "RefKind", ")", "==", "AArch64MCExpr", "::", "VK_SABS", ")", "{", "if", "(", "SignedValue", ">", "<NUM_LIT>", "||", "SignedValue", "<", "-", "<NUM_LIT>", ")", "Ctx", ".", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "fixup value out of range", "<STR_LIT>", ")", ";", "if", "(", "SignedValue", "<", "<NUM_LIT>", ")", "SignedValue", "=", "~", "SignedValue", ";", "Value", "=", "static_cast", "<", "uint64_t", ">", "(", "SignedValue" ]
LLVM
BPF
CPP
next_suggestion
Virtual ISA
16
[ "initializeBPFMIPeepholeTruncElimPass", "(", "PR", ")", ";" ]
[ "PassRegistry", "&", "PR", "=", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ";", "initializeBPFAbstractMemberAccessPass", "(", "PR", ")", ";", "initializeBPFPreserveDITypePass", "(", "PR", ")", ";", "initializeBPFMIPeepholePass", "(", "PR", ")", ";" ]
GCC
mips
MD
stmt_completion
CPU
17
[ ")", "]", ")" ]
[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "ANYF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fma", ":", "ANYF", "(", "match_operand", ":", "ANYF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "ANYF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "ANYF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]
LLVM
ARM
CPP
next_suggestion
CPU
18
[ "if", "(", "Scale", ">", "<NUM_LIT>", ")", "O", "<<", "<STR_LIT>", " * ", "<STR_LIT>", "<<", "Scale", ";" ]
[ "}", "O", "<<", "<STR_LIT>", "[", "<STR_LIT>", "<<", "TRI", "->", "getAsmName", "(", "MO1", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO3", ".", "getReg", "(", ")", ")", "O", "<<", "<STR_LIT>", ", ", "<STR_LIT>", "<<", "TRI", "->", "getAsmName", "(", "MO3", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "unsigned", "ImmOffs", "=", "MO2", ".", "getImm", "(", ")", ")", "{", "O", "<<", "<STR_LIT>", ", #", "<STR_LIT>", "<<", "ImmOffs", ";" ]
LLVM
AArch64
TD
next_suggestion
CPU
19
[ "}" ]
[ "def", "roW", ":", "LoadStore8RO", "<", "sz", ",", "V", ",", "opc", ",", "asm", ",", "(", "outs", "regtype", ":", "$", "Rt", ")", ",", "(", "ins", "GPR64sp", ":", "$", "Rn", ",", "GPR32", ":", "$", "Rm", ",", "ro_Wextend8", ":", "$", "extend", ")", ",", "[", "(", "set", "(", "Ty", "regtype", ":", "$", "Rt", ")", ",", "(", "loadop", "(", "ro_Windexed8", "GPR64sp", ":", "$", "Rn", ",", "GPR32", ":", "$", "Rm", ",", "ro_Wextend8", ":", "$", "extend", ")", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteLDIdx", ",", "ReadAdrBase", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]
LLVM
ARM
CPP
stmt_completion
CPU
20
[ ":" ]
[ "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_VFPV3_FP16", ":", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_VFPV3_D16", ":", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_VFPV3_D16_FP16", ":", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_VFPV3XD", ":", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_VFPV3XD_FP16", ":", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_VFPV4" ]
LLVM
SNES
TD
stmt_completion
DSP
21
[ "src", ",", "imm", ":", "$", "k", ")", ")", ",", "(", "implicit", "P", ")", "]", ">", ";" ]
[ "def", "SBCIRdK", ":", "FRdK", "<", "<NUM_LIT>", ",", "(", "outs", "MainRegs", ":", "$", "rd", ")", ",", "(", "ins", "MainRegs", ":", "$", "src", ",", "imm_ldi16", ":", "$", "k", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "i16", ":", "$", "rd", ",", "(", "sube", "i16", ":", "$" ]
LLVM
Hexagon
TD
stmt_completion
DSP
22
[ "=", "<NUM_LIT>", ";" ]
[ "def", "L2_loadrub_io", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_17e0d2cd", ",", "TypeLD", ">", ",", "Enc_211aaa", ",", "AddrModeRel", ",", "PostInc_BaseImm", "{", "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", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad" ]
GCC
fr30
MD
next_suggestion
DSP
23
[ "<STR_LIT>" ]
[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]
GCC
i386
CPP
next_suggestion
CPU
24
[ "pic_reg_used", "=", "true", ";" ]
[ "x", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "x", ",", "NULL", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "x", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "emit_insn", "(", "gen_push", "(", "hard_frame_pointer_rtx", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "insn", "=", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "allocate", "=", "frame", ".", "to_allocate", ";", "if", "(", "!", "frame", ".", "save_regs_using_mov", ")", "ix86_emit_save_regs", "(", ")", ";", "else", "allocate", "+=", "frame", ".", "nregs", "*", "UNITS_PER_WORD", ";", "if", "(", "TARGET_RED_ZONE", "&&", "frame", ".", "save_regs_using_mov", ")", "ix86_emit_save_regs_using_mov", "(", "frame_pointer_needed", "?", "hard_frame_pointer_rtx", ":", "stack_pointer_rtx", ",", "-", "frame", ".", "nregs", "*", "UNITS_PER_WORD", ")", ";", "if", "(", "allocate", "==", "<NUM_LIT>", ")", ";", "else", "if", "(", "!", "TARGET_STACK_PROBE", "||", "allocate", "<", "CHECK_STACK_LIMIT", ")", "pro_epilogue_adjust_stack", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "allocate", ")", ",", "-", "<NUM_LIT>", ")", ";", "else", "{", "rtx", "eax", "=", "gen_rtx_REG", "(", "SImode", ",", "<NUM_LIT>", ")", ";", "bool", "eax_live", "=", "ix86_eax_live_at_start_p", "(", ")", ";", "rtx", "t", ";", "gcc_assert", "(", "!", "TARGET_64BIT", ")", ";", "if", "(", "eax_live", ")", "{", "emit_insn", "(", "gen_push", "(", "eax", ")", ")", ";", "allocate", "-=", "<NUM_LIT>", ";", "}", "emit_move_insn", "(", "eax", ",", "GEN_INT", "(", "allocate", ")", ")", ";", "insn", "=", "emit_insn", "(", "gen_allocate_stack_worker", "(", "eax", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "t", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "allocate", ")", ")", ";", "t", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "t", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "t", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "if", "(", "eax_live", ")", "{", "if", "(", "frame_pointer_needed", ")", "t", "=", "plus_constant", "(", "hard_frame_pointer_rtx", ",", "allocate", "-", "frame", ".", "to_allocate", "-", "frame", ".", "nregs", "*", "UNITS_PER_WORD", ")", ";", "else", "t", "=", "plus_constant", "(", "stack_pointer_rtx", ",", "allocate", ")", ";", "emit_move_insn", "(", "eax", ",", "gen_rtx_MEM", "(", "SImode", ",", "t", ")", ")", ";", "}", "}", "if", "(", "frame", ".", "save_regs_using_mov", "&&", "!", "TARGET_RED_ZONE", ")", "{", "if", "(", "!", "frame_pointer_needed", "||", "!", "frame", ".", "to_allocate", ")", "ix86_emit_save_regs_using_mov", "(", "stack_pointer_rtx", ",", "frame", ".", "to_allocate", ")", ";", "else", "ix86_emit_save_regs_using_mov", "(", "hard_frame_pointer_rtx", ",", "-", "frame", ".", "nregs", "*", "UNITS_PER_WORD", ")", ";", "}", "pic_reg_used", "=", "false", ";", "if", "(", "pic_offset_table_rtx", "&&", "(", "regs_ever_live", "[", "REAL_PIC_OFFSET_TABLE_REGNUM", "]", "||", "current_function_profile", ")", ")", "{", "unsigned", "int", "alt_pic_reg_used", "=", "ix86_select_alt_pic_regnum", "(", ")", ";", "if", "(", "alt_pic_reg_used", "!=", "INVALID_REGNUM", ")", "REGNO", "(", "pic_offset_table_rtx", ")", "=", "alt_pic_reg_used", ";" ]
GCC
mips
MD
next_suggestion
CPU
25
[ "<STR_LIT>", ")" ]
[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")" ]
LLVM
WebAssembly
CPP
next_suggestion
Virtual ISA
26
[ "case", "WebAssembly", "::", "ATOMIC_RMW_SUB_I64_S", ":" ]
[ "case", "WebAssembly", "::", "ATOMIC_LOAD8_U_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD8_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD8_U_I64_S", ":", "case", "WebAssembly", "::", "STORE8_I32", ":", "case", "WebAssembly", "::", "STORE8_I32_S", ":", "case", "WebAssembly", "::", "STORE8_I64", ":", "case", "WebAssembly", "::", "STORE8_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_STORE8_I32", ":", "case", "WebAssembly", "::", "ATOMIC_STORE8_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_STORE8_I64", ":", "case", "WebAssembly", "::", "ATOMIC_STORE8_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_ADD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_ADD_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_ADD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_ADD_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_SUB_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_SUB_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_SUB_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_SUB_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_AND_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_AND_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_AND_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_AND_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_OR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_OR_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_OR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_OR_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XOR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XOR_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XOR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XOR_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XCHG_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XCHG_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XCHG_I64_S", ":", "return", "<NUM_LIT>", ";", "case", "WebAssembly", "::", "LOAD16_S_I32", ":", "case", "WebAssembly", "::", "LOAD16_S_I32_S", ":", "case", "WebAssembly", "::", "LOAD16_U_I32", ":", "case", "WebAssembly", "::", "LOAD16_U_I32_S", ":", "case", "WebAssembly", "::", "LOAD16_S_I64", ":", "case", "WebAssembly", "::", "LOAD16_S_I64_S", ":", "case", "WebAssembly", "::", "LOAD16_U_I64", ":", "case", "WebAssembly", "::", "LOAD16_U_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD16_U_I32", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD16_U_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD16_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD16_U_I64_S", ":", "case", "WebAssembly", "::", "STORE16_I32", ":", "case", "WebAssembly", "::", "STORE16_I32_S", ":", "case", "WebAssembly", "::", "STORE16_I64", ":", "case", "WebAssembly", "::", "STORE16_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_STORE16_I32", ":", "case", "WebAssembly", "::", "ATOMIC_STORE16_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_STORE16_I64", ":", "case", "WebAssembly", "::", "ATOMIC_STORE16_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_ADD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_ADD_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_ADD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_ADD_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_SUB_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_SUB_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_SUB_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_SUB_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_AND_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_AND_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_AND_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_AND_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_OR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_OR_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_OR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_OR_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XOR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XOR_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XOR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XOR_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XCHG_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XCHG_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XCHG_I64_S", ":", "return", "<NUM_LIT>", ";", "case", "WebAssembly", "::", "LOAD_I32", ":", "case", "WebAssembly", "::", "LOAD_I32_S", ":", "case", "WebAssembly", "::", "LOAD_F32", ":", "case", "WebAssembly", "::", "LOAD_F32_S", ":", "case", "WebAssembly", "::", "STORE_I32", ":", "case", "WebAssembly", "::", "STORE_I32_S", ":", "case", "WebAssembly", "::", "STORE_F32", ":", "case", "WebAssembly", "::", "STORE_F32_S", ":", "case", "WebAssembly", "::", "LOAD32_S_I64", ":", "case", "WebAssembly", "::", "LOAD32_S_I64_S", ":", "case", "WebAssembly", "::", "LOAD32_U_I64", ":", "case", "WebAssembly", "::", "LOAD32_U_I64_S", ":", "case", "WebAssembly", "::", "STORE32_I64", ":", "case", "WebAssembly", "::", "STORE32_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD32_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD32_U_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_STORE_I32", ":", "case", "WebAssembly", "::", "ATOMIC_STORE_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_STORE32_I64", ":", "case", "WebAssembly", "::", "ATOMIC_STORE32_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_ADD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_ADD_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_ADD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_ADD_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_SUB_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_SUB_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_SUB_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_SUB_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_AND_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_AND_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_AND_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_AND_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_OR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_OR_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_OR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_OR_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_XOR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_XOR_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_XOR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_XOR_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_XCHG_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_XCHG_I32_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_XCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_XCHG_I64_S", ":", "return", "<NUM_LIT>", ";", "case", "WebAssembly", "::", "LOAD_I64", ":", "case", "WebAssembly", "::", "LOAD_I64_S", ":", "case", "WebAssembly", "::", "LOAD_F64", ":", "case", "WebAssembly", "::", "LOAD_F64_S", ":", "case", "WebAssembly", "::", "STORE_I64", ":", "case", "WebAssembly", "::", "STORE_I64_S", ":", "case", "WebAssembly", "::", "STORE_F64", ":", "case", "WebAssembly", "::", "STORE_F64_S", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_STORE_I64", ":", "case", "WebAssembly", "::", "ATOMIC_STORE_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_ADD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_ADD_I64_S", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_SUB_I64", ":" ]
LLVM
X86
CPP
stmt_completion
CPU
27
[ "N", ")", ";" ]
[ "assert", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", "==", "N", "->", "getOpcode", "(", ")", "||", "<STR_LIT>", "::", "<STR_LIT>", "==", "N", "->", "getOpcode", "(", ")", "||", "<STR_LIT>", "::", "<STR_LIT>", "==", "N", "->", "getOpcode", "(", ")", "||", "<STR_LIT>", "::", "<STR_LIT>", "==", "N", "->", "getOpcode", "(", ")", ")", "&&", "<STR_LIT>", "Unexpected horizontal add/sub opcode", "<STR_LIT>", ")", ";", "if", "(", "!", "shouldUseHorizontalOp", "(", "true", ",", "DAG", ",", "Subtarget", ")", ")", "{", "MVT", "VT", "=", "N", "->", "getSimpleValueType", "(", "<NUM_LIT>", ")", ";", "SDValue", "LHS", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "RHS", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "LHS", "!=", "RHS", "&&", "LHS", ".", "getOpcode", "(", ")", "==", "N", "->", "getOpcode", "(", ")", "&&", "LHS", ".", "getOpcode", "(", ")", "==", "RHS", ".", "getOpcode", "(", ")", "&&", "LHS", ".", "getValueType", "(", ")", "==", "RHS", ".", "getValueType", "(", ")", "&&", "N", "->", "isOnlyUserOf", "(", "LHS", ".", "getNode", "(", ")", ")", "&&", "N", "->", "isOnlyUserOf", "(", "RHS", ".", "getNode", "(", ")", ")", ")", "{", "SDValue", "LHS0", "=", "LHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "LHS1", "=", "LHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "RHS0", "=", "RHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "RHS1", "=", "RHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "LHS0", "==", "LHS1", "||", "LHS0", ".", "isUndef", "(", ")", "||", "LHS1", ".", "isUndef", "(", ")", ")", "&&", "(", "RHS0", "==", "RHS1", "||", "RHS0", ".", "isUndef", "(", ")", "||", "RHS1", ".", "isUndef", "(", ")", ")", ")", "{", "SDLoc", "DL", "(" ]
LLVM
SPIRV
CPP
stmt_completion
Virtual ISA
28
[ ")", ";" ]
[ "BitVector", "Reserved", "(", "getNumRegs", "(", ")" ]
LLVM
ARM
TD
stmt_completion
CPU
29
[ "]", ">", ";" ]
[ "def", "VST4d16Pseudo", ":", "VSTQQPseudo", "<", "IIC_VST4", ">", ",", "Sched", "<", "[", "WriteVST4" ]
LLVM
TriCore
CPP
next_suggestion
MPU
30
[ "if", "(", "Base", ".", "getReg", "(", ")", ")", "O", "<<", "<STR_LIT>", "[%", "<STR_LIT>", "<<", "StringRef", "(", "getRegisterName", "(", "Base", ".", "getReg", "(", ")", ")", ")", ".", "lower", "(", ")", "<<", "'", "]", "'", ";" ]
[ "const", "MCOperand", "&", "Base", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "const", "MCOperand", "&", "Disp", "=", "MI", "->", "getOperand", "(", "OpNum", "+", "<NUM_LIT>", ")", ";" ]
LLVM
X86
CPP
next_suggestion
CPU
31
[ "}" ]
[ "SDValue", "P", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "DstVT", ",", "Op0", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SINT_TO_FP", ",", "dl", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "P", ")", ";", "}", "if", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "LOAD", ")", "{", "LoadSDNode", "*", "Ld", "=", "cast", "<", "LoadSDNode", ">", "(", "Op0", ".", "getNode", "(", ")", ")", ";", "EVT", "VT", "=", "Ld", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "Ld", "->", "isVolatile", "(", ")", "&&", "!", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ".", "isVector", "(", ")", "&&", "ISD", "::", "isNON_EXTLoad", "(", "Op0", ".", "getNode", "(", ")", ")", "&&", "Op0", ".", "hasOneUse", "(", ")", "&&", "!", "XTLI", "->", "getSubtarget", "(", ")", "->", "is64Bit", "(", ")", "&&", "VT", "==", "MVT", "::", "i64", ")", "{", "SDValue", "FILDChain", "=", "XTLI", "->", "BuildFILD", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "Ld", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "Ld", "->", "getChain", "(", ")", ",", "Op0", ",", "DAG", ")", ";", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "Op0", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "FILDChain", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "return", "FILDChain", ";", "}" ]
LLVM
AArch64
CPP
stmt_completion
CPU
32
[ "getValue", "(", ")", ")", ";" ]
[ "void", "AArch64InstructionSelector", "::", "renderTruncImm", "(", "MachineInstrBuilder", "&", "MIB", ",", "const", "MachineInstr", "&", "MI", ",", "int", "OpIdx", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_CONSTANT", "&&", "OpIdx", "==", "-", "<NUM_LIT>", "&&", "<STR_LIT>", "Expected G_CONSTANT", "<STR_LIT>", ")", ";", "Optional", "<", "int64_t", ">", "CstVal", "=", "getConstantVRegSExtVal", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "assert", "(", "CstVal", "&&", "<STR_LIT>", "Expected constant value", "<STR_LIT>", ")", ";", "MIB", ".", "addImm", "(", "CstVal", "." ]
LLVM
Hexagon
CPP
next_suggestion
DSP
33
[ "return", "Changed", ";" ]
[ "MachineBasicBlock", "::", "iterator", "I", ",", "E", ",", "NextI", ";", "for", "(", "I", "=", "B", ".", "begin", "(", ")", ",", "E", "=", "B", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "NextI", ")", "{", "NextI", "=", "std", "::", "next", "(", "I", ")", ";", "if", "(", "isCondset", "(", "*", "I", ")", ")", "Changed", "|=", "split", "(", "*", "I", ",", "UpdRegs", ")", ";", "}" ]
LLVM
Hexagon
TD
stmt_completion
DSP
34
[ ">", ",", "Enc_454a26", "{" ]
[ "def", "C2_andn", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pt4", ",", "PredRegs", ":", "$", "Ps4", ")", ",", "<STR_LIT>", ",", "tc_640086b5", ",", "TypeCR" ]
LLVM
ARM
TD
next_suggestion
CPU
35
[ "let", "unsignedFlag", "=", "(", "?", "(", "i32", "VTI", ".", "Unsigned", ")", ")", ";" ]
[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "VTI", "=", "VTI_", ";", "let", "immediateType", "=", "immType", ";" ]
LLVM
ARM
CPP
next_suggestion
CPU
36
[ "}" ]
[ "void", "ARMTargetLowering", "::", "addMVEVectorTypes", "(", "bool", "HasMVEFP", ")", "{", "const", "MVT", "IntTypes", "[", "]", "=", "{", "MVT", "::", "v16i8", ",", "MVT", "::", "v8i16", ",", "MVT", "::", "v4i32", "}", ";", "for", "(", "auto", "VT", ":", "IntTypes", ")", "{", "addRegisterClass", "(", "VT", ",", "&", "ARM", "::", "QPRRegClass", ")", ";", "setOperationAction", "(", "ISD", "::", "VECTOR_SHUFFLE", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "BUILD_VECTOR", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SHL", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SRA", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SRL", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SMIN", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SMAX", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UMIN", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UMAX", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "ABS", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIV", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UREM", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SREM", ",", "VT", ",", "Expand", ")", ";", "if", "(", "!", "HasMVEFP", ")", "{", "setOperationAction", "(", "ISD", "::", "SINT_TO_FP", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UINT_TO_FP", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_SINT", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "VT", ",", "Expand", ")", ";", "}" ]
LLVM
AArch64
TD
stmt_completion
CPU
37
[ ":", "$", "Rm", ")", ")", ")", ")", "]", ">", ";" ]
[ "def", "v2i32", ":", "BaseSIMDThreeSameVector", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "opc", ",", "V64", ",", "asm", ",", "<STR_LIT>", ",", "[", "(", "set", "V64", ":", "$", "Rd", ",", "(", "v2i32", "(", "OpNode", "(", "v2i32", "V64", ":", "$", "Rn", ")", ",", "(", "v2i32", "V64" ]
LLVM
ARM
TD
stmt_completion
CPU
38
[ "v2i32", ",", "VectorIndex32", ">", "{" ]
[ "def", "VDUPLN32d", ":", "VDUPLND", "<", "{", "?", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "<STR_LIT>", ",", "<STR_LIT>", "," ]
GCC
gcn
CPP
stmt_completion
GPU
39
[ "<STR_LIT>", ")", ";" ]
[ "exit", "(", "<NUM_LIT>", ")", ";", "}", "DLSYM_FN", "(", "hsa_status_string", ")", "DLSYM_FN", "(", "hsa_agent_get_info", ")", "DLSYM_FN", "(", "hsa_init", ")", "DLSYM_FN", "(", "hsa_iterate_agents", ")", "DLSYM_FN", "(", "hsa_region_get_info", ")", "DLSYM_FN", "(", "hsa_queue_create", ")", "DLSYM_FN", "(", "hsa_agent_iterate_regions", ")", "DLSYM_FN", "(", "hsa_executable_destroy", ")", "DLSYM_FN", "(", "hsa_executable_create", ")", "DLSYM_FN", "(", "hsa_executable_global_variable_define", ")", "DLSYM_FN", "(", "hsa_executable_load_code_object", ")", "DLSYM_FN", "(", "hsa_executable_freeze", ")", "DLSYM_FN", "(", "hsa_signal_create", ")", "DLSYM_FN", "(", "hsa_memory_allocate", ")", "DLSYM_FN", "(", "hsa_memory_copy", ")", "DLSYM_FN", "(", "hsa_memory_free", ")", "DLSYM_FN", "(", "hsa_signal_destroy", ")", "DLSYM_FN", "(", "hsa_executable_get_symbol", ")", "DLSYM_FN", "(", "hsa_executable_symbol_get_info", ")", "DLSYM_FN", "(", "hsa_signal_wait_acquire", ")", "DLSYM_FN", "(", "hsa_signal_wait_relaxed", ")", "DLSYM_FN", "(", "hsa_signal_store_relaxed", ")", "DLSYM_FN", "(", "hsa_queue_destroy", ")", "DLSYM_FN", "(", "hsa_code_object_deserialize", ")", "DLSYM_FN", "(", "hsa_queue_load_write_index_relaxed", ")", "DLSYM_FN", "(", "hsa_queue_store_write_index_relaxed", ")", "DLSYM_FN", "(", "hsa_shut_down", ")", "return", ";", "fail", ":", "fprintf", "(", "stderr", ",", "<STR_LIT>", "Failed to find HSA functions in ", "<STR_LIT>", "HSA_RUNTIME_LIB", "<STR_LIT>", "\\n" ]
GCC
aarch64
CPP
stmt_completion
CPU
40
[ ")", ";" ]
[ "void", "aarch64_gen_atomic_cas", "(", "rtx", "rval", ",", "rtx", "mem", ",", "rtx", "expected", ",", "rtx", "desired", ",", "rtx", "model", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "gen", "=", "gen_aarch64_atomic_casqi", ";", "break", ";", "case", "HImode", ":", "gen", "=", "gen_aarch64_atomic_cashi", ";", "break", ";", "case", "SImode", ":", "gen", "=", "gen_aarch64_atomic_cassi", ";", "break", ";", "case", "DImode", ":", "gen", "=", "gen_aarch64_atomic_casdi", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "rval", ",", "expected", ")", ")", ";", "emit_insn", "(", "gen", "(", "rval", ",", "mem", ",", "desired", ",", "model", ")", ")", ";", "aarch64_gen_compare_reg", "(", "EQ", ",", "rval", ",", "expected" ]
LLVM
Hexagon
TD
next_suggestion
DSP
41
[ "let", "isTaken", "=", "Inst", "{", "<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", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]
GCC
epiphany
MD
stmt_completion
MPU
42
[ "QI", "V2HI", "V4QI", "]", ")" ]
[ "(", "define_mode_iterator", "WMODE", "[", "SI", "SF", "HI", "QI", "V2HI", "V4QI", "]", ")", "(", "define_mode_iterator", "WMODE2", "[", "SI", "SF", "HI" ]
GCC
aarch64
CPP
stmt_completion
CPU
43
[ "<STR_LIT>", "w", "<STR_LIT>", "(", "a", ")", ":", ")", ";" ]
[ "_", "_", "asm__", "(", "<STR_LIT>", "saddlv %d0,%1.4s", "<STR_LIT>", ":", "<STR_LIT>", "=w", "<STR_LIT>", "(", "result", ")", ":" ]
GCC
m68k
MD
next_suggestion
MPU
44
[ "if", "(", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]
[ "<STR_LIT>", "{", "if", "(", "FP_REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "&", "FP_REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{" ]
LLVM
X86
CPP
next_suggestion
CPU
45
[ "if", "(", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "FP0", "||", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "FP1", ")", "return", "false", ";" ]
[ "CallingConv", "::", "ID", "CC", "=", "F", ".", "getCallingConv", "(", ")", ";", "if", "(", "CC", "!=", "CallingConv", "::", "C", "&&", "CC", "!=", "CallingConv", "::", "Fast", "&&", "CC", "!=", "CallingConv", "::", "Tail", "&&", "CC", "!=", "CallingConv", "::", "SwiftTail", "&&", "CC", "!=", "CallingConv", "::", "X86_FastCall", "&&", "CC", "!=", "CallingConv", "::", "X86_StdCall", "&&", "CC", "!=", "CallingConv", "::", "X86_ThisCall", "&&", "CC", "!=", "CallingConv", "::", "X86_64_SysV", "&&", "CC", "!=", "CallingConv", "::", "Win64", ")", "return", "false", ";", "if", "(", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "X86MFInfo", "->", "getBytesToPopOnReturn", "(", ")", ")", ")", "return", "false", ";", "if", "(", "(", "CC", "==", "CallingConv", "::", "Fast", "&&", "TM", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "||", "CC", "==", "CallingConv", "::", "Tail", "||", "CC", "==", "CallingConv", "::", "SwiftTail", ")", "return", "false", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "RetRegs", ";", "if", "(", "Ret", "->", "getNumOperands", "(", ")", ">", "<NUM_LIT>", ")", "{", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "<NUM_LIT>", ">", "Outs", ";", "GetReturnInfo", "(", "CC", ",", "F", ".", "getReturnType", "(", ")", ",", "F", ".", "getAttributes", "(", ")", ",", "Outs", ",", "TLI", ",", "DL", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ValLocs", ";", "CCState", "CCInfo", "(", "CC", ",", "F", ".", "isVarArg", "(", ")", ",", "*", "FuncInfo", ".", "MF", ",", "ValLocs", ",", "I", "->", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_X86", ")", ";", "const", "Value", "*", "RV", "=", "Ret", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "Register", "Reg", "=", "getRegForValue", "(", "RV", ")", ";", "if", "(", "Reg", "==", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "ValLocs", ".", "size", "(", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "CCValAssign", "&", "VA", "=", "ValLocs", "[", "<NUM_LIT>", "]", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "return", "false", ";", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "return", "false", ";" ]
LLVM
PowerPC
CPP
stmt_completion
CPU
46
[ "NewCallSeqStart", ";" ]
[ "ISD", "::", "ArgFlagsTy", "ArgFlags", "=", "Outs", "[", "i", "]", ".", "Flags", ";", "bool", "Result", ";", "if", "(", "Outs", "[", "i", "]", ".", "IsFixed", ")", "{", "Result", "=", "CC_PPC32_SVR4", "(", "i", ",", "ArgVT", ",", "ArgVT", ",", "CCValAssign", "::", "Full", ",", "ArgFlags", ",", "CCInfo", ")", ";", "}", "else", "{", "Result", "=", "CC_PPC32_SVR4_VarArg", "(", "i", ",", "ArgVT", ",", "ArgVT", ",", "CCValAssign", "::", "Full", ",", "ArgFlags", ",", "CCInfo", ")", ";", "}", "if", "(", "Result", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "Call operand #", "<STR_LIT>", "<<", "i", "<<", "<STR_LIT>", " has unhandled type ", "<STR_LIT>", "<<", "EVT", "(", "ArgVT", ")", ".", "getEVTString", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "llvm_unreachable", "(", "<NUM_LIT>", ")", ";", "}", "}", "}", "else", "{", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CC_PPC32_SVR4", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ByValArgLocs", ";", "CCState", "CCByValInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "ByValArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCByValInfo", ".", "AllocateStack", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", ",", "PtrByteSize", ")", ";", "CCByValInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CC_PPC32_SVR4_ByVal", ")", ";", "unsigned", "NumBytes", "=", "CCByValInfo", ".", "getNextStackOffset", "(", ")", ";", "int", "SPDiff", "=", "CalculateTailCallSPDiff", "(", "DAG", ",", "isTailCall", ",", "NumBytes", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "DAG", ".", "getIntPtrConstant", "(", "NumBytes", ",", "true", ")", ")", ";", "SDValue", "CallSeqStart", "=", "Chain", ";", "SDValue", "LROp", ",", "FPOp", ";", "Chain", "=", "EmitTailCallLoadFPAndRetAddr", "(", "DAG", ",", "SPDiff", ",", "Chain", ",", "LROp", ",", "FPOp", ",", "false", ",", "dl", ")", ";", "SDValue", "StackPtr", "=", "DAG", ".", "getRegister", "(", "PPC", "::", "R1", ",", "MVT", "::", "i32", ")", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ",", "<NUM_LIT>", ">", "RegsToPass", ";", "SmallVector", "<", "TailCallArgumentInfo", ",", "<NUM_LIT>", ">", "TailCallArguments", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOpChains", ";", "bool", "seenFloatArg", "=", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "j", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Outs", "[", "i", "]", ".", "Flags", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "assert", "(", "(", "j", "<", "ByValArgLocs", ".", "size", "(", ")", ")", "&&", "<STR_LIT>", "Index out of bounds!", "<STR_LIT>", ")", ";", "CCValAssign", "&", "ByValVA", "=", "ByValArgLocs", "[", "j", "++", "]", ";", "assert", "(", "(", "VA", ".", "getValNo", "(", ")", "==", "ByValVA", ".", "getValNo", "(", ")", ")", "&&", "<STR_LIT>", "ValNo mismatch!", "<STR_LIT>", ")", ";", "unsigned", "LocMemOffset", "=", "ByValVA", ".", "getLocMemOffset", "(", ")", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "LocMemOffset", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "getPointerTy", "(", ")", ",", "StackPtr", ",", "PtrOff", ")", ";", "SDValue", "MemcpyCall", "=", "CreateCopyOfByValArgument", "(", "Arg", ",", "PtrOff", ",", "CallSeqStart", ".", "getNode", "(", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Flags", ",", "DAG", ",", "dl", ")", ";", "SDValue", "NewCallSeqStart", "=", "DAG", ".", "getCALLSEQ_START", "(", "MemcpyCall", ",", "CallSeqStart", ".", "getNode", "(", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "DAG", ".", "ReplaceAllUsesWith", "(", "CallSeqStart", ".", "getNode", "(", ")", ",", "NewCallSeqStart", ".", "getNode", "(", ")", ")", ";", "Chain", "=", "CallSeqStart", "=" ]
LLVM
ARM
CPP
next_suggestion
CPU
47
[ "}" ]
[ "void", "addProcIFlagsOperands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{", "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "unsigned", "(", "getProcIFlags", "(", ")", ")", ")", ")", ";" ]
LLVM
Hexagon
TD
stmt_completion
DSP
48
[ "<NUM_LIT>", ";" ]
[ "def", "A2_addsp", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_679309b8", ",", "TypeALU64", ">", "{", "let", "isPseudo", "=" ]
GCC
mips
MD
next_suggestion
CPU
49
[ "<STR_LIT>" ]
[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V2HI", "[", "(", "match_operand", ":", "V4QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_PRECEU_PH_QBLA", ")", ")", "]" ]
LLVM
Hexagon
TD
next_suggestion
DSP
50
[ "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]
[ "def", "C2_muxii", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "s32_0Imm", ":", "$", "Ii", ",", "s8_0Imm", ":", "$", "II", ")", ",", "<STR_LIT>", ",", "tc_4c5ba658", ",", "TypeALU32_2op", ">", ",", "Enc_830e5d", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]
GCC
rs6000
MD
stmt_completion
CPU
51
[ ")" ]
[ "(", "define_predicate", "<STR_LIT>", "(", "and", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>" ]
LLVM
ARM
TD
next_suggestion
CPU
52
[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";" ]
[ "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]
LLVM
GBZ80
TD
next_suggestion
MPU
53
[ "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";" ]
[ "class", "GBZ80Inst", "<", "dag", "outs", ",", "dag", "ins", ",", "string", "asmstr", ">", ":", "Instruction", "{", "let", "Namespace", "=", "<STR_LIT>", ";" ]
GCC
aarch64
CPP
stmt_completion
CPU
54
[ ",", "_", "_", "c", ")", ";" ]
[ "return", "_", "_", "builtin_aarch64_simd_bslv16qi_uuuu", "(", "_", "_", "a", ",", "_", "_", "b" ]
LLVM
Hexagon
TD
stmt_completion
DSP
55
[ "=", "<NUM_LIT>", ";" ]
[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "LC1", ",", "SA1", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits" ]
LLVM
Mips
CPP
program_repair
CPU
56
[ "<FIXS>", "const", "GlobalValue", "*", "Val", "=", "G", "->", "getGlobal", "(", ")", ";", "InternalLinkage", "=", "Val", "->", "hasInternalLinkage", "(", ")", ";", "<FIXE>", "<FIXS>", "<STR_LIT>", "::", "<STR_LIT>", ",", "Chain", ",", "FuncInfo", "->", "callPtrInfo", "(", "Val", ")", ")", ";", "<FIXE>", "<FIXS>", "Callee", "=", "getAddrGlobal", "(", "G", ",", "Ty", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "Chain", ",", "FuncInfo", "->", "callPtrInfo", "(", "Val", ")", ")", ";", "<FIXE>", "<FIXS>", "Callee", "=", "DAG", ".", "getTargetExternalSymbol", "(", "Sym", ",", "getPointerTy", "(", ")", ",", "<FIXE>", "<FIXS>", "<STR_LIT>", "::", "<STR_LIT>", ",", "Chain", ",", "FuncInfo", "->", "callPtrInfo", "(", "Sym", ")", ")", ";", "<FIXE>", "<FIXS>", "Callee", "=", "getAddrGlobal", "(", "S", ",", "Ty", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "Chain", ",", "FuncInfo", "->", "callPtrInfo", "(", "Sym", ")", ")", ";", "<FIXE>" ]
[ "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "if", "(", "IsPICCall", ")", "{", "<BUGS>", "InternalLinkage", "=", "G", "->", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ";", "<BUGE>", "if", "(", "InternalLinkage", ")", "Callee", "=", "getAddrLocal", "(", "G", ",", "Ty", ",", "DAG", ",", "HasMips64", ")", ";", "else", "if", "(", "LargeGOT", ")", "Callee", "=", "getAddrGlobalLargeGOT", "(", "G", ",", "Ty", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<BUGS>", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<BUGE>", "else", "<BUGS>", "Callee", "=", "getAddrGlobal", "(", "G", ",", "Ty", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<BUGE>", "}", "elseCallee", "=", "DAG", ".", "getTargetGlobalAddress", "(", "G", "->", "getGlobal", "(", ")", ",", "DL", ",", "getPointerTy", "(", ")", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "GlobalOrExternal", "=", "true", ";", "}", "else", "if", "(", "ExternalSymbolSDNode", "*", "S", "=", "dyn_cast", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "{", "if", "(", "!", "IsN64", "&&", "!", "IsPIC", ")", "<BUGS>", "Callee", "=", "DAG", ".", "getTargetExternalSymbol", "(", "S", "->", "getSymbol", "(", ")", ",", "getPointerTy", "(", ")", ",", "<BUGE>", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "else", "if", "(", "LargeGOT", ")", "Callee", "=", "getAddrGlobalLargeGOT", "(", "S", ",", "Ty", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<BUGS>", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<BUGE>", "else", "<BUGS>", "Callee", "=", "getAddrGlobal", "(", "S", ",", "Ty", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<BUGE>", "GlobalOrExternal", "=", "true", ";", "}" ]
GCC
alpha
MD
stmt_completion
MPU
57
[ ")", "]" ]
[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec_volatile", ":", "DI", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPECV_SC", ")", ")", "(", "set", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]
GCC
i386
MD
stmt_completion
CPU
58
[ ")" ]
[ "(", "define_reservation", "<STR_LIT>", "<STR_LIT>" ]
LLVM
Hexagon
TD
next_suggestion
DSP
59
[ "bits", "<", "<NUM_LIT>", ">", "Rs32", ";" ]
[ "class", "Enc_a1e29d", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Ii", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "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>", "}", ";" ]
GCC
csky
CPP
code_generation
CPU
60
[ "static", "void", "push_csky_minipool_fix", "(", "rtx_insn", "*", "insn", ",", "HOST_WIDE_INT", "address", ",", "rtx", "*", "loc", ",", "machine_mode", "mode", ",", "rtx", "value", ")", "{", ":", "CSKY_LRW16_RANGE", ")", "(", "GET_MODE_SIZE", "(", "(", "mode", ")", ")", ">=", "<NUM_LIT>", "?", "GET_MODE_SIZE", "(", "(", "mode", ")", ")", ":", "<NUM_LIT>", ")", "Mfix", "*", "fix", "=", "(", "Mfix", "*", ")", "obstack_alloc", "(", "&", "minipool_obstack", ",", "sizeof", "(", "*", "fix", ")", ")", ";", "fix", "->", "insn", "=", "insn", ";", "fix", "->", "address", "=", "address", ";", "fix", "->", "loc", "=", "loc", ";", "fix", "->", "mode", "=", "mode", ";", "fix", "->", "fix_size", "=", "CSKY_MINIPOOL_FIX_SIZE", "(", "mode", ")", ";", "fix", "->", "value", "=", "value", ";", "fix", "->", "forwards", "=", "CSKY_CONSTANT_POOL_RANGE", ";", "fix", "->", "backwards", "=", "<NUM_LIT>", ";", "fix", "->", "minipool", "=", "NULL", ";", "gcc_assert", "(", "fix", "->", "forwards", "||", "fix", "->", "backwards", ")", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "<STR_LIT>", ";; %smode fixup for i%d; addr %lu, range (%ld,%ld): ", "<STR_LIT>", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "INSN_UID", "(", "insn", ")", ",", "(", "unsigned", "long", ")", "address", ",", "-", "<NUM_LIT>", "*", "(", "long", ")", "fix", "->", "backwards", ",", "(", "long", ")", "fix", "->", "forwards", ")", ";", "print_csky_value", "(", "dump_file", ",", "fix", "->", "value", ")", ";", "fprintf", "(", "dump_file", ",", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}", "fix", "->", "next", "=", "NULL", ";", "if", "(", "minipool_fix_head", "!=", "NULL", ")", "minipool_fix_tail", "->", "next", "=", "fix", ";", "else", "minipool_fix_head", "=", "fix", ";", "minipool_fix_tail", "=", "fix", ";", "}" ]
[ "Record", "INSN", ",", "which", "will", "need", "fixing", "up", "to", "load", "a", "value", "from", "the", "minipool", ".", "ADDRESS", "is", "the", "offset", "of", "the", "insn", "since", "the", "start", "of", "the", "function", ";", "LOC", "is", "a", "pointer", "to", "the", "part", "of", "the", "insn", "which", "requires", "fixing", ";", "VALUE", "is", "the", "constant", "that", "must", "be", "loaded", ",", "which", "is", "of", "type", "MODE", "." ]
LLVM
Hexagon
CPP
next_suggestion
DSP
61
[ "return", "PReg1", "==", "PReg2", "&&", "Hexagon", "::", "PredRegsRegClass", ".", "contains", "(", "PReg1", ")", "&&", "Hexagon", "::", "PredRegsRegClass", ".", "contains", "(", "PReg2", ")", "&&", "getPredicateSense", "(", "MI1", ",", "HII", ")", "!=", "getPredicateSense", "(", "MI2", ",", "HII", ")", "&&", "HII", "->", "isDotNewInst", "(", "MI1", ")", "==", "HII", "->", "isDotNewInst", "(", "MI2", ")", ";" ]
[ "bool", "HexagonPacketizerList", "::", "arePredicatesComplements", "(", "MachineInstr", "*", "MI1", ",", "MachineInstr", "*", "MI2", ")", "{", "if", "(", "getPredicateSense", "(", "MI1", ",", "HII", ")", "==", "PK_Unknown", "||", "getPredicateSense", "(", "MI2", ",", "HII", ")", "==", "PK_Unknown", ")", "return", "false", ";", "SUnit", "*", "SU", "=", "MIToSUnit", "[", "MI1", "]", ";", "for", "(", "auto", "I", ":", "CurrentPacketMIs", ")", "{", "SUnit", "*", "PacketSU", "=", "MIToSUnit", ".", "find", "(", "I", ")", "->", "second", ";", "if", "(", "PacketSU", "->", "isSucc", "(", "SU", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "PacketSU", "->", "Succs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "auto", "Dep", "=", "PacketSU", "->", "Succs", "[", "i", "]", ";", "if", "(", "Dep", ".", "getSUnit", "(", ")", "==", "SU", "&&", "Dep", ".", "getKind", "(", ")", "==", "SDep", "::", "Data", "&&", "Hexagon", "::", "PredRegsRegClass", ".", "contains", "(", "Dep", ".", "getReg", "(", ")", ")", ")", "{", "if", "(", "restrictingDepExistInPacket", "(", "I", ",", "Dep", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "}", "}", "}", "}", "unsigned", "PReg1", "=", "getPredicatedRegister", "(", "MI1", ",", "HII", ")", ";", "unsigned", "PReg2", "=", "getPredicatedRegister", "(", "MI2", ",", "HII", ")", ";" ]
LLVM
X86
TD
program_repair
CPU
62
[ "<FIXS>", "def", "_Fp32", ":", "FpIf32", "(", "outs", "RFP32", ":", "$", "dst", ")", ",", "(", "ins", "RFP32", ":", "$", "src1", ",", "RFP32", ":", "$", "src2", ")", ",", "CondMovFP", ",", "<FIXE>", "<FIXS>", "def", "_Fp64", ":", "FpIf64", "(", "outs", "RFP64", ":", "$", "dst", ")", ",", "(", "ins", "RFP64", ":", "$", "src1", ",", "RFP64", ":", "$", "src2", ")", ",", "CondMovFP", ",", "<FIXE>" ]
[ "multiclass", "FPCMov", "PatLeaf", "cc", ">", "{", "<BUGS>", "def", "_Fp32", ":", "FpI", "(", "outs", "RFP32", ":", "$", "dst", ")", ",", "(", "ins", "RFP32", ":", "$", "src1", ",", "RFP32", ":", "$", "src2", ")", ",", "CondMovFP", ",", "<BUGE>", "[", "(", "set", "RFP32", ":", "$", "dst", ",", "(", "X86cmov", "RFP32", ":", "$", "src1", ",", "RFP32", ":", "$", "src2", ",", "cc", ")", ")", "]", ">", ";", "<BUGS>", "def", "_Fp64", ":", "FpI", "(", "outs", "RFP64", ":", "$", "dst", ")", ",", "(", "ins", "RFP64", ":", "$", "src1", ",", "RFP64", ":", "$", "src2", ")", ",", "CondMovFP", ",", "<BUGE>", "[", "(", "set", "RFP64", ":", "$", "dst", ",", "(", "X86cmov", "RFP64", ":", "$", "src1", ",", "RFP64", ":", "$", "src2", ",", "cc", ")", ")", "]", ">", ";", "def", "_Fp80", ":", "FpI_", "(", "outs", "RFP80", ":", "$", "dst", ")", ",", "(", "ins", "RFP80", ":", "$", "src1", ",", "RFP80", ":", "$", "src2", ")", ",", "CondMovFP", "," ]
LLVM
AArch64
TD
stmt_completion
CPU
63
[ ")", "(", "v2i32", "(", "INSERT_SUBREG", "(", "v2i32", "(", "IMPLICIT_DEF", ")", ")", ",", "FPR32Op", ":", "$", "Rd", ",", "ssub", ")", ")", ",", "V64", ":", "$", "Rn", ",", "V128", ":", "$", "Rm", ",", "VectorIndexS", ":", "$", "idx", ")", ")", ",", "ssub", ")", ">", ";" ]
[ "def", ":", "Pat", "<", "(", "i32", "(", "Accum", "(", "i32", "FPR32Op", ":", "$", "Rd", ")", ",", "(", "i32", "(", "vector_extract", "(", "v4i32", "(", "insert_subvector", "(", "undef", ")", ",", "(", "v2i32", "(", "int_aarch64_neon_sqrdmulh", "(", "v2i32", "V64", ":", "$", "Rn", ")", ",", "(", "v2i32", "(", "AArch64duplane32", "(", "v4i32", "V128", ":", "$", "Rm", ")", ",", "VectorIndexS", ":", "$", "idx", ")", ")", ")", ")", ",", "(", "i64", "<NUM_LIT>", ")", ")", ")", ",", "(", "i64", "<NUM_LIT>", ")", ")", ")", ")", ")", ",", "(", "EXTRACT_SUBREG", "(", "v2i32", "(", "!", "cast", "<", "Instruction", ">", "(", "NAME", "#", "v2i32_indexed" ]
LLVM
ECLair
CPP
stmt_completion
MPU
64
[ ")", ";" ]
[ "const", "MCExpr", "*", "Val", "=", "getImm", "(", ")", ";", "return", "static_cast", "<", "const", "MCConstantExpr", "*", ">", "(", "Val", ")", "->", "getValue", "(" ]
LLVM
Hexagon
CPP
next_suggestion
DSP
65
[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " Add instruction ", "<STR_LIT>", "<<", "*", "MI", ")", ";" ]
[ "if", "(", "!", "MI", ")", "return", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "!", "MO", ".", "isImplicit", "(", ")", ")", "RegDefs", ".", "insert", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "TII", "->", "isZeroCost", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", ";", "if", "(", "!", "Resources", "->", "canReserveResources", "(", "*", "MI", ")", "||", "isNewStore", "(", "*", "MI", ")", ")", "{", "assert", "(", "TII", "->", "mayBeNewStore", "(", "*", "MI", ")", "&&", "<STR_LIT>", "Expecting .new store", "<STR_LIT>", ")", ";", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineInstr", "*", "NewMI", "=", "MF", "->", "CreateMachineInstr", "(", "TII", "->", "get", "(", "TII", "->", "getDotNewOp", "(", "*", "MI", ")", ")", ",", "MI", "->", "getDebugLoc", "(", ")", ")", ";", "if", "(", "Resources", "->", "canReserveResources", "(", "*", "NewMI", ")", ")", "Resources", "->", "reserveResources", "(", "*", "NewMI", ")", ";", "else", "Resources", "->", "reserveResources", "(", "*", "MI", ")", ";", "MF", "->", "delete", "MachineInstr", "(", "NewMI", ")", ";", "}", "else", "Resources", "->", "reserveResources", "(", "*", "MI", ")", ";" ]
GCC
bfin
CPP
stmt_completion
DSP
66
[ "+", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";" ]
[ "if", "(", "group", "==", "<NUM_LIT>", ")", "{", "if", "(", "D_REGNO_P", "(", "regno", ")", ")", "{", "group", "=", "<NUM_LIT>", ";", "first_dreg_to_save", "=", "lastdreg", "=", "regno", "-", "REG_R0", ";", "}", "else", "if", "(", "regno", ">=", "REG_P0", "&&", "regno", "<=", "REG_P7", ")", "{", "group", "=", "<NUM_LIT>", ";", "first_preg_to_save", "=", "lastpreg", "=", "regno", "-", "REG_P0", ";", "}", "else", "return", "<NUM_LIT>", ";", "continue", ";", "}", "if", "(", "group", "==", "<NUM_LIT>", ")", "{", "if", "(", "regno", ">=", "REG_P0", "&&", "regno", "<=", "REG_P7", ")", "{", "group", "=", "<NUM_LIT>", ";", "first_preg_to_save", "=", "lastpreg", "=", "regno", "-", "REG_P0", ";", "}", "else", "if", "(", "regno", "!=", "REG_R0", "+", "lastdreg" ]
GCC
xtensa
CPP
stmt_completion
MPU
67
[ ";" ]
[ "x", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "return", "(", "SYMBOL_REF_P", "(", "x", ")", "||", "CONST_INT_P", "(", "x", ")", ")", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ";", "}", "if", "(", "CONST_INT_P", "(", "x", ")", "&&", "!", "xtensa_simm12b", "(", "INTVAL", "(", "x", ")", ")", ")", "return", "true", ";", "return", "false" ]
LLVM
X86
CPP
next_suggestion
CPU
68
[ "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ValVT", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "isImmutable", ")", ";" ]
[ "SDValue", "X86TargetLowering", "::", "LowerMemArgument", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "const", "CCValAssign", "&", "VA", ",", "MachineFrameInfo", "*", "MFI", ",", "unsigned", "i", ")", "const", "{", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Ins", "[", "i", "]", ".", "Flags", ";", "bool", "AlwaysUseMutable", "=", "FuncIsMadeTailCallSafe", "(", "CallConv", ")", ";", "bool", "isImmutable", "=", "!", "AlwaysUseMutable", "&&", "!", "Flags", ".", "isByVal", "(", ")", ";", "EVT", "ValVT", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "Indirect", ")", "ValVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "else", "ValVT", "=", "VA", ".", "getValVT", "(", ")", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "Flags", ".", "getByValSize", "(", ")", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "isImmutable", ")", ";", "return", "DAG", ".", "getFrameIndex", "(", "FI", ",", "getPointerTy", "(", ")", ")", ";", "}", "else", "{" ]
LLVM
X86
CPP
next_suggestion
CPU
69
[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Small", ",", "Overflow", ",", "Small", ")", ";" ]
[ "static", "SDValue", "expandFP_TO_UINT_SSE", "(", "MVT", "VT", ",", "SDValue", "Src", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "const", "X86Subtarget", "&", "Subtarget", ")", "{", "MVT", "SrcVT", "=", "Src", ".", "getSimpleValueType", "(", ")", ";", "unsigned", "DstBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "assert", "(", "DstBits", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "expandFP_TO_UINT_SSE - only vXi32 supported", "<STR_LIT>", ")", ";", "SDValue", "Small", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Src", ")", ";", "SDValue", "Big", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "FSUB", ",", "dl", ",", "SrcVT", ",", "Src", ",", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", ",", "dl", ",", "SrcVT", ")", ")", ")", ";", "if", "(", "VT", "==", "MVT", "::", "v8i32", "&&", "!", "Subtarget", ".", "hasAVX2", "(", ")", ")", "{", "SDValue", "Overflow", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "dl", ",", "VT", ",", "Small", ",", "Big", ")", ";" ]
LLVM
Hexagon
TD
next_suggestion
DSP
70
[ "let", "InputType", "=", "<STR_LIT>", ";" ]
[ "def", "A4_cmphgt", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_85d5d03f", ",", "TypeS_3op", ">", ",", "Enc_c2b48e", ",", "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>", ";" ]
LLVM
Hexagon
TD
next_suggestion
DSP
71
[ "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]
[ "def", "A2_svsubhs", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rt32", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_61830035", ",", "TypeALU32_3op", ">", ",", "Enc_bd6011", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";" ]
LLVM
X86
CPP
next_suggestion
CPU
72
[ "}" ]
[ "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "VecVT", ",", "N0", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "Res", ")", ";", "Res", "=", "DAG", ".", "getZExtOrTrunc", "(", "Res", ",", "dl", ",", "VT", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "VT", ",", "Res", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ")", ";", "return", "Res", ";" ]
LLVM
AMDGPU
CPP
next_suggestion
GPU
73
[ "}" ]
[ "return", "&", "(", "*", "(", "--", "(", "Region", "->", "getEntry", "(", ")", "->", "getParent", "(", ")", "->", "end", "(", ")", ")", ")", ")", ";", "}", "MachineBasicBlock", "*", "LastMerge", "=", "MF", "->", "CreateMachineBasicBlock", "(", ")", ";", "if", "(", "Exit", "==", "nullptr", ")", "{", "MachineFunction", "::", "iterator", "ExitIter", "=", "MF", "->", "end", "(", ")", ";", "MF", "->", "insert", "(", "ExitIter", ",", "LastMerge", ")", ";", "}", "else", "{", "MachineFunction", "::", "iterator", "ExitIter", "=", "Exit", "->", "getIterator", "(", ")", ";", "MF", "->", "insert", "(", "ExitIter", ",", "LastMerge", ")", ";", "LastMerge", "->", "addSuccessor", "(", "Exit", ")", ";", "insertUnconditionalBranch", "(", "LastMerge", ",", "Exit", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Created exit block: ", "<STR_LIT>", "<<", "LastMerge", "->", "getNumber", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";" ]
GCC
arm
MD
next_suggestion
CPU
74
[ "<STR_LIT>", ")" ]
[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")" ]
GCC
h8300
MD
stmt_completion
MPU
75
[ "<STR_LIT>", ")", ")" ]
[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "HI", "(", "zero_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>" ]
GCC
frv
MD
next_suggestion
VLIW
76
[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]
[ "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_MPACKH", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]
GCC
rs6000
MD
stmt_completion
CPU
77
[ "<STR_LIT>", "<STR_LIT>", ")" ]
[ "(", "define_cpu_unit", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_cpu_unit" ]
GCC
aarch64
MD
stmt_completion
CPU
78
[ "]", ")" ]
[ "(", "define_code_iterator", "ANY_EXTEND", "[", "sign_extend", "zero_extend", "]", ")", "(", "define_code_iterator", "ANY_EXTEND2", "[", "sign_extend", "zero_extend" ]
LLVM
SystemZ
TD
stmt_completion
CPU
79
[ "CCValues", ";" ]
[ "bits", "<", "<NUM_LIT>", ">", "CompareZeroCCMask", "=", "<NUM_LIT>", ";", "bit", "CCMaskFirst", "=", "<NUM_LIT>", ";", "bit", "CCMaskLast", "=", "<NUM_LIT>", ";", "bit", "IsLogical", "=", "<NUM_LIT>", ";", "bit", "CCIfNoSignedWrap", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "SimpleBDXLoad", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "SimpleBDXStore", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "Has20BitOffset", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "HasIndex", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "Is128Bit", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "AccessBytes", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]
LLVM
PowerPC
CPP
code_generation
CPU
80
[ "void", "PPCRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected", "<STR_LIT>", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "OffsetOperandNo", "=", "getOffsetONFromFION", "(", "MI", ",", "FIOperandNum", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "int", "FPSI", "=", "FI", "->", "getFramePointerSaveIndex", "(", ")", ";", "unsigned", "OpC", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "FPSI", "&&", "FrameIndex", "==", "FPSI", "&&", "(", "OpC", "==", "PPC", "::", "DYNALLOC", "||", "OpC", "==", "PPC", "::", "DYNALLOC8", ")", ")", "{", "lowerDynamicAlloc", "(", "II", ")", ";", "return", ";", "}", "if", "(", "OpC", "==", "PPC", "::", "SPILL_CR", ")", "{", "lowerCRSpilling", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "RESTORE_CR", ")", "{", "lowerCRRestore", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "SPILL_CRBIT", ")", "{", "lowerCRBitSpilling", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "RESTORE_CRBIT", ")", "{", "lowerCRBitRestore", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "SPILL_VRSAVE", ")", "{", "lowerVRSAVESpilling", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "RESTORE_VRSAVE", ")", "{", "lowerVRSAVERestore", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameIndex", "<", "<NUM_LIT>", "?", "getBaseRegister", "(", "MF", ")", ":", "getFrameRegister", "(", "MF", ")", ",", "false", ")", ";", "bool", "isIXAddr", "=", "usesIXAddr", "(", "MI", ")", ";", "bool", "noImmForm", "=", "!", "MI", ".", "isInlineAsm", "(", ")", "&&", "!", "ImmToIdxMap", ".", "count", "(", "OpC", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "Naked", ")", ")", "{", "if", "(", "!", "(", "hasBasePointer", "(", "MF", ")", "&&", "FrameIndex", "<", "<NUM_LIT>", ")", ")", "Offset", "+=", "MFI", "->", "getStackSize", "(", ")", ";", "}", "assert", "(", "OpC", "!=", "PPC", "::", "DBG_VALUE", "&&", "<STR_LIT>", "This should be handle in a target independent way", "<STR_LIT>", ")", ";", "if", "(", "!", "noImmForm", "&&", "isInt", "<", "<NUM_LIT>", ">", "(", "Offset", ")", "&&", "(", "!", "isIXAddr", "||", "(", "Offset", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", ")", "{", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "bool", "is64Bit", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "const", "TargetRegisterClass", "*", "G8RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC", "::", "GPRCRegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "is64Bit", "?", "G8RC", ":", "GPRC", ";", "unsigned", "SRegHi", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ",", "SReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "is64Bit", "?", "PPC", "::", "LIS8", ":", "PPC", "::", "LIS", ")", ",", "SRegHi", ")", ".", "addImm", "(", "Offset", ">>", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "is64Bit", "?", "PPC", "::", "ORI8", ":", "PPC", "::", "ORI", ")", ",", "SReg", ")", ".", "addReg", "(", "SRegHi", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Offset", ")", ";", "unsigned", "OperandBase", ";", "if", "(", "noImmForm", ")", "OperandBase", "=", "<NUM_LIT>", ";", "else", "if", "(", "OpC", "!=", "TargetOpcode", "::", "INLINEASM", ")", "{", "assert", "(", "ImmToIdxMap", ".", "count", "(", "OpC", ")", "&&", "<STR_LIT>", "No indexed form of load or store available!", "<STR_LIT>", ")", ";", "unsigned", "NewOpcode", "=", "ImmToIdxMap", ".", "find", "(", "OpC", ")", "->", "second", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "NewOpcode", ")", ")", ";", "OperandBase", "=", "<NUM_LIT>", ";", "}", "else", "{", "OperandBase", "=", "OffsetOperandNo", ";", "}", "unsigned", "StackReg", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getReg", "(", ")", ";", "MI", ".", "getOperand", "(", "OperandBase", ")", ".", "ChangeToRegister", "(", "StackReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "OperandBase", "+", "<NUM_LIT>", ")", ".", "ChangeToRegister", "(", "SReg", ",", "false", ",", "false", ",", "true", ")", ";", "}" ]
[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]
LLVM
PowerPC
CPP
next_suggestion
CPU
81
[ "++", "Result", ";" ]
[ "unsigned", "Shift", "=", "<NUM_LIT>", ";", "if", "(", "!", "isInt", "<", "<NUM_LIT>", ">", "(", "Imm", ")", ")", "{", "Shift", "=", "countTrailingZeros", "<", "uint64_t", ">", "(", "Imm", ")", ";", "int64_t", "ImmSh", "=", "static_cast", "<", "uint64_t", ">", "(", "Imm", ")", ">>", "Shift", ";", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "ImmSh", ")", ")", "{", "Imm", "=", "ImmSh", ";", "}", "else", "{", "Remainder", "=", "Imm", ";", "Shift", "=", "<NUM_LIT>", ";", "Imm", ">>=", "<NUM_LIT>", ";", "}", "}", "unsigned", "Result", "=", "<NUM_LIT>", ";", "unsigned", "Lo", "=", "Imm", "&", "<NUM_LIT>", ";", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "Imm", ")", ")", "{" ]
GCC
i386
CPP
stmt_completion
CPU
82
[ ";" ]
[ "bool", "ix86_function_value_regno_p", "(", "int", "regno", ")", "{", "if", "(", "regno", "==", "<NUM_LIT>", "||", "(", "regno", "==", "FIRST_FLOAT_REG", "&&", "TARGET_FLOAT_RETURNS_IN_80387", ")", "||", "(", "regno", "==", "FIRST_SSE_REG", "&&", "TARGET_SSE", ")", ")", "return", "true", ";", "if", "(", "!", "TARGET_64BIT", "&&", "(", "regno", "==", "FIRST_MMX_REG", "&&", "TARGET_MMX", ")", ")", "return", "true", ";", "return", "false" ]
LLVM
Hexagon
TD
next_suggestion
DSP
83
[ "bits", "<", "<NUM_LIT>", ">", "Rx32", ";" ]
[ "class", "Enc_d15d19", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Mu2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Mu2", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Vs32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Vs32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]
LLVM
Hexagon
TD
next_suggestion
DSP
84
[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]
[ "def", "C2_or", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pt4", ",", "PredRegs", ":", "$", "Ps4", ")", ",", "<STR_LIT>", ",", "tc_640086b5", ",", "TypeCR", ">", ",", "Enc_454a26", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]
LLVM
Lanai
CPP
next_suggestion
CPU
85
[ "}" ]
[ "}", "void", "Lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", ";", "MCOperand", "LowerSymbolOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCSymbol", "*", "Sym", ")", "const", ";", "MCSymbol", "*", "GetGlobalAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", ";", "MCSymbol", "*", "GetBlockAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", ";", "MCSymbol", "*", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", ";", "MCSymbol", "*", "GetJumpTableSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", ";", "MCSymbol", "*", "GetConstantPoolIndexSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", ";" ]
LLVM
X86
CPP
next_suggestion
CPU
86
[ "OpcodeSelect", "=", "<STR_LIT>", "::", "<STR_LIT>", ";" ]
[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "VT", ",", "Op", ",", "VMask", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "dl", ",", "VT", ",", "Op", ",", "VMask", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]
GCC
i386
CPP
code_generation
CPU
87
[ "bool", "symbolic_reference_mentioned_p", "(", "rtx", "op", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ")", "return", "true", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "op", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "op", ")", ")", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'", "E", "'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "op", ",", "i", ")", "-", "<NUM_LIT>", ";", "j", ">=", "<NUM_LIT>", ";", "j", "--", ")", "if", "(", "symbolic_reference_mentioned_p", "(", "XVECEXP", "(", "op", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'", "e", "'", "&&", "symbolic_reference_mentioned_p", "(", "XEXP", "(", "op", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}" ]
[ "Return", "true", "if", "OP", "contains", "a", "symbol", "reference" ]
GCC
rs6000
CPP
stmt_completion
CPU
88
[ "rtx", "*", "str_mem", ")", "{" ]
[ "static", "bool", "is_store_insn", "(", "rtx", "insn", "," ]
LLVM
AMDGPU
CPP
next_suggestion
GPU
89
[ "return", "false", ";" ]
[ "Id", "=", "toFuncId", "(", "Loc", "->", "second", ")", ";", "return", "true", ";", "}", "Id", "=", "AMDGPULibFunc", "::", "EI_NONE", ";" ]
LLVM
Hexagon
TD
next_suggestion
DSP
90
[ "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]
[ "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";" ]
LLVM
R600
CPP
next_suggestion
GPU
91
[ "}" ]
[ "bool", "programSpillsRegisters", "(", ")", "{", "return", "!", "SpilledRegisters", ".", "empty", "(", ")", ";" ]
LLVM
AArch64
TD
stmt_completion
CPU
92
[ "<NUM_LIT>", ";" ]
[ "def", "Xrs", ":", "BaseAddSubSReg", "<", "isSub", ",", "<NUM_LIT>", ",", "GPR64", ",", "arith_shifted_reg64", ",", "mnemonic", ",", "OpNode", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=" ]
LLVM
ARM
TD
stmt_completion
CPU
93
[ ";" ]
[ "def", "VecListThreeDByteIndexAsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "let", "ParserMethod", "=", "<STR_LIT>" ]
LLVM
AArch64
TD
next_suggestion
CPU
94
[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";" ]
[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]
LLVM
Hexagon
TD
next_suggestion
DSP
95
[ "let", "cofRelax1", "=", "<NUM_LIT>", ";" ]
[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicateLate", "=", "<NUM_LIT>", ";" ]
LLVM
AMDGPU
CPP
next_suggestion
GPU
96
[ "break", ";" ]
[ "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "SkipThreshold", "=", "SkipThresholdFlag", ";", "MachineBasicBlock", "*", "EmptyMBBAtEnd", "=", "nullptr", ";", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "KillInstrs", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_MASK_BRANCH", ":", "MadeChange", "|=", "skipMaskBranch", "(", "MI", ",", "MBB", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_BRANCH", ":", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ")", ")", "{", "assert", "(", "&", "MI", "==", "&", "MBB", ".", "back", "(", ")", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "MadeChange", "=", "true", ";", "}" ]
GCC
arm
MD
stmt_completion
CPU
97
[ "<", "V_mode_nunits", ">", "/", "<NUM_LIT>", ")", "+", "i", ")" ]
[ "for", "(", "i", "=", "<NUM_LIT>", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "GEN_INT", "(", "(" ]
GCC
i386
CPP
stmt_completion
CPU
98
[ "_", "_", "i0", ",", "_", "_", "i1", ")", ";" ]
[ "return", "(", "_", "_", "m64", ")", "_", "_", "builtin_ia32_vec_init_v2si", "(" ]
GCC
i386
CPP
stmt_completion
CPU
99
[ "_", "_", "LY", ",", "const", "int", "_", "_", "M", ")", "{" ]
[ "extern", "_", "_", "inline", "int", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cmpestrc", "(", "_", "_", "m128i", "_", "_", "X", ",", "int", "_", "_", "LX", ",", "_", "_", "m128i", "_", "_", "Y", ",", "int" ]

ComBack++: A Multi-Language Dataset Providing End-to-End Support for Compiler Backend Development

ComBack++ is a large-scale, multi-platform and multi-language compiler backend code dataset. It is sourced from GCC and LLVM backends corresponding to 183 target platforms.

Dataset Information

  • Source Data

    • GCC
    Category Target Platform C++ Function C++ KLoC Machine Description KLoC
    CPU 30 56,211 858.2 228.5
    MPU 35 8,713 243.8 87.1
    GPU 2 731 12.7 3.0
    VLIW 5 1,323 32.8 17.8
    DSP 4 542 17.2 6.1
    Virtual 5 558 10.5 0.1
    SUM 81 68,078 1175.2 342.6
    • LLVM
    Category Target Platform C++ Function C++ KLoC TableGen KLoC
    CPU 43 97,972 3,768.4 1,157.7
    MPU 30 12,552 190.7 24.8
    GPU 5 28,267 886.8 168.5
    VLIW 5 2,386 27.4 0.8
    DSP 7 11,584 296.8 129.4
    Virtual 12 10,538 199.4 12.9
    SUM 102 163,299 5,369.5 1,494.1
  • Tasks

    • Statement-Level Completion: complete current statement.
    //Inputs:
    ...
    adjustReg(MBB,LastFrameDestroy, DL, SPReg, FPReg, -StackSize+RVFI->getVarArgsSaveSize() 
    //Ground Truth:
    MachineInstr::FrameDestroy);
    
    • Next-Statement Suggestion: predict the next statement.
    //Inputs:
    ...
    maxCallFrameSize = (maxCallFrameSize + AlignMask) & ~AlignMask;
    //Ground Truth:
    MFI -> setMaxCallFrameSize(maxCallFrameSize);
    
    • Code Generation: generate a function template with function description in natrual language.
    //Inputs:
    getPointerRegClass: Returns a TargetRegisterClass used for pointer values.
    //Ground Truth:
    TargetRegisterClass *RegisterInfo::getPointerRegClass(MachineFunction &MF ,unsigned Kind) {
       return Subtarget.is64Bit() ? <ISA_LIT> : <ISA_LIT>;
    }
    
    • Program Repair: automatically fixing bugs at identified locations.
    //Inputs:
    int64_t Imm; <BUGS> MCExpr::VariantKind VK; <BUGE> ...
    //Ground Truth:
    <FIXS> MCExpr::VariantKind VK = MCExpr::VK_None; <FIXE>
    

Organization

  • ./*.jsonl: Take data of RISC-V,ARC,NVPTX both in GCC and LLVM as test set, split train/valid set in the ratio of 90%:10% of other targets excluding RI5CY(RI5CY is custmoized based on RISCV)

    Task Programming Language Train Valid Test
    Statement-Level Completion C++ 149,368 (16.41M) 16,480 (1.84M) 7,897 (0.82M)
    Statement-Level Completion TableGen/MD 120,460 (4.46M) 13,295 (0.50M) 7,090 (0.25M)
    Next-Statement Suggestion C++ 137,155 (20.55M) 15,218 (2.32M) 8,109 (1.09M)
    Next-Statement Suggestion TableGen/MD 124,528 (6.71M) 14,009 (0.76M) 2,726 (0.14M)
    Code Generation C++ 37,805 (10.69M) 4,137 (1.16M) 2,944 (0.73M)
    Program Repair C++ 40,578 (4.33M) 4,539 (0.48M) 2,623 (0.29M)
    Program Repair TableGen/MD 25,983 (2.95M) 2,975 (0.33M) 1,814 (0.24M)
Downloads last month
4