Compiler_Type
stringclasses 2
values | Target
stringclasses 176
values | Programming Language
stringclasses 3
values | Task
stringclasses 4
values | Target_Type
stringclasses 7
values | Idx
int64 0
636k
| Ground_Truth
listlengths 0
2.32k
| Input
listlengths 1
1.02k
|
---|---|---|---|---|---|---|---|
GCC | c4x | MD | next_suggestion | DSP | 3,600 | [
"(",
"clobber",
"(",
"reg",
":",
"CC_NOOV",
"<NUM_LIT>",
")",
")",
"]",
")"
] | [
"(",
"clobber",
"(",
"reg",
":",
"CC_NOOV",
"<NUM_LIT>",
")",
")",
"]",
")",
"(",
"parallel",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"mult",
":",
"HF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"CC_NOOV",
"<NUM_LIT>",
")",
")",
"]",
")",
"(",
"parallel",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"mult",
":",
"HF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"CC_NOOV",
"<NUM_LIT>",
")",
")",
"]",
")",
"(",
"parallel",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"mult",
":",
"HF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"CC_NOOV",
"<NUM_LIT>",
")",
")",
"]",
")",
"(",
"parallel",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"minus",
":",
"HF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"CC_NOOV",
"<NUM_LIT>",
")",
")",
"]",
")",
"(",
"parallel",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"mult",
":",
"HF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")"
] |
GCC | spu | CPP | stmt_completion | MPU | 3,601 | [
")",
")",
";"
] | [
"a0123",
"=",
"spu_add",
"(",
"spu_rlmaska",
"(",
"(",
"vec_int4",
")",
"(",
"a",
")",
",",
"-",
"<NUM_LIT>",
")",
",",
"spu_extend",
"(",
"a",
")",
")",
";",
"return",
"(",
"vec_adds",
"(",
"a0123",
",",
"b"
] |
LLVM | TPC | TD | next_suggestion | Virtual ISA | 3,602 | [
"let",
"PredPolarity",
"=",
"pred",
"{",
"<NUM_LIT>",
"}",
";"
] | [
"let",
"Itinerary",
"=",
"IIC_ScalarOp",
";",
"let",
"isReMaterializable",
"=",
"<NUM_LIT>",
";",
"let",
"isAsCheapAsAMove",
"=",
"<NUM_LIT>",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"dest",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"src",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"optype",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"sw",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"pred",
";",
"let",
"Dest",
"=",
"dest",
";",
"let",
"SrcA",
"=",
"src",
";",
"let",
"OperandType",
"=",
"optype",
";",
"let",
"Switches",
"=",
"sw",
";",
"let",
"PredAddress",
"=",
"pred",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] |
GCC | sparc | CPP | next_suggestion | CPU | 3,603 | [
"}"
] | [
"emit_barrier",
"(",
")",
";",
"emit_label",
"(",
"neglab",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"f0",
",",
"gen_rtx_MINUS",
"(",
"mode",
",",
"in",
",",
"limit",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"i0",
",",
"gen_rtx_FIX",
"(",
"DImode",
",",
"gen_rtx_FIX",
"(",
"mode",
",",
"f0",
")",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_movdi",
"(",
"i1",
",",
"const1_rtx",
")",
")",
";",
"emit_insn",
"(",
"gen_ashldi3",
"(",
"i1",
",",
"i1",
",",
"GEN_INT",
"(",
"<NUM_LIT>",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_xordi3",
"(",
"out",
",",
"i0",
",",
"i1",
")",
")",
";",
"emit_label",
"(",
"donelab",
")",
";"
] |
LLVM | MSP430 | CPP | stmt_completion | MPU | 3,604 | [
".",
"addReg",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
".",
"addMBB",
"(",
"thisMBB",
")",
";"
] | [
"BuildMI",
"(",
"BB",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
".",
"addMBB",
"(",
"copy1MBB",
")",
".",
"addImm",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
")",
";",
"F",
"->",
"insert",
"(",
"I",
",",
"copy0MBB",
")",
";",
"F",
"->",
"insert",
"(",
"I",
",",
"copy1MBB",
")",
";",
"for",
"(",
"MachineBasicBlock",
"::",
"succ_iterator",
"SI",
"=",
"BB",
"->",
"succ_begin",
"(",
")",
",",
"SE",
"=",
"BB",
"->",
"succ_end",
"(",
")",
";",
"SI",
"!=",
"SE",
";",
"++",
"SI",
")",
"EM",
"->",
"insert",
"(",
"std",
"::",
"make_pair",
"(",
"*",
"SI",
",",
"copy1MBB",
")",
")",
";",
"copy1MBB",
"->",
"transferSuccessors",
"(",
"BB",
")",
";",
"BB",
"->",
"addSuccessor",
"(",
"copy0MBB",
")",
";",
"BB",
"->",
"addSuccessor",
"(",
"copy1MBB",
")",
";",
"BB",
"=",
"copy0MBB",
";",
"BB",
"->",
"addSuccessor",
"(",
"copy1MBB",
")",
";",
"BB",
"=",
"copy1MBB",
";",
"BuildMI",
"(",
"BB",
",",
"dl",
",",
"TII",
".",
"get",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
",",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
".",
"addReg",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
".",
"addMBB",
"(",
"copy0MBB",
")"
] |
GCC | aarch64 | CPP | stmt_completion | CPU | 3,605 | [
"<NUM_LIT>",
";"
] | [
"this",
"->",
"m_insn_fma_head_map",
"=",
"new",
"hash_map",
"<",
"rtx_insn",
"*",
",",
"fma_node",
"*",
">",
";",
"this",
"->",
"m_fma_forests",
".",
"clear",
"(",
")",
";",
"this",
"->",
"m_next_forest_id",
"="
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 3,606 | [
"const",
"SUnit",
"*",
"TryCandNextClusterSU",
"=",
"TryCand",
".",
"AtTop",
"?",
"DAG",
"->",
"getNextClusterSucc",
"(",
")",
":",
"DAG",
"->",
"getNextClusterPred",
"(",
")",
";"
] | [
"TryCand",
".",
"initResourceDelta",
"(",
"DAG",
",",
"SchedModel",
")",
";",
"if",
"(",
"tryLess",
"(",
"TryCand",
".",
"ResDelta",
".",
"CritResources",
",",
"Cand",
".",
"ResDelta",
".",
"CritResources",
",",
"TryCand",
",",
"Cand",
",",
"ResourceReduce",
")",
")",
"return",
"TryCand",
".",
"Reason",
"!=",
"NoCand",
";",
"if",
"(",
"tryGreater",
"(",
"TryCand",
".",
"ResDelta",
".",
"DemandedResources",
",",
"Cand",
".",
"ResDelta",
".",
"DemandedResources",
",",
"TryCand",
",",
"Cand",
",",
"ResourceDemand",
")",
")",
"return",
"TryCand",
".",
"Reason",
"!=",
"NoCand",
";",
"if",
"(",
"tryLatency",
"(",
"TryCand",
",",
"Cand",
",",
"*",
"Zone",
")",
")",
"return",
"TryCand",
".",
"Reason",
"!=",
"NoCand",
";",
"if",
"(",
"tryLess",
"(",
"getWeakLeft",
"(",
"TryCand",
".",
"SU",
",",
"TryCand",
".",
"AtTop",
")",
",",
"getWeakLeft",
"(",
"Cand",
".",
"SU",
",",
"Cand",
".",
"AtTop",
")",
",",
"TryCand",
",",
"Cand",
",",
"Weak",
")",
")",
"return",
"TryCand",
".",
"Reason",
"!=",
"NoCand",
";",
"}",
"const",
"SUnit",
"*",
"CandNextClusterSU",
"=",
"Cand",
".",
"AtTop",
"?",
"DAG",
"->",
"getNextClusterSucc",
"(",
")",
":",
"DAG",
"->",
"getNextClusterPred",
"(",
")",
";"
] |
LLVM | SystemZ | CPP | next_suggestion | CPU | 3,607 | [
"EmitToStreamer",
"(",
"*",
"OutStreamer",
",",
"MCInstBuilder",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
".",
"addReg",
"(",
"ScratchReg",
")",
".",
"addImm",
"(",
"CallTarget",
"&",
"<NUM_LIT>",
")",
")",
";"
] | [
"void",
"SystemZAsmPrinter",
"::",
"LowerPATCHPOINT",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"SystemZMCInstLower",
"&",
"Lower",
")",
"{",
"auto",
"&",
"Ctx",
"=",
"OutStreamer",
"->",
"getContext",
"(",
")",
";",
"MCSymbol",
"*",
"MILabel",
"=",
"Ctx",
".",
"createTempSymbol",
"(",
")",
";",
"OutStreamer",
"->",
"emitLabel",
"(",
"MILabel",
")",
";",
"SM",
".",
"recordPatchPoint",
"(",
"*",
"MILabel",
",",
"MI",
")",
";",
"PatchPointOpers",
"Opers",
"(",
"&",
"MI",
")",
";",
"unsigned",
"EncodedBytes",
"=",
"<NUM_LIT>",
";",
"const",
"MachineOperand",
"&",
"CalleeMO",
"=",
"Opers",
".",
"getCallTarget",
"(",
")",
";",
"if",
"(",
"CalleeMO",
".",
"isImm",
"(",
")",
")",
"{",
"uint64_t",
"CallTarget",
"=",
"CalleeMO",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"CallTarget",
")",
"{",
"unsigned",
"ScratchIdx",
"=",
"-",
"<NUM_LIT>",
";",
"unsigned",
"ScratchReg",
"=",
"<NUM_LIT>",
";",
"do",
"{",
"ScratchIdx",
"=",
"Opers",
".",
"getNextScratchIdx",
"(",
"ScratchIdx",
"+",
"<NUM_LIT>",
")",
";",
"ScratchReg",
"=",
"MI",
".",
"getOperand",
"(",
"ScratchIdx",
")",
".",
"getReg",
"(",
")",
";",
"}",
"while",
"(",
"ScratchReg",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";"
] |
LLVM | PowerPC | CPP | stmt_completion | CPU | 3,608 | [
")",
";"
] | [
"const",
"Triple",
"&",
"TheTriple",
"=",
"STI",
".",
"getTargetTriple",
"(",
")",
";",
"IsPPC64",
"=",
"(",
"TheTriple",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"ppc64",
"||",
"TheTriple",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"ppc64le",
")",
";",
"IsDarwin",
"=",
"TheTriple",
".",
"isMacOSX",
"(",
")",
";",
"setAvailableFeatures",
"(",
"ComputeAvailableFeatures",
"(",
"STI",
".",
"getFeatureBits",
"(",
")",
")"
] |
LLVM | Mips | CPP | next_suggestion | CPU | 3,609 | [
"}"
] | [
"if",
"(",
"UserOffset",
"<=",
"TrialOffset",
")",
"{",
"if",
"(",
"TrialOffset",
"-",
"UserOffset",
"<=",
"MaxDisp",
")",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"NegativeOK",
")",
"{",
"if",
"(",
"UserOffset",
"-",
"TrialOffset",
"<=",
"MaxDisp",
")",
"return",
"true",
";",
"}",
"return",
"false",
";"
] |
LLVM | Mips | CPP | next_suggestion | CPU | 3,610 | [
"return",
"MCDisassembler",
"::",
"Success",
";"
] | [
"int32_t",
"BranchOffset",
"=",
"SignExtend32",
"<",
"<NUM_LIT>",
">",
"(",
"Offset",
")",
"<<",
"<NUM_LIT>",
";",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"BranchOffset",
")",
")",
";"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 3,611 | [
"case",
"AMDGPU",
"::",
"SI_SPILL_V64_SAVE",
":"
] | [
"case",
"AMDGPU",
"::",
"SI_SPILL_A512_RESTORE",
":",
"return",
"<NUM_LIT>",
";",
"case",
"AMDGPU",
"::",
"SI_SPILL_S256_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_S256_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_V256_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_V256_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_A256_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_A256_RESTORE",
":",
"return",
"<NUM_LIT>",
";",
"case",
"AMDGPU",
"::",
"SI_SPILL_S224_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_S224_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_V224_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_V224_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_A224_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_A224_RESTORE",
":",
"return",
"<NUM_LIT>",
";",
"case",
"AMDGPU",
"::",
"SI_SPILL_S192_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_S192_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_V192_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_V192_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_A192_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_A192_RESTORE",
":",
"return",
"<NUM_LIT>",
";",
"case",
"AMDGPU",
"::",
"SI_SPILL_S160_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_S160_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_V160_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_V160_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_A160_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_A160_RESTORE",
":",
"return",
"<NUM_LIT>",
";",
"case",
"AMDGPU",
"::",
"SI_SPILL_S128_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_S128_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_V128_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_V128_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_A128_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_A128_RESTORE",
":",
"return",
"<NUM_LIT>",
";",
"case",
"AMDGPU",
"::",
"SI_SPILL_S96_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_S96_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_V96_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_V96_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_A96_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_A96_RESTORE",
":",
"return",
"<NUM_LIT>",
";",
"case",
"AMDGPU",
"::",
"SI_SPILL_S64_SAVE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_S64_RESTORE",
":"
] |
LLVM | PowerPC | TD | next_suggestion | CPU | 3,612 | [
"let",
"ParserMatchClass",
"=",
"PPCCRBitMaskOperand",
";"
] | [
"let",
"EncoderMethod",
"=",
"<STR_LIT>",
";",
"let",
"DecoderMethod",
"=",
"<STR_LIT>",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 3,613 | [
"let",
"opExtentAlign",
"=",
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isTerminator",
"=",
"<NUM_LIT>",
";",
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"isRestrictNoSlot1Store",
"=",
"<NUM_LIT>",
";",
"let",
"Defs",
"=",
"[",
"PC",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 3,614 | [
"false",
";"
] | [
"}",
"if",
"(",
"isTargetShuffleEquivalent",
"(",
"MaskVT",
",",
"Mask",
",",
"{",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"}",
")",
"&&",
"(",
"AllowFloatDomain",
"||",
"!",
"Subtarget",
".",
"hasSSE41",
"(",
")",
")",
")",
"{",
"Shuffle",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"SrcVT",
"=",
"DstVT",
"=",
"MVT",
"::",
"v4f32",
";",
"return",
"true",
";",
"}",
"}",
"if",
"(",
"(",
"(",
"MaskVT",
"==",
"MVT",
"::",
"v8i16",
"||",
"MaskVT",
"==",
"MVT",
"::",
"v16i8",
")",
"&&",
"Subtarget",
".",
"hasSSE2",
"(",
")",
")",
"||",
"(",
"(",
"MaskVT",
"==",
"MVT",
"::",
"v16i16",
"||",
"MaskVT",
"==",
"MVT",
"::",
"v32i8",
")",
"&&",
"Subtarget",
".",
"hasInt256",
"(",
")",
")",
"||",
"(",
"(",
"MaskVT",
"==",
"MVT",
"::",
"v32i16",
"||",
"MaskVT",
"==",
"MVT",
"::",
"v64i8",
")",
"&&",
"Subtarget",
".",
"hasBWI",
"(",
")",
")",
")",
"{",
"if",
"(",
"matchShuffleWithPACK",
"(",
"MaskVT",
",",
"SrcVT",
",",
"V1",
",",
"V2",
",",
"Shuffle",
",",
"Mask",
",",
"DAG",
",",
"Subtarget",
")",
")",
"{",
"DstVT",
"=",
"MaskVT",
";",
"return",
"true",
";",
"}",
"}",
"if",
"(",
"(",
"MaskVT",
"==",
"MVT",
"::",
"v4f32",
"&&",
"Subtarget",
".",
"hasSSE1",
"(",
")",
")",
"||",
"(",
"MaskVT",
".",
"is128BitVector",
"(",
")",
"&&",
"Subtarget",
".",
"hasSSE2",
"(",
")",
")",
"||",
"(",
"MaskVT",
".",
"is256BitVector",
"(",
")",
"&&",
"<NUM_LIT>",
"<=",
"EltSizeInBits",
"&&",
"Subtarget",
".",
"hasAVX",
"(",
")",
")",
"||",
"(",
"MaskVT",
".",
"is256BitVector",
"(",
")",
"&&",
"Subtarget",
".",
"hasAVX2",
"(",
")",
")",
"||",
"(",
"MaskVT",
".",
"is512BitVector",
"(",
")",
"&&",
"Subtarget",
".",
"hasAVX512",
"(",
")",
")",
")",
"{",
"if",
"(",
"matchShuffleWithUNPCK",
"(",
"MaskVT",
",",
"V1",
",",
"V2",
",",
"Shuffle",
",",
"IsUnary",
",",
"Mask",
",",
"DL",
",",
"DAG",
",",
"Subtarget",
")",
")",
"{",
"SrcVT",
"=",
"DstVT",
"=",
"MaskVT",
";",
"if",
"(",
"MaskVT",
".",
"is256BitVector",
"(",
")",
"&&",
"!",
"Subtarget",
".",
"hasAVX2",
"(",
")",
")",
"SrcVT",
"=",
"DstVT",
"=",
"(",
"<NUM_LIT>",
"==",
"EltSizeInBits",
"?",
"MVT",
"::",
"v8f32",
":",
"MVT",
"::",
"v4f64",
")",
";",
"return",
"true",
";",
"}",
"}",
"if",
"(",
"(",
"EltSizeInBits",
"%",
"V1",
".",
"getScalarValueSizeInBits",
"(",
")",
")",
"==",
"<NUM_LIT>",
"&&",
"(",
"EltSizeInBits",
"%",
"V2",
".",
"getScalarValueSizeInBits",
"(",
")",
")",
"==",
"<NUM_LIT>",
")",
"{",
"bool",
"IsBlend",
"=",
"true",
";",
"unsigned",
"NumV1Elts",
"=",
"V1",
".",
"getValueType",
"(",
")",
".",
"getVectorNumElements",
"(",
")",
";",
"unsigned",
"NumV2Elts",
"=",
"V2",
".",
"getValueType",
"(",
")",
".",
"getVectorNumElements",
"(",
")",
";",
"unsigned",
"Scale1",
"=",
"NumV1Elts",
"/",
"NumMaskElts",
";",
"unsigned",
"Scale2",
"=",
"NumV2Elts",
"/",
"NumMaskElts",
";",
"APInt",
"DemandedZeroV1",
"=",
"APInt",
"::",
"getNullValue",
"(",
"NumV1Elts",
")",
";",
"APInt",
"DemandedZeroV2",
"=",
"APInt",
"::",
"getNullValue",
"(",
"NumV2Elts",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"!=",
"NumMaskElts",
";",
"++",
"i",
")",
"{",
"int",
"M",
"=",
"Mask",
"[",
"i",
"]",
";",
"if",
"(",
"M",
"==",
"SM_SentinelUndef",
")",
"continue",
";",
"if",
"(",
"M",
"==",
"SM_SentinelZero",
")",
"{",
"DemandedZeroV1",
".",
"setBits",
"(",
"i",
"*",
"Scale1",
",",
"(",
"i",
"+",
"<NUM_LIT>",
")",
"*",
"Scale1",
")",
";",
"DemandedZeroV2",
".",
"setBits",
"(",
"i",
"*",
"Scale2",
",",
"(",
"i",
"+",
"<NUM_LIT>",
")",
"*",
"Scale2",
")",
";",
"continue",
";",
"}",
"if",
"(",
"M",
"==",
"(",
"int",
")",
"i",
")",
"{",
"DemandedZeroV2",
".",
"setBits",
"(",
"i",
"*",
"Scale2",
",",
"(",
"i",
"+",
"<NUM_LIT>",
")",
"*",
"Scale2",
")",
";",
"continue",
";",
"}",
"if",
"(",
"M",
"==",
"(",
"int",
")",
"(",
"i",
"+",
"NumMaskElts",
")",
")",
"{",
"DemandedZeroV1",
".",
"setBits",
"(",
"i",
"*",
"Scale1",
",",
"(",
"i",
"+",
"<NUM_LIT>",
")",
"*",
"Scale1",
")",
";",
"continue",
";",
"}",
"IsBlend",
"="
] |
LLVM | ARM | CPP | stmt_completion | CPU | 3,615 | [
"false",
";"
] | [
"}",
"if",
"(",
"UC",
".",
"hasPersonality",
"(",
")",
")",
"{",
"Error",
"(",
"L",
",",
"<STR_LIT>",
".cantunwind can't be used with .personality directive",
"<STR_LIT>",
")",
";",
"UC",
".",
"emitPersonalityLocNotes",
"(",
")",
";",
"return",
"true",
";",
"}",
"getTargetStreamer",
"(",
")",
".",
"emitCantUnwind",
"(",
")",
";",
"return"
] |
GCC | s390 | MD | next_suggestion | MPU | 3,616 | [
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"<STR_LIT>",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | pa | CPP | program_repair | CPU | 3,617 | [
"<FIXS>",
"if",
"(",
"n_bytes",
">",
"<NUM_LIT>",
")",
"<FIXE>"
] | [
"if",
"(",
"align",
">=",
"<NUM_LIT>",
")",
"{",
"<BUGS>",
"if",
"(",
"n_bytes",
">",
"<NUM_LIT>",
")",
"<BUGE>",
"goto",
"copy_with_loop",
";"
] |
GCC | m68k | MD | next_suggestion | MPU | 3,618 | [
"if",
"(",
"FP_REG_P",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
")"
] | [
"<STR_LIT>",
"{",
"if",
"(",
"DATA_REG_P",
"(",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
")",
"{",
"operands",
"[",
"<NUM_LIT>",
"]",
"=",
"GEN_INT",
"(",
"<NUM_LIT>",
")",
"return",
"<STR_LIT>",
"}"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 3,619 | [
"if",
"(",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"break",
";"
] | [
"if",
"(",
"And",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"AND",
")",
"break",
";",
"SDValue",
"X",
"=",
"And",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"X",
".",
"getSimpleValueType",
"(",
")",
".",
"getSizeInBits",
"(",
")",
">",
"<NUM_LIT>",
")",
"break",
";",
"if",
"(",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
"||",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"And",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"break",
";",
"uint64_t",
"Mask",
"=",
"And",
".",
"getConstantOperandVal",
"(",
"<NUM_LIT>",
")",
">>",
"N",
".",
"getConstantOperandVal",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"!",
"foldMaskAndShiftToScale",
"(",
"*",
"CurDAG",
",",
"N",
",",
"Mask",
",",
"N",
",",
"X",
",",
"AM",
")",
")",
"return",
"false",
";",
"break",
";",
"}",
"case",
"ISD",
"::",
"SMUL_LOHI",
":",
"case",
"ISD",
"::",
"UMUL_LOHI",
":",
"if",
"(",
"N",
".",
"getResNo",
"(",
")",
"!=",
"<NUM_LIT>",
")",
"break",
";",
"LLVM_FALLTHROUGH",
";",
"case",
"ISD",
"::",
"MUL",
":",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"if",
"(",
"AM",
".",
"BaseType",
"==",
"X86ISelAddressMode",
"::",
"RegBase",
"&&",
"AM",
".",
"Base_Reg",
".",
"getNode",
"(",
")",
"==",
"nullptr",
"&&",
"AM",
".",
"IndexReg",
".",
"getNode",
"(",
")",
"==",
"nullptr",
")",
"{",
"if",
"(",
"ConstantSDNode",
"*",
"CN",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"if",
"(",
"CN",
"->",
"getZExtValue",
"(",
")",
"==",
"<NUM_LIT>",
"||",
"CN",
"->",
"getZExtValue",
"(",
")",
"==",
"<NUM_LIT>",
"||",
"CN",
"->",
"getZExtValue",
"(",
")",
"==",
"<NUM_LIT>",
")",
"{",
"AM",
".",
"Scale",
"=",
"unsigned",
"(",
"CN",
"->",
"getZExtValue",
"(",
")",
")",
"-",
"<NUM_LIT>",
";",
"SDValue",
"MulVal",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"Reg",
";",
"if",
"(",
"MulVal",
".",
"getNode",
"(",
")",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"ADD",
"&&",
"MulVal",
".",
"hasOneUse",
"(",
")",
"&&",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"MulVal",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"{",
"Reg",
"=",
"MulVal",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"ConstantSDNode",
"*",
"AddVal",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"MulVal",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"uint64_t",
"Disp",
"=",
"AddVal",
"->",
"getSExtValue",
"(",
")",
"*",
"CN",
"->",
"getZExtValue",
"(",
")",
";",
"if",
"(",
"foldOffsetIntoAddress",
"(",
"Disp",
",",
"AM",
")",
")",
"Reg",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"}",
"else",
"{",
"Reg",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"}",
"AM",
".",
"IndexReg",
"=",
"AM",
".",
"Base_Reg",
"=",
"Reg",
";",
"return",
"false",
";",
"}",
"}",
"break",
";",
"case",
"ISD",
"::",
"SUB",
":",
"{",
"HandleSDNode",
"Handle",
"(",
"N",
")",
";",
"X86ISelAddressMode",
"Backup",
"=",
"AM",
";",
"if",
"(",
"matchAddressRecursively",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"AM",
",",
"Depth",
"+",
"<NUM_LIT>",
")",
")",
"{",
"AM",
"=",
"Backup",
";",
"break",
";",
"}",
"if",
"(",
"AM",
".",
"IndexReg",
".",
"getNode",
"(",
")",
"||",
"AM",
".",
"isRIPRelative",
"(",
")",
")",
"{",
"AM",
"=",
"Backup",
";",
"break",
";",
"}",
"int",
"Cost",
"=",
"<NUM_LIT>",
";",
"SDValue",
"RHS",
"=",
"Handle",
".",
"getValue",
"(",
")",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"!",
"RHS",
".",
"getNode",
"(",
")",
"->",
"hasOneUse",
"(",
")",
"||",
"RHS",
".",
"getNode",
"(",
")",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"CopyFromReg",
"||",
"RHS",
".",
"getNode",
"(",
")",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"TRUNCATE",
"||",
"RHS",
".",
"getNode",
"(",
")",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"ANY_EXTEND",
"||",
"(",
"RHS",
".",
"getNode",
"(",
")",
"->",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"ZERO_EXTEND",
"&&",
"RHS",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getValueType",
"(",
")",
"==",
"MVT",
"::",
"i32",
")",
")",
"++",
"Cost",
";",
"if",
"(",
"(",
"AM",
".",
"BaseType",
"==",
"X86ISelAddressMode",
"::",
"RegBase",
"&&",
"AM",
".",
"Base_Reg",
".",
"getNode",
"(",
")",
"&&",
"AM",
".",
"Base_Reg",
"->",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"DELETED_NODE",
"&&",
"!",
"AM",
".",
"Base_Reg",
".",
"getNode",
"(",
")",
"->",
"hasOneUse",
"(",
")",
")",
"||",
"AM",
".",
"BaseType",
"==",
"X86ISelAddressMode",
"::",
"FrameIndexBase",
")",
"--",
"Cost",
";",
"if",
"(",
"(",
"AM",
".",
"hasSymbolicDisplacement",
"(",
")",
"&&",
"!",
"Backup",
".",
"hasSymbolicDisplacement",
"(",
")",
")",
"+",
"(",
"(",
"AM",
".",
"Disp",
"!=",
"<NUM_LIT>",
")",
"&&",
"(",
"Backup",
".",
"Disp",
"==",
"<NUM_LIT>",
")",
")",
"+",
"(",
"AM",
".",
"Segment",
".",
"getNode",
"(",
")",
"&&",
"!",
"Backup",
".",
"Segment",
".",
"getNode",
"(",
")",
")",
">=",
"<NUM_LIT>",
")",
"--",
"Cost",
";",
"if",
"(",
"Cost",
">=",
"<NUM_LIT>",
")",
"{",
"AM",
"=",
"Backup",
";",
"break",
";",
"}",
"SDValue",
"Zero",
"=",
"CurDAG",
"->",
"getConstant",
"(",
"<NUM_LIT>",
",",
"dl",
",",
"N",
".",
"getValueType",
"(",
")",
")",
";",
"SDValue",
"Neg",
"=",
"CurDAG",
"->",
"getNode",
"(",
"ISD",
"::",
"SUB",
",",
"dl",
",",
"N",
".",
"getValueType",
"(",
")",
",",
"Zero",
",",
"RHS",
")",
";",
"AM",
".",
"IndexReg",
"=",
"Neg",
";",
"AM",
".",
"Scale",
"=",
"<NUM_LIT>",
";",
"insertDAGNode",
"(",
"*",
"CurDAG",
",",
"Handle",
".",
"getValue",
"(",
")",
",",
"Zero",
")",
";",
"insertDAGNode",
"(",
"*",
"CurDAG",
",",
"Handle",
".",
"getValue",
"(",
")",
",",
"Neg",
")",
";",
"return",
"false",
";",
"}",
"case",
"ISD",
"::",
"ADD",
":",
"if",
"(",
"!",
"matchAdd",
"(",
"N",
",",
"AM",
",",
"Depth",
")",
")",
"return",
"false",
";",
"break",
";",
"case",
"ISD",
"::",
"OR",
":",
"if",
"(",
"CurDAG",
"->",
"haveNoCommonBitsSet",
"(",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
"&&",
"!",
"matchAdd",
"(",
"N",
",",
"AM",
",",
"Depth",
")",
")",
"return",
"false",
";",
"break",
";",
"case",
"ISD",
"::",
"AND",
":",
"{",
"if",
"(",
"AM",
".",
"IndexReg",
".",
"getNode",
"(",
")",
"!=",
"nullptr",
"||",
"AM",
".",
"Scale",
"!=",
"<NUM_LIT>",
")",
"break",
";",
"SDValue",
"Shift",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"Shift",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"SRL",
"&&",
"Shift",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"SHL",
")",
"break",
";",
"SDValue",
"X",
"=",
"Shift",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"X",
".",
"getSimpleValueType",
"(",
")",
".",
"getSizeInBits",
"(",
")",
">",
"<NUM_LIT>",
")",
"break",
";"
] |
GCC | rx | MD | stmt_completion | CPU | 3,620 | [
"<STR_LIT>",
")"
] | [
"(",
"ior",
"(",
"match_operand",
"<NUM_LIT>"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 3,621 | [
"idx",
";"
] | [
"def",
"i16",
":",
"BaseSIMDScalarCPY",
"<",
"FPR16",
",",
"V128",
",",
"asm",
",",
"<STR_LIT>",
",",
"VectorIndexH",
">",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"idx",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"="
] |
GCC | tilegx | MD | stmt_completion | VLIW | 3,622 | [
"[",
"<NUM_LIT>",
"]",
","
] | [
"tilegx_expand_builtin_vector_binop",
"(",
"gen_vec_widen_smult_lo_v4qi",
",",
"V2SImode",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
",",
"V4HImode",
",",
"operands"
] |
GCC | nds32 | CPP | code_generation | CPU | 3,623 | [
"bool",
"nds32_n10_mm_to_ex_p",
"(",
"rtx_insn",
"*",
"producer",
",",
"rtx_insn",
"*",
"consumer",
")",
"{",
"rtx",
"def_reg",
";",
"switch",
"(",
"get_attr_type",
"(",
"producer",
")",
")",
"{",
"case",
"TYPE_LOAD",
":",
"case",
"TYPE_MUL",
":",
"case",
"TYPE_MAC",
":",
"case",
"TYPE_DALU64",
":",
"case",
"TYPE_DMUL",
":",
"case",
"TYPE_DMAC",
":",
"case",
"TYPE_DALUROUND",
":",
"case",
"TYPE_DBPICK",
":",
"case",
"TYPE_DWEXT",
":",
"def_reg",
"=",
"SET_DEST",
"(",
"PATTERN",
"(",
"producer",
")",
")",
";",
"break",
";",
"case",
"TYPE_DIV",
":",
"if",
"(",
"divmod_p",
"(",
"producer",
")",
")",
"{",
"rtx",
"def_reg1",
"=",
"SET_DEST",
"(",
"parallel_element",
"(",
"producer",
",",
"<NUM_LIT>",
")",
")",
";",
"rtx",
"def_reg2",
"=",
"SET_DEST",
"(",
"parallel_element",
"(",
"producer",
",",
"<NUM_LIT>",
")",
")",
";",
"return",
"(",
"n10_consumed_by_ex_dep_p",
"(",
"consumer",
",",
"def_reg1",
")",
"||",
"n10_consumed_by_ex_dep_p",
"(",
"consumer",
",",
"def_reg2",
")",
")",
";",
"}",
"def_reg",
"=",
"SET_DEST",
"(",
"PATTERN",
"(",
"producer",
")",
")",
";",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"return",
"n10_consumed_by_ex_dep_p",
"(",
"consumer",
",",
"def_reg",
")",
";",
"}"
] | [
"Check",
"dependencies",
"from",
"MM",
"to",
"EX",
"."
] |
LLVM | ARM | TD | next_suggestion | CPU | 3,624 | [
"}"
] | [
"return",
"Imm",
">",
"=",
"<NUM_LIT>",
"&",
"&",
"Imm",
"<",
"<NUM_LIT>",
";",
"}",
"]",
">",
"{",
"let",
"ParserMatchClass",
"=",
"Imm0_32AsmOperand",
";"
] |
LLVM | Mips | TD | stmt_completion | CPU | 3,625 | [
"]",
">",
";"
] | [
"def",
":",
"ItinRW",
"<",
"[",
"GenericReadCOP0",
"]",
",",
"[",
"II_DMFC0"
] |
GCC | alpha | CPP | code_generation | MPU | 3,626 | [
"rtx",
"alpha_use_linkage",
"(",
"rtx",
"func",
",",
"bool",
"lflag",
",",
"bool",
"rflag",
")",
"{",
"struct",
"alpha_links",
"*",
"al",
"=",
"NULL",
";",
"const",
"char",
"*",
"name",
"=",
"XSTR",
"(",
"func",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"cfun",
"->",
"machine",
"->",
"links",
")",
"{",
"alpha_links",
"*",
"*",
"slot",
"=",
"cfun",
"->",
"machine",
"->",
"links",
"->",
"get",
"(",
"name",
")",
";",
"if",
"(",
"slot",
")",
"al",
"=",
"*",
"slot",
";",
"}",
"else",
"cfun",
"->",
"machine",
"->",
"links",
"=",
"hash_map",
"<",
"const",
"char",
"*",
",",
"alpha_links",
"*",
",",
"string_traits",
">",
"::",
"create_ggc",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"al",
"==",
"NULL",
")",
"{",
"size_t",
"buf_len",
";",
"char",
"*",
"linksym",
";",
"tree",
"id",
";",
"if",
"(",
"name",
"[",
"<NUM_LIT>",
"]",
"==",
"'",
"*",
"'",
")",
"name",
"++",
";",
"id",
"=",
"maybe_get_identifier",
"(",
"name",
")",
";",
"if",
"(",
"id",
")",
"{",
"while",
"(",
"IDENTIFIER_TRANSPARENT_ALIAS",
"(",
"id",
")",
")",
"id",
"=",
"TREE_CHAIN",
"(",
"id",
")",
";",
"name",
"=",
"IDENTIFIER_POINTER",
"(",
"id",
")",
";",
"}",
"buf_len",
"=",
"strlen",
"(",
"name",
")",
"+",
"<NUM_LIT>",
"+",
"<NUM_LIT>",
";",
"linksym",
"=",
"(",
"char",
"*",
")",
"alloca",
"(",
"buf_len",
")",
";",
"snprintf",
"(",
"linksym",
",",
"buf_len",
",",
"<STR_LIT>",
"$%d..%s..lk",
"<STR_LIT>",
",",
"cfun",
"->",
"funcdef_no",
",",
"name",
")",
";",
"al",
"=",
"ggc_alloc",
"<",
"alpha_links",
">",
"(",
")",
";",
"al",
"->",
"func",
"=",
"func",
";",
"al",
"->",
"linkage",
"=",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"ggc_strdup",
"(",
"linksym",
")",
")",
";",
"cfun",
"->",
"machine",
"->",
"links",
"->",
"put",
"(",
"ggc_strdup",
"(",
"name",
")",
",",
"al",
")",
";",
"}",
"al",
"->",
"rkind",
"=",
"rflag",
"?",
"KIND_CODEADDR",
":",
"KIND_LINKAGE",
";",
"if",
"(",
"lflag",
")",
"return",
"gen_rtx_MEM",
"(",
"Pmode",
",",
"plus_constant",
"(",
"Pmode",
",",
"al",
"->",
"linkage",
",",
"<NUM_LIT>",
")",
")",
";",
"else",
"return",
"al",
"->",
"linkage",
";",
"}"
] | [
"Return",
"a",
"SYMBOL_REF",
"representing",
"the",
"reference",
"to",
"the",
".linkage",
"entry",
"of",
"function",
"FUNC",
"built",
"for",
"calls",
"made",
"from",
"CFUNDECL",
".",
"LFLAG",
"is",
"1",
"if",
"this",
"is",
"the",
"reference",
"to",
"the",
"linkage",
"pointer",
"value",
",",
"0",
"if",
"this",
"is",
"the",
"reference",
"to",
"the",
"function",
"entry",
"value",
".",
"RFLAG",
"is",
"1",
"if",
"this",
"a",
"reduced",
"reference",
"(",
"code",
"address",
"only",
")",
",",
"0",
"if",
"this",
"is",
"a",
"full",
"reference",
"."
] |
LLVM | PowerPC | CPP | next_suggestion | CPU | 3,627 | [
"return",
"findScratchRegister",
"(",
"TmpMBB",
",",
"true",
")",
";"
] | [
"bool",
"PPCFrameLowering",
"::",
"canUseAsEpilogue",
"(",
"const",
"MachineBasicBlock",
"&",
"MBB",
")",
"const",
"{",
"MachineBasicBlock",
"*",
"TmpMBB",
"=",
"const_cast",
"<",
"MachineBasicBlock",
"*",
">",
"(",
"&",
"MBB",
")",
";"
] |
GCC | arm | CPP | next_suggestion | CPU | 3,628 | [
"}"
] | [
"_",
"_",
"arm_vaddq_m_n_f16",
"(",
"float16x8_t",
"_",
"_",
"inactive",
",",
"float16x8_t",
"_",
"_",
"a",
",",
"float16_t",
"_",
"_",
"b",
",",
"mve_pred16_t",
"_",
"_",
"p",
")",
"{",
"return",
"_",
"_",
"builtin_mve_vaddq_m_n_fv8hf",
"(",
"_",
"_",
"inactive",
",",
"_",
"_",
"a",
",",
"_",
"_",
"b",
",",
"_",
"_",
"p",
")",
";"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 3,629 | [
"let",
"DecoderMethod",
"=",
"<STR_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"L",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"offset",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rt2",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rn",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rt",
";"
] |
LLVM | Mips | CPP | next_suggestion | CPU | 3,630 | [
"return",
"&",
"Mips",
"::",
"ValueMappings",
"[",
"Mips",
"::",
"MSAIdx",
"]",
";"
] | [
"static",
"const",
"MipsRegisterBankInfo",
"::",
"ValueMapping",
"*",
"getMSAMapping",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"{",
"assert",
"(",
"MF",
".",
"getSubtarget",
"<",
"MipsSubtarget",
">",
"(",
")",
".",
"hasMSA",
"(",
")",
"&&",
"<STR_LIT>",
"MSA mapping not available on target without MSA.",
"<STR_LIT>",
")",
";"
] |
LLVM | R600 | CPP | stmt_completion | GPU | 3,631 | [
"(",
"Op",
")",
",",
"ConstPtrVT",
")",
";"
] | [
"switch",
"(",
"G",
"->",
"getAddressSpace",
"(",
")",
")",
"{",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"{",
"assert",
"(",
"G",
"->",
"getOffset",
"(",
")",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Do not know what to do with an non-zero offset",
"<STR_LIT>",
")",
";",
"if",
"(",
"hasDefinedInitializer",
"(",
"GV",
")",
")",
"break",
";",
"unsigned",
"Offset",
";",
"if",
"(",
"MFI",
"->",
"LocalMemoryObjects",
".",
"count",
"(",
"GV",
")",
"==",
"<NUM_LIT>",
")",
"{",
"uint64_t",
"Size",
"=",
"TD",
"->",
"getTypeAllocSize",
"(",
"GV",
"->",
"getType",
"(",
")",
"->",
"getElementType",
"(",
")",
")",
";",
"Offset",
"=",
"MFI",
"->",
"LDSSize",
";",
"MFI",
"->",
"LocalMemoryObjects",
"[",
"GV",
"]",
"=",
"Offset",
";",
"MFI",
"->",
"LDSSize",
"+=",
"Size",
";",
"}",
"else",
"{",
"Offset",
"=",
"MFI",
"->",
"LocalMemoryObjects",
"[",
"GV",
"]",
";",
"}",
"return",
"DAG",
".",
"getConstant",
"(",
"Offset",
",",
"getPointerTy",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"}",
"case",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"{",
"MachineFrameInfo",
"*",
"FrameInfo",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getFrameInfo",
"(",
")",
";",
"Type",
"*",
"EltType",
"=",
"GV",
"->",
"getType",
"(",
")",
"->",
"getElementType",
"(",
")",
";",
"unsigned",
"Size",
"=",
"TD",
"->",
"getTypeAllocSize",
"(",
"EltType",
")",
";",
"unsigned",
"Alignment",
"=",
"TD",
"->",
"getPrefTypeAlignment",
"(",
"EltType",
")",
";",
"MVT",
"PrivPtrVT",
"=",
"getPointerTy",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"MVT",
"ConstPtrVT",
"=",
"getPointerTy",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"int",
"FI",
"=",
"FrameInfo",
"->",
"CreateStackObject",
"(",
"Size",
",",
"Alignment",
",",
"false",
")",
";",
"SDValue",
"InitPtr",
"=",
"DAG",
".",
"getFrameIndex",
"(",
"FI",
",",
"PrivPtrVT",
")",
";",
"const",
"GlobalVariable",
"*",
"Var",
"=",
"cast",
"<",
"GlobalVariable",
">",
"(",
"GV",
")",
";",
"if",
"(",
"!",
"Var",
"->",
"hasInitializer",
"(",
")",
")",
"{",
"return",
"DAG",
".",
"getZExtOrTrunc",
"(",
"InitPtr",
",",
"SDLoc"
] |
GCC | arm | CPP | next_suggestion | CPU | 3,632 | [
"}"
] | [
"_",
"_",
"rv",
".",
"_",
"_",
"o",
"=",
"_",
"_",
"builtin_neon_vld4_dupv8qi",
"(",
"(",
"const",
"_",
"_",
"builtin_neon_qi",
"*",
")",
"_",
"_",
"a",
")",
";",
"return",
"_",
"_",
"rv",
".",
"_",
"_",
"i",
";"
] |
LLVM | PowerPC | CPP | stmt_completion | CPU | 3,633 | [
".",
"VSEId",
")",
";"
] | [
"void",
"PPCVSXSwapRemoval",
"::",
"markSwapsForRemoval",
"(",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"\\n*** Marking swaps for removal ***\\n\\n",
"<STR_LIT>",
")",
";",
"for",
"(",
"unsigned",
"EntryIdx",
"=",
"<NUM_LIT>",
";",
"EntryIdx",
"<",
"SwapVector",
".",
"size",
"(",
")",
";",
"++",
"EntryIdx",
")",
"{",
"if",
"(",
"SwapVector",
"[",
"EntryIdx",
"]",
".",
"IsLoad",
"&&",
"SwapVector",
"[",
"EntryIdx",
"]",
".",
"IsSwap",
")",
"{",
"int",
"Repr",
"=",
"EC",
"->",
"getLeaderValue",
"(",
"SwapVector",
"[",
"EntryIdx",
"]",
".",
"VSEId",
")",
";",
"if",
"(",
"!",
"SwapVector",
"[",
"Repr",
"]",
".",
"WebRejected",
")",
"{",
"MachineInstr",
"*",
"MI",
"=",
"SwapVector",
"[",
"EntryIdx",
"]",
".",
"VSEMI",
";",
"Register",
"DefReg",
"=",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
";",
"for",
"(",
"MachineInstr",
"&",
"UseMI",
":",
"MRI",
"->",
"use_nodbg_instructions",
"(",
"DefReg",
")",
")",
"{",
"int",
"UseIdx",
"=",
"SwapMap",
"[",
"&",
"UseMI",
"]",
";",
"SwapVector",
"[",
"UseIdx",
"]",
".",
"WillRemove",
"=",
"<NUM_LIT>",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Marking swap fed by load for removal: ",
"<STR_LIT>",
")",
";",
"LLVM_DEBUG",
"(",
"UseMI",
".",
"dump",
"(",
")",
")",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"SwapVector",
"[",
"EntryIdx",
"]",
".",
"IsStore",
"&&",
"SwapVector",
"[",
"EntryIdx",
"]",
".",
"IsSwap",
")",
"{",
"int",
"Repr",
"=",
"EC",
"->",
"getLeaderValue",
"(",
"SwapVector",
"[",
"EntryIdx",
"]"
] |
GCC | h8300 | MD | program_repair | MPU | 3,634 | [
"<FIXS>",
"(",
"define_insn_and_split",
"<STR_LIT>",
"<FIXE>",
"<FIXS>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<FIXE>",
"<FIXS>",
"(",
"define_insn_and_split",
"<STR_LIT>",
"<FIXE>",
"<FIXS>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<FIXE>"
] | [
"operands",
"[",
"<NUM_LIT>",
"]",
"=",
"gen_rtx_SIGN_EXTEND",
"(",
"SImode",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
"}",
")",
"<BUGS>",
"(",
"define_insn",
"<STR_LIT>",
"<BUGE>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mult",
":",
"SI",
"(",
"sign_extend",
":",
"SI",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"<BUGS>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<BUGE>",
"<BUGS>",
"(",
"define_insn",
"<STR_LIT>",
"<BUGE>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mult",
":",
"SI",
"(",
"sign_extend",
":",
"SI",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"sign_extend",
":",
"SI",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"<BUGS>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<BUGE>",
"(",
"define_expand",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | powerpcspe | CPP | stmt_completion | CPU | 3,635 | [
"a",
")",
",",
"(",
"vec_int4",
")",
"(",
"b",
")",
")",
")",
")",
";"
] | [
"return",
"(",
"(",
"qword",
")",
"(",
"vec_cmpgt",
"(",
"(",
"vec_int4",
")",
"("
] |
LLVM | SystemZ | TD | stmt_completion | CPU | 3,636 | [
"outs",
")",
",",
"(",
"ins",
"cls1",
":",
"$",
"R1",
",",
"cls2",
":",
"$",
"R2",
")",
",",
"mnemonic",
"#",
"<STR_LIT>",
",",
"[",
"]",
">",
"{"
] | [
"class",
"SideEffectBinaryRRFc",
"<",
"string",
"mnemonic",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"opcode",
",",
"RegisterOperand",
"cls1",
",",
"RegisterOperand",
"cls2",
">",
":",
"InstRRFc",
"<",
"opcode",
",",
"("
] |
LLVM | X86 | TD | program_repair | CPU | 3,637 | [
"<FIXS>",
"def",
"HWWriteResGroup121",
":",
"SchedWriteRes",
"[",
"HWPort0",
",",
"HWFPDivider",
"]",
">",
"{",
"<FIXE>",
"<FIXS>",
"let",
"ResourceCycles",
"=",
"[",
"<NUM_LIT>",
",",
"<NUM_LIT>",
"]",
";",
"<FIXE>"
] | [
"}",
"def",
":",
"InstRW",
"[",
"HWWriteResGroup120",
"]",
",",
"(",
"instregex",
"<STR_LIT>",
")",
">",
";",
"<BUGS>",
"def",
"HWWriteResGroup121",
":",
"SchedWriteRes",
"[",
"HWPort0",
"]",
">",
"{",
"<BUGE>",
"let",
"Latency",
"=",
"<NUM_LIT>",
";",
"let",
"NumMicroOps",
"=",
"<NUM_LIT>",
";",
"<BUGS>",
"let",
"ResourceCycles",
"=",
"[",
"<NUM_LIT>",
"]",
";",
"<BUGE>",
"}",
"def",
":",
"InstRW",
"[",
"HWWriteResGroup121",
"]",
",",
"(",
"instregex",
"<STR_LIT>",
",",
"<STR_LIT>",
")",
">",
";"
] |
GCC | i386 | CPP | next_suggestion | CPU | 3,638 | [
"}"
] | [
"extern",
"_",
"_",
"inline",
"void",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_storeu_ps",
"(",
"float",
"*",
"_",
"_",
"P",
",",
"_",
"_",
"m128",
"_",
"_",
"A",
")",
"{",
"*",
"(",
"_",
"_",
"m128_u",
"*",
")",
"_",
"_",
"P",
"=",
"_",
"_",
"A",
";"
] |
GCC | arm | CPP | next_suggestion | CPU | 3,639 | [
"}"
] | [
"_",
"_",
"arm_vreinterpretq_s8_u16",
"(",
"uint16x8_t",
"_",
"_",
"a",
")",
"{",
"return",
"(",
"int8x16_t",
")",
"_",
"_",
"a",
";"
] |
GCC | i386 | MD | stmt_completion | CPU | 3,640 | [
")",
")",
")",
")"
] | [
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>"
] |
GCC | m68hc11 | CPP | next_suggestion | MPU | 3,641 | [
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PRE_INC",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"PRE_DEC",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"POST_INC",
"||",
"GET_CODE",
"(",
"x",
")",
"==",
"POST_DEC",
")",
"return",
"GET_CODE",
"(",
"x",
")",
";"
] | [
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"!=",
"MEM",
")",
"return",
"CONST",
";",
"x",
"=",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
";"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 3,642 | [
">",
";"
] | [
"def",
"UImm5s8Operand",
":",
"UImmScaledMemoryIndexed",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>"
] |
GCC | h8300 | MD | program_repair | MPU | 3,643 | [
"<FIXS>",
"<STR_LIT>",
"<FIXE>"
] | [
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"<BUGS>",
"<STR_LIT>",
"<BUGE>",
"[",
"(",
"parallel",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"zero_extract",
":",
"QI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"clobber",
"(",
"reg",
":",
"CC",
"CC_REG",
")",
")",
"]",
")",
"]",
")"
] |
GCC | i386 | MD | program_repair | CPU | 3,644 | [
"<FIXS>",
"(",
"clobber",
"(",
"match_scratch",
":",
"SF",
"<NUM_LIT>",
"<STR_LIT>",
")",
")",
"<FIXE>"
] | [
"(",
"match_operand",
":",
"SF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"(",
"match_operand",
":",
"SF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"SF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"<BUGS>",
"(",
"clobber",
"(",
"match_scratch",
":",
"SF",
"<NUM_LIT>",
"<STR_LIT>",
")",
")",
"<BUGE>",
"(",
"clobber",
"(",
"reg",
":",
"CC",
"<NUM_LIT>",
")",
")",
"]",
"<STR_LIT>"
] |
GCC | i386 | MD | stmt_completion | CPU | 3,645 | [
"<STR_LIT>",
")",
")",
")"
] | [
"(",
"and",
"(",
"not",
"(",
"match_test",
"<STR_LIT>",
")",
")",
"(",
"match_operand",
"<NUM_LIT>"
] |
GCC | arm | CPP | next_suggestion | CPU | 3,646 | [
"_",
"_",
"i1",
"=",
"_",
"_",
"i1",
"<<",
"<NUM_LIT>",
"|",
"(",
"unsigned",
"char",
")",
"_",
"_",
"b4",
";"
] | [
"static",
"_",
"_",
"inline",
"_",
"_",
"m64",
"_",
"mm_set_pi8",
"(",
"char",
"_",
"_",
"b7",
",",
"char",
"_",
"_",
"b6",
",",
"char",
"_",
"_",
"b5",
",",
"char",
"_",
"_",
"b4",
",",
"char",
"_",
"_",
"b3",
",",
"char",
"_",
"_",
"b2",
",",
"char",
"_",
"_",
"b1",
",",
"char",
"_",
"_",
"b0",
")",
"{",
"unsigned",
"int",
"_",
"_",
"i1",
",",
"_",
"_",
"i0",
";",
"_",
"_",
"i1",
"=",
"(",
"unsigned",
"char",
")",
"_",
"_",
"b7",
";",
"_",
"_",
"i1",
"=",
"_",
"_",
"i1",
"<<",
"<NUM_LIT>",
"|",
"(",
"unsigned",
"char",
")",
"_",
"_",
"b6",
";",
"_",
"_",
"i1",
"=",
"_",
"_",
"i1",
"<<",
"<NUM_LIT>",
"|",
"(",
"unsigned",
"char",
")",
"_",
"_",
"b5",
";"
] |
GCC | frv | MD | stmt_completion | VLIW | 3,647 | [
"<STR_LIT>",
")",
")"
] | [
"(",
"eq_attr",
"<STR_LIT>"
] |
LLVM | TVM | CPP | next_suggestion | Virtual ISA | 3,648 | [
"return",
"rv",
";"
] | [
"rv",
"(",
"curStack",
"+=",
"rv",
"(",
"pushUndef",
"(",
")",
")",
")",
";",
"}",
"}",
"else",
"{",
"i",
"=",
"from",
".",
"position",
"(",
"StackVreg",
"(",
"*",
"Preserved",
")",
")",
";",
"}",
"if",
"(",
"numPops",
")",
"--",
"numPops",
";",
"if",
"(",
"i",
"!=",
"j",
")",
"{",
"if",
"(",
"i",
"==",
"<NUM_LIT>",
")",
"{",
"rv",
"(",
"curStack",
"+=",
"rv",
"(",
"xchgTop",
"(",
"j",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"j",
"==",
"<NUM_LIT>",
")",
"{",
"rv",
"(",
"curStack",
"+=",
"rv",
"(",
"xchgTop",
"(",
"i",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"i",
"<=",
"XchgLimit",
"&&",
"j",
"<=",
"XchgLimit",
")",
"{",
"rv",
"(",
"curStack",
"+=",
"rv",
"(",
"xchg",
"(",
"i",
",",
"j",
")",
")",
")",
";",
"}",
"else",
"{",
"rv",
"(",
"curStack",
"+=",
"rv",
"(",
"xchgTop",
"(",
"i",
")",
")",
")",
";",
"rv",
"(",
"curStack",
"+=",
"rv",
"(",
"xchgTop",
"(",
"j",
")",
")",
")",
";",
"rv",
"(",
"curStack",
"+=",
"rv",
"(",
"xchgTop",
"(",
"i",
")",
")",
")",
";",
"}",
"}",
"}",
"if",
"(",
"numPops",
")",
"rv",
"(",
"curStack",
"+=",
"rv",
"(",
"makeBlkdrop",
"(",
"numPops",
")",
")",
")",
";",
"rv",
".",
"optimize",
"(",
")",
";",
"rv",
".",
"annotate",
"(",
"from",
")",
";"
] |
LLVM | Mips | TD | stmt_completion | CPU | 3,649 | [
">",
";"
] | [
"class",
"CLE_S_D_ENC",
":",
"MSA_3R_FMT",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 3,650 | [
"targets",
"(",
")",
".",
"triple",
"(",
")",
")",
")",
";"
] | [
"if",
"(",
"pConfig",
".",
"targets",
"(",
")",
".",
"triple",
"(",
")",
".",
"isOSWindows",
"(",
")",
")",
"{",
"assert",
"(",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"COFF linker is not supported yet",
"<STR_LIT>",
")",
";",
"}",
"return",
"new",
"AArch64GNULDBackend",
"(",
"pConfig",
",",
"new",
"AArch64GNUInfo",
"(",
"pConfig",
"."
] |
GCC | rs6000 | CPP | program_repair | CPU | 3,651 | [
"<FIXS>",
"const",
"char",
"*",
"call_name",
";",
"<FIXE>"
] | [
"rs6000_longcall_ref",
"(",
"call_ref",
")",
"rtx",
"call_ref",
";",
"{",
"<BUGS>",
"char",
"*",
"call_name",
";",
"<BUGE>",
"tree",
"node",
";",
"if",
"(",
"GET_CODE",
"(",
"call_ref",
")",
"!=",
"SYMBOL_REF",
")"
] |
LLVM | ARM64 | TD | next_suggestion | CPU | 3,652 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Ra",
";"
] | [
"class",
"BaseThreeOperandFPData",
"<",
"bit",
"isNegated",
",",
"bit",
"isSub",
",",
"RegisterClass",
"regtype",
",",
"string",
"asm",
",",
"list",
"<",
"dag",
">",
"pat",
">",
":",
"I",
"<",
"(",
"outs",
"regtype",
":",
"$",
"Rd",
")",
",",
"(",
"ins",
"regtype",
":",
"$",
"Rn",
",",
"regtype",
":",
"$",
"Rm",
",",
"regtype",
":",
"$",
"Ra",
")",
",",
"asm",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"pat",
">",
",",
"Sched",
"<",
"[",
"WriteFMul",
"]",
">",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"Rd",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rn",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rm",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Ra",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"isNegated",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"isSub",
";"
] |
LLVM | AArch64 | CPP | program_repair | CPU | 3,653 | [
"<FIXS>",
"return",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VT",
",",
"Mov",
")",
";",
"<FIXE>"
] | [
"SDValue",
"Mov",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MovTy",
",",
"DAG",
".",
"getConstant",
"(",
"CnstVal",
",",
"MVT",
"::",
"i32",
")",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"<BUGS>",
"return",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BITCAST",
",",
"dl",
",",
"VT",
",",
"Mov",
")",
";",
"<BUGE>",
"}",
"if",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"CnstVal",
")",
")",
"{"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 3,654 | [
"Ptr",
",",
"DstInfo",
",",
"Align",
"(",
"<NUM_LIT>",
")",
",",
"MachineMemOperand",
"::",
"MODereferenceable",
")",
";"
] | [
"SDValue",
"AMDGPUTargetLowering",
"::",
"storeStackInputValue",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"const",
"SDLoc",
"&",
"SL",
",",
"SDValue",
"Chain",
",",
"SDValue",
"ArgVal",
",",
"int64_t",
"Offset",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"MachinePointerInfo",
"DstInfo",
"=",
"MachinePointerInfo",
"::",
"getStack",
"(",
"MF",
",",
"Offset",
")",
";",
"SDValue",
"Ptr",
"=",
"DAG",
".",
"getConstant",
"(",
"Offset",
",",
"SL",
",",
"MVT",
"::",
"i32",
")",
";",
"SDValue",
"Store",
"=",
"DAG",
".",
"getStore",
"(",
"Chain",
",",
"SL",
",",
"ArgVal",
","
] |
GCC | c6x | MD | next_suggestion | VLIW | 3,655 | [
"operands",
"[",
"<NUM_LIT>",
"]",
"=",
"gen_reg_rtx",
"(",
"DFmode",
")"
] | [
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"unspec",
":",
"DF",
"[",
"(",
"match_operand",
":",
"DF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_RCP",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"mult",
":",
"DF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"minus",
":",
"DF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"mult",
":",
"DF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"mult",
":",
"DF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"minus",
":",
"DF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"mult",
":",
"DF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"mult",
":",
"DF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"minus",
":",
"DF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"mult",
":",
"DF",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"DF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mult",
":",
"DF",
"(",
"match_operand",
":",
"DF",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"]",
"<STR_LIT>",
"{",
"operands",
"[",
"<NUM_LIT>",
"]",
"=",
"force_reg",
"(",
"DFmode",
",",
"const_double_from_real_value",
"(",
"dconst2",
",",
"DFmode",
")",
")",
"operands",
"[",
"<NUM_LIT>",
"]",
"=",
"gen_reg_rtx",
"(",
"DFmode",
")"
] |
GCC | sparc | MD | stmt_completion | CPU | 3,656 | [
")",
")",
"]"
] | [
"(",
"neg",
":",
"SI",
"(",
"geu",
":",
"SI",
"(",
"reg",
":",
"CC",
"CC_REG",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")"
] |
GCC | xtensa | MD | stmt_completion | MPU | 3,657 | [
"match_op_dup",
"<NUM_LIT>"
] | [
"(",
"define_insn_and_split",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"pc",
")",
"(",
"if_then_else",
"(",
"match_operator",
"<NUM_LIT>",
"<STR_LIT>",
"[",
"(",
"and",
":",
"SI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"(",
"label_ref",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"pc",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"ashift",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"(",
"set",
"(",
"pc",
")",
"(",
"if_then_else",
"("
] |
GCC | aarch64 | CPP | next_suggestion | CPU | 3,658 | [
"x",
"=",
"copy_to_mode_reg",
"(",
"inner_mode",
",",
"XVECEXP",
"(",
"vals",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
";"
] | [
"rtx",
"x",
",",
"mem",
";",
"int",
"i",
";",
"x",
"=",
"XVECEXP",
"(",
"vals",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"x",
")",
"&&",
"!",
"CONST_DOUBLE_P",
"(",
"x",
")",
")",
"n_var",
"=",
"<NUM_LIT>",
",",
"one_var",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"<",
"n_elts",
";",
"++",
"i",
")",
"{",
"x",
"=",
"XVECEXP",
"(",
"vals",
",",
"<NUM_LIT>",
",",
"i",
")",
";",
"if",
"(",
"!",
"CONST_INT_P",
"(",
"x",
")",
"&&",
"!",
"CONST_DOUBLE_P",
"(",
"x",
")",
")",
"++",
"n_var",
",",
"one_var",
"=",
"i",
";",
"if",
"(",
"!",
"rtx_equal_p",
"(",
"x",
",",
"XVECEXP",
"(",
"vals",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
")",
")",
"all_same",
"=",
"false",
";",
"}",
"if",
"(",
"n_var",
"==",
"<NUM_LIT>",
")",
"{",
"rtx",
"constant",
"=",
"aarch64_simd_make_constant",
"(",
"vals",
")",
";",
"if",
"(",
"constant",
"!=",
"NULL_RTX",
")",
"{",
"emit_move_insn",
"(",
"target",
",",
"constant",
")",
";",
"return",
";",
"}",
"}",
"if",
"(",
"all_same",
")",
"{"
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 3,659 | [
"}"
] | [
"assert",
"(",
"N",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Invalid number of operands!",
"<STR_LIT>",
")",
";",
"const",
"MCConstantExpr",
"*",
"MCE",
"=",
"cast",
"<",
"MCConstantExpr",
">",
"(",
"getImm",
"(",
")",
")",
";",
"Inst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"createImm",
"(",
"MCE",
"->",
"getValue",
"(",
")",
"/",
"<NUM_LIT>",
")",
")",
";"
] |
LLVM | AMDGPU | CPP | program_repair | GPU | 3,660 | [
"<FIXS>",
"}",
"else",
"if",
"(",
"Opc",
"==",
"AMDGPU",
"::",
"V_ACCVGPR_READ_B32_e64",
")",
"{",
"<FIXE>"
] | [
"int",
"OpNo",
"=",
"MI",
"->",
"getOperandNo",
"(",
"&",
"Op",
")",
";",
"if",
"(",
"OpNo",
"==",
"SrcCIdx",
")",
"{",
"NeedWaitStates",
"=",
"MFMAWritesAGPROverlappedSrcCWaitStates",
";",
"<BUGS>",
"}",
"else",
"if",
"(",
"Opc",
"==",
"AMDGPU",
"::",
"V_ACCVGPR_READ_B32",
")",
"{",
"<BUGE>",
"switch",
"(",
"HazardDefLatency",
")",
"{",
"case",
"<NUM_LIT>",
":",
"NeedWaitStates",
"=",
"MFMA4x4WritesAGPRAccVgprReadWaitStates",
";",
"break",
";"
] |
GCC | frv | MD | next_suggestion | VLIW | 3,661 | [
"<STR_LIT>"
] | [
"(",
"unspec",
":",
"DI",
"[",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_MQLMTHS",
")",
")",
"]"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 3,662 | [
":",
"$",
"LHS",
")",
",",
"res",
">",
";"
] | [
"class",
"UnOpFrag",
"<",
"dag",
"res",
">",
":",
"PatFrag",
"<",
"(",
"ops",
"node"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 3,663 | [
"let",
"isPredicateLate",
"=",
"<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>",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 3,664 | [
"}"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"hasNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"CextOpcode",
"=",
"<STR_LIT>",
";",
"let",
"InputType",
"=",
"<STR_LIT>",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";"
] |
LLVM | Mips | CPP | next_suggestion | CPU | 3,665 | [
"for",
"(",
"MachineOperand",
"&",
"MO",
":",
"UserMI",
"->",
"operands",
"(",
")",
")",
"if",
"(",
"MO",
".",
"isCPI",
"(",
")",
")",
"{"
] | [
"unsigned",
"CPI",
"=",
"CPEMI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getIndex",
"(",
")",
";",
"std",
"::",
"vector",
"<",
"CPEntry",
">",
"&",
"CPEs",
"=",
"CPEntries",
"[",
"CPI",
"]",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"CPEs",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"CPEs",
"[",
"i",
"]",
".",
"CPEMI",
"==",
"CPEMI",
")",
"continue",
";",
"if",
"(",
"CPEs",
"[",
"i",
"]",
".",
"CPEMI",
"==",
"nullptr",
")",
"continue",
";",
"if",
"(",
"isCPEntryInRange",
"(",
"UserMI",
",",
"UserOffset",
",",
"CPEs",
"[",
"i",
"]",
".",
"CPEMI",
",",
"U",
".",
"getLongFormMaxDisp",
"(",
")",
",",
"U",
".",
"NegOk",
")",
")",
"{",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"Replacing CPE#",
"<STR_LIT>",
"<<",
"CPI",
"<<",
"<STR_LIT>",
" with CPE#",
"<STR_LIT>",
"<<",
"CPEs",
"[",
"i",
"]",
".",
"CPI",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"U",
".",
"CPEMI",
"=",
"CPEs",
"[",
"i",
"]",
".",
"CPEMI",
";"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 3,666 | [
"}"
] | [
"bool",
"MLxExpansion",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"Fn",
")",
"{",
"TII",
"=",
"static_cast",
"<",
"const",
"ARMBaseInstrInfo",
"*",
">",
"(",
"Fn",
".",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
")",
";",
"TRI",
"=",
"Fn",
".",
"getTarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"MRI",
"=",
"&",
"Fn",
".",
"getRegInfo",
"(",
")",
";",
"const",
"ARMSubtarget",
"*",
"STI",
"=",
"&",
"Fn",
".",
"getTarget",
"(",
")",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
")",
";",
"isLikeA9",
"=",
"STI",
"->",
"isLikeA9",
"(",
")",
"||",
"STI",
"->",
"isSwift",
"(",
")",
";",
"isSwift",
"=",
"STI",
"->",
"isSwift",
"(",
")",
";",
"bool",
"Modified",
"=",
"false",
";",
"for",
"(",
"MachineFunction",
"::",
"iterator",
"MFI",
"=",
"Fn",
".",
"begin",
"(",
")",
",",
"E",
"=",
"Fn",
".",
"end",
"(",
")",
";",
"MFI",
"!=",
"E",
";",
"++",
"MFI",
")",
"{",
"MachineBasicBlock",
"&",
"MBB",
"=",
"*",
"MFI",
";",
"Modified",
"|=",
"ExpandFPMLxInstructions",
"(",
"MBB",
")",
";",
"}",
"return",
"Modified",
";"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 3,667 | [
"ST",
".",
"makeLIDRangeMetadata",
"(",
"LoadZU",
")",
";"
] | [
"ST",
".",
"makeLIDRangeMetadata",
"(",
"LocalSizeY",
")",
";",
"ST",
".",
"makeLIDRangeMetadata",
"(",
"LocalSizeZ",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"LocalSizeY",
",",
"LocalSizeZ",
")",
";",
"}",
"assert",
"(",
"IsAMDGCN",
")",
";",
"Function",
"*",
"DispatchPtrFn",
"=",
"Intrinsic",
"::",
"getDeclaration",
"(",
"Mod",
",",
"Intrinsic",
"::",
"amdgcn_dispatch_ptr",
")",
";",
"CallInst",
"*",
"DispatchPtr",
"=",
"Builder",
".",
"CreateCall",
"(",
"DispatchPtrFn",
",",
"{",
"}",
")",
";",
"DispatchPtr",
"->",
"addRetAttr",
"(",
"Attribute",
"::",
"NoAlias",
")",
";",
"DispatchPtr",
"->",
"addRetAttr",
"(",
"Attribute",
"::",
"NonNull",
")",
";",
"F",
".",
"removeFnAttr",
"(",
"<STR_LIT>",
"amdgpu-no-dispatch-ptr",
"<STR_LIT>",
")",
";",
"DispatchPtr",
"->",
"addDereferenceableRetAttr",
"(",
"<NUM_LIT>",
")",
";",
"Type",
"*",
"I32Ty",
"=",
"Type",
"::",
"getInt32Ty",
"(",
"Mod",
"->",
"getContext",
"(",
")",
")",
";",
"Value",
"*",
"CastDispatchPtr",
"=",
"Builder",
".",
"CreateBitCast",
"(",
"DispatchPtr",
",",
"PointerType",
"::",
"get",
"(",
"I32Ty",
",",
"AMDGPUAS",
"::",
"CONSTANT_ADDRESS",
")",
")",
";",
"Value",
"*",
"GEPXY",
"=",
"Builder",
".",
"CreateConstInBoundsGEP1_64",
"(",
"I32Ty",
",",
"CastDispatchPtr",
",",
"<NUM_LIT>",
")",
";",
"LoadInst",
"*",
"LoadXY",
"=",
"Builder",
".",
"CreateAlignedLoad",
"(",
"I32Ty",
",",
"GEPXY",
",",
"Align",
"(",
"<NUM_LIT>",
")",
")",
";",
"Value",
"*",
"GEPZU",
"=",
"Builder",
".",
"CreateConstInBoundsGEP1_64",
"(",
"I32Ty",
",",
"CastDispatchPtr",
",",
"<NUM_LIT>",
")",
";",
"LoadInst",
"*",
"LoadZU",
"=",
"Builder",
".",
"CreateAlignedLoad",
"(",
"I32Ty",
",",
"GEPZU",
",",
"Align",
"(",
"<NUM_LIT>",
")",
")",
";",
"MDNode",
"*",
"MD",
"=",
"MDNode",
"::",
"get",
"(",
"Mod",
"->",
"getContext",
"(",
")",
",",
"None",
")",
";",
"LoadXY",
"->",
"setMetadata",
"(",
"LLVMContext",
"::",
"MD_invariant_load",
",",
"MD",
")",
";",
"LoadZU",
"->",
"setMetadata",
"(",
"LLVMContext",
"::",
"MD_invariant_load",
",",
"MD",
")",
";"
] |
GCC | mips | MD | next_suggestion | CPU | 3,668 | [
"<STR_LIT>"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"unspec",
":",
"DI",
"[",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"V2HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"V2HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_MAQ_S_W_PHL",
")",
")",
"(",
"set",
"(",
"reg",
":",
"CCDSP",
"CCDSP_OU_REGNUM",
")",
"(",
"unspec",
":",
"CCDSP",
"[",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
"]",
"UNSPEC_MAQ_S_W_PHL",
")",
")",
"]"
] |
GCC | i386 | MD | next_suggestion | CPU | 3,669 | [
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")"
] | [
"(",
"if_then_else",
"(",
"match_test",
"<STR_LIT>",
")"
] |
GCC | microblaze | MD | next_suggestion | MPU | 3,670 | [
"(",
"eq",
"(",
"symbol_ref",
"<STR_LIT>",
")",
"(",
"const_int",
"MB_PIPE_3",
")",
")",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
GCC | arm | CPP | stmt_completion | CPU | 3,671 | [
"_",
"_",
"b",
")",
"{"
] | [
"_",
"_",
"arm_vcmpeqq_n_u8",
"(",
"uint8x16_t",
"_",
"_",
"a",
",",
"uint8_t"
] |
GCC | arm | CPP | next_suggestion | CPU | 3,672 | [
"}"
] | [
"HOST_WIDE_INT",
"rounded_size",
";",
"struct",
"scratch_reg",
"sr",
";",
"get_scratch_register_on_entry",
"(",
"&",
"sr",
",",
"regno1",
",",
"live_regs",
")",
";",
"emit_move_insn",
"(",
"reg1",
",",
"GEN_INT",
"(",
"first",
")",
")",
";",
"rounded_size",
"=",
"size",
"&",
"-",
"PROBE_INTERVAL",
";",
"emit_move_insn",
"(",
"sr",
".",
"reg",
",",
"GEN_INT",
"(",
"rounded_size",
")",
")",
";",
"emit_set_insn",
"(",
"reg1",
",",
"gen_rtx_MINUS",
"(",
"Pmode",
",",
"stack_pointer_rtx",
",",
"reg1",
")",
")",
";",
"emit_set_insn",
"(",
"sr",
".",
"reg",
",",
"gen_rtx_MINUS",
"(",
"Pmode",
",",
"reg1",
",",
"sr",
".",
"reg",
")",
")",
";",
"emit_insn",
"(",
"gen_probe_stack_range",
"(",
"reg1",
",",
"reg1",
",",
"sr",
".",
"reg",
")",
")",
";",
"if",
"(",
"size",
"!=",
"rounded_size",
")",
"{",
"HOST_WIDE_INT",
"rem",
"=",
"size",
"-",
"rounded_size",
";",
"if",
"(",
"rem",
">",
"<NUM_LIT>",
"||",
"(",
"TARGET_THUMB2",
"&&",
"rem",
">",
"<NUM_LIT>",
")",
")",
"{",
"emit_set_insn",
"(",
"sr",
".",
"reg",
",",
"plus_constant",
"(",
"Pmode",
",",
"sr",
".",
"reg",
",",
"-",
"PROBE_INTERVAL",
")",
")",
";",
"emit_stack_probe",
"(",
"plus_constant",
"(",
"Pmode",
",",
"sr",
".",
"reg",
",",
"PROBE_INTERVAL",
"-",
"rem",
")",
")",
";"
] |
LLVM | X86 | TD | stmt_completion | CPU | 3,673 | [
"(",
"!",
"cast",
"<",
"I",
">",
"(",
"OpcPrefix",
"#",
"DQrm",
")",
"addr",
":",
"$",
"src",
")",
">",
";"
] | [
"def",
":",
"Pat",
"<",
"(",
"v2i64",
"(",
"ExtOp",
"(",
"bc_v4i32",
"(",
"v2f64",
"(",
"scalar_to_vector",
"(",
"loadf64",
"addr",
":",
"$",
"src",
")",
")",
")",
")",
")",
")",
","
] |
LLVM | MOS | CPP | next_suggestion | MPU | 3,674 | [
"}"
] | [
"void",
"addFastRegAlloc",
"(",
")",
"override",
"{",
"addOptimizedRegAlloc",
"(",
")",
";"
] |
GCC | i386 | MD | stmt_completion | CPU | 3,675 | [
"<STR_LIT>",
")",
")",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>"
] |
GCC | sh | MD | stmt_completion | CPU | 3,676 | [
"<STR_LIT>",
")"
] | [
"[",
"(",
"set",
"(",
"match_operand",
":",
"V4HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"vec_select",
":",
"V4HI",
"(",
"vec_concat",
":",
"V8HI",
"(",
"match_operand",
":",
"V4HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"V4HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"parallel",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
")",
")",
")",
"]",
"<STR_LIT>",
"{",
"return",
"(",
"TARGET_LITTLE_ENDIAN",
"?",
"<STR_LIT>",
":"
] |
LLVM | SystemZ | CPP | stmt_completion | CPU | 3,677 | [
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<NUM_LIT>",
")",
";"
] | [
"return",
"decodeRegisterClass",
"(",
"Inst",
",",
"RegNo",
","
] |
GCC | alpha | CPP | next_suggestion | MPU | 3,678 | [
"add_op",
"=",
"GEN_INT",
"(",
"f",
")",
";"
] | [
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"copy_rtx",
"(",
"subtarget",
")",
",",
"tmp",
")",
")",
";",
"tmp",
"=",
"gen_rtx_ASHIFT",
"(",
"DImode",
",",
"copy_rtx",
"(",
"subtarget",
")",
",",
"GEN_INT",
"(",
"exact_log2",
"(",
"t",
")",
")",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"target",
",",
"tmp",
")",
")",
";",
"}",
"else",
"if",
"(",
"f",
"==",
"<NUM_LIT>",
"&&",
"t",
"==",
"-",
"<NUM_LIT>",
")",
"{",
"tmp",
"=",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"DImode",
",",
"cond",
",",
"const0_rtx",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"copy_rtx",
"(",
"subtarget",
")",
",",
"tmp",
")",
")",
";",
"emit_insn",
"(",
"gen_negdi2",
"(",
"target",
",",
"copy_rtx",
"(",
"subtarget",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"diff",
"==",
"<NUM_LIT>",
"||",
"diff",
"==",
"<NUM_LIT>",
"||",
"diff",
"==",
"<NUM_LIT>",
")",
"{",
"rtx",
"add_op",
";",
"tmp",
"=",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"DImode",
",",
"cond",
",",
"const0_rtx",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"copy_rtx",
"(",
"subtarget",
")",
",",
"tmp",
")",
")",
";",
"if",
"(",
"diff",
"==",
"<NUM_LIT>",
")",
"emit_insn",
"(",
"gen_adddi3",
"(",
"target",
",",
"copy_rtx",
"(",
"subtarget",
")",
",",
"GEN_INT",
"(",
"f",
")",
")",
")",
";",
"else",
"{"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 3,679 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rd32",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rt32",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rs32",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rs32",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rd32",
";"
] |
LLVM | R600 | CPP | next_suggestion | GPU | 3,680 | [
"}"
] | [
"break",
";",
"}",
"case",
"AMDGPU",
"::",
"SI_SPILL_S512_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_S256_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_S128_RESTORE",
":",
"case",
"AMDGPU",
"::",
"SI_SPILL_S64_RESTORE",
":",
"{",
"unsigned",
"NumSubRegs",
"=",
"getNumSubRegsForSpillOp",
"(",
"MI",
"->",
"getOpcode",
"(",
")",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"NumSubRegs",
";",
"i",
"<",
"e",
";",
"++",
"i",
")",
"{",
"SIMachineFunctionInfo",
"::",
"SpilledReg",
"Spill",
";",
"unsigned",
"FrameIndex",
"=",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
";",
"unsigned",
"SubReg",
"=",
"RI",
".",
"getPhysRegSubReg",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
",",
"&",
"AMDGPU",
"::",
"SGPR_32RegClass",
",",
"i",
")",
";",
"Spill",
"=",
"MFI",
"->",
"SpillTracker",
".",
"getSpilledReg",
"(",
"FrameIndex",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"get",
"(",
"AMDGPU",
"::",
"V_READLANE_B32",
")",
",",
"SubReg",
")",
".",
"addReg",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
".",
"addImm",
"(",
"Spill",
".",
"Lane",
"+",
"i",
")",
";",
"}",
"MI",
"->",
"eraseFromParent",
"(",
")",
";",
"break",
";"
] |
LLVM | ARM | CPP | stmt_completion | CPU | 3,681 | [
"Out of range shift amount",
"<STR_LIT>",
")",
";"
] | [
"unsigned",
"ShImm",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"MO2",
".",
"getImm",
"(",
")",
")",
";",
"bool",
"isAdd",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"MO2",
".",
"getImm",
"(",
")",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"<STR_LIT>",
"::",
"<STR_LIT>",
"ShOp",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"MO2",
".",
"getImm",
"(",
")",
")",
";",
"unsigned",
"SBits",
"=",
"getShiftOp",
"(",
"ShOp",
")",
";",
"assert",
"(",
"(",
"ShImm",
"&",
"~",
"<NUM_LIT>",
")",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>"
] |
GCC | i386 | MD | stmt_completion | CPU | 3,682 | [
"<STR_LIT>",
"<STR_LIT>",
")"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"TF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"any_logic",
":",
"TF",
"(",
"match_operand",
":",
"TF",
"<NUM_LIT>"
] |
GCC | mips | MD | stmt_completion | CPU | 3,683 | [
"]",
",",
"operands",
"[",
"<NUM_LIT>",
"]",
")",
")"
] | [
"<STR_LIT>",
"{",
"if",
"(",
"mips_legitimize_move",
"(",
"DImode",
",",
"operands",
"[",
"<NUM_LIT>"
] |
GCC | sh | CPP | code_generation | CPU | 3,684 | [
"static",
"rtx_insn",
"*",
"gen_block_redirect",
"(",
"rtx_insn",
"*",
"jump",
",",
"int",
"addr",
",",
"int",
"need_block",
")",
"{",
"int",
"dead",
"=",
"<NUM_LIT>",
";",
"rtx_insn",
"*",
"prev",
"=",
"prev_nonnote_insn",
"(",
"jump",
")",
";",
"if",
"(",
"prev",
"&&",
"NONJUMP_INSN_P",
"(",
"prev",
")",
"&&",
"!",
"prev",
"->",
"delete",
"d",
"(",
")",
")",
"{",
"if",
"(",
"INSN_CODE",
"(",
"prev",
")",
"==",
"CODE_FOR_indirect_jump_scratch",
")",
"return",
"prev",
";",
"if",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"prev",
")",
")",
"==",
"USE",
"||",
"GET_CODE",
"(",
"PATTERN",
"(",
"prev",
")",
")",
"==",
"CLOBBER",
"||",
"get_attr_in_delay_slot",
"(",
"prev",
")",
"==",
"IN_DELAY_SLOT_YES",
")",
"prev",
"=",
"jump",
";",
"else",
"if",
"(",
"(",
"need_block",
"&=",
"~",
"<NUM_LIT>",
")",
"<",
"<NUM_LIT>",
")",
"return",
"prev",
";",
"else",
"if",
"(",
"recog_memoized",
"(",
"prev",
")",
"==",
"CODE_FOR_block_branch_redirect",
")",
"need_block",
"=",
"<NUM_LIT>",
";",
"}",
"if",
"(",
"GET_CODE",
"(",
"PATTERN",
"(",
"jump",
")",
")",
"==",
"RETURN",
")",
"{",
"if",
"(",
"!",
"need_block",
")",
"return",
"prev",
";",
"return",
"emit_insn_before",
"(",
"gen_block_branch_redirect",
"(",
"const0_rtx",
")",
",",
"jump",
")",
";",
"}",
"rtx",
"dest",
"=",
"XEXP",
"(",
"SET_SRC",
"(",
"PATTERN",
"(",
"jump",
")",
")",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"optimize",
"&&",
"(",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"dest",
")",
")",
"-",
"addr",
"+",
"(",
"unsigned",
")",
"<NUM_LIT>",
">",
"<NUM_LIT>",
"+",
"<NUM_LIT>",
")",
")",
"{",
"rtx_insn",
"*",
"scan",
";",
"unsigned",
"attempt",
"=",
"<NUM_LIT>",
",",
"used",
";",
"int",
"jump_left",
"=",
"flag_expensive_optimizations",
"+",
"<NUM_LIT>",
";",
"for",
"(",
"scan",
"=",
"jump",
";",
"(",
"scan",
"=",
"PREV_INSN",
"(",
"scan",
")",
")",
";",
")",
"{",
"if",
"(",
"scan",
"->",
"delete",
"d",
"(",
")",
")",
"continue",
";",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"scan",
")",
";",
"if",
"(",
"code",
"==",
"CODE_LABEL",
"||",
"code",
"==",
"JUMP_INSN",
")",
"break",
";",
"if",
"(",
"code",
"==",
"INSN",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"scan",
")",
")",
"!=",
"USE",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"scan",
")",
")",
"!=",
"CLOBBER",
"&&",
"get_attr_in_delay_slot",
"(",
"scan",
")",
"==",
"IN_DELAY_SLOT_YES",
")",
"{",
"attempt",
"&=",
"~",
"regs_used",
"(",
"PATTERN",
"(",
"scan",
")",
",",
"<NUM_LIT>",
")",
";",
"break",
";",
"}",
"}",
"for",
"(",
"used",
"=",
"dead",
"=",
"<NUM_LIT>",
",",
"scan",
"=",
"JUMP_LABEL_AS_INSN",
"(",
"jump",
")",
";",
"(",
"scan",
"=",
"NEXT_INSN",
"(",
"scan",
")",
")",
";",
")",
"{",
"if",
"(",
"scan",
"->",
"delete",
"d",
"(",
")",
")",
"continue",
";",
"rtx_code",
"code",
"=",
"GET_CODE",
"(",
"scan",
")",
";",
"if",
"(",
"INSN_P",
"(",
"scan",
")",
")",
"{",
"used",
"|=",
"regs_used",
"(",
"PATTERN",
"(",
"scan",
")",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"code",
"==",
"CALL_INSN",
")",
"used",
"|=",
"regs_used",
"(",
"CALL_INSN_FUNCTION_USAGE",
"(",
"scan",
")",
",",
"<NUM_LIT>",
")",
";",
"dead",
"|=",
"(",
"used",
">>",
"<NUM_LIT>",
")",
"&",
"~",
"used",
";",
"if",
"(",
"dead",
"&",
"attempt",
")",
"{",
"dead",
"&=",
"attempt",
";",
"break",
";",
"}",
"if",
"(",
"code",
"==",
"JUMP_INSN",
")",
"{",
"if",
"(",
"jump_left",
"--",
"&&",
"simplejump_p",
"(",
"scan",
")",
")",
"scan",
"=",
"JUMP_LABEL_AS_INSN",
"(",
"scan",
")",
";",
"else",
"break",
";",
"}",
"}",
"}",
"dead",
"&=",
"<NUM_LIT>",
";",
"}",
"else",
"if",
"(",
"optimize",
"&&",
"need_block",
">=",
"<NUM_LIT>",
")",
"{",
"rtx_insn",
"*",
"next",
"=",
"next_active_insn",
"(",
"as_a",
"<",
"rtx_insn",
"*",
">",
"(",
"dest",
")",
")",
";",
"next",
"=",
"next_active_insn",
"(",
"next",
")",
";",
"if",
"(",
"next",
"&&",
"JUMP_P",
"(",
"next",
")",
"&&",
"GET_CODE",
"(",
"PATTERN",
"(",
"next",
")",
")",
"==",
"SET",
"&&",
"recog_memoized",
"(",
"next",
")",
"==",
"CODE_FOR_jump_compact",
")",
"{",
"dest",
"=",
"JUMP_LABEL",
"(",
"next",
")",
";",
"if",
"(",
"dest",
"&&",
"(",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"dest",
")",
")",
"-",
"addr",
"+",
"(",
"unsigned",
")",
"<NUM_LIT>",
">",
"<NUM_LIT>",
"+",
"<NUM_LIT>",
")",
")",
"gen_block_redirect",
"(",
"next",
",",
"INSN_ADDRESSES",
"(",
"INSN_UID",
"(",
"next",
")",
")",
",",
"-",
"<NUM_LIT>",
")",
";",
"}",
"}",
"if",
"(",
"dead",
")",
"{",
"rtx",
"reg",
"=",
"gen_rtx_REG",
"(",
"SImode",
",",
"exact_log2",
"(",
"dead",
"&",
"-",
"dead",
")",
")",
";",
"rtx_insn",
"*",
"insn",
"=",
"emit_insn_before",
"(",
"gen_indirect_jump_scratch",
"(",
"reg",
",",
"GEN_INT",
"(",
"unspec_bbr_uid",
"++",
")",
")",
",",
"jump",
")",
";",
"INSN_LOCATION",
"(",
"insn",
")",
"=",
"INSN_LOCATION",
"(",
"jump",
")",
";",
"INSN_CODE",
"(",
"insn",
")",
"=",
"CODE_FOR_indirect_jump_scratch",
";",
"return",
"insn",
";",
"}",
"else",
"if",
"(",
"need_block",
")",
"return",
"emit_insn_before",
"(",
"gen_block_branch_redirect",
"(",
"GEN_INT",
"(",
"unspec_bbr_uid",
"++",
")",
")",
",",
"jump",
")",
";",
"return",
"prev",
";",
"}"
] | [
"Create",
"an",
"instruction",
"that",
"prevents",
"redirection",
"of",
"a",
"conditional",
"branch",
"to",
"the",
"destination",
"of",
"the",
"JUMP",
"with",
"address",
"ADDR",
".",
"If",
"the",
"branch",
"needs",
"to",
"be",
"implemented",
"as",
"an",
"indirect",
"jump",
",",
"try",
"to",
"find",
"a",
"scratch",
"register",
"for",
"it",
".",
"If",
"NEED_BLOCK",
"is",
"0",
",",
"do",
"n't",
"do",
"anything",
"unless",
"we",
"need",
"a",
"scratch",
"register",
".",
"If",
"any",
"preceding",
"insn",
"that",
"does",
"n't",
"fit",
"into",
"a",
"delay",
"slot",
"is",
"good",
"enough",
",",
"pass",
"1",
".",
"Pass",
"2",
"if",
"a",
"definite",
"blocking",
"insn",
"is",
"needed",
".",
"-1",
"is",
"used",
"internally",
"to",
"avoid",
"deep",
"recursion",
".",
"If",
"a",
"blocking",
"instruction",
"is",
"made",
"or",
"recognized",
",",
"return",
"it",
"."
] |
LLVM | ARM | CPP | code_generation | CPU | 3,685 | [
"const",
"LegalizerInfo",
"*",
"ARMSubtarget",
"::",
"getLegalizerInfo",
"(",
")",
"const",
"{",
"assert",
"(",
"GISel",
"&&",
"<STR_LIT>",
"Access to GlobalISel APIs not set",
"<STR_LIT>",
")",
";",
"return",
"GISel",
"->",
"getLegalizerInfo",
"(",
")",
";",
"}"
] | [
"Expose",
"LegalizerInfo",
"so",
"the",
"clients",
"can",
"re-use",
"."
] |
LLVM | SystemZ | CPP | program_repair | CPU | 3,686 | [
"<FIXS>",
"uint64_t",
"SystemZMCCodeEmitter",
"::",
"getDispOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"unsigned",
"OpNum",
",",
"SmallVectorImpl",
"MCFixup",
">",
"&",
"Fixups",
",",
"const",
"MCSubtargetInfo",
"&",
"STI",
",",
"unsigned",
"OpSize",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
"Kind",
")",
"const",
"{",
"<FIXE>",
"<FIXS>",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"<FIXE>",
"<FIXS>",
"<FIXE>",
"<FIXS>",
"unsigned",
"MIBitSize",
"=",
"MCII",
".",
"get",
"(",
"MI",
".",
"getOpcode",
"(",
")",
")",
".",
"getSize",
"(",
")",
"*",
"<NUM_LIT>",
";",
"uint32_t",
"RawBitOffset",
"=",
"getOperandBitOffset",
"(",
"MI",
",",
"OpNum",
",",
"STI",
")",
";",
"uint32_t",
"BitOffset",
"=",
"MIBitSize",
"-",
"RawBitOffset",
"-",
"OpSize",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"BitOffset",
">>",
"<NUM_LIT>",
",",
"MO",
".",
"getExpr",
"(",
")",
",",
"(",
"MCFixupKind",
")",
"Kind",
",",
"MI",
".",
"getLoc",
"(",
")",
")",
")",
";",
"<FIXE>"
] | [
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unexpected operand type!",
"<STR_LIT>",
")",
";",
"}",
"<BUGS>",
"uint64_t",
"SystemZMCCodeEmitter",
"::",
"getDispOpValue",
"(",
"const",
"MCInst",
"&",
"MI",
",",
"unsigned",
"OpNum",
",",
"SmallVectorImpl",
"MCFixup",
">",
"&",
"Fixups",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
"Kind",
")",
"const",
"{",
"<BUGE>",
"const",
"MCOperand",
"&",
"MO",
"=",
"MI",
".",
"getOperand",
"(",
"OpNum",
")",
";",
"<BUGS>",
"if",
"(",
"MO",
".",
"isImm",
"(",
")",
")",
"{",
"++",
"MemOpsEmitted",
";",
"<BUGE>",
"return",
"static_cast",
"uint64_t",
">",
"(",
"MO",
".",
"getImm",
"(",
")",
")",
";",
"<BUGS>",
"}",
"<BUGE>",
"if",
"(",
"MO",
".",
"isExpr",
"(",
")",
")",
"{",
"<BUGS>",
"unsigned",
"ByteOffs",
"=",
"MemOpsEmitted",
"++",
"==",
"<NUM_LIT>",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
";",
"Fixups",
".",
"push_back",
"(",
"MCFixup",
"::",
"create",
"(",
"ByteOffs",
",",
"MO",
".",
"getExpr",
"(",
")",
",",
"(",
"MCFixupKind",
")",
"Kind",
",",
"MI",
".",
"getLoc",
"(",
")",
")",
")",
";",
"<BUGE>",
"assert",
"(",
"Fixups",
".",
"size",
"(",
")",
"<=",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"More than two memory operands in MI?",
"<STR_LIT>",
")",
";",
"return",
"<NUM_LIT>",
";",
"}"
] |
LLVM | PowerPC | TD | stmt_completion | CPU | 3,687 | [
",",
"DIVWE",
",",
"DIVWEO",
",",
"DIVWEU",
",",
"DIVWEUO",
")",
">",
";"
] | [
"def",
":",
"InstRW",
"<",
"[",
"P10W_DV_25C",
",",
"P10W_DISP_ANY",
",",
"P10DV_Read",
",",
"P10DV_Read",
"]",
",",
"(",
"instrs",
"DIVD",
",",
"DIVDO",
",",
"DIVDU",
",",
"DIVDUO"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 3,688 | [
"<STR_LIT>",
";"
] | [
"let",
"DecoderMethod",
"=",
"<STR_LIT>",
";",
"let",
"PrintMethod",
"="
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 3,689 | [
"}",
"=",
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>"
] |
GCC | i386 | CPP | next_suggestion | CPU | 3,690 | [
"}"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m512i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm512_srl_epi64",
"(",
"_",
"_",
"m512i",
"_",
"_",
"A",
",",
"_",
"_",
"m128i",
"_",
"_",
"B",
")",
"{",
"return",
"(",
"_",
"_",
"m512i",
")",
"_",
"_",
"builtin_ia32_psrlq512_mask",
"(",
"(",
"_",
"_",
"v8di",
")",
"_",
"_",
"A",
",",
"(",
"_",
"_",
"v2di",
")",
"_",
"_",
"B",
",",
"(",
"_",
"_",
"v8di",
")",
"_",
"mm512_undefined_epi32",
"(",
")",
",",
"(",
"_",
"_",
"mmask8",
")",
"-",
"<NUM_LIT>",
")",
";"
] |
GCC | aarch64 | CPP | stmt_completion | CPU | 3,691 | [
"index",
")",
";"
] | [
"return",
"_",
"_",
"aarch64_vset_lane_any",
"(",
"_",
"_",
"elem",
",",
"_",
"_",
"vec",
",",
"_",
"_"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 3,692 | [
"auto",
"X86FI",
"=",
"MF",
".",
"getInfo",
"<",
"X86MachineFunctionInfo",
">",
"(",
")",
";"
] | [
"else",
"if",
"(",
"RegVT",
".",
"is128BitVector",
"(",
")",
")",
"RC",
"=",
"Subtarget",
".",
"hasVLX",
"(",
")",
"?",
"&",
"X86",
"::",
"VR128XRegClass",
":",
"&",
"X86",
"::",
"VR128RegClass",
";",
"else",
"if",
"(",
"RegVT",
"==",
"MVT",
"::",
"x86mmx",
")",
"RC",
"=",
"&",
"X86",
"::",
"VR64RegClass",
";",
"else",
"if",
"(",
"RegVT",
"==",
"MVT",
"::",
"v1i1",
")",
"RC",
"=",
"&",
"X86",
"::",
"VK1RegClass",
";",
"else",
"if",
"(",
"RegVT",
"==",
"MVT",
"::",
"v8i1",
")",
"RC",
"=",
"&",
"X86",
"::",
"VK8RegClass",
";",
"else",
"if",
"(",
"RegVT",
"==",
"MVT",
"::",
"v16i1",
")",
"RC",
"=",
"&",
"X86",
"::",
"VK16RegClass",
";",
"else",
"if",
"(",
"RegVT",
"==",
"MVT",
"::",
"v32i1",
")",
"RC",
"=",
"&",
"X86",
"::",
"VK32RegClass",
";",
"else",
"if",
"(",
"RegVT",
"==",
"MVT",
"::",
"v64i1",
")",
"RC",
"=",
"&",
"X86",
"::",
"VK64RegClass",
";",
"else",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unknown argument type!",
"<STR_LIT>",
")",
";",
"Register",
"Reg",
"=",
"MF",
".",
"addLiveIn",
"(",
"VA",
".",
"getLocReg",
"(",
")",
",",
"RC",
")",
";",
"ArgValue",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"dl",
",",
"Reg",
",",
"RegVT",
")",
";",
"}",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"SExt",
")",
"ArgValue",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AssertSext",
",",
"dl",
",",
"RegVT",
",",
"ArgValue",
",",
"DAG",
".",
"getValueType",
"(",
"VA",
".",
"getValVT",
"(",
")",
")",
")",
";",
"else",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"ZExt",
")",
"ArgValue",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AssertZext",
",",
"dl",
",",
"RegVT",
",",
"ArgValue",
",",
"DAG",
".",
"getValueType",
"(",
"VA",
".",
"getValVT",
"(",
")",
")",
")",
";",
"else",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"BCvt",
")",
"ArgValue",
"=",
"DAG",
".",
"getBitcast",
"(",
"VA",
".",
"getValVT",
"(",
")",
",",
"ArgValue",
")",
";",
"if",
"(",
"VA",
".",
"isExtInLoc",
"(",
")",
")",
"{",
"if",
"(",
"RegVT",
".",
"isVector",
"(",
")",
"&&",
"VA",
".",
"getValVT",
"(",
")",
".",
"getScalarType",
"(",
")",
"!=",
"MVT",
"::",
"i1",
")",
"ArgValue",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"VA",
".",
"getValVT",
"(",
")",
",",
"ArgValue",
")",
";",
"else",
"if",
"(",
"VA",
".",
"getValVT",
"(",
")",
".",
"isVector",
"(",
")",
"&&",
"VA",
".",
"getValVT",
"(",
")",
".",
"getScalarType",
"(",
")",
"==",
"MVT",
"::",
"i1",
"&&",
"(",
"(",
"VA",
".",
"getLocVT",
"(",
")",
"==",
"MVT",
"::",
"i64",
")",
"||",
"(",
"VA",
".",
"getLocVT",
"(",
")",
"==",
"MVT",
"::",
"i32",
")",
"||",
"(",
"VA",
".",
"getLocVT",
"(",
")",
"==",
"MVT",
"::",
"i16",
")",
"||",
"(",
"VA",
".",
"getLocVT",
"(",
")",
"==",
"MVT",
"::",
"i8",
")",
")",
")",
"{",
"ArgValue",
"=",
"lowerRegToMasks",
"(",
"ArgValue",
",",
"VA",
".",
"getValVT",
"(",
")",
",",
"RegVT",
",",
"dl",
",",
"DAG",
")",
";",
"}",
"else",
"ArgValue",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TRUNCATE",
",",
"dl",
",",
"VA",
".",
"getValVT",
"(",
")",
",",
"ArgValue",
")",
";",
"}",
"}",
"else",
"{",
"assert",
"(",
"VA",
".",
"isMemLoc",
"(",
")",
")",
";",
"ArgValue",
"=",
"LowerMemArgument",
"(",
"Chain",
",",
"CallConv",
",",
"Ins",
",",
"dl",
",",
"DAG",
",",
"VA",
",",
"MFI",
",",
"InsIndex",
")",
";",
"}",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"Indirect",
"&&",
"!",
"Ins",
"[",
"I",
"]",
".",
"Flags",
".",
"isByVal",
"(",
")",
")",
"ArgValue",
"=",
"DAG",
".",
"getLoad",
"(",
"VA",
".",
"getValVT",
"(",
")",
",",
"dl",
",",
"Chain",
",",
"ArgValue",
",",
"MachinePointerInfo",
"(",
")",
")",
";",
"InVals",
".",
"push_back",
"(",
"ArgValue",
")",
";",
"}",
"for",
"(",
"unsigned",
"I",
"=",
"<NUM_LIT>",
",",
"E",
"=",
"Ins",
".",
"size",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
")",
"{",
"if",
"(",
"Ins",
"[",
"I",
"]",
".",
"Flags",
".",
"isSwiftAsync",
"(",
")",
")",
"{"
] |
GCC | rs6000 | MD | program_repair | CPU | 3,693 | [
"<FIXS>",
"<STR_LIT>",
"<FIXE>"
] | [
"[",
"(",
"set",
"(",
"match_operand",
":",
"CCFP",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"compare",
":",
"CCFP",
"(",
"match_operand",
":",
"SF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"SF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]",
"<BUGS>",
"<STR_LIT>",
"<BUGE>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
] |
LLVM | XCore | CPP | next_suggestion | MPU | 3,694 | [
"BuildMI",
"(",
"MBB",
",",
"I",
",",
"DL",
",",
"get",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
",",
"DestReg",
")",
".",
"addFrameIndex",
"(",
"FrameIndex",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";"
] | [
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
"->",
"getFrameInfo",
"(",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
"->",
"getMachineMemOperand",
"(",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"*",
"MF",
",",
"FrameIndex",
")",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"MFI",
".",
"getObjectSize",
"(",
"FrameIndex",
")",
",",
"MFI",
".",
"getObjectAlignment",
"(",
"FrameIndex",
")",
")",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 3,695 | [
"}"
] | [
"let",
"isBranch",
"=",
"<NUM_LIT>",
";",
"let",
"isNewValue",
"=",
"<NUM_LIT>",
";",
"let",
"cofMax1",
"=",
"<NUM_LIT>",
";",
"let",
"isRestrictNoSlot1Store",
"=",
"<NUM_LIT>",
";",
"let",
"Defs",
"=",
"[",
"PC",
"]",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isTaken",
"=",
"Inst",
"{",
"<NUM_LIT>",
"}",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentAlign",
"=",
"<NUM_LIT>",
";",
"let",
"opNewValue",
"=",
"<NUM_LIT>",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 3,696 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
GCC | arm | MD | stmt_completion | CPU | 3,697 | [
")",
"]"
] | [
"(",
"unspec",
":",
"V4HF",
"[",
"(",
"match_operand",
":",
"V4HF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"V4HF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_VPADD",
")"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 3,698 | [
"const",
"GlobalValue",
"*",
"GV",
"=",
"MO",
".",
"getGlobal",
"(",
")",
";"
] | [
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"<unknown operand type>",
"<STR_LIT>",
")",
";",
"case",
"MachineOperand",
"::",
"MO_Register",
":",
"{",
"unsigned",
"Reg",
"=",
"MO",
".",
"getReg",
"(",
")",
";",
"assert",
"(",
"TargetRegisterInfo",
"::",
"isPhysicalRegister",
"(",
"Reg",
")",
")",
";",
"assert",
"(",
"!",
"MO",
".",
"getSubReg",
"(",
")",
"&&",
"<STR_LIT>",
"Subregs should be eliminated!",
"<STR_LIT>",
")",
";",
"if",
"(",
"ARM",
"::",
"GPRPairRegClass",
".",
"contains",
"(",
"Reg",
")",
")",
"{",
"const",
"MachineFunction",
"&",
"MF",
"=",
"*",
"MI",
"->",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
";",
"const",
"TargetRegisterInfo",
"*",
"TRI",
"=",
"MF",
".",
"getTarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
";",
"Reg",
"=",
"TRI",
"->",
"getSubReg",
"(",
"Reg",
",",
"ARM",
"::",
"gsub_0",
")",
";",
"}",
"O",
"<<",
"ARMInstPrinter",
"::",
"getRegisterName",
"(",
"Reg",
")",
";",
"break",
";",
"}",
"case",
"MachineOperand",
"::",
"MO_Immediate",
":",
"{",
"int64_t",
"Imm",
"=",
"MO",
".",
"getImm",
"(",
")",
";",
"O",
"<<",
"'",
"#",
"'",
";",
"if",
"(",
"(",
"Modifier",
"&&",
"strcmp",
"(",
"Modifier",
",",
"<STR_LIT>",
"lo16",
"<STR_LIT>",
")",
"==",
"<NUM_LIT>",
")",
"||",
"(",
"TF",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
"O",
"<<",
"<STR_LIT>",
":lower16:",
"<STR_LIT>",
";",
"else",
"if",
"(",
"(",
"Modifier",
"&&",
"strcmp",
"(",
"Modifier",
",",
"<STR_LIT>",
"hi16",
"<STR_LIT>",
")",
"==",
"<NUM_LIT>",
")",
"||",
"(",
"TF",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
"O",
"<<",
"<STR_LIT>",
":upper16:",
"<STR_LIT>",
";",
"O",
"<<",
"Imm",
";",
"break",
";",
"}",
"case",
"MachineOperand",
"::",
"MO_MachineBasicBlock",
":",
"O",
"<<",
"*",
"MO",
".",
"getMBB",
"(",
")",
"->",
"getSymbol",
"(",
")",
";",
"return",
";",
"case",
"MachineOperand",
"::",
"MO_GlobalAddress",
":",
"{"
] |
GCC | ia64 | CPP | code_generation | CPU | 3,699 | [
"static",
"void",
"fix_range",
"(",
"const",
"char",
"*",
"const_str",
")",
"{",
"int",
"i",
",",
"first",
",",
"last",
";",
"char",
"*",
"str",
",",
"*",
"dash",
",",
"*",
"comma",
";",
"i",
"=",
"strlen",
"(",
"const_str",
")",
";",
"str",
"=",
"(",
"char",
"*",
")",
"alloca",
"(",
"i",
"+",
"<NUM_LIT>",
")",
";",
"memcpy",
"(",
"str",
",",
"const_str",
",",
"i",
"+",
"<NUM_LIT>",
")",
";",
"while",
"(",
"<NUM_LIT>",
")",
"{",
"dash",
"=",
"strchr",
"(",
"str",
",",
"'",
"-",
"'",
")",
";",
"if",
"(",
"!",
"dash",
")",
"{",
"warning",
"(",
"<NUM_LIT>",
",",
"<STR_LIT>",
"value of %<-mfixed-range%> must have form REG1-REG2",
"<STR_LIT>",
")",
";",
"return",
";",
"}",
"*",
"dash",
"=",
"'",
"\\0",
"'",
";",
"comma",
"=",
"strchr",
"(",
"dash",
"+",
"<NUM_LIT>",
",",
"'",
",",
"'",
")",
";",
"if",
"(",
"comma",
")",
"*",
"comma",
"=",
"'",
"\\0",
"'",
";",
"first",
"=",
"decode_reg_name",
"(",
"str",
")",
";",
"if",
"(",
"first",
"<",
"<NUM_LIT>",
")",
"{",
"warning",
"(",
"<NUM_LIT>",
",",
"<STR_LIT>",
"unknown register name: %s",
"<STR_LIT>",
",",
"str",
")",
";",
"return",
";",
"}",
"last",
"=",
"decode_reg_name",
"(",
"dash",
"+",
"<NUM_LIT>",
")",
";",
"if",
"(",
"last",
"<",
"<NUM_LIT>",
")",
"{",
"warning",
"(",
"<NUM_LIT>",
",",
"<STR_LIT>",
"unknown register name: %s",
"<STR_LIT>",
",",
"dash",
"+",
"<NUM_LIT>",
")",
";",
"return",
";",
"}",
"*",
"dash",
"=",
"'",
"-",
"'",
";",
"if",
"(",
"first",
">",
"last",
")",
"{",
"warning",
"(",
"<NUM_LIT>",
",",
"<STR_LIT>",
"%s-%s is an empty range",
"<STR_LIT>",
",",
"str",
",",
"dash",
"+",
"<NUM_LIT>",
")",
";",
"return",
";",
"}",
"for",
"(",
"i",
"=",
"first",
";",
"i",
"<=",
"last",
";",
"++",
"i",
")",
"fixed_regs",
"[",
"i",
"]",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"!",
"comma",
")",
"break",
";",
"*",
"comma",
"=",
"'",
",",
"'",
";",
"str",
"=",
"comma",
"+",
"<NUM_LIT>",
";",
"}",
"}"
] | [
"Parse",
"the",
"-mfixed-range=",
"option",
"string",
"."
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.