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 | ARM | TD | next_suggestion | CPU | 621,800 | [
"}"
] | [
"def",
"AddrMode2AsmOperand",
":",
"AsmOperandClass",
"{",
"let",
"Name",
"=",
"<STR_LIT>",
";",
"}",
"def",
"addrmode2",
":",
"MemOperand",
",",
"ComplexPattern",
"<",
"i32",
",",
"<NUM_LIT>",
",",
"<STR_LIT>",
",",
"[",
"]",
">",
"{",
"let",
"EncoderMethod",
"=",
"<STR_LIT>",
";",
"let",
"PrintMethod",
"=",
"<STR_LIT>",
";",
"let",
"ParserMatchClass",
"=",
"AddrMode2AsmOperand",
";",
"let",
"MIOperandInfo",
"=",
"(",
"ops",
"GPR",
":",
"$",
"base",
",",
"GPR",
":",
"$",
"offsreg",
",",
"i32imm",
":",
"$",
"offsimm",
")",
";"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 621,801 | [
"case",
"'",
"P",
"'",
":"
] | [
"bool",
"X86ATTAsmPrinter",
"::",
"PrintAsmMemoryOperand",
"(",
"const",
"MachineInstr",
"*",
"MI",
",",
"unsigned",
"OpNo",
",",
"unsigned",
"AsmVariant",
",",
"const",
"char",
"*",
"ExtraCode",
")",
"{",
"if",
"(",
"ExtraCode",
"&&",
"ExtraCode",
"[",
"<NUM_LIT>",
"]",
")",
"{",
"if",
"(",
"ExtraCode",
"[",
"<NUM_LIT>",
"]",
"!=",
"<NUM_LIT>",
")",
"return",
"true",
";",
"switch",
"(",
"ExtraCode",
"[",
"<NUM_LIT>",
"]",
")",
"{",
"default",
":",
"return",
"true",
";",
"case",
"'",
"b",
"'",
":",
"case",
"'",
"h",
"'",
":",
"case",
"'",
"w",
"'",
":",
"case",
"'",
"k",
"'",
":",
"case",
"'",
"q",
"'",
":",
"break",
";"
] |
LLVM | AArch64 | CPP | code_generation | CPU | 621,802 | [
"int",
"AArch64TTIImpl",
"::",
"getArithmeticReductionCost",
"(",
"unsigned",
"Opcode",
",",
"Type",
"*",
"ValTy",
",",
"bool",
"IsPairwiseForm",
")",
"{",
"if",
"(",
"IsPairwiseForm",
")",
"return",
"BaseT",
"::",
"getArithmeticReductionCost",
"(",
"Opcode",
",",
"ValTy",
",",
"IsPairwiseForm",
")",
";",
"std",
"::",
"pair",
"<",
"int",
",",
"MVT",
">",
"LT",
"=",
"TLI",
"->",
"getTypeLegalizationCost",
"(",
"DL",
",",
"ValTy",
")",
";",
"MVT",
"MTy",
"=",
"LT",
".",
"second",
";",
"int",
"ISD",
"=",
"TLI",
"->",
"InstructionOpcodeToISD",
"(",
"Opcode",
")",
";",
"assert",
"(",
"ISD",
"&&",
"<STR_LIT>",
"Invalid opcode",
"<STR_LIT>",
")",
";",
"static",
"const",
"CostTblEntry",
"CostTblNoPairwise",
"[",
"]",
"{",
"{",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"v8i8",
",",
"<NUM_LIT>",
"}",
",",
"{",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"v16i8",
",",
"<NUM_LIT>",
"}",
",",
"{",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"v4i16",
",",
"<NUM_LIT>",
"}",
",",
"{",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"v8i16",
",",
"<NUM_LIT>",
"}",
",",
"{",
"ISD",
"::",
"ADD",
",",
"MVT",
"::",
"v4i32",
",",
"<NUM_LIT>",
"}",
",",
"}",
";",
"if",
"(",
"const",
"auto",
"*",
"Entry",
"=",
"CostTableLookup",
"(",
"CostTblNoPairwise",
",",
"ISD",
",",
"MTy",
")",
")",
"return",
"LT",
".",
"first",
"*",
"Entry",
"->",
"Cost",
";",
"return",
"BaseT",
"::",
"getArithmeticReductionCost",
"(",
"Opcode",
",",
"ValTy",
",",
"IsPairwiseForm",
")",
";",
"}"
] | [
"Calculate",
"the",
"cost",
"of",
"vector",
"reduction",
"intrinsics",
"."
] |
LLVM | GBZ80 | CPP | stmt_completion | MPU | 621,803 | [
")",
";"
] | [
"return",
"getRegisterName",
"(",
"RegNo"
] |
LLVM | Patmos | CPP | stmt_completion | VLIW | 621,804 | [
")",
"const",
"{"
] | [
"const",
"PatmosRegisterInfo",
"&",
"getPatmosRegisterInfo",
"("
] |
LLVM | SystemZ | CPP | code_generation | CPU | 621,805 | [
"std",
"::",
"pair",
"<",
"SDValue",
",",
"SDValue",
">",
"SystemZSelectionDAGInfo",
"::",
"EmitTargetCodeForMemcmp",
"(",
"SelectionDAG",
"&",
"DAG",
",",
"SDLoc",
"DL",
",",
"SDValue",
"Chain",
",",
"SDValue",
"Src1",
",",
"SDValue",
"Src2",
",",
"SDValue",
"Size",
",",
"MachinePointerInfo",
"Op1PtrInfo",
",",
"MachinePointerInfo",
"Op2PtrInfo",
")",
"const",
"{",
"if",
"(",
"auto",
"*",
"CSize",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Size",
")",
")",
"{",
"uint64_t",
"Bytes",
"=",
"CSize",
"->",
"getZExtValue",
"(",
")",
";",
"assert",
"(",
"Bytes",
">",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Caller should have handled 0-size case",
"<STR_LIT>",
")",
";",
"Chain",
"=",
"emitCLC",
"(",
"DAG",
",",
"DL",
",",
"Chain",
",",
"Src1",
",",
"Src2",
",",
"Bytes",
")",
";",
"SDValue",
"Glue",
"=",
"Chain",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
";",
"return",
"std",
"::",
"make_pair",
"(",
"addIPMSequence",
"(",
"DL",
",",
"Glue",
",",
"DAG",
")",
",",
"Chain",
")",
";",
"}",
"return",
"std",
"::",
"make_pair",
"(",
"SDValue",
"(",
")",
",",
"SDValue",
"(",
")",
")",
";",
"}"
] | [
"Emit",
"target-specific",
"code",
"that",
"performs",
"a",
"memcmp/bcmp",
",",
"in",
"cases",
"where",
"that",
"is",
"faster",
"than",
"a",
"libcall",
"."
] |
GCC | aarch64 | CPP | code_generation | CPU | 621,806 | [
"static",
"void",
"aarch64_init_builtins",
"(",
")",
"{",
"aarch64_general_init_builtins",
"(",
")",
";",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
")",
";",
"}"
] | [
"Implement",
"TARGET_INIT_BUILTINS",
"."
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 621,807 | [
",",
"OpNo",
")",
")",
"/",
"<NUM_LIT>",
";"
] | [
"unsigned",
"getOpSize",
"(",
"const",
"MachineInstr",
"&",
"MI",
",",
"unsigned",
"OpNo",
")",
"const",
"{",
"return",
"RI",
".",
"getRegSizeInBits",
"(",
"*",
"getOpRegClass",
"(",
"MI"
] |
LLVM | SystemZ | CPP | stmt_completion | CPU | 621,808 | [
"BackChain",
",",
"MachinePointerInfo",
"(",
")",
")",
";"
] | [
"if",
"(",
"Depth",
">",
"<NUM_LIT>",
")",
"{",
"if",
"(",
"!",
"MF",
".",
"getSubtarget",
"<",
"SystemZSubtarget",
">",
"(",
")",
".",
"hasBackChain",
"(",
")",
")",
"report_fatal_error",
"(",
"<STR_LIT>",
"Unsupported stack frame traversal count",
"<STR_LIT>",
")",
";",
"SDValue",
"Offset",
"=",
"DAG",
".",
"getConstant",
"(",
"TFL",
"->",
"getBackchainOffset",
"(",
"MF",
")",
",",
"DL",
",",
"PtrVT",
")",
";",
"while",
"(",
"Depth",
"--",
")",
"{",
"BackChain",
"=",
"DAG",
".",
"getLoad",
"(",
"PtrVT",
",",
"DL",
",",
"DAG",
".",
"getEntryNode",
"(",
")",
","
] |
LLVM | Sparc | CPP | next_suggestion | CPU | 621,809 | [
"CommentString",
"=",
"<STR_LIT>",
"!",
"<STR_LIT>",
";"
] | [
"SparcELFMCAsmInfo",
"::",
"SparcELFMCAsmInfo",
"(",
"const",
"Triple",
"&",
"TheTriple",
")",
"{",
"bool",
"isV9",
"=",
"(",
"TheTriple",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"sparcv9",
")",
";",
"IsLittleEndian",
"=",
"(",
"TheTriple",
".",
"getArch",
"(",
")",
"==",
"Triple",
"::",
"sparcel",
")",
";",
"if",
"(",
"isV9",
")",
"{",
"PointerSize",
"=",
"CalleeSaveStackSlotSize",
"=",
"<NUM_LIT>",
";",
"}",
"Data16bitsDirective",
"=",
"<STR_LIT>",
"\\t.half\\t",
"<STR_LIT>",
";",
"Data32bitsDirective",
"=",
"<STR_LIT>",
"\\t.word\\t",
"<STR_LIT>",
";",
"Data64bitsDirective",
"=",
"(",
"isV9",
")",
"?",
"<STR_LIT>",
"\\t.xword\\t",
"<STR_LIT>",
":",
"nullptr",
";",
"ZeroDirective",
"=",
"<STR_LIT>",
"\\t.skip\\t",
"<STR_LIT>",
";"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 621,810 | [
".",
"getFixed",
"(",
")",
";"
] | [
"int",
"AArch64FrameLowering",
"::",
"getSEHFrameIndexOffset",
"(",
"const",
"MachineFunction",
"&",
"MF",
",",
"int",
"FI",
")",
"const",
"{",
"const",
"auto",
"*",
"RegInfo",
"=",
"static_cast",
"<",
"const",
"AArch64RegisterInfo",
"*",
">",
"(",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"getRegisterInfo",
"(",
")",
")",
";",
"int",
"ObjectOffset",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"getObjectOffset",
"(",
"FI",
")",
";",
"return",
"RegInfo",
"->",
"getLocalAddressRegister",
"(",
"MF",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"?",
"getFPOffset",
"(",
"MF",
",",
"ObjectOffset",
")",
".",
"getFixed",
"(",
")",
":",
"getStackOffset",
"(",
"MF",
",",
"ObjectOffset",
")"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 621,811 | [
"RetOps",
"[",
"<NUM_LIT>",
"]",
"=",
"Chain",
";"
] | [
"if",
"(",
"CallConv",
"==",
"CallingConv",
"::",
"X86_INTR",
"&&",
"!",
"Outs",
".",
"empty",
"(",
")",
")",
"report_fatal_error",
"(",
"<STR_LIT>",
"X86 interrupts may not return any value",
"<STR_LIT>",
")",
";",
"SmallVector",
"<",
"CCValAssign",
",",
"<NUM_LIT>",
">",
"RVLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"isVarArg",
",",
"MF",
",",
"RVLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"CCInfo",
".",
"AnalyzeReturn",
"(",
"Outs",
",",
"RetCC_X86",
")",
";",
"SDValue",
"Flag",
";",
"SmallVector",
"<",
"SDValue",
",",
"<NUM_LIT>",
">",
"RetOps",
";",
"RetOps",
".",
"push_back",
"(",
"Chain",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getTargetConstant",
"(",
"FuncInfo",
"->",
"getBytesToPopOnReturn",
"(",
")",
",",
"dl",
",",
"MVT",
"::",
"i32",
")",
")",
";",
"for",
"(",
"unsigned",
"I",
"=",
"<NUM_LIT>",
",",
"OutsIndex",
"=",
"<NUM_LIT>",
",",
"E",
"=",
"RVLocs",
".",
"size",
"(",
")",
";",
"I",
"!=",
"E",
";",
"++",
"I",
",",
"++",
"OutsIndex",
")",
"{",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"I",
"]",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&",
"<STR_LIT>",
"Can only return in registers!",
"<STR_LIT>",
")",
";",
"SDValue",
"ValToCopy",
"=",
"OutVals",
"[",
"OutsIndex",
"]",
";",
"EVT",
"ValVT",
"=",
"ValToCopy",
".",
"getValueType",
"(",
")",
";",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"SExt",
")",
"ValToCopy",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SIGN_EXTEND",
",",
"dl",
",",
"VA",
".",
"getLocVT",
"(",
")",
",",
"ValToCopy",
")",
";",
"else",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"ZExt",
")",
"ValToCopy",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ZERO_EXTEND",
",",
"dl",
",",
"VA",
".",
"getLocVT",
"(",
")",
",",
"ValToCopy",
")",
";",
"else",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"AExt",
")",
"{",
"if",
"(",
"ValVT",
".",
"isVector",
"(",
")",
"&&",
"ValVT",
".",
"getVectorElementType",
"(",
")",
"==",
"MVT",
"::",
"i1",
")",
"ValToCopy",
"=",
"lowerMasksToReg",
"(",
"ValToCopy",
",",
"VA",
".",
"getLocVT",
"(",
")",
",",
"dl",
",",
"DAG",
")",
";",
"else",
"ValToCopy",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ANY_EXTEND",
",",
"dl",
",",
"VA",
".",
"getLocVT",
"(",
")",
",",
"ValToCopy",
")",
";",
"}",
"else",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"BCvt",
")",
"ValToCopy",
"=",
"DAG",
".",
"getBitcast",
"(",
"VA",
".",
"getLocVT",
"(",
")",
",",
"ValToCopy",
")",
";",
"assert",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"!=",
"CCValAssign",
"::",
"FPExt",
"&&",
"<STR_LIT>",
"Unexpected FP-extend for return value.",
"<STR_LIT>",
")",
";",
"if",
"(",
"(",
"ValVT",
"==",
"MVT",
"::",
"f32",
"||",
"ValVT",
"==",
"MVT",
"::",
"f64",
"||",
"VA",
".",
"getLocReg",
"(",
")",
"==",
"X86",
"::",
"XMM0",
"||",
"VA",
".",
"getLocReg",
"(",
")",
"==",
"X86",
"::",
"XMM1",
")",
"&&",
"(",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"!",
"Subtarget",
".",
"hasSSE1",
"(",
")",
")",
")",
"{",
"report_fatal_error",
"(",
"<STR_LIT>",
"SSE register return with SSE disabled",
"<STR_LIT>",
")",
";",
"}",
"if",
"(",
"ValVT",
"==",
"MVT",
"::",
"f64",
"&&",
"(",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"!",
"Subtarget",
".",
"hasSSE2",
"(",
")",
")",
")",
"report_fatal_error",
"(",
"<STR_LIT>",
"SSE2 register return with SSE2 disabled",
"<STR_LIT>",
")",
";",
"if",
"(",
"VA",
".",
"getLocReg",
"(",
")",
"==",
"X86",
"::",
"FP0",
"||",
"VA",
".",
"getLocReg",
"(",
")",
"==",
"X86",
"::",
"FP1",
")",
"{",
"if",
"(",
"isScalarFPTypeInSSEReg",
"(",
"VA",
".",
"getValVT",
"(",
")",
")",
")",
"ValToCopy",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"FP_EXTEND",
",",
"dl",
",",
"MVT",
"::",
"f80",
",",
"ValToCopy",
")",
";",
"RetOps",
".",
"push_back",
"(",
"ValToCopy",
")",
";",
"continue",
";",
"}",
"if",
"(",
"Subtarget",
".",
"is64Bit",
"(",
")",
")",
"{",
"if",
"(",
"ValVT",
"==",
"MVT",
"::",
"x86mmx",
")",
"{",
"if",
"(",
"VA",
".",
"getLocReg",
"(",
")",
"==",
"X86",
"::",
"XMM0",
"||",
"VA",
".",
"getLocReg",
"(",
")",
"==",
"X86",
"::",
"XMM1",
")",
"{",
"ValToCopy",
"=",
"DAG",
".",
"getBitcast",
"(",
"MVT",
"::",
"i64",
",",
"ValToCopy",
")",
";",
"ValToCopy",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SCALAR_TO_VECTOR",
",",
"dl",
",",
"MVT",
"::",
"v2i64",
",",
"ValToCopy",
")",
";",
"if",
"(",
"!",
"Subtarget",
".",
"hasSSE2",
"(",
")",
")",
"ValToCopy",
"=",
"DAG",
".",
"getBitcast",
"(",
"MVT",
"::",
"v4f32",
",",
"ValToCopy",
")",
";",
"}",
"}",
"}",
"SmallVector",
"<",
"std",
"::",
"pair",
"<",
"unsigned",
",",
"SDValue",
">",
",",
"<NUM_LIT>",
">",
"RegsToPass",
";",
"if",
"(",
"VA",
".",
"needsCustom",
"(",
")",
")",
"{",
"assert",
"(",
"VA",
".",
"getValVT",
"(",
")",
"==",
"MVT",
"::",
"v64i1",
"&&",
"<STR_LIT>",
"Currently the only custom case is when we split v64i1 to 2 regs",
"<STR_LIT>",
")",
";",
"Passv64i1ArgInRegs",
"(",
"dl",
",",
"DAG",
",",
"Chain",
",",
"ValToCopy",
",",
"RegsToPass",
",",
"VA",
",",
"RVLocs",
"[",
"++",
"I",
"]",
",",
"Subtarget",
")",
";",
"assert",
"(",
"<NUM_LIT>",
"==",
"RegsToPass",
".",
"size",
"(",
")",
"&&",
"<STR_LIT>",
"Expecting two registers after Pass64BitArgInRegs",
"<STR_LIT>",
")",
";",
"}",
"else",
"{",
"RegsToPass",
".",
"push_back",
"(",
"std",
"::",
"make_pair",
"(",
"VA",
".",
"getLocReg",
"(",
")",
",",
"ValToCopy",
")",
")",
";",
"}",
"for",
"(",
"auto",
"&",
"Reg",
":",
"RegsToPass",
")",
"{",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"Reg",
".",
"first",
",",
"Reg",
".",
"second",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"Reg",
".",
"first",
",",
"Reg",
".",
"second",
".",
"getValueType",
"(",
")",
")",
")",
";",
"}",
"}",
"if",
"(",
"unsigned",
"SRetReg",
"=",
"FuncInfo",
"->",
"getSRetReturnReg",
"(",
")",
")",
"{",
"SDValue",
"Val",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"RetOps",
"[",
"<NUM_LIT>",
"]",
",",
"dl",
",",
"SRetReg",
",",
"getPointerTy",
"(",
"MF",
".",
"getDataLayout",
"(",
")",
")",
")",
";",
"unsigned",
"RetValReg",
"=",
"(",
"Subtarget",
".",
"is64Bit",
"(",
")",
"&&",
"!",
"Subtarget",
".",
"isTarget64BitILP32",
"(",
")",
")",
"?",
"X86",
"::",
"RAX",
":",
"X86",
"::",
"EAX",
";",
"Chain",
"=",
"DAG",
".",
"getCopyToReg",
"(",
"Chain",
",",
"dl",
",",
"RetValReg",
",",
"Val",
",",
"Flag",
")",
";",
"Flag",
"=",
"Chain",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
";",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"RetValReg",
",",
"getPointerTy",
"(",
"DAG",
".",
"getDataLayout",
"(",
")",
")",
")",
")",
";",
"}",
"const",
"X86RegisterInfo",
"*",
"TRI",
"=",
"Subtarget",
".",
"getRegisterInfo",
"(",
")",
";",
"const",
"MCPhysReg",
"*",
"I",
"=",
"TRI",
"->",
"getCalleeSavedRegsViaCopy",
"(",
"&",
"DAG",
".",
"getMachineFunction",
"(",
")",
")",
";",
"if",
"(",
"I",
")",
"{",
"for",
"(",
";",
"*",
"I",
";",
"++",
"I",
")",
"{",
"if",
"(",
"X86",
"::",
"GR64RegClass",
".",
"contains",
"(",
"*",
"I",
")",
")",
"RetOps",
".",
"push_back",
"(",
"DAG",
".",
"getRegister",
"(",
"*",
"I",
",",
"MVT",
"::",
"i64",
")",
")",
";",
"else",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unexpected register class in CSRsViaCopy!",
"<STR_LIT>",
")",
";",
"}",
"}"
] |
LLVM | PowerPC | CPP | next_suggestion | CPU | 621,812 | [
"}"
] | [
"static",
"unsigned",
"getFramePointerSaveOffset",
"(",
"bool",
"isPPC64",
",",
"bool",
"isDarwinABI",
")",
"{",
"if",
"(",
"isDarwinABI",
")",
"return",
"isPPC64",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
";",
"return",
"-",
"<NUM_LIT>",
"U",
";"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 621,813 | [
")",
";",
"return",
"NULL",
";"
] | [
"Value",
"*",
"X86IREmitter",
"::",
"visitRDSEED",
"(",
"const",
"SDNode",
"*",
"N",
")",
"{",
"llvm_unreachable",
"(",
"<STR_LIT>",
"visitRDSEED Unimplemented X86 visit...",
"<STR_LIT>"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 621,814 | [
"return",
"TRI",
"->",
"isAGPRClass",
"(",
"getDataRegClass",
"(",
"*",
"CI",
".",
"I",
")",
")",
"?",
"TRI",
"->",
"getAGPRClassForBitWidth",
"(",
"BitWidth",
")",
":",
"TRI",
"->",
"getVGPRClassForBitWidth",
"(",
"BitWidth",
")",
";"
] | [
"case",
"<NUM_LIT>",
":",
"return",
"&",
"AMDGPU",
"::",
"SGPR_256RegClass",
";",
"case",
"<NUM_LIT>",
":",
"return",
"&",
"AMDGPU",
"::",
"SGPR_512RegClass",
";",
"}",
"}",
"unsigned",
"BitWidth",
"=",
"<NUM_LIT>",
"*",
"(",
"CI",
".",
"Width",
"+",
"Paired",
".",
"Width",
")",
";"
] |
GCC | sparc | MD | stmt_completion | CPU | 621,815 | [
")"
] | [
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]"
] |
LLVM | MCS51 | CPP | code_generation | MPU | 621,816 | [
"bool",
"MCS51AsmBackend",
"::",
"writeNopData",
"(",
"raw_ostream",
"&",
"OS",
",",
"uint64_t",
"Count",
")",
"const",
"{",
"assert",
"(",
"(",
"Count",
"%",
"<NUM_LIT>",
")",
"==",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"NOP instructions must be 2 bytes",
"<STR_LIT>",
")",
";",
"OS",
".",
"write_zeros",
"(",
"Count",
")",
";",
"return",
"true",
";",
"}"
] | [
"Write",
"an",
"(",
"optimal",
")",
"nop",
"sequence",
"of",
"Count",
"bytes",
"to",
"the",
"given",
"output",
"."
] |
GCC | rs6000 | MD | next_suggestion | CPU | 621,817 | [
"<STR_LIT>"
] | [
"(",
"unspec",
":",
"V2DI",
"[",
"(",
"match_operand",
":",
"V2DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"V2DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_VCFUGED",
")",
")",
"]",
"<STR_LIT>"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 621,818 | [
"<NUM_LIT>",
";"
] | [
"def",
"A4_pzxtbt",
":",
"HInst",
"<",
"(",
"outs",
"IntRegs",
":",
"$",
"Rd32",
")",
",",
"(",
"ins",
"PredRegs",
":",
"$",
"Pu4",
",",
"IntRegs",
":",
"$",
"Rs32",
")",
",",
"<STR_LIT>",
",",
"tc_5a2711e5",
",",
"TypeALU32_2op",
">",
",",
"Enc_fb6577",
",",
"PredNewRel",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"="
] |
GCC | cris | CPP | code_generation | MPU | 621,819 | [
"int",
"cris_side_effect_mode_ok",
"(",
"enum",
"rtx_code",
"code",
",",
"rtx",
"*",
"ops",
",",
"int",
"lreg",
",",
"int",
"rreg",
",",
"int",
"rval",
",",
"int",
"multop",
",",
"int",
"other_op",
")",
"{",
"int",
"mult",
"=",
"multop",
"<",
"<NUM_LIT>",
"?",
"<NUM_LIT>",
":",
"INTVAL",
"(",
"ops",
"[",
"multop",
"]",
")",
";",
"rtx",
"reg_rtx",
"=",
"ops",
"[",
"rreg",
"]",
";",
"rtx",
"val_rtx",
"=",
"ops",
"[",
"rval",
"]",
";",
"if",
"(",
"!",
"BASE_P",
"(",
"reg_rtx",
")",
")",
"reg_rtx",
"=",
"val_rtx",
",",
"val_rtx",
"=",
"ops",
"[",
"rreg",
"]",
";",
"if",
"(",
"!",
"BASE_P",
"(",
"reg_rtx",
")",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"!",
"TARGET_SIDE_EFFECT_PREFIXES",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"GET_CODE",
"(",
"val_rtx",
")",
"==",
"MULT",
")",
"{",
"mult",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"val_rtx",
",",
"<NUM_LIT>",
")",
")",
";",
"val_rtx",
"=",
"XEXP",
"(",
"val_rtx",
",",
"<NUM_LIT>",
")",
";",
"code",
"=",
"MULT",
";",
"}",
"if",
"(",
"other_op",
">=",
"<NUM_LIT>",
")",
"{",
"if",
"(",
"GET_MODE_SIZE",
"(",
"GET_MODE",
"(",
"ops",
"[",
"other_op",
"]",
")",
")",
">",
"UNITS_PER_WORD",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"(",
"BASE_P",
"(",
"ops",
"[",
"lreg",
"]",
")",
"&&",
"BASE_P",
"(",
"ops",
"[",
"other_op",
"]",
")",
"&&",
"REGNO",
"(",
"ops",
"[",
"lreg",
"]",
")",
"==",
"REGNO",
"(",
"ops",
"[",
"other_op",
"]",
")",
")",
"||",
"rtx_equal_p",
"(",
"ops",
"[",
"other_op",
"]",
",",
"ops",
"[",
"lreg",
"]",
")",
")",
"return",
"<NUM_LIT>",
";",
"}",
"if",
"(",
"ops",
"[",
"lreg",
"]",
"==",
"frame_pointer_rtx",
"||",
"ops",
"[",
"rreg",
"]",
"==",
"frame_pointer_rtx",
"||",
"ops",
"[",
"rval",
"]",
"==",
"frame_pointer_rtx",
"||",
"(",
"other_op",
">=",
"<NUM_LIT>",
"&&",
"ops",
"[",
"other_op",
"]",
"==",
"frame_pointer_rtx",
")",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"code",
"==",
"PLUS",
"&&",
"!",
"BASE_P",
"(",
"val_rtx",
")",
")",
"{",
"if",
"(",
"rtx_equal_p",
"(",
"ops",
"[",
"lreg",
"]",
",",
"reg_rtx",
")",
"&&",
"GET_CODE",
"(",
"val_rtx",
")",
"==",
"CONST_INT",
"&&",
"(",
"INTVAL",
"(",
"val_rtx",
")",
"<=",
"<NUM_LIT>",
"&&",
"INTVAL",
"(",
"val_rtx",
")",
">=",
"-",
"<NUM_LIT>",
")",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"CONSTANT_P",
"(",
"val_rtx",
")",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"GET_CODE",
"(",
"val_rtx",
")",
"==",
"MEM",
"&&",
"BASE_OR_AUTOINCR_P",
"(",
"XEXP",
"(",
"val_rtx",
",",
"<NUM_LIT>",
")",
")",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"GET_CODE",
"(",
"val_rtx",
")",
"==",
"SIGN_EXTEND",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"val_rtx",
",",
"<NUM_LIT>",
")",
")",
"==",
"MEM",
"&&",
"BASE_OR_AUTOINCR_P",
"(",
"XEXP",
"(",
"XEXP",
"(",
"val_rtx",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
")",
")",
"return",
"<NUM_LIT>",
";",
"return",
"<NUM_LIT>",
";",
"}",
"else",
"if",
"(",
"code",
"==",
"MULT",
"||",
"(",
"code",
"==",
"PLUS",
"&&",
"BASE_P",
"(",
"val_rtx",
")",
")",
")",
"{",
"if",
"(",
"rtx_equal_p",
"(",
"ops",
"[",
"lreg",
"]",
",",
"reg_rtx",
")",
"||",
"(",
"mult",
"==",
"<NUM_LIT>",
"&&",
"rtx_equal_p",
"(",
"ops",
"[",
"lreg",
"]",
",",
"val_rtx",
")",
")",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"mult",
"!=",
"<NUM_LIT>",
"&&",
"mult",
"!=",
"<NUM_LIT>",
"&&",
"mult",
"!=",
"<NUM_LIT>",
")",
"return",
"<NUM_LIT>",
";",
"if",
"(",
"!",
"BASE_P",
"(",
"reg_rtx",
")",
")",
"return",
"<NUM_LIT>",
";",
"return",
"<NUM_LIT>",
";",
"}",
"internal_error",
"(",
"<STR_LIT>",
"internal error: cris_side_effect_mode_ok with bad operands",
"<STR_LIT>",
")",
";",
"}"
] | [
"Check",
"various",
"objections",
"to",
"the",
"side-effect",
".",
"Used",
"in",
"the",
"test-part",
"of",
"an",
"anonymous",
"insn",
"describing",
"an",
"insn",
"with",
"a",
"possible",
"side-effect",
".",
"Returns",
"nonzero",
"if",
"the",
"implied",
"side-effect",
"is",
"ok.",
"code",
":",
"PLUS",
"or",
"MULT",
"ops",
":",
"An",
"array",
"of",
"rtx",
":",
"es",
".",
"lreg",
",",
"rreg",
",",
"rval",
",",
"The",
"variables",
"multop",
"and",
"other_op",
"are",
"indexes",
"into",
"this",
",",
"or",
"-1",
"if",
"they",
"are",
"not",
"applicable",
".",
"lreg",
":",
"The",
"register",
"that",
"gets",
"assigned",
"in",
"the",
"side-effect",
".",
"rreg",
":",
"One",
"register",
"in",
"the",
"side-effect",
"expression",
"rval",
":",
"The",
"other",
"register",
",",
"or",
"an",
"int",
".",
"multop",
":",
"An",
"integer",
"to",
"multiply",
"rval",
"with",
".",
"other_op",
":",
"One",
"of",
"the",
"entities",
"of",
"the",
"main",
"effect",
",",
"whose",
"mode",
"we",
"must",
"consider",
"."
] |
LLVM | AMDGPU | CPP | code_generation | GPU | 621,820 | [
"TargetLoweringBase",
"::",
"LegalizeTypeAction",
"SITargetLowering",
"::",
"getPreferredVectorAction",
"(",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"VT",
".",
"getVectorNumElements",
"(",
")",
"!=",
"<NUM_LIT>",
"&&",
"VT",
".",
"getScalarType",
"(",
")",
".",
"bitsLE",
"(",
"MVT",
"::",
"i16",
")",
")",
"return",
"TypeSplitVector",
";",
"return",
"TargetLoweringBase",
"::",
"getPreferredVectorAction",
"(",
"VT",
")",
";",
"}"
] | [
"Customize",
"the",
"preferred",
"legalization",
"strategy",
"for",
"certain",
"types",
"."
] |
GCC | arm | CPP | stmt_completion | CPU | 621,821 | [
",",
"_",
"_",
"c",
")",
";"
] | [
"return",
"(",
"int32x4_t",
")",
"_",
"_",
"builtin_neon_vbslv4si",
"(",
"(",
"int32x4_t",
")",
"_",
"_",
"a",
",",
"_",
"_",
"b"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 621,822 | [
"llvm_unreachable",
"(",
"<STR_LIT>",
"unhandled opcode for narrow intrinsic",
"<STR_LIT>",
")",
";"
] | [
"Intrinsic",
"::",
"arm_uadd8",
";",
"case",
"Instruction",
"::",
"Sub",
":",
"return",
"ARMCodeGenPrepare",
"::",
"TypeSize",
"==",
"<NUM_LIT>",
"?",
"Intrinsic",
"::",
"arm_usub16",
":",
"Intrinsic",
"::",
"arm_usub8",
";",
"}"
] |
LLVM | Sparc | CPP | stmt_completion | CPU | 621,823 | [
"Op",
";"
] | [
"static",
"SDValue",
"LowerATOMIC_LOAD_STORE",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"{",
"if",
"(",
"isStrongerThanMonotonic",
"(",
"cast",
"<",
"AtomicSDNode",
">",
"(",
"Op",
")",
"->",
"getOrdering",
"(",
")",
")",
")",
"return",
"SDValue",
"(",
")",
";",
"return"
] |
LLVM | Z80 | CPP | code_generation | MPU | 621,824 | [
"void",
"Z80InstrInfo",
"::",
"loadRegFromStackSlot",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"unsigned",
"DstReg",
",",
"int",
"FI",
",",
"const",
"TargetRegisterClass",
"*",
"TRC",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"unsigned",
"Opc",
";",
"switch",
"(",
"TRI",
"->",
"getSpillSize",
"(",
"*",
"TRC",
")",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unexpected regclass size",
"<STR_LIT>",
")",
";",
"case",
"<NUM_LIT>",
":",
"Opc",
"=",
"Z80",
"::",
"LD8ro",
";",
"break",
";",
"case",
"<NUM_LIT>",
":",
"Opc",
"=",
"Subtarget",
".",
"has16BitEZ80Ops",
"(",
")",
"?",
"Z80",
"::",
"LD16ro",
":",
"Z80",
"::",
"LD88ro",
";",
"break",
";",
"case",
"<NUM_LIT>",
":",
"assert",
"(",
"Subtarget",
".",
"is24Bit",
"(",
")",
"&&",
"<STR_LIT>",
"Only 24-bit should have 3 byte stack slots",
"<STR_LIT>",
")",
";",
"Opc",
"=",
"Z80",
"::",
"LD24ro",
";",
"break",
";",
"}",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
",",
"get",
"(",
"Opc",
")",
",",
"DstReg",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
";",
"return",
";",
"unsigned",
"RC",
",",
"LoOpc",
",",
"LoIdx",
",",
"HiOpc",
",",
"HiIdx",
",",
"HiOff",
";",
"bool",
"Split",
"=",
"Z80",
"::",
"splitReg",
"(",
"TRI",
"->",
"getSpillSize",
"(",
"*",
"TRC",
")",
",",
"Z80",
"::",
"LD8ro",
",",
"Z80",
"::",
"LD16ro",
",",
"Z80",
"::",
"LD24ro",
",",
"RC",
",",
"LoOpc",
",",
"LoIdx",
",",
"HiOpc",
",",
"HiIdx",
",",
"HiOff",
",",
"Subtarget",
".",
"hasEZ80Ops",
"(",
")",
")",
";",
"MachineInstrBuilder",
"LoMIB",
"=",
"addSubReg",
"(",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
",",
"get",
"(",
"LoOpc",
")",
")",
",",
"DstReg",
",",
"LoIdx",
",",
"TRI",
",",
"RegState",
"::",
"DefineNoRead",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"Split",
")",
"{",
"MachineInstrBuilder",
"HiMIB",
"=",
"addSubReg",
"(",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"MBB",
".",
"findDebugLoc",
"(",
"MI",
")",
",",
"get",
"(",
"HiOpc",
")",
")",
",",
"DstReg",
",",
"HiIdx",
",",
"TRI",
",",
"RegState",
"::",
"Define",
")",
".",
"addFrameIndex",
"(",
"FI",
")",
".",
"addImm",
"(",
"HiOff",
")",
";",
"HiMIB",
"->",
"addRegisterDefined",
"(",
"DstReg",
",",
"TRI",
")",
";",
"}",
"}"
] | [
"Load",
"the",
"specified",
"register",
"of",
"the",
"given",
"register",
"class",
"from",
"the",
"specified",
"stack",
"frame",
"index",
"."
] |
GCC | rl78 | MD | next_suggestion | MPU | 621,825 | [
"]"
] | [
"[",
"(",
"set",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
":",
"QI",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"QI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")"
] |
LLVM | SystemZ | CPP | stmt_completion | CPU | 621,826 | [
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"return",
"DAG",
".",
"UnrollVectorOp",
"(",
"N",
")",
";"
] | [
"SDValue",
"SystemZTargetLowering",
"::",
"combineIntDIVREM",
"(",
"SDNode",
"*",
"N",
",",
"DAGCombinerInfo",
"&",
"DCI",
")",
"const",
"{",
"SelectionDAG",
"&",
"DAG",
"=",
"DCI",
".",
"DAG",
";",
"EVT",
"VT",
"=",
"N",
"->",
"getValueType",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"VT",
".",
"isVector",
"(",
")",
"&&",
"isTypeLegal",
"(",
"VT",
")",
"&&",
"DAG",
".",
"isConstantIntBuildVectorOrConstantInt",
"(",
"N"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 621,827 | [
"(",
")",
",",
"<NUM_LIT>",
")",
";"
] | [
"assert",
"(",
"Subtarget",
"->",
"hasAVX512",
"(",
")",
"&&",
"<STR_LIT>",
"MGATHER/MSCATTER are supported on AVX-512 arch only",
"<STR_LIT>",
")",
";",
"MaskedScatterSDNode",
"*",
"N",
"=",
"cast",
"<",
"MaskedScatterSDNode",
">",
"(",
"Op",
".",
"getNode",
"(",
")",
")",
";",
"MVT",
"VT",
"=",
"N",
"->",
"getValue",
"(",
")",
".",
"getSimpleValueType",
"(",
")",
";",
"assert",
"(",
"VT",
".",
"getScalarSizeInBits",
"(",
")",
">=",
"<NUM_LIT>",
"&&",
"<STR_LIT>",
"Unsupported scatter op",
"<STR_LIT>",
")",
";",
"SDLoc",
"dl",
"(",
"Op",
")",
";",
"if",
"(",
"N",
"->",
"getNumValues",
"(",
")",
"==",
"<NUM_LIT>",
")",
"{",
"SDValue",
"Index",
"=",
"N",
"->",
"getIndex",
"(",
")",
";",
"if",
"(",
"!",
"Subtarget",
"->",
"hasVLX",
"(",
")",
"&&",
"!",
"VT",
".",
"is512BitVector",
"(",
")",
"&&",
"!",
"Index",
".",
"getSimpleValueType",
"(",
")",
".",
"is512BitVector",
"(",
")",
")",
"Index",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"SIGN_EXTEND",
",",
"dl",
",",
"MVT",
"::",
"v8i64",
",",
"Index",
")",
";",
"SDVTList",
"VTs",
"=",
"DAG",
".",
"getVTList",
"(",
"N",
"->",
"getMask",
"(",
")",
".",
"getValueType",
"(",
")",
",",
"MVT",
"::",
"Other",
")",
";",
"SDValue",
"Ops",
"[",
"]",
"=",
"{",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Index",
"}",
";",
"SDValue",
"NewScatter",
"=",
"DAG",
".",
"getMaskedScatter",
"(",
"VTs",
",",
"VT",
",",
"dl",
",",
"Ops",
",",
"N",
"->",
"getMemOperand",
"(",
")",
")",
";",
"DAG",
".",
"ReplaceAllUsesWith",
"(",
"Op",
",",
"SDValue",
"(",
"NewScatter",
".",
"getNode",
"(",
")",
",",
"<NUM_LIT>",
")",
")",
";",
"return",
"SDValue",
"(",
"NewScatter",
".",
"getNode"
] |
GCC | s390 | MD | program_repair | MPU | 621,828 | [
"<FIXS>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"minus",
":",
"HI",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"<FIXE>",
"<FIXS>",
"<FIXE>",
"<FIXS>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<FIXE>"
] | [
"(",
"define_insn",
"<STR_LIT>",
"<BUGS>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"minus",
":",
"HI",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"HI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"<BUGE>",
"(",
"clobber",
"(",
"reg",
":",
"CC",
"<NUM_LIT>",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"<BUGS>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")",
"<BUGE>"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 621,829 | [
"GA",
"->",
"getTargetFlags",
"(",
")",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";"
] | [
"if",
"(",
"BasePtr",
".",
"getOpcode",
"(",
")",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"if",
"(",
"const",
"auto",
"*",
"GA",
"=",
"dyn_cast",
"<",
"GlobalAddressSDNode",
">",
"(",
"BasePtr",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
")",
"return"
] |
LLVM | X86 | TD | stmt_completion | CPU | 621,830 | [
")",
">",
";"
] | [
"def",
":",
"InstRW",
"<",
"[",
"HWWrite2P01",
"]",
",",
"(",
"instrs",
"FCOMPP",
",",
"UCOM_FPPr"
] |
GCC | rs6000 | CPP | code_generation | CPU | 621,831 | [
"static",
"bool",
"rs6000_can_inline_p",
"(",
"tree",
"caller",
",",
"tree",
"callee",
")",
"{",
"bool",
"ret",
"=",
"false",
";",
"tree",
"caller_tree",
"=",
"DECL_FUNCTION_SPECIFIC_TARGET",
"(",
"caller",
")",
";",
"tree",
"callee_tree",
"=",
"DECL_FUNCTION_SPECIFIC_TARGET",
"(",
"callee",
")",
";",
"if",
"(",
"!",
"callee_tree",
")",
"ret",
"=",
"true",
";",
"else",
"{",
"HOST_WIDE_INT",
"caller_isa",
";",
"struct",
"cl_target_option",
"*",
"callee_opts",
"=",
"TREE_TARGET_OPTION",
"(",
"callee_tree",
")",
";",
"HOST_WIDE_INT",
"callee_isa",
"=",
"callee_opts",
"->",
"x_rs6000_isa_flags",
";",
"HOST_WIDE_INT",
"explicit_isa",
"=",
"callee_opts",
"->",
"x_rs6000_isa_flags_explicit",
";",
"if",
"(",
"caller_tree",
")",
"caller_isa",
"=",
"TREE_TARGET_OPTION",
"(",
"caller_tree",
")",
"->",
"x_rs6000_isa_flags",
";",
"else",
"caller_isa",
"=",
"rs6000_isa_flags",
";",
"cgraph_node",
"*",
"callee_node",
"=",
"cgraph_node",
"::",
"get",
"(",
"callee",
")",
";",
"if",
"(",
"ipa_fn_summaries",
"&&",
"ipa_fn_summaries",
"->",
"get",
"(",
"callee_node",
")",
"!=",
"NULL",
")",
"{",
"unsigned",
"int",
"info",
"=",
"ipa_fn_summaries",
"->",
"get",
"(",
"callee_node",
")",
"->",
"target_info",
";",
"if",
"(",
"(",
"info",
"&",
"RS6000_FN_TARGET_INFO_HTM",
")",
"==",
"<NUM_LIT>",
")",
"{",
"callee_isa",
"&=",
"~",
"OPTION_MASK_HTM",
";",
"explicit_isa",
"&=",
"~",
"OPTION_MASK_HTM",
";",
"}",
"}",
"callee_isa",
"&=",
"~",
"(",
"OPTION_MASK_P8_FUSION",
"|",
"OPTION_MASK_P10_FUSION",
")",
";",
"explicit_isa",
"&=",
"~",
"(",
"OPTION_MASK_P8_FUSION",
"|",
"OPTION_MASK_P10_FUSION",
")",
";",
"if",
"(",
"(",
"(",
"caller_isa",
"&",
"callee_isa",
")",
"==",
"callee_isa",
")",
"&&",
"(",
"caller_isa",
"&",
"explicit_isa",
")",
"==",
"(",
"callee_isa",
"&",
"explicit_isa",
")",
")",
"ret",
"=",
"true",
";",
"}",
"if",
"(",
"TARGET_DEBUG_TARGET",
")",
"fprintf",
"(",
"stderr",
",",
"<STR_LIT>",
"rs6000_can_inline_p:, caller %s, callee %s, %s inline\\n",
"<STR_LIT>",
",",
"get_decl_name",
"(",
"caller",
")",
",",
"get_decl_name",
"(",
"callee",
")",
",",
"(",
"ret",
"?",
"<STR_LIT>",
"can",
"<STR_LIT>",
":",
"<STR_LIT>",
"cannot",
"<STR_LIT>",
")",
")",
";",
"return",
"ret",
";",
"}"
] | [
"Hook",
"to",
"determine",
"if",
"one",
"function",
"can",
"safely",
"inline",
"another",
"."
] |
GCC | mips | CPP | code_generation | CPU | 621,832 | [
"static",
"unsigned",
"HOST_WIDE_INT",
"mips_asan_shadow_offset",
"(",
"void",
")",
"{",
"if",
"(",
"mips_abi",
"==",
"ABI_N32",
")",
"return",
"(",
"HOST_WIDE_INT_1",
"<<",
"<NUM_LIT>",
")",
";",
"if",
"(",
"POINTER_SIZE",
"==",
"<NUM_LIT>",
")",
"return",
"(",
"HOST_WIDE_INT_1",
"<<",
"<NUM_LIT>",
")",
";",
"else",
"return",
"HOST_WIDE_INT_C",
"(",
"<NUM_LIT>",
")",
";",
"}"
] | [
"Implement",
"the",
"TARGET_ASAN_SHADOW_OFFSET",
"hook",
"."
] |
LLVM | TriCore | TD | stmt_completion | MPU | 621,833 | [
"DataRegs",
":",
"$",
"fsrc",
",",
"DataRegs",
":",
"$",
"s1",
",",
"immSExt9",
":",
"$",
"const9",
",",
"(",
"i32",
"TriCore_LOGIC_AND_EQ",
")",
")",
")",
"]",
">",
";"
] | [
"def",
"AND_EQrc",
":",
"RC",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"(",
"outs",
"DataRegs",
":",
"$",
"d",
")",
",",
"(",
"ins",
"DataRegs",
":",
"$",
"fsrc",
",",
"DataRegs",
":",
"$",
"s1",
",",
"s9imm",
":",
"$",
"const9",
")",
",",
"<STR_LIT>",
",",
"[",
"(",
"set",
"DataRegs",
":",
"$",
"d",
",",
"(",
"TriCoreLogicCmp"
] |
LLVM | ARM | TD | stmt_completion | CPU | 621,834 | [
"outs",
"QPR",
":",
"$",
"Vd",
")",
",",
"(",
"ins",
"QPR",
":",
"$",
"Vm",
")",
",",
"IIC_VUNAQ",
",",
"OpcodeStr",
",",
"Dt",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"[",
"(",
"set",
"QPR",
":",
"$",
"Vd",
",",
"(",
"ResTy",
"(",
"OpNode",
"(",
"OpTy",
"QPR",
":",
"$",
"Vm",
")",
")",
")",
")",
"]",
">",
";"
] | [
"class",
"N2VQ",
"<",
"bits",
"<",
"<NUM_LIT>",
">",
"op24_23",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"op21_20",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"op19_18",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"op17_16",
",",
"bits",
"<",
"<NUM_LIT>",
">",
"op11_7",
",",
"bit",
"op4",
",",
"string",
"OpcodeStr",
",",
"string",
"Dt",
",",
"ValueType",
"ResTy",
",",
"ValueType",
"OpTy",
",",
"SDNode",
"OpNode",
">",
":",
"N2V",
"<",
"op24_23",
",",
"op21_20",
",",
"op19_18",
",",
"op17_16",
",",
"op11_7",
",",
"<NUM_LIT>",
",",
"op4",
",",
"("
] |
GCC | s390 | MD | stmt_completion | MPU | 621,835 | [
")"
] | [
"[",
"(",
"set",
"(",
"match_operand",
":",
"VI_HW_QHS",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"unspec",
":",
"VI_HW_QHS",
"[",
"(",
"match_operand",
":",
"VI_HW_QHS",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"VI_HW_QHS",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"const_int",
"VSTRING_FLAG_CS",
")",
"]",
"UNSPEC_VEC_VFENE",
")",
")",
"(",
"set",
"(",
"reg",
":",
"CCRAW",
"CC_REGNUM",
")",
"(",
"unspec",
":",
"CCRAW",
"[",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"VSTRING_FLAG_CS",
")",
"]",
"UNSPEC_VEC_VFENECC",
")",
")",
"]"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 621,836 | [
"unsigned",
"FstHalfBegin",
"=",
"(",
"Imm",
"&",
"<NUM_LIT>",
")",
"*",
"HalfSize",
";"
] | [
"void",
"DecodeVPERM2X128Mask",
"(",
"EVT",
"VT",
",",
"unsigned",
"Imm",
",",
"SmallVectorImpl",
"<",
"int",
">",
"&",
"ShuffleMask",
")",
"{",
"unsigned",
"HalfSize",
"=",
"VT",
".",
"getVectorNumElements",
"(",
")",
"/",
"<NUM_LIT>",
";"
] |
GCC | or1k | CPP | code_generation | CPU | 621,837 | [
"static",
"bool",
"or",
"<NUM_LIT>",
"k_rtx_costs",
"(",
"rtx",
"x",
",",
"machine_mode",
"mode",
",",
"int",
"outer_code",
",",
"int",
",",
"int",
"*",
"total",
",",
"bool",
")",
"{",
"switch",
"(",
"GET_CODE",
"(",
"x",
")",
")",
"{",
"case",
"CONST_INT",
":",
"if",
"(",
"x",
"==",
"const0_rtx",
")",
"*",
"total",
"=",
"<NUM_LIT>",
";",
"else",
"if",
"(",
"(",
"outer_code",
"==",
"PLUS",
"||",
"outer_code",
"==",
"XOR",
"||",
"outer_code",
"==",
"MULT",
")",
"&&",
"satisfies_constraint_I",
"(",
"x",
")",
")",
"*",
"total",
"=",
"<NUM_LIT>",
";",
"else",
"if",
"(",
"(",
"outer_code",
"==",
"AND",
"||",
"outer_code",
"==",
"IOR",
")",
"&&",
"satisfies_constraint_K",
"(",
"x",
")",
")",
"*",
"total",
"=",
"<NUM_LIT>",
";",
"else",
"if",
"(",
"satisfies_constraint_I",
"(",
"x",
")",
"||",
"satisfies_constraint_K",
"(",
"x",
")",
"||",
"satisfies_constraint_M",
"(",
"x",
")",
")",
"*",
"total",
"=",
"<NUM_LIT>",
";",
"else",
"*",
"total",
"=",
"COSTS_N_INSNS",
"(",
"<NUM_LIT>",
")",
";",
"return",
"true",
";",
"case",
"CONST_DOUBLE",
":",
"*",
"total",
"=",
"(",
"x",
"==",
"CONST0_RTX",
"(",
"mode",
")",
"?",
"<NUM_LIT>",
":",
"COSTS_N_INSNS",
"(",
"<NUM_LIT>",
")",
")",
";",
"return",
"true",
";",
"case",
"HIGH",
":",
"*",
"total",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"case",
"LO_SUM",
":",
"*",
"total",
"=",
"(",
"outer_code",
"==",
"MEM",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
")",
";",
"return",
"true",
";",
"case",
"CONST",
":",
"case",
"SYMBOL_REF",
":",
"case",
"LABEL_REF",
":",
"if",
"(",
"outer_code",
"==",
"LO_SUM",
"||",
"outer_code",
"==",
"HIGH",
")",
"*",
"total",
"=",
"<NUM_LIT>",
";",
"else",
"{",
"*",
"total",
"=",
"COSTS_N_INSNS",
"(",
"<NUM_LIT>",
"+",
"(",
"outer_code",
"!=",
"MEM",
")",
")",
";",
"}",
"return",
"true",
";",
"case",
"PLUS",
":",
"if",
"(",
"outer_code",
"==",
"MEM",
")",
"*",
"total",
"=",
"<NUM_LIT>",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"return",
"false",
";",
"}"
] | [
"Worker",
"for",
"TARGET_RTX_COSTS",
"."
] |
LLVM | ARM | CPP | code_generation | CPU | 621,838 | [
"bool",
"ARMCodeGenPrepare",
"::",
"runOnFunction",
"(",
"Function",
"&",
"F",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"F",
")",
"||",
"DisableCGP",
")",
"return",
"false",
";",
"auto",
"*",
"TPC",
"=",
"&",
"getAnalysis",
"<",
"TargetPassConfig",
">",
"(",
")",
";",
"if",
"(",
"!",
"TPC",
")",
"return",
"false",
";",
"const",
"TargetMachine",
"&",
"TM",
"=",
"TPC",
"->",
"getTM",
"<",
"TargetMachine",
">",
"(",
")",
";",
"ST",
"=",
"&",
"TM",
".",
"getSubtarget",
"<",
"ARMSubtarget",
">",
"(",
"F",
")",
";",
"bool",
"MadeChange",
"=",
"false",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"ARM CGP: Running on ",
"<STR_LIT>",
"<<",
"F",
".",
"getName",
"(",
")",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"for",
"(",
"BasicBlock",
"&",
"BB",
":",
"F",
")",
"{",
"auto",
"&",
"Insts",
"=",
"BB",
".",
"getInstList",
"(",
")",
";",
"for",
"(",
"auto",
"&",
"I",
":",
"Insts",
")",
"{",
"if",
"(",
"AllVisited",
".",
"count",
"(",
"&",
"I",
")",
")",
"continue",
";",
"if",
"(",
"isa",
"<",
"ICmpInst",
">",
"(",
"I",
")",
")",
"{",
"auto",
"&",
"CI",
"=",
"cast",
"<",
"ICmpInst",
">",
"(",
"I",
")",
";",
"if",
"(",
"CI",
".",
"isSigned",
"(",
")",
"||",
"!",
"isa",
"<",
"IntegerType",
">",
"(",
"CI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
"->",
"getType",
"(",
")",
")",
")",
"continue",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"ARM CGP: Searching from: ",
"<STR_LIT>",
"<<",
"CI",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"for",
"(",
"auto",
"&",
"Op",
":",
"CI",
".",
"operands",
"(",
")",
")",
"{",
"if",
"(",
"auto",
"*",
"I",
"=",
"dyn_cast",
"<",
"Instruction",
">",
"(",
"Op",
")",
")",
"{",
"if",
"(",
"isa",
"<",
"ZExtInst",
">",
"(",
"I",
")",
")",
"MadeChange",
"|=",
"TryToPromote",
"(",
"I",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"else",
"MadeChange",
"|=",
"TryToPromote",
"(",
"I",
")",
";",
"}",
"}",
"}",
"}",
"Promoter",
"->",
"Cleanup",
"(",
")",
";",
"LLVM_DEBUG",
"(",
"if",
"(",
"verifyFunction",
"(",
"F",
",",
"&",
"dbgs",
"(",
")",
")",
")",
"{",
"dbgs",
"(",
")",
";",
"report_fatal_error",
"(",
"<STR_LIT>",
"Broken function after type promotion",
"<STR_LIT>",
")",
";",
"}",
")",
";",
"}",
"if",
"(",
"MadeChange",
")",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"After ARMCodeGenPrepare: ",
"<STR_LIT>",
"<<",
"F",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"return",
"MadeChange",
";",
"}"
] | [
"runOnFunction",
"-",
"Virtual",
"method",
"overriden",
"by",
"subclasses",
"to",
"do",
"the",
"per-function",
"processing",
"of",
"the",
"pass",
"."
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 621,839 | [
"GIComplexPatternEquiv",
"<",
"am_unscaled128",
">",
";"
] | [
"def",
"gi_am_unscaled128",
":",
"GIComplexOperandMatcher",
"<",
"s64",
",",
"<STR_LIT>",
">",
","
] |
GCC | i386 | CPP | code_generation | CPU | 621,840 | [
"static",
"int",
"ix86_register_move_cost",
"(",
"machine_mode",
"mode",
",",
"reg_class_t",
"class1_i",
",",
"reg_class_t",
"class2_i",
")",
"{",
"enum",
"reg_class",
"class1",
"=",
"(",
"enum",
"reg_class",
")",
"class1_i",
";",
"enum",
"reg_class",
"class2",
"=",
"(",
"enum",
"reg_class",
")",
"class2_i",
";",
"if",
"(",
"inline_secondary_memory_needed",
"(",
"mode",
",",
"class1",
",",
"class2",
",",
"false",
")",
")",
"{",
"int",
"cost",
"=",
"<NUM_LIT>",
";",
"cost",
"+=",
"inline_memory_move_cost",
"(",
"mode",
",",
"class1",
",",
"<NUM_LIT>",
")",
";",
"cost",
"+=",
"inline_memory_move_cost",
"(",
"mode",
",",
"class2",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
">",
"BITS_PER_WORD",
"&&",
"TARGET_MEMORY_MISMATCH_STALL",
"&&",
"targetm",
".",
"class_max_nregs",
"(",
"class1",
",",
"mode",
")",
">",
"targetm",
".",
"class_max_nregs",
"(",
"class2",
",",
"mode",
")",
")",
"cost",
"+=",
"<NUM_LIT>",
";",
"if",
"(",
"(",
"MMX_CLASS_P",
"(",
"class1",
")",
"&&",
"MAYBE_FLOAT_CLASS_P",
"(",
"class2",
")",
")",
"||",
"(",
"MMX_CLASS_P",
"(",
"class2",
")",
"&&",
"MAYBE_FLOAT_CLASS_P",
"(",
"class1",
")",
")",
")",
"cost",
"+=",
"<NUM_LIT>",
";",
"return",
"cost",
";",
"}",
"if",
"(",
"MMX_CLASS_P",
"(",
"class1",
")",
"!=",
"MMX_CLASS_P",
"(",
"class2",
")",
")",
"gcc_unreachable",
"(",
")",
";",
"if",
"(",
"SSE_CLASS_P",
"(",
"class1",
")",
"!=",
"SSE_CLASS_P",
"(",
"class2",
")",
")",
"return",
"(",
"SSE_CLASS_P",
"(",
"class1",
")",
"?",
"ix86_cost",
"->",
"hard_register",
".",
"sse_to_integer",
":",
"ix86_cost",
"->",
"hard_register",
".",
"integer_to_sse",
")",
";",
"if",
"(",
"MASK_CLASS_P",
"(",
"class1",
")",
"!=",
"MASK_CLASS_P",
"(",
"class2",
")",
")",
"{",
"return",
"(",
"MASK_CLASS_P",
"(",
"class1",
")",
"?",
"ix86_cost",
"->",
"hard_register",
".",
"mask_to_integer",
":",
"ix86_cost",
"->",
"hard_register",
".",
"integer_to_mask",
")",
";",
"}",
"if",
"(",
"MASK_CLASS_P",
"(",
"class1",
")",
"&&",
"MASK_CLASS_P",
"(",
"class2",
")",
")",
"return",
"ix86_cost",
"->",
"hard_register",
".",
"mask_move",
";",
"if",
"(",
"MAYBE_FLOAT_CLASS_P",
"(",
"class1",
")",
")",
"return",
"ix86_cost",
"->",
"hard_register",
".",
"fp_move",
";",
"if",
"(",
"MAYBE_SSE_CLASS_P",
"(",
"class1",
")",
")",
"{",
"if",
"(",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
"<=",
"<NUM_LIT>",
")",
"return",
"ix86_cost",
"->",
"hard_register",
".",
"xmm_move",
";",
"if",
"(",
"GET_MODE_BITSIZE",
"(",
"mode",
")",
"<=",
"<NUM_LIT>",
")",
"return",
"ix86_cost",
"->",
"hard_register",
".",
"ymm_move",
";",
"return",
"ix86_cost",
"->",
"hard_register",
".",
"zmm_move",
";",
"}",
"if",
"(",
"MAYBE_MMX_CLASS_P",
"(",
"class1",
")",
")",
"return",
"ix86_cost",
"->",
"hard_register",
".",
"mmx_move",
";",
"return",
"<NUM_LIT>",
";",
"}"
] | [
"Return",
"the",
"cost",
"of",
"moving",
"data",
"from",
"a",
"register",
"in",
"class",
"CLASS1",
"to",
"one",
"in",
"class",
"CLASS2",
".",
"It",
"is",
"not",
"required",
"that",
"the",
"cost",
"always",
"equal",
"2",
"when",
"FROM",
"is",
"the",
"same",
"as",
"TO",
";",
"on",
"some",
"machines",
"it",
"is",
"expensive",
"to",
"move",
"between",
"registers",
"if",
"they",
"are",
"not",
"general",
"registers",
"."
] |
LLVM | ARM | TD | stmt_completion | CPU | 621,841 | [
",",
"shr_imm16",
">",
"{"
] | [
"def",
"MVE_VSHRNi32bh",
":",
"MVE_VxSHRN",
"<",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>"
] |
LLVM | R600 | CPP | next_suggestion | GPU | 621,842 | [
"if",
"(",
"!",
"isVSrc",
"(",
"OtherRegClass",
")",
"&&",
"!",
"isSSrc",
"(",
"OtherRegClass",
")",
")",
"continue",
";"
] | [
"int32_t",
"Imm",
"=",
"analyzeImmediate",
"(",
"Node",
"->",
"getOperand",
"(",
"i",
")",
".",
"getNode",
"(",
")",
")",
";",
"if",
"(",
"Imm",
"!=",
"-",
"<NUM_LIT>",
"&&",
"Imm",
"!=",
"<NUM_LIT>",
")",
"{",
"Immediate",
"=",
"Imm",
";",
"}",
"}",
"if",
"(",
"!",
"HaveVSrc",
"&&",
"!",
"HaveSSrc",
")",
"return",
"Node",
";",
"bool",
"ScalarSlotUsed",
"=",
"HaveVSrc",
"&&",
"HaveSSrc",
";",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"Ops",
";",
"bool",
"Promote2e64",
"=",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"Node",
"->",
"getNumOperands",
"(",
")",
",",
"Op",
"=",
"NumDefs",
";",
"i",
"!=",
"e",
"&&",
"Op",
"<",
"NumOps",
";",
"++",
"i",
",",
"++",
"Op",
")",
"{",
"const",
"SDValue",
"&",
"Operand",
"=",
"Node",
"->",
"getOperand",
"(",
"i",
")",
";",
"Ops",
".",
"push_back",
"(",
"Operand",
")",
";",
"if",
"(",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"Operand",
".",
"getNode",
"(",
")",
")",
"||",
"isa",
"<",
"ConstantFPSDNode",
">",
"(",
"Operand",
".",
"getNode",
"(",
")",
")",
")",
"continue",
";",
"unsigned",
"RegClass",
"=",
"Desc",
"->",
"OpInfo",
"[",
"Op",
"]",
".",
"RegClass",
";",
"if",
"(",
"isVSrc",
"(",
"RegClass",
")",
"||",
"isSSrc",
"(",
"RegClass",
")",
")",
"{",
"if",
"(",
"!",
"foldImm",
"(",
"Ops",
"[",
"i",
"]",
",",
"Immediate",
",",
"ScalarSlotUsed",
")",
")",
"{",
"ensureSRegLimit",
"(",
"DAG",
",",
"Ops",
"[",
"i",
"]",
",",
"RegClass",
",",
"ScalarSlotUsed",
")",
";",
"}",
"continue",
";",
"}",
"if",
"(",
"i",
"==",
"<NUM_LIT>",
"&&",
"DescRev",
"&&",
"fitsRegClass",
"(",
"DAG",
",",
"Ops",
"[",
"<NUM_LIT>",
"]",
",",
"RegClass",
")",
")",
"{",
"unsigned",
"OtherRegClass",
"=",
"Desc",
"->",
"OpInfo",
"[",
"NumDefs",
"]",
".",
"RegClass",
";",
"assert",
"(",
"isVSrc",
"(",
"OtherRegClass",
")",
"||",
"isSSrc",
"(",
"OtherRegClass",
")",
")",
";",
"if",
"(",
"foldImm",
"(",
"Ops",
"[",
"<NUM_LIT>",
"]",
",",
"Immediate",
",",
"ScalarSlotUsed",
")",
"||",
"(",
"!",
"fitsRegClass",
"(",
"DAG",
",",
"Ops",
"[",
"<NUM_LIT>",
"]",
",",
"RegClass",
")",
"&&",
"fitsRegClass",
"(",
"DAG",
",",
"Ops",
"[",
"<NUM_LIT>",
"]",
",",
"OtherRegClass",
")",
")",
")",
"{",
"std",
"::",
"swap",
"(",
"Ops",
"[",
"<NUM_LIT>",
"]",
",",
"Ops",
"[",
"<NUM_LIT>",
"]",
")",
";",
"Desc",
"=",
"DescRev",
";",
"DescRev",
"=",
"nullptr",
";",
"continue",
";",
"}",
"}",
"if",
"(",
"Immediate",
")",
"continue",
";",
"if",
"(",
"DescE64",
")",
"{",
"unsigned",
"OtherRegClass",
"=",
"DescE64",
"->",
"OpInfo",
"[",
"Op",
"]",
".",
"RegClass",
";"
] |
GCC | m68k | MD | next_suggestion | MPU | 621,843 | [
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"and",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")"
] |
LLVM | PowerPC | CPP | stmt_completion | CPU | 621,844 | [
",",
"FalseWeight",
"=",
"<NUM_LIT>",
";"
] | [
"CodeMetrics",
"::",
"collectEphemeralValues",
"(",
"L",
",",
"&",
"AC",
",",
"EphValues",
")",
";",
"CodeMetrics",
"Metrics",
";",
"for",
"(",
"BasicBlock",
"*",
"BB",
":",
"L",
"->",
"blocks",
"(",
")",
")",
"Metrics",
".",
"analyzeBasicBlock",
"(",
"BB",
",",
"*",
"this",
",",
"EphValues",
")",
";",
"if",
"(",
"Metrics",
".",
"NumInsts",
"<=",
"(",
"<NUM_LIT>",
"*",
"SchedModel",
".",
"getIssueWidth",
"(",
")",
")",
")",
"return",
"false",
";",
"}",
"for",
"(",
"Loop",
"::",
"block_iterator",
"I",
"=",
"L",
"->",
"block_begin",
"(",
")",
",",
"IE",
"=",
"L",
"->",
"block_end",
"(",
")",
";",
"I",
"!=",
"IE",
";",
"++",
"I",
")",
"if",
"(",
"mightUseCTR",
"(",
"*",
"I",
",",
"LibInfo",
")",
")",
"return",
"false",
";",
"SmallVector",
"<",
"BasicBlock",
"*",
",",
"<NUM_LIT>",
">",
"ExitingBlocks",
";",
"L",
"->",
"getExitingBlocks",
"(",
"ExitingBlocks",
")",
";",
"for",
"(",
"auto",
"&",
"BB",
":",
"ExitingBlocks",
")",
"{",
"Instruction",
"*",
"TI",
"=",
"BB",
"->",
"getTerminator",
"(",
")",
";",
"if",
"(",
"!",
"TI",
")",
"continue",
";",
"if",
"(",
"BranchInst",
"*",
"BI",
"=",
"dyn_cast",
"<",
"BranchInst",
">",
"(",
"TI",
")",
")",
"{",
"uint64_t",
"TrueWeight",
"=",
"<NUM_LIT>"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 621,845 | [
"<STR_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",
"InputType",
"="
] |
GCC | mips | MD | stmt_completion | CPU | 621,846 | [
")",
")",
")"
] | [
"(",
"ior",
"(",
"match_test",
"(",
"<STR_LIT>",
")",
")",
"(",
"match_test",
"(",
"<STR_LIT>",
")",
")"
] |
GCC | rs6000 | CPP | stmt_completion | CPU | 621,847 | [
"blsi_u64",
"(",
"unsigned",
"long",
"long",
"_",
"_",
"X",
")",
"{"
] | [
"long",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"_"
] |
LLVM | SPIRV | CPP | program_repair | Virtual ISA | 621,848 | [
"<FIXS>",
"return",
"finishCreatingSPIRVType",
"(",
"LLVMTy",
",",
"MIB",
")",
";",
"<FIXE>"
] | [
".",
"addDef",
"(",
"createTypeVReg",
"(",
"CurMF",
"->",
"getRegInfo",
"(",
")",
")",
")",
".",
"addImm",
"(",
"BitWidth",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
";",
"<BUGS>",
"return",
"restOfCreateSPIRVType",
"(",
"LLVMTy",
",",
"MIB",
")",
";",
"<BUGE>",
"}",
"SPIRVType",
"*"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 621,849 | [
"BuildMI",
"(",
"*",
"FuncInfo",
".",
"MBB",
",",
"FuncInfo",
".",
"InsertPt",
",",
"DbgLoc",
",",
"TII",
".",
"get",
"(",
"OpReg",
")",
",",
"ResultReg",
")",
".",
"addReg",
"(",
"Op0Reg",
")",
";"
] | [
"case",
"Instruction",
"::",
"LShr",
":",
"OpReg",
"=",
"X86",
"::",
"SHR32rCL",
";",
"break",
";",
"case",
"Instruction",
"::",
"AShr",
":",
"OpReg",
"=",
"X86",
"::",
"SAR32rCL",
";",
"break",
";",
"case",
"Instruction",
"::",
"Shl",
":",
"OpReg",
"=",
"X86",
"::",
"SHL32rCL",
";",
"break",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"else",
"if",
"(",
"I",
"->",
"getType",
"(",
")",
"->",
"isIntegerTy",
"(",
"<NUM_LIT>",
")",
")",
"{",
"CReg",
"=",
"X86",
"::",
"RCX",
";",
"RC",
"=",
"&",
"X86",
"::",
"GR64RegClass",
";",
"switch",
"(",
"I",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"Instruction",
"::",
"LShr",
":",
"OpReg",
"=",
"X86",
"::",
"SHR64rCL",
";",
"break",
";",
"case",
"Instruction",
"::",
"AShr",
":",
"OpReg",
"=",
"X86",
"::",
"SAR64rCL",
";",
"break",
";",
"case",
"Instruction",
"::",
"Shl",
":",
"OpReg",
"=",
"X86",
"::",
"SHL64rCL",
";",
"break",
";",
"default",
":",
"return",
"false",
";",
"}",
"}",
"else",
"{",
"return",
"false",
";",
"}",
"MVT",
"VT",
";",
"if",
"(",
"!",
"isTypeLegal",
"(",
"I",
"->",
"getType",
"(",
")",
",",
"VT",
")",
")",
"return",
"false",
";",
"unsigned",
"Op0Reg",
"=",
"getRegForValue",
"(",
"I",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"Op0Reg",
"==",
"<NUM_LIT>",
")",
"return",
"false",
";",
"unsigned",
"Op1Reg",
"=",
"getRegForValue",
"(",
"I",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"Op1Reg",
"==",
"<NUM_LIT>",
")",
"return",
"false",
";",
"BuildMI",
"(",
"*",
"FuncInfo",
".",
"MBB",
",",
"FuncInfo",
".",
"InsertPt",
",",
"DbgLoc",
",",
"TII",
".",
"get",
"(",
"TargetOpcode",
"::",
"COPY",
")",
",",
"CReg",
")",
".",
"addReg",
"(",
"Op1Reg",
")",
";",
"if",
"(",
"CReg",
"!=",
"X86",
"::",
"CL",
")",
"BuildMI",
"(",
"*",
"FuncInfo",
".",
"MBB",
",",
"FuncInfo",
".",
"InsertPt",
",",
"DbgLoc",
",",
"TII",
".",
"get",
"(",
"TargetOpcode",
"::",
"KILL",
")",
",",
"X86",
"::",
"CL",
")",
".",
"addReg",
"(",
"CReg",
",",
"RegState",
"::",
"Kill",
")",
";",
"unsigned",
"ResultReg",
"=",
"createResultReg",
"(",
"RC",
")",
";"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 621,850 | [
"const",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";"
] | [
"bool",
"ARMBaseRegisterInfo",
"::",
"cannotEliminateFrame",
"(",
"const",
"MachineFunction",
"&",
"MF",
")",
"const",
"{"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 621,851 | [
";"
] | [
"unsigned",
"getRegisterBitWidth",
"(",
"bool",
"Vector",
")",
"{",
"if",
"(",
"Vector",
")",
"{",
"if",
"(",
"ST",
"->",
"hasNEON",
"(",
")",
")",
"return",
"<NUM_LIT>",
";",
"return",
"<NUM_LIT>",
";",
"}",
"return",
"<NUM_LIT>"
] |
LLVM | Hexagon | CPP | next_suggestion | DSP | 621,852 | [
"while",
"(",
"unsigned",
"n",
"=",
"MI",
".",
"getNumOperands",
"(",
")",
")",
"MI",
".",
"RemoveOperand",
"(",
"n",
"-",
"<NUM_LIT>",
")",
";"
] | [
"MachineOperand",
"&",
"Op",
"=",
"MI",
".",
"getOperand",
"(",
"NOp",
")",
";",
"if",
"(",
"!",
"Op",
".",
"isReg",
"(",
")",
"||",
"!",
"Op",
".",
"isDef",
"(",
")",
"||",
"Op",
".",
"isImplicit",
"(",
")",
")",
"break",
";",
"T",
".",
"add",
"(",
"Op",
")",
";",
"NOp",
"++",
";",
"}",
"unsigned",
"PredReg",
",",
"PredRegPos",
",",
"PredRegFlags",
";",
"bool",
"GotPredReg",
"=",
"getPredReg",
"(",
"Cond",
",",
"PredReg",
",",
"PredRegPos",
",",
"PredRegFlags",
")",
";",
"(",
"void",
")",
"GotPredReg",
";",
"assert",
"(",
"GotPredReg",
")",
";",
"T",
".",
"addReg",
"(",
"PredReg",
",",
"PredRegFlags",
")",
";",
"while",
"(",
"NOp",
"<",
"NumOps",
")",
"T",
".",
"add",
"(",
"MI",
".",
"getOperand",
"(",
"NOp",
"++",
")",
")",
";",
"MI",
".",
"setDesc",
"(",
"get",
"(",
"PredOpc",
")",
")",
";"
] |
LLVM | PowerPC | TD | stmt_completion | CPU | 621,853 | [
"$",
"XB",
")",
")",
"]",
">",
";"
] | [
"def",
"XSCVDPUXWSs",
":",
"XX2Form",
"<",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"(",
"outs",
"vssrc",
":",
"$",
"XT",
")",
",",
"(",
"ins",
"vssrc",
":",
"$",
"XB",
")",
",",
"<STR_LIT>",
",",
"IIC_VecFP",
",",
"[",
"(",
"set",
"f32",
":",
"$",
"XT",
",",
"(",
"PPCfctiwuz",
"f32",
":"
] |
LLVM | ARM | CPP | stmt_completion | CPU | 621,854 | [
":"
] | [
"case",
"Match_RequiresNotITBlock",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"<STR_LIT>",
"flag setting instruction only valid outside IT block",
"<STR_LIT>",
")",
";",
"case",
"Match_RequiresITBlock",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"<STR_LIT>",
"instruction only valid inside IT block",
"<STR_LIT>",
")",
";",
"case",
"Match_RequiresV6",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"<STR_LIT>",
"instruction variant requires ARMv6 or later",
"<STR_LIT>",
")",
";",
"case",
"Match_RequiresThumb2",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"<STR_LIT>",
"instruction variant requires Thumb2",
"<STR_LIT>",
")",
";",
"case",
"Match_RequiresV8",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"<STR_LIT>",
"instruction variant requires ARMv8 or later",
"<STR_LIT>",
")",
";",
"case",
"Match_RequiresFlagSetting",
":",
"return",
"Error",
"(",
"IDLoc",
",",
"<STR_LIT>",
"no flag-preserving variant of this instruction available",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange0_1",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [0,1]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange0_3",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [0,3]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange0_7",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [0,7]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange0_15",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [0,15]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange0_31",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [0,31]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange0_32",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [0,32]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange0_63",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [0,63]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange0_239",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [0,239]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange0_255",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [0,255]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange0_4095",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [0,4095]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange0_65535",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [0,65535]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange1_7",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [1,7]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange1_8",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [1,8]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange1_15",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [1,15]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange1_16",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [1,16]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange1_31",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [1,31]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange1_32",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [1,32]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange1_64",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [1,64]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange8_8",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be 8.",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange16_16",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be 16.",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange32_32",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be 32.",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange256_65535",
":",
"return",
"Error",
"(",
"ErrorLoc",
",",
"<STR_LIT>",
"immediate operand must be in the range [255,65535]",
"<STR_LIT>",
")",
";",
"case",
"Match_ImmRange0_16777215"
] |
LLVM | Sparc | CPP | stmt_completion | CPU | 621,855 | [
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<NUM_LIT>",
")",
";"
] | [
"std",
"::",
"vector",
"<",
"unsigned",
">",
"SparcTargetLowering",
"::",
"getRegClassForInlineAsmConstraint",
"(",
"const",
"std",
"::",
"string",
"&",
"Constraint",
",",
"MVT",
"VT",
")",
"const",
"{",
"if",
"(",
"Constraint",
".",
"size",
"(",
")",
"!=",
"<NUM_LIT>",
")",
"return",
"std",
"::",
"vector",
"<",
"unsigned",
">",
"(",
")",
";",
"switch",
"(",
"Constraint",
"[",
"<NUM_LIT>",
"]",
")",
"{",
"default",
":",
"break",
";",
"case",
"'",
"r",
"'",
":",
"return",
"make_vector",
"<",
"unsigned",
">",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"<STR_LIT>",
"::",
"<STR_LIT>",
","
] |
LLVM | LoongArch | TD | stmt_completion | CPU | 621,856 | [
"FPR64",
">",
";"
] | [
"def",
"FNMSUB_D",
":",
"FP_ALU_4R",
"<",
"<NUM_LIT>",
",",
"<STR_LIT>",
","
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 621,857 | [
")",
"return",
"FIXED_NUM_SGPRS_FOR_INIT_BUG",
";"
] | [
"if",
"(",
"STI",
"->",
"getFeatureBits",
"(",
")",
".",
"test",
"(",
"FeatureSGPRInitBug",
")"
] |
GCC | i386 | MD | next_suggestion | CPU | 621,858 | [
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"reg",
":",
"CCC",
"FLAGS_REG",
")",
"(",
"compare",
":",
"CCC",
"(",
"neg",
":",
"QI",
"(",
"ltu",
":",
"QI",
"(",
"reg",
":",
"CCC",
"FLAGS_REG",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
"(",
"geu",
":",
"QI",
"(",
"reg",
":",
"CCC",
"FLAGS_REG",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 621,859 | [
"OpMaskName",
";"
] | [
"CASE_MASK_MOVDUP",
"(",
"MOVDDUP",
",",
"m",
")",
"CASE_MASK_MOVDUP",
"(",
"MOVDDUP",
",",
"r",
")",
"CASE_MASK_MOVDUP",
"(",
"MOVSHDUP",
",",
"m",
")",
"CASE_MASK_MOVDUP",
"(",
"MOVSHDUP",
",",
"r",
")",
"CASE_MASK_MOVDUP",
"(",
"MOVSLDUP",
",",
"m",
")",
"CASE_MASK_MOVDUP",
"(",
"MOVSLDUP",
",",
"r",
")",
"CASE_MASK_PMOVZX",
"(",
"PMOVZXBD",
",",
"m",
")",
"CASE_MASK_PMOVZX",
"(",
"PMOVZXBD",
",",
"r",
")",
"CASE_MASK_PMOVZX",
"(",
"PMOVZXBQ",
",",
"m",
")",
"CASE_MASK_PMOVZX",
"(",
"PMOVZXBQ",
",",
"r",
")",
"CASE_MASK_PMOVZX",
"(",
"PMOVZXBW",
",",
"m",
")",
"CASE_MASK_PMOVZX",
"(",
"PMOVZXBW",
",",
"r",
")",
"CASE_MASK_PMOVZX",
"(",
"PMOVZXDQ",
",",
"m",
")",
"CASE_MASK_PMOVZX",
"(",
"PMOVZXDQ",
",",
"r",
")",
"CASE_MASK_PMOVZX",
"(",
"PMOVZXWD",
",",
"m",
")",
"CASE_MASK_PMOVZX",
"(",
"PMOVZXWD",
",",
"r",
")",
"CASE_MASK_PMOVZX",
"(",
"PMOVZXWQ",
",",
"m",
")",
"CASE_MASK_PMOVZX",
"(",
"PMOVZXWQ",
",",
"r",
")",
"CASE_MASK_UNPCK",
"(",
"PUNPCKHBW",
",",
"m",
")",
"CASE_MASK_UNPCK",
"(",
"PUNPCKHBW",
",",
"r",
")",
"CASE_MASK_UNPCK",
"(",
"PUNPCKHWD",
",",
"m",
")",
"CASE_MASK_UNPCK",
"(",
"PUNPCKHWD",
",",
"r",
")",
"CASE_MASK_UNPCK",
"(",
"PUNPCKHDQ",
",",
"m",
")",
"CASE_MASK_UNPCK",
"(",
"PUNPCKHDQ",
",",
"r",
")",
"CASE_MASK_UNPCK",
"(",
"PUNPCKLBW",
",",
"m",
")",
"CASE_MASK_UNPCK",
"(",
"PUNPCKLBW",
",",
"r",
")",
"CASE_MASK_UNPCK",
"(",
"PUNPCKLWD",
",",
"m",
")",
"CASE_MASK_UNPCK",
"(",
"PUNPCKLWD",
",",
"r",
")",
"CASE_MASK_UNPCK",
"(",
"PUNPCKLDQ",
",",
"m",
")",
"CASE_MASK_UNPCK",
"(",
"PUNPCKLDQ",
",",
"r",
")",
"CASE_MASK_UNPCK",
"(",
"UNPCKHPD",
",",
"m",
")",
"CASE_MASK_UNPCK",
"(",
"UNPCKHPD",
",",
"r",
")",
"CASE_MASK_UNPCK",
"(",
"UNPCKHPS",
",",
"m",
")",
"CASE_MASK_UNPCK",
"(",
"UNPCKHPS",
",",
"r",
")",
"CASE_MASK_UNPCK",
"(",
"UNPCKLPD",
",",
"m",
")",
"CASE_MASK_UNPCK",
"(",
"UNPCKLPD",
",",
"r",
")",
"CASE_MASK_UNPCK",
"(",
"UNPCKLPS",
",",
"m",
")",
"CASE_MASK_UNPCK",
"(",
"UNPCKLPS",
",",
"r",
")",
"CASE_MASK_SHUF",
"(",
"PALIGNR",
",",
"r",
")",
"CASE_MASK_SHUF",
"(",
"PALIGNR",
",",
"m",
")",
"CASE_MASK_SHUF",
"(",
"ALIGNQ",
",",
"r",
")",
"CASE_MASK_SHUF",
"(",
"ALIGNQ",
",",
"m",
")",
"CASE_MASK_SHUF",
"(",
"ALIGND",
",",
"r",
")",
"CASE_MASK_SHUF",
"(",
"ALIGND",
",",
"m",
")",
"CASE_MASK_SHUF",
"(",
"SHUFPD",
",",
"m",
")",
"CASE_MASK_SHUF",
"(",
"SHUFPD",
",",
"r",
")",
"CASE_MASK_SHUF",
"(",
"SHUFPS",
",",
"m",
")",
"CASE_MASK_SHUF",
"(",
"SHUFPS",
",",
"r",
")",
"CASE_MASK_VPERMILPI",
"(",
"PERMILPD",
",",
"m",
")",
"CASE_MASK_VPERMILPI",
"(",
"PERMILPD",
",",
"r",
")",
"CASE_MASK_VPERMILPI",
"(",
"PERMILPS",
",",
"m",
")",
"CASE_MASK_VPERMILPI",
"(",
"PERMILPS",
",",
"r",
")",
"CASE_MASK_VPERMILPI",
"(",
"PSHUFD",
",",
"m",
")",
"CASE_MASK_VPERMILPI",
"(",
"PSHUFD",
",",
"r",
")",
"CASE_MASK_VPERMILPI",
"(",
"PSHUFHW",
",",
"m",
")",
"CASE_MASK_VPERMILPI",
"(",
"PSHUFHW",
",",
"r",
")",
"CASE_MASK_VPERMILPI",
"(",
"PSHUFLW",
",",
"m",
")",
"CASE_MASK_VPERMILPI",
"(",
"PSHUFLW",
",",
"r",
")",
"CASE_MASK_VPERM",
"(",
"PERMPD",
",",
"m",
")",
"CASE_MASK_VPERM",
"(",
"PERMPD",
",",
"r",
")",
"CASE_MASK_VPERM",
"(",
"PERMQ",
",",
"m",
")",
"CASE_MASK_VPERM",
"(",
"PERMQ",
",",
"r",
")",
"CASE_MASK_VSHUF",
"(",
"<NUM_LIT>",
",",
"m",
")",
"CASE_MASK_VSHUF",
"(",
"<NUM_LIT>",
",",
"r",
")",
"CASE_MASK_VSHUF",
"(",
"<NUM_LIT>",
",",
"m",
")",
"CASE_MASK_VSHUF",
"(",
"<NUM_LIT>",
",",
"r",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTF64X2",
",",
"Z128",
",",
"rm",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTI64X2",
",",
"Z128",
",",
"rm",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTF64X2",
",",
",",
"rm",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTI64X2",
",",
",",
"rm",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTF64X4",
",",
",",
"rm",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTI64X4",
",",
",",
"rm",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTF32X4",
",",
"Z256",
",",
"rm",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTI32X4",
",",
"Z256",
",",
"rm",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTF32X4",
",",
",",
"rm",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTI32X4",
",",
",",
"rm",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTF32X8",
",",
",",
"rm",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTI32X8",
",",
",",
"rm",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTF32X2",
",",
"Z256",
",",
"r",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTI32X2",
",",
"Z256",
",",
"r",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTF32X2",
",",
"Z256",
",",
"m",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTI32X2",
",",
"Z256",
",",
"m",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTF32X2",
",",
"Z",
",",
"r",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTI32X2",
",",
"Z",
",",
"r",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTF32X2",
",",
"Z",
",",
"m",
")",
"CASE_MASK_INS_COMMON",
"(",
"BROADCASTI32X2",
",",
"Z",
",",
"m",
")",
"MaskRegName",
"=",
"getRegName",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getReg",
"(",
")",
")",
";",
"break",
";",
"}",
"OpMaskName",
"+=",
"<STR_LIT>",
" {%",
"<STR_LIT>",
";",
"OpMaskName",
"+=",
"MaskRegName",
";",
"OpMaskName",
"+=",
"<STR_LIT>",
"}",
"<STR_LIT>",
";",
"if",
"(",
"MaskWithZero",
")",
"OpMaskName",
"+=",
"<STR_LIT>",
" {z}",
"<STR_LIT>",
";",
"return"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 621,860 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] | [
"def",
"Xrri",
":",
"BaseExtractImm",
"<",
"GPR64",
",",
"imm0_63",
",",
"asm",
",",
"[",
"(",
"set",
"GPR64",
":",
"$",
"Rd",
",",
"(",
"AArch64Extr",
"GPR64",
":",
"$",
"Rn",
",",
"GPR64",
":",
"$",
"Rm",
",",
"imm0_63",
":",
"$",
"imm",
")",
")",
"]",
">",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 621,861 | [
"}"
] | [
"ScheduleDAGInstrs",
"*",
"createMachineScheduler",
"(",
"MachineSchedContext",
"*",
"C",
")",
"const",
"override",
"{",
"const",
"AArch64Subtarget",
"&",
"ST",
"=",
"C",
"->",
"MF",
"->",
"getSubtarget",
"<",
"AArch64Subtarget",
">",
"(",
")",
";",
"ScheduleDAGMILive",
"*",
"DAG",
"=",
"createGenericSchedLive",
"(",
"C",
")",
";",
"DAG",
"->",
"addMutation",
"(",
"createLoadClusterDAGMutation",
"(",
"DAG",
"->",
"TII",
",",
"DAG",
"->",
"TRI",
")",
")",
";",
"DAG",
"->",
"addMutation",
"(",
"createStoreClusterDAGMutation",
"(",
"DAG",
"->",
"TII",
",",
"DAG",
"->",
"TRI",
")",
")",
";",
"if",
"(",
"ST",
".",
"hasFusion",
"(",
")",
")",
"DAG",
"->",
"addMutation",
"(",
"createAArch64MacroFusionDAGMutation",
"(",
")",
")",
";",
"return",
"DAG",
";"
] |
LLVM | SystemZ | TD | stmt_completion | CPU | 621,862 | [
"Requires",
"<",
"[",
"FeatureHighWord",
"]",
">",
";"
] | [
"def",
"STMux",
":",
"StoreRXYPseudo",
"<",
"store",
",",
"GRX32",
",",
"<NUM_LIT>",
">",
","
] |
GCC | sparc | MD | stmt_completion | CPU | 621,863 | [
"<STR_LIT>",
")",
")"
] | [
"(",
"and",
":",
"DI",
"(",
"not",
":",
"DI",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>"
] |
GCC | nds32 | MD | stmt_completion | CPU | 621,864 | [
")"
] | [
"(",
"define_insn_reservation",
"<STR_LIT>",
"<NUM_LIT>",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 621,865 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"src1",
";"
] | [
"let",
"offsetBits",
"=",
"!",
"if",
"(",
"!",
"eq",
"(",
"ImmOpStr",
",",
"<STR_LIT>",
")",
",",
"offset",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
",",
"!",
"if",
"(",
"!",
"eq",
"(",
"ImmOpStr",
",",
"<STR_LIT>",
")",
",",
"offset",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
",",
"!",
"if",
"(",
"!",
"eq",
"(",
"ImmOpStr",
",",
"<STR_LIT>",
")",
",",
"offset",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
",",
"offset",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
")",
")",
")",
";",
"let",
"hasNewValue",
"=",
"!",
"if",
"(",
"!",
"eq",
"(",
"ImmOpStr",
",",
"<STR_LIT>",
")",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"let",
"IClass",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"MajOp",
";"
] |
GCC | aarch64 | CPP | next_suggestion | CPU | 621,866 | [
"tree",
"ftype_jcvt",
"=",
"build_function_type_list",
"(",
"intSI_type_node",
",",
"double_type_node",
",",
"NULL",
")",
";"
] | [
"aarch64_simd_switcher",
"simd",
";",
"aarch64_init_simd_builtins",
"(",
")",
";",
"}",
"aarch64_init_crc32_builtins",
"(",
")",
";",
"aarch64_init_builtin_rsqrt",
"(",
")",
";",
"aarch64_init_rng_builtins",
"(",
")",
";",
"aarch64_init_data_intrinsics",
"(",
")",
";"
] |
GCC | loongarch | CPP | next_suggestion | CPU | 621,867 | [
"}"
] | [
"if",
"(",
"!",
"isa",
")",
"isa",
"=",
"&",
"tmp",
";",
"if",
"(",
"abi",
".",
"ext",
"==",
"ABI_EXT_BASE",
")",
"switch",
"(",
"abi",
".",
"base",
")",
"{",
"case",
"ABI_BASE_LP64D",
":",
"case",
"ABI_BASE_LP64F",
":",
"case",
"ABI_BASE_LP64S",
":",
"*",
"isa",
"=",
"isa_required",
"(",
"abi",
")",
";",
"return",
"ARCH_LOONGARCH64",
";"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 621,868 | [
";"
] | [
"class",
"MRSI",
":",
"RtSystemI",
"<",
"<NUM_LIT>",
",",
"(",
"outs",
"GPR64",
":",
"$",
"Rt",
")",
",",
"(",
"ins",
"mrs_sysreg_op",
":",
"$",
"systemreg",
")",
",",
"<STR_LIT>",
",",
"<STR_LIT>",
">",
"{",
"bits",
"<",
"<NUM_LIT>",
">",
"systemreg",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"systemreg",
";",
"let",
"DecoderNamespace",
"=",
"<STR_LIT>"
] |
GCC | i386 | MD | next_suggestion | CPU | 621,869 | [
"<STR_LIT>"
] | [
"(",
"define_insn",
"<STR_LIT>",
"[",
"(",
"set",
"(",
"match_operand",
":",
"V4SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"vec_concat",
":",
"V4SI",
"(",
"unspec",
":",
"V2SI",
"[",
"(",
"match_operand",
":",
"V2DF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_FIX_NOTRUNC",
")",
"(",
"const_vector",
":",
"V2SI",
"[",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"]",
")",
")",
")",
"]"
] |
LLVM | SystemZ | CPP | stmt_completion | CPU | 621,870 | [
")",
";"
] | [
"MachineInstrBuilder",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
",",
"MI",
")",
".",
"addImm",
"(",
"CCValid",
")",
".",
"addImm",
"(",
"CCMask",
")",
".",
"addReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"RegState",
"::",
"Implicit",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Opcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"MI",
".",
"setDesc",
"(",
"get",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"MachineInstrBuilder",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
",",
"MI",
")",
".",
"addImm",
"(",
"CCValid",
")",
".",
"addImm",
"(",
"CCMask",
")",
".",
"addReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"RegState",
"::",
"Implicit",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Opcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"MachineOperand",
"FirstOp",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"const",
"uint32_t",
"*",
"RegMask",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getRegMask",
"(",
")",
";",
"MI",
".",
"RemoveOperand",
"(",
"<NUM_LIT>",
")",
";",
"MI",
".",
"RemoveOperand",
"(",
"<NUM_LIT>",
")",
";",
"MI",
".",
"setDesc",
"(",
"get",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"MachineInstrBuilder",
"(",
"*",
"MI",
".",
"getParent",
"(",
")",
"->",
"getParent",
"(",
")",
",",
"MI",
")",
".",
"addImm",
"(",
"CCValid",
")",
".",
"addImm",
"(",
"CCMask",
")",
".",
"add",
"(",
"FirstOp",
")",
".",
"addRegMask",
"(",
"RegMask",
")",
".",
"addReg",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"RegState",
"::",
"Implicit",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"Opcode",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"{",
"MachineOperand",
"Target",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"const",
"uint32_t",
"*",
"RegMask",
"=",
"MI",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getRegMask",
"(",
")",
";",
"MI",
".",
"RemoveOperand",
"(",
"<NUM_LIT>",
")",
";",
"MI",
".",
"RemoveOperand",
"(",
"<NUM_LIT>"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 621,871 | [
"}"
] | [
"void",
"setExceptionsType",
"(",
"ExceptionHandling",
"::",
"ExceptionsType",
"ExType",
")",
"{",
"ExceptionsType",
"=",
"ExType",
";"
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 621,872 | [
")",
"{"
] | [
"bool",
"SelectAddrModeIndexedS9S128",
"(",
"SDValue",
"N",
",",
"SDValue",
"&",
"Base",
",",
"SDValue",
"&",
"OffImm"
] |
LLVM | TGSI | CPP | next_suggestion | Virtual ISA | 621,873 | [
"for",
"(",
"MBBVector",
"::",
"const_iterator",
"iterBlk",
"=",
"OrderedBlks",
".",
"begin",
"(",
")",
",",
"iterBlkEnd",
"=",
"OrderedBlks",
".",
"end",
"(",
")",
";",
"iterBlk",
"!=",
"iterBlkEnd",
";",
"++",
"iterBlk",
",",
"++",
"i",
")",
"{"
] | [
"void",
"printOrderedBlocks",
"(",
")",
"const",
"{",
"size_t",
"i",
"=",
"<NUM_LIT>",
";"
] |
LLVM | Hexagon | CPP | stmt_completion | DSP | 621,874 | [
"FS",
")",
";"
] | [
"HexagonSubtarget",
"::",
"HexagonSubtarget",
"(",
"const",
"Triple",
"&",
"TT",
",",
"StringRef",
"CPU",
",",
"StringRef",
"FS",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
":",
"HexagonGenSubtargetInfo",
"(",
"TT",
",",
"CPU",
",",
"FS",
")",
",",
"OptLevel",
"(",
"TM",
".",
"getOptLevel",
"(",
")",
")",
",",
"CPUString",
"(",
"Hexagon_MC",
"::",
"selectHexagonCPU",
"(",
"CPU",
")",
")",
",",
"TargetTriple",
"(",
"TT",
")",
",",
"InstrInfo",
"(",
"initializeSubtargetDependencies",
"(",
"CPU",
",",
"FS",
")",
")",
",",
"RegInfo",
"(",
"getHwMode",
"(",
")",
")",
",",
"TLInfo",
"(",
"TM",
",",
"*",
"this",
")",
",",
"InstrItins",
"(",
"getInstrItineraryForCPU",
"(",
"CPUString",
")",
")",
"{",
"Hexagon_MC",
"::",
"addArchSubtarget",
"(",
"this",
","
] |
GCC | mn10300 | CPP | next_suggestion | MPU | 621,875 | [
"}"
] | [
"if",
"(",
"TARGET_ALLOW_SETLB",
")",
"mn10300_scan_for_setlb_lcc",
"(",
")",
";",
"if",
"(",
"TARGET_ALLOW_LIW",
")",
"mn10300_bundle_liw",
"(",
")",
";",
"}"
] |
GCC | i386 | CPP | stmt_completion | CPU | 621,876 | [
"_",
"_",
"v32hi",
")",
"_",
"_",
"W",
",",
"(",
"_",
"_",
"mmask32",
")",
"_",
"_",
"U",
")",
";"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m512i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm512_mask_slli_epi16",
"(",
"_",
"_",
"m512i",
"_",
"_",
"W",
",",
"_",
"_",
"mmask32",
"_",
"_",
"U",
",",
"_",
"_",
"m512i",
"_",
"_",
"A",
",",
"const",
"int",
"_",
"_",
"B",
")",
"{",
"return",
"(",
"_",
"_",
"m512i",
")",
"_",
"_",
"builtin_ia32_psllwi512_mask",
"(",
"(",
"_",
"_",
"v32hi",
")",
"_",
"_",
"A",
",",
"_",
"_",
"B",
",",
"("
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 621,877 | [
"let",
"hasNewValue",
"=",
"<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 | X86 | CPP | next_suggestion | CPU | 621,878 | [
"Register",
"Op2Reg",
"=",
"MI",
".",
"getOperand",
"(",
"CommutableOpIdx2",
")",
".",
"getReg",
"(",
")",
";"
] | [
"if",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"TSFlags",
")",
")",
"{",
"KMaskOp",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"TSFlags",
")",
"||",
"IsIntrinsic",
")",
"FirstCommutableVecOp",
"=",
"<NUM_LIT>",
";",
"LastCommutableVecOp",
"++",
";",
"}",
"else",
"if",
"(",
"IsIntrinsic",
")",
"{",
"FirstCommutableVecOp",
"=",
"<NUM_LIT>",
";",
"}",
"if",
"(",
"isMem",
"(",
"MI",
",",
"LastCommutableVecOp",
")",
")",
"LastCommutableVecOp",
"--",
";",
"if",
"(",
"SrcOpIdx1",
"!=",
"CommuteAnyOperandIndex",
"&&",
"(",
"SrcOpIdx1",
"<",
"FirstCommutableVecOp",
"||",
"SrcOpIdx1",
">",
"LastCommutableVecOp",
"||",
"SrcOpIdx1",
"==",
"KMaskOp",
")",
")",
"return",
"false",
";",
"if",
"(",
"SrcOpIdx2",
"!=",
"CommuteAnyOperandIndex",
"&&",
"(",
"SrcOpIdx2",
"<",
"FirstCommutableVecOp",
"||",
"SrcOpIdx2",
">",
"LastCommutableVecOp",
"||",
"SrcOpIdx2",
"==",
"KMaskOp",
")",
")",
"return",
"false",
";",
"if",
"(",
"SrcOpIdx1",
"==",
"CommuteAnyOperandIndex",
"||",
"SrcOpIdx2",
"==",
"CommuteAnyOperandIndex",
")",
"{",
"unsigned",
"CommutableOpIdx2",
"=",
"SrcOpIdx2",
";",
"if",
"(",
"SrcOpIdx1",
"==",
"SrcOpIdx2",
")",
"CommutableOpIdx2",
"=",
"LastCommutableVecOp",
";",
"else",
"if",
"(",
"SrcOpIdx2",
"==",
"CommuteAnyOperandIndex",
")",
"CommutableOpIdx2",
"=",
"SrcOpIdx1",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 621,879 | [
"let",
"opExtentBits",
"=",
"<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>",
";"
] |
GCC | s390 | MD | stmt_completion | MPU | 621,880 | [
"<STR_LIT>",
"<STR_LIT>",
")"
] | [
"(",
"match_operand",
":",
"DD_DF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"set_attr"
] |
LLVM | R600 | TD | program_repair | GPU | 621,881 | [
"<FIXS>",
"op",
",",
"outs",
",",
"ins",
",",
"opName",
"#",
"<STR_LIT>",
"#",
"asm",
",",
"pat",
",",
"opName",
",",
"NumSrcArgs",
",",
"HasMods",
"<FIXE>"
] | [
"multiclass",
"VOP3_Helper",
"vop3",
"op",
",",
"string",
"opName",
",",
"dag",
"outs",
",",
"dag",
"ins",
",",
"string",
"asm",
",",
"list",
"dag",
">",
"pat",
",",
"int",
"NumSrcArgs",
",",
"bit",
"HasMods",
">",
":",
"VOP3_m",
"<BUGS>",
"op",
",",
"outs",
",",
"ins",
",",
"opName",
"#",
"asm",
",",
"pat",
",",
"opName",
",",
"NumSrcArgs",
",",
"HasMods",
"<BUGE>",
">",
";",
"multiclass",
"VOPC_CLASS_F32",
"vopc",
"op",
",",
"string",
"opName",
">",
":"
] |
GCC | sh | MD | stmt_completion | CPU | 621,882 | [
")",
"]",
")"
] | [
"(",
"if_then_else",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"if_then_else",
"(",
"match_operand",
"<NUM_LIT>",
"<STR_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
"]"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 621,883 | [
"let",
"isBranch",
"=",
"<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>",
";"
] |
GCC | rs6000 | CPP | next_suggestion | CPU | 621,884 | [
"}"
] | [
"bool",
"*",
"yes",
"=",
"(",
"bool",
"*",
")",
"xyes",
";",
"if",
"(",
"REGNO",
"(",
"reg",
")",
"==",
"ALTIVEC_ARG_RETURN",
")",
"*",
"yes",
"=",
"true",
";"
] |
GCC | i386 | MD | stmt_completion | CPU | 621,885 | [
"V16SI",
"<STR_LIT>",
")",
"]",
")"
] | [
"(",
"define_mode_attr",
"GATHER_SCATTER_SF_MEM_MODE",
"[",
"(",
"V8DI",
"<STR_LIT>",
")",
"("
] |
LLVM | ARM | CPP | stmt_completion | CPU | 621,886 | [
";"
] | [
"unsigned",
"NumOperands",
"=",
"MI",
".",
"getDesc",
"(",
")",
".",
"getNumOperands",
"(",
")",
";",
"unsigned",
"OffField",
"=",
"MI",
".",
"getOperand",
"(",
"NumOperands",
"-",
"<NUM_LIT>",
")",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"Opcode",
"==",
"ARM",
"::",
"t2LDRi12",
"||",
"Opcode",
"==",
"ARM",
"::",
"t2LDRi8",
"||",
"Opcode",
"==",
"ARM",
"::",
"t2STRi12",
"||",
"Opcode",
"==",
"ARM",
"::",
"t2STRi8",
"||",
"Opcode",
"==",
"ARM",
"::",
"t2LDRDi8",
"||",
"Opcode",
"==",
"ARM",
"::",
"t2STRDi8",
"||",
"Opcode",
"==",
"ARM",
"::",
"LDRi12",
"||",
"Opcode",
"==",
"ARM",
"::",
"STRi12",
")",
"return",
"OffField",
";",
"if",
"(",
"Opcode",
"==",
"ARM",
"::",
"tLDRi",
"||",
"Opcode",
"==",
"ARM",
"::",
"tSTRi",
"||",
"Opcode",
"==",
"ARM",
"::",
"tLDRspi",
"||",
"Opcode",
"==",
"ARM",
"::",
"tSTRspi",
")",
"return",
"OffField",
"*",
"<NUM_LIT>",
";",
"int",
"Offset",
"=",
"isAM3",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"OffField",
")",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"OffField",
")",
"*",
"<NUM_LIT>",
";",
"<STR_LIT>",
"::",
"<STR_LIT>",
"Op",
"=",
"isAM3",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"OffField",
")",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"OffField",
")",
";",
"if",
"(",
"Op",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"return",
"-",
"Offset",
";",
"return",
"Offset"
] |
LLVM | TPC | TD | next_suggestion | Virtual ISA | 621,887 | [
"}"
] | [
"let",
"ParserMatchClass",
"=",
"X2AsmOperand",
";",
"let",
"MIOperandInfo",
"=",
"(",
"ops",
"i8imm",
":",
"$",
"x2",
")",
";"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 621,888 | [
"<NUM_LIT>",
";"
] | [
"def",
"L2_loadbzw4_zomap",
":",
"HInst",
"<",
"(",
"outs",
"DoubleRegs",
":",
"$",
"Rdd32",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rs32",
")",
",",
"<STR_LIT>",
",",
"tc_17e0d2cd",
",",
"TypeMAPPING",
">",
"{",
"let",
"isPseudo",
"=",
"<NUM_LIT>",
";",
"let",
"isCodeGenOnly",
"="
] |
GCC | arm | CPP | stmt_completion | CPU | 621,889 | [
")",
"{"
] | [
"_",
"_",
"arm_vrev64q_f32",
"(",
"float32x4_t",
"_",
"_",
"a"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 621,890 | [
"return",
"Infos",
"[",
"Kind",
"-",
"FirstTargetFixupKind",
"]",
";"
] | [
"const",
"MCFixupKindInfo",
"&",
"AMDGPUAsmBackend",
"::",
"getFixupKindInfo",
"(",
"MCFixupKind",
"Kind",
")",
"const",
"{",
"const",
"static",
"MCFixupKindInfo",
"Infos",
"[",
"AMDGPU",
"::",
"NumTargetFixupKinds",
"]",
"=",
"{",
"{",
"<STR_LIT>",
"fixup_si_sopp_br",
"<STR_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
",",
"{",
"<STR_LIT>",
"fixup_si_rodata",
"<STR_LIT>",
",",
"<NUM_LIT>",
",",
"<NUM_LIT>",
",",
"MCFixupKindInfo",
"::",
"FKF_IsPCRel",
"}",
"}",
";",
"if",
"(",
"Kind",
"<",
"FirstTargetFixupKind",
")",
"return",
"MCAsmBackend",
"::",
"getFixupKindInfo",
"(",
"Kind",
")",
";"
] |
GCC | s390 | MD | next_suggestion | MPU | 621,891 | [
"[",
"(",
"set_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
")"
] | [
"(",
"unspec",
":",
"VEC_HW",
"[",
"(",
"match_operand",
":",
"<",
"non_vec",
">",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_VEC_INSERT_AND_ZERO",
")",
")",
"]",
"<STR_LIT>",
"<STR_LIT>"
] |
LLVM | OR1K | CPP | stmt_completion | CPU | 621,892 | [
",",
"unsigned",
"N",
")",
"const",
"{"
] | [
"void",
"addRegOperands",
"(",
"MCInst",
"&",
"Inst"
] |
LLVM | AVR | CPP | stmt_completion | MPU | 621,893 | [
"getImm",
"(",
")",
"<<",
"<STR_LIT>",
"\\\"",
"<STR_LIT>",
";"
] | [
"O",
"<<",
"<STR_LIT>",
"Immediate: \\\"",
"<STR_LIT>",
"<<",
"*",
"getImm",
"(",
")",
"<<",
"<STR_LIT>",
"\\\"",
"<STR_LIT>",
";",
"break",
";",
"case",
"k_Memri",
":",
"{",
"O",
"<<",
"<STR_LIT>",
"Memri: \\\"",
"<STR_LIT>",
"<<",
"getReg",
"(",
")",
"<<",
"'",
"+",
"'",
"<<",
"*"
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 621,894 | [
"for",
"(",
"auto",
"&",
"RenderFn",
":",
"*",
"ImmFns",
")",
"RenderFn",
"(",
"AddMI",
")",
";"
] | [
"bool",
"Is32Bit",
"=",
"MRI",
".",
"getType",
"(",
"LHS",
".",
"getReg",
"(",
")",
")",
".",
"getSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
";",
"auto",
"ImmFns",
"=",
"selectArithImmed",
"(",
"RHS",
")",
";",
"unsigned",
"Opc",
"=",
"OpcTable",
"[",
"Is32Bit",
"]",
"[",
"ImmFns",
".",
"hasValue",
"(",
")",
"]",
";",
"auto",
"AddMI",
"=",
"MIRBuilder",
".",
"buildInstr",
"(",
"Opc",
",",
"{",
"DefReg",
"}",
",",
"{",
"LHS",
".",
"getReg",
"(",
")",
"}",
")",
";",
"if",
"(",
"ImmFns",
")",
"{"
] |
LLVM | SystemZ | CPP | next_suggestion | CPU | 621,895 | [
"}"
] | [
"unsigned",
"LoadOpcode",
",",
"StoreOpcode",
";",
"getLoadStoreOpcodes",
"(",
"RC",
",",
"LoadOpcode",
",",
"StoreOpcode",
")",
";",
"addFrameReference",
"(",
"BuildMI",
"(",
"MBB",
",",
"MBBI",
",",
"DL",
",",
"get",
"(",
"StoreOpcode",
")",
")",
".",
"addReg",
"(",
"SrcReg",
",",
"getKillRegState",
"(",
"isKill",
")",
")",
",",
"FrameIdx",
")",
";"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 621,896 | [
")",
",",
"<NUM_LIT>",
">",
";"
] | [
"def",
":",
"InstAlias",
"<",
"<STR_LIT>",
"#",
"<STR_LIT>",
",",
"(",
"CMGTv4i32",
"V128",
":",
"$",
"dst",
",",
"V128",
":",
"$",
"src2",
",",
"V128",
":",
"$",
"src1"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 621,897 | [
"return",
"true",
";"
] | [
"ISD",
"::",
"LoadExtType",
"ExtType",
"=",
"LD",
"->",
"getExtensionType",
"(",
")",
";",
"if",
"(",
"ExtType",
"!=",
"ISD",
"::",
"NON_EXTLOAD",
"&&",
"ExtType",
"!=",
"ISD",
"::",
"EXTLOAD",
")",
"return",
"false",
";",
"if",
"(",
"N",
".",
"hasOneUse",
"(",
")",
"&&",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
"==",
"Address",
"&&",
"N",
".",
"getNode",
"(",
")",
"->",
"isOperandOf",
"(",
"Chain",
".",
"getNode",
"(",
")",
")",
")",
"{",
"Load",
"=",
"N",
";"
] |
LLVM | PTX | CPP | program_repair | GPU | 621,898 | [
"<FIXS>",
"const",
"std",
"::",
"string",
"&",
"ParamName",
"=",
"PM",
".",
"getParamName",
"(",
"Param",
")",
";",
"<FIXE>"
] | [
"if",
"(",
"Outs",
".",
"size",
"(",
")",
"==",
"<NUM_LIT>",
")",
"{",
"unsigned",
"ParamSize",
"=",
"OutVals",
"[",
"<NUM_LIT>",
"]",
".",
"getValueType",
"(",
")",
".",
"getSizeInBits",
"(",
")",
";",
"unsigned",
"Param",
"=",
"PM",
".",
"addReturnParam",
"(",
"ParamSize",
")",
";",
"<BUGS>",
"std",
"::",
"string",
"ParamName",
"=",
"PM",
".",
"getParamName",
"(",
"Param",
")",
";",
"<BUGE>",
"SDValue",
"ParamValue",
"=",
"DAG",
".",
"getTargetExternalSymbol",
"(",
"ParamName",
".",
"c_str",
"(",
")",
",",
"MVT",
"::",
"Other",
")",
";",
"Chain",
"=",
"DAG",
".",
"getNode",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
",",
"dl",
",",
"MVT",
"::",
"Other",
",",
"Chain",
","
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 621,899 | [
"let",
"isCodeGenOnly",
"=",
"<NUM_LIT>",
";"
] | [
"def",
"A2_vaddb_map",
":",
"HInst",
"<",
"(",
"outs",
"DoubleRegs",
":",
"$",
"Rdd32",
")",
",",
"(",
"ins",
"DoubleRegs",
":",
"$",
"Rss32",
",",
"DoubleRegs",
":",
"$",
"Rtt32",
")",
",",
"<STR_LIT>",
",",
"tc_946df596",
",",
"TypeMAPPING",
">",
"{",
"let",
"isPseudo",
"=",
"<NUM_LIT>",
";"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.