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
|
---|---|---|---|---|---|---|---|
GCC | i386 | CPP | next_suggestion | CPU | 622,600 | [
"if",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"not",
"hrow_p",
")",
"TREE_NOTHROW",
"(",
"decl",
")",
"=",
"<NUM_LIT>",
";"
] | [
"type",
"=",
"ix86_get_builtin_func_type",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"tcode",
")",
";",
"decl",
"=",
"add_builtin_function_ext_scope",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"name",
",",
"type",
",",
"i",
",",
"BUILT_IN_MD",
",",
"NULL",
",",
"NULL_TREE",
")",
";",
"ix86_builtins",
"[",
"i",
"]",
"=",
"decl",
";",
"if",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"const_p",
")",
"TREE_READONLY",
"(",
"decl",
")",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"pure_p",
")",
"DECL_PURE_P",
"(",
"decl",
")",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"ix86_builtins_isa",
"[",
"i",
"]",
".",
"leaf_p",
")",
"DECL_ATTRIBUTES",
"(",
"decl",
")",
"=",
"build_tree_list",
"(",
"get_identifier",
"(",
"<STR_LIT>",
"leaf",
"<STR_LIT>",
")",
",",
"NULL_TREE",
")",
";"
] |
GCC | mn10300 | CPP | program_repair | MPU | 622,601 | [
"<FIXS>",
"mn10300_return_in_memory",
"(",
"const_tree",
"type",
",",
"const_tree",
"fntype",
"ATTRIBUTE_UNUSED",
")",
"<FIXE>"
] | [
"static",
"bool",
"<BUGS>",
"mn10300_return_in_memory",
"(",
"tree",
"type",
",",
"tree",
"fntype",
"ATTRIBUTE_UNUSED",
")",
"<BUGE>",
"{",
"return",
"(",
"int_size_in_bytes",
"(",
"type",
")",
">",
"<NUM_LIT>"
] |
LLVM | XCore | CPP | stmt_completion | MPU | 622,602 | [
"<STR_LIT>",
"Can only return in registers!",
"<STR_LIT>",
")",
";"
] | [
"if",
"(",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"liveout_empty",
"(",
")",
")",
"{",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"if",
"(",
"RVLocs",
"[",
"i",
"]",
".",
"isRegLoc",
"(",
")",
")",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getRegInfo",
"(",
")",
".",
"addLiveOut",
"(",
"RVLocs",
"[",
"i",
"]",
".",
"getLocReg",
"(",
")",
")",
";",
"}",
"SDValue",
"Flag",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
";",
"i",
"!=",
"RVLocs",
".",
"size",
"(",
")",
";",
"++",
"i",
")",
"{",
"CCValAssign",
"&",
"VA",
"=",
"RVLocs",
"[",
"i",
"]",
";",
"assert",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
"&&"
] |
GCC | sh | MD | stmt_completion | CPU | 622,603 | [
")",
"]",
")"
] | [
"(",
"set_attr_alternative",
"<STR_LIT>",
"[",
"(",
"if_then_else",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"if_then_else",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
")",
"(",
"if_then_else",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"(",
"const_string",
"<STR_LIT>",
")",
"]"
] |
GCC | pru | CPP | next_suggestion | CPU | 622,604 | [
"}"
] | [
"static",
"bool",
"pru_hard_regno_scratch_ok",
"(",
"unsigned",
"int",
"regno",
")",
"{",
"if",
"(",
"(",
"!",
"reload_completed",
"||",
"frame_pointer_needed",
")",
"&&",
"(",
"IN_RANGE",
"(",
"regno",
",",
"HARD_FRAME_POINTER_REGNUM",
",",
"HARD_FRAME_POINTER_REGNUM",
"+",
"<NUM_LIT>",
")",
"||",
"IN_RANGE",
"(",
"regno",
",",
"FRAME_POINTER_REGNUM",
",",
"FRAME_POINTER_REGNUM",
"+",
"<NUM_LIT>",
")",
")",
")",
"return",
"false",
";",
"return",
"true",
";"
] |
LLVM | AArch64 | CPP | next_suggestion | CPU | 622,605 | [
"if",
"(",
"MFI",
".",
"getStackID",
"(",
"FI",
")",
"==",
"TargetStackID",
"::",
"ScalableVector",
")",
"Base",
"=",
"CurDAG",
"->",
"getTargetFrameIndex",
"(",
"FI",
",",
"TLI",
"->",
"getPointerTy",
"(",
"DL",
")",
")",
";"
] | [
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"if",
"(",
"MemVT",
"==",
"EVT",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"N",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"ADD",
")",
"return",
"false",
";",
"SDValue",
"VScale",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"VScale",
".",
"getOpcode",
"(",
")",
"!=",
"ISD",
"::",
"VSCALE",
")",
"return",
"false",
";",
"TypeSize",
"TS",
"=",
"MemVT",
".",
"getSizeInBits",
"(",
")",
";",
"int64_t",
"MemWidthBytes",
"=",
"static_cast",
"<",
"int64_t",
">",
"(",
"TS",
".",
"getKnownMinValue",
"(",
")",
")",
"/",
"<NUM_LIT>",
";",
"int64_t",
"MulImm",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"VScale",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
"->",
"getSExtValue",
"(",
")",
";",
"if",
"(",
"(",
"MulImm",
"%",
"MemWidthBytes",
")",
"!=",
"<NUM_LIT>",
")",
"return",
"false",
";",
"int64_t",
"Offset",
"=",
"MulImm",
"/",
"MemWidthBytes",
";",
"if",
"(",
"Offset",
"<",
"Min",
"||",
"Offset",
">",
"Max",
")",
"return",
"false",
";",
"Base",
"=",
"N",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"if",
"(",
"Base",
".",
"getOpcode",
"(",
")",
"==",
"ISD",
"::",
"FrameIndex",
")",
"{",
"int",
"FI",
"=",
"cast",
"<",
"FrameIndexSDNode",
">",
"(",
"Base",
")",
"->",
"getIndex",
"(",
")",
";"
] |
GCC | xtensa | CPP | program_repair | MPU | 622,606 | [
"<FIXS>",
"xtensa_expand_call",
"(",
"int",
"callop",
",",
"rtx",
"*",
"operands",
")",
"<FIXE>"
] | [
"void",
"<BUGS>",
"xtensa_prepare_expand_call",
"(",
"int",
"callop",
",",
"rtx",
"*",
"operands",
")",
"<BUGE>",
"{",
"rtx",
"addr",
"=",
"XEXP",
"(",
"operands",
"[",
"callop",
"]",
",",
"<NUM_LIT>",
")",
";",
"if",
"(",
"flag_pic",
"&&",
"SYMBOL_REF_P",
"(",
"addr",
")"
] |
LLVM | ARM64 | TD | next_suggestion | CPU | 622,607 | [
"}"
] | [
"let",
"PrintMethod",
"=",
"<STR_LIT>",
";",
"let",
"ParserMatchClass",
"=",
"MemoryIndexed64SImm7",
";",
"let",
"MIOperandInfo",
"=",
"(",
"ops",
"GPR64sp",
":",
"$",
"base",
",",
"i32imm",
":",
"$",
"offset",
")",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 622,608 | [
"let",
"CextOpcode",
"=",
"<STR_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 | AMDGPU | CPP | code_generation | GPU | 622,609 | [
"bool",
"AMDGPUSetWavePriority",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"const",
"unsigned",
"HighPriority",
"=",
"<NUM_LIT>",
";",
"const",
"unsigned",
"LowPriority",
"=",
"<NUM_LIT>",
";",
"Function",
"&",
"F",
"=",
"MF",
".",
"getFunction",
"(",
")",
";",
"if",
"(",
"skipFunction",
"(",
"F",
")",
"||",
"!",
"AMDGPU",
"::",
"isEntryFunctionCC",
"(",
"F",
".",
"getCallingConv",
"(",
")",
")",
")",
"return",
"false",
";",
"const",
"GCNSubtarget",
"&",
"ST",
"=",
"MF",
".",
"getSubtarget",
"<",
"GCNSubtarget",
">",
"(",
")",
";",
"TII",
"=",
"ST",
".",
"getInstrInfo",
"(",
")",
";",
"MBBInfoSet",
"MBBInfos",
";",
"SmallVector",
"<",
"const",
"MachineBasicBlock",
"*",
",",
"<NUM_LIT>",
">",
"Worklist",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"{",
"if",
"(",
"any_of",
"(",
"MBB",
",",
"isVMEMLoad",
")",
")",
"Worklist",
".",
"push_back",
"(",
"&",
"MBB",
")",
";",
"}",
"while",
"(",
"!",
"Worklist",
".",
"empty",
"(",
")",
")",
"{",
"const",
"MachineBasicBlock",
"*",
"MBB",
"=",
"Worklist",
".",
"pop_back_val",
"(",
")",
";",
"MBBInfo",
"&",
"Info",
"=",
"MBBInfos",
"[",
"MBB",
"]",
";",
"if",
"(",
"!",
"Info",
".",
"MayReachVMEMLoad",
")",
"{",
"Info",
".",
"MayReachVMEMLoad",
"=",
"true",
";",
"Worklist",
".",
"append",
"(",
"MBB",
"->",
"pred_begin",
"(",
")",
",",
"MBB",
"->",
"pred_end",
"(",
")",
")",
";",
"}",
"}",
"MachineBasicBlock",
"&",
"Entry",
"=",
"MF",
".",
"front",
"(",
")",
";",
"if",
"(",
"!",
"MBBInfos",
"[",
"&",
"Entry",
"]",
".",
"MayReachVMEMLoad",
")",
"return",
"false",
";",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"Entry",
".",
"begin",
"(",
")",
",",
"E",
"=",
"Entry",
".",
"end",
"(",
")",
";",
"while",
"(",
"I",
"!=",
"E",
"&&",
"!",
"SIInstrInfo",
"::",
"isVALU",
"(",
"*",
"I",
")",
"&&",
"!",
"I",
"->",
"isTerminator",
"(",
")",
")",
"++",
"I",
";",
"Entry",
".",
"insert",
"(",
"I",
",",
"BuildSetprioMI",
"(",
"MF",
",",
"HighPriority",
")",
")",
";",
"SmallSet",
"<",
"MachineBasicBlock",
"*",
",",
"<NUM_LIT>",
">",
"PriorityLoweringBlocks",
";",
"for",
"(",
"MachineBasicBlock",
"&",
"MBB",
":",
"MF",
")",
"{",
"if",
"(",
"MBBInfos",
"[",
"&",
"MBB",
"]",
".",
"MayReachVMEMLoad",
")",
"{",
"if",
"(",
"MBB",
".",
"succ_empty",
"(",
")",
")",
"PriorityLoweringBlocks",
".",
"insert",
"(",
"&",
"MBB",
")",
";",
"continue",
";",
"}",
"if",
"(",
"CanLowerPriorityDirectlyInPredecessors",
"(",
"MBB",
",",
"MBBInfos",
")",
")",
"{",
"for",
"(",
"MachineBasicBlock",
"*",
"Pred",
":",
"MBB",
".",
"predecessors",
"(",
")",
")",
"{",
"if",
"(",
"MBBInfos",
"[",
"Pred",
"]",
".",
"MayReachVMEMLoad",
")",
"PriorityLoweringBlocks",
".",
"insert",
"(",
"Pred",
")",
";",
"}",
"continue",
";",
"}",
"PriorityLoweringBlocks",
".",
"insert",
"(",
"&",
"MBB",
")",
";",
"}",
"for",
"(",
"MachineBasicBlock",
"*",
"MBB",
":",
"PriorityLoweringBlocks",
")",
"{",
"MachineBasicBlock",
"::",
"iterator",
"I",
"=",
"MBB",
"->",
"end",
"(",
")",
",",
"B",
"=",
"MBB",
"->",
"begin",
"(",
")",
";",
"while",
"(",
"I",
"!=",
"B",
")",
"{",
"if",
"(",
"isVMEMLoad",
"(",
"*",
"--",
"I",
")",
")",
"{",
"++",
"I",
";",
"break",
";",
"}",
"}",
"MBB",
"->",
"insert",
"(",
"I",
",",
"BuildSetprioMI",
"(",
"MF",
",",
"LowPriority",
")",
")",
";",
"}",
"return",
"true",
";",
"}"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] |
LLVM | X86 | TD | stmt_completion | CPU | 622,610 | [
"HWPort06",
",",
"HWPort0156",
"]",
">",
"{"
] | [
"def",
"HWWriteResGroup59",
":",
"SchedWriteRes",
"<",
"["
] |
LLVM | VE | CPP | next_suggestion | CPU | 622,611 | [
"}"
] | [
"SDValue",
"VETargetLowering",
"::",
"LowerVAARG",
"(",
"SDValue",
"Op",
",",
"SelectionDAG",
"&",
"DAG",
")",
"const",
"{",
"SDNode",
"*",
"Node",
"=",
"Op",
".",
"getNode",
"(",
")",
";",
"EVT",
"VT",
"=",
"Node",
"->",
"getValueType",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"InChain",
"=",
"Node",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"VAListPtr",
"=",
"Node",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"EVT",
"PtrVT",
"=",
"VAListPtr",
".",
"getValueType",
"(",
")",
";",
"const",
"Value",
"*",
"SV",
"=",
"cast",
"<",
"SrcValueSDNode",
">",
"(",
"Node",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
")",
"->",
"getValue",
"(",
")",
";",
"SDLoc",
"DL",
"(",
"Node",
")",
";",
"SDValue",
"VAList",
"=",
"DAG",
".",
"getLoad",
"(",
"PtrVT",
",",
"DL",
",",
"InChain",
",",
"VAListPtr",
",",
"MachinePointerInfo",
"(",
"SV",
")",
")",
";",
"SDValue",
"Chain",
"=",
"VAList",
".",
"getValue",
"(",
"<NUM_LIT>",
")",
";",
"SDValue",
"NextPtr",
";",
"if",
"(",
"VT",
"==",
"MVT",
"::",
"f32",
")",
"{",
"NextPtr",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"PtrVT",
",",
"VAList",
",",
"DAG",
".",
"getIntPtrConstant",
"(",
"<NUM_LIT>",
",",
"DL",
")",
")",
";",
"unsigned",
"InternalOffset",
"=",
"<NUM_LIT>",
";",
"VAList",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"PtrVT",
",",
"VAList",
",",
"DAG",
".",
"getConstant",
"(",
"InternalOffset",
",",
"DL",
",",
"PtrVT",
")",
")",
";",
"}",
"else",
"{",
"NextPtr",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"PtrVT",
",",
"VAList",
",",
"DAG",
".",
"getIntPtrConstant",
"(",
"<NUM_LIT>",
",",
"DL",
")",
")",
";",
"}",
"InChain",
"=",
"DAG",
".",
"getStore",
"(",
"Chain",
",",
"DL",
",",
"NextPtr",
",",
"VAListPtr",
",",
"MachinePointerInfo",
"(",
"SV",
")",
")",
";",
"return",
"DAG",
".",
"getLoad",
"(",
"VT",
",",
"DL",
",",
"InChain",
",",
"VAList",
",",
"MachinePointerInfo",
"(",
")",
",",
"std",
"::",
"min",
"(",
"PtrVT",
".",
"getSizeInBits",
"(",
")",
",",
"VT",
".",
"getSizeInBits",
"(",
")",
")",
"/",
"<NUM_LIT>",
")",
";"
] |
LLVM | PowerPC | TD | stmt_completion | CPU | 622,612 | [
",",
"s16imm",
":",
"$",
"imm",
")",
">",
";"
] | [
"def",
"SUBIC",
":",
"PPCAsmPseudo",
"<",
"<STR_LIT>",
",",
"(",
"ins",
"gprc",
":",
"$",
"rA",
",",
"gprc",
":",
"$",
"rB"
] |
GCC | i386 | MD | program_repair | CPU | 622,613 | [
"<FIXS>",
"[",
"(",
"match_operand",
":",
"P",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"<FIXE>"
] | [
"[",
"(",
"pc",
")",
"(",
"match_operator",
":",
"ssescalarmode",
">",
"<NUM_LIT>",
"<STR_LIT>",
"[",
"(",
"unspec",
":",
"P",
"<BUGS>",
"[",
"(",
"match_operand",
":",
"P",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"<BUGE>",
"(",
"match_operand",
":",
"VEC_GATHER_IDXSI",
">",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
")",
"]",
"UNSPEC_VSIBADDR",
")",
"]",
")"
] |
LLVM | SystemZ | CPP | next_suggestion | CPU | 622,614 | [
"return",
"true",
";"
] | [
"static",
"bool",
"shouldSwapCmpOperands",
"(",
"SDValue",
"Op0",
",",
"SDValue",
"Op1",
",",
"unsigned",
"ICmpType",
")",
"{",
"if",
"(",
"Op0",
".",
"getValueType",
"(",
")",
"==",
"MVT",
"::",
"f128",
")",
"return",
"false",
";",
"if",
"(",
"isa",
"<",
"ConstantFPSDNode",
">",
"(",
"Op1",
")",
")",
"return",
"false",
";",
"ConstantSDNode",
"*",
"COp1",
"=",
"dyn_cast",
"<",
"ConstantSDNode",
">",
"(",
"Op1",
")",
";",
"if",
"(",
"COp1",
"&&",
"COp1",
"->",
"getZExtValue",
"(",
")",
"==",
"<NUM_LIT>",
")",
"return",
"false",
";",
"if",
"(",
"(",
"isNaturalMemoryOperand",
"(",
"Op0",
",",
"ICmpType",
")",
"&&",
"Op0",
".",
"hasOneUse",
"(",
")",
")",
"&&",
"!",
"(",
"isNaturalMemoryOperand",
"(",
"Op1",
",",
"ICmpType",
")",
"&&",
"Op1",
".",
"hasOneUse",
"(",
")",
")",
")",
"{",
"if",
"(",
"!",
"COp1",
")",
"return",
"true",
";",
"if",
"(",
"ICmpType",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"COp1",
"->",
"getZExtValue",
"(",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"ICmpType",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"isInt",
"<",
"<NUM_LIT>",
">",
"(",
"COp1",
"->",
"getSExtValue",
"(",
")",
")",
")",
"return",
"false",
";"
] |
GCC | rs6000 | CPP | stmt_completion | CPU | 622,615 | [
"INTEGER_CST",
")",
"{"
] | [
"static",
"rtx",
"spe_expand_predicate_builtin",
"(",
"enum",
"insn_code",
"icode",
",",
"tree",
"arglist",
",",
"rtx",
"target",
")",
"{",
"rtx",
"pat",
",",
"scratch",
",",
"tmp",
";",
"tree",
"form",
"=",
"TREE_VALUE",
"(",
"arglist",
")",
";",
"tree",
"arg0",
"=",
"TREE_VALUE",
"(",
"TREE_CHAIN",
"(",
"arglist",
")",
")",
";",
"tree",
"arg1",
"=",
"TREE_VALUE",
"(",
"TREE_CHAIN",
"(",
"TREE_CHAIN",
"(",
"arglist",
")",
")",
")",
";",
"rtx",
"op0",
"=",
"expand_expr",
"(",
"arg0",
",",
"NULL_RTX",
",",
"VOIDmode",
",",
"<NUM_LIT>",
")",
";",
"rtx",
"op1",
"=",
"expand_expr",
"(",
"arg1",
",",
"NULL_RTX",
",",
"VOIDmode",
",",
"<NUM_LIT>",
")",
";",
"enum",
"machine_mode",
"mode0",
"=",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"<NUM_LIT>",
"]",
".",
"mode",
";",
"enum",
"machine_mode",
"mode1",
"=",
"insn_data",
"[",
"icode",
"]",
".",
"operand",
"[",
"<NUM_LIT>",
"]",
".",
"mode",
";",
"int",
"form_int",
";",
"enum",
"rtx_code",
"code",
";",
"if",
"(",
"TREE_CODE",
"(",
"form",
")",
"!="
] |
LLVM | ARM64 | TD | next_suggestion | CPU | 622,616 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rn",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"Rn",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"immr",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"imms",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opc",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"immr",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"imms",
";"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 622,617 | [
"Scale",
"==",
"<NUM_LIT>",
";"
] | [
"}",
"if",
"(",
"Subtarget",
"->",
"getGeneration",
"(",
")",
">=",
"AMDGPUSubtarget",
"::",
"GFX10",
")",
"return",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"AM",
".",
"BaseOffs",
")",
"&&",
"AM",
".",
"Scale",
"==",
"<NUM_LIT>",
";",
"return",
"isUInt",
"<",
"<NUM_LIT>",
">",
"(",
"AM",
".",
"BaseOffs",
")",
"&&",
"AM",
"."
] |
LLVM | LoongArch | CPP | code_generation | CPU | 622,618 | [
"SDValue",
"LoongArchTargetLowering",
"::",
"LowerFormalArguments",
"(",
"SDValue",
"Chain",
",",
"CallingConv",
"::",
"ID",
"CallConv",
",",
"bool",
"IsVarArg",
",",
"const",
"SmallVectorImpl",
"<",
"ISD",
"::",
"InputArg",
">",
"&",
"Ins",
",",
"const",
"SDLoc",
"&",
"DL",
",",
"SelectionDAG",
"&",
"DAG",
",",
"SmallVectorImpl",
"<",
"SDValue",
">",
"&",
"InVals",
")",
"const",
"{",
"MachineFunction",
"&",
"MF",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
";",
"switch",
"(",
"CallConv",
")",
"{",
"default",
":",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Unsupported calling convention",
"<STR_LIT>",
")",
";",
"case",
"CallingConv",
"::",
"C",
":",
"case",
"CallingConv",
"::",
"Fast",
":",
"break",
";",
"case",
"CallingConv",
"::",
"GHC",
":",
"if",
"(",
"!",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"hasFeature",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
"||",
"!",
"MF",
".",
"getSubtarget",
"(",
")",
".",
"hasFeature",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
"report_fatal_error",
"(",
"<STR_LIT>",
"GHC calling convention requires the F and D extensions",
"<STR_LIT>",
")",
";",
"}",
"EVT",
"PtrVT",
"=",
"getPointerTy",
"(",
"DAG",
".",
"getDataLayout",
"(",
")",
")",
";",
"MVT",
"GRLenVT",
"=",
"Subtarget",
".",
"getGRLenVT",
"(",
")",
";",
"unsigned",
"GRLenInBytes",
"=",
"Subtarget",
".",
"getGRLen",
"(",
")",
"/",
"<NUM_LIT>",
";",
"std",
"::",
"vector",
"<",
"SDValue",
">",
"OutChains",
";",
"SmallVector",
"<",
"CCValAssign",
">",
"ArgLocs",
";",
"CCState",
"CCInfo",
"(",
"CallConv",
",",
"IsVarArg",
",",
"MF",
",",
"ArgLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
")",
";",
"if",
"(",
"CallConv",
"==",
"CallingConv",
"::",
"GHC",
")",
"CCInfo",
".",
"AnalyzeFormalArguments",
"(",
"Ins",
",",
"CC_LoongArch_GHC",
")",
";",
"else",
"analyzeInputArgs",
"(",
"MF",
",",
"CCInfo",
",",
"Ins",
",",
"false",
",",
"CC_LoongArch",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"ArgLocs",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"CCValAssign",
"&",
"VA",
"=",
"ArgLocs",
"[",
"i",
"]",
";",
"SDValue",
"ArgValue",
";",
"if",
"(",
"VA",
".",
"isRegLoc",
"(",
")",
")",
"ArgValue",
"=",
"unpackFromRegLoc",
"(",
"DAG",
",",
"Chain",
",",
"VA",
",",
"DL",
",",
"Ins",
"[",
"i",
"]",
",",
"*",
"this",
")",
";",
"else",
"ArgValue",
"=",
"unpackFromMemLoc",
"(",
"DAG",
",",
"Chain",
",",
"VA",
",",
"DL",
")",
";",
"if",
"(",
"VA",
".",
"getLocInfo",
"(",
")",
"==",
"CCValAssign",
"::",
"Indirect",
")",
"{",
"InVals",
".",
"push_back",
"(",
"DAG",
".",
"getLoad",
"(",
"VA",
".",
"getValVT",
"(",
")",
",",
"DL",
",",
"Chain",
",",
"ArgValue",
",",
"MachinePointerInfo",
"(",
")",
")",
")",
";",
"unsigned",
"ArgIndex",
"=",
"Ins",
"[",
"i",
"]",
".",
"OrigArgIndex",
";",
"unsigned",
"ArgPartOffset",
"=",
"Ins",
"[",
"i",
"]",
".",
"PartOffset",
";",
"assert",
"(",
"ArgPartOffset",
"==",
"<NUM_LIT>",
")",
";",
"while",
"(",
"i",
"+",
"<NUM_LIT>",
"!=",
"e",
"&&",
"Ins",
"[",
"i",
"+",
"<NUM_LIT>",
"]",
".",
"OrigArgIndex",
"==",
"ArgIndex",
")",
"{",
"CCValAssign",
"&",
"PartVA",
"=",
"ArgLocs",
"[",
"i",
"+",
"<NUM_LIT>",
"]",
";",
"unsigned",
"PartOffset",
"=",
"Ins",
"[",
"i",
"+",
"<NUM_LIT>",
"]",
".",
"PartOffset",
"-",
"ArgPartOffset",
";",
"SDValue",
"Offset",
"=",
"DAG",
".",
"getIntPtrConstant",
"(",
"PartOffset",
",",
"DL",
")",
";",
"SDValue",
"Address",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"ADD",
",",
"DL",
",",
"PtrVT",
",",
"ArgValue",
",",
"Offset",
")",
";",
"InVals",
".",
"push_back",
"(",
"DAG",
".",
"getLoad",
"(",
"PartVA",
".",
"getValVT",
"(",
")",
",",
"DL",
",",
"Chain",
",",
"Address",
",",
"MachinePointerInfo",
"(",
")",
")",
")",
";",
"++",
"i",
";",
"}",
"continue",
";",
"}",
"InVals",
".",
"push_back",
"(",
"ArgValue",
")",
";",
"}",
"if",
"(",
"IsVarArg",
")",
"{",
"ArrayRef",
"<",
"MCPhysReg",
">",
"ArgRegs",
"=",
"ArrayRef",
"(",
"ArgGPRs",
")",
";",
"unsigned",
"Idx",
"=",
"CCInfo",
".",
"getFirstUnallocated",
"(",
"ArgRegs",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"MachineFrameInfo",
"&",
"MFI",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"MachineRegisterInfo",
"&",
"RegInfo",
"=",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"auto",
"*",
"LoongArchFI",
"=",
"MF",
".",
"getInfo",
"<",
"LoongArchMachineFunctionInfo",
">",
"(",
")",
";",
"int",
"VaArgOffset",
",",
"VarArgsSaveSize",
";",
"if",
"(",
"ArgRegs",
".",
"size",
"(",
")",
"==",
"Idx",
")",
"{",
"VaArgOffset",
"=",
"CCInfo",
".",
"getStackSize",
"(",
")",
";",
"VarArgsSaveSize",
"=",
"<NUM_LIT>",
";",
"}",
"else",
"{",
"VarArgsSaveSize",
"=",
"GRLenInBytes",
"*",
"(",
"ArgRegs",
".",
"size",
"(",
")",
"-",
"Idx",
")",
";",
"VaArgOffset",
"=",
"-",
"VarArgsSaveSize",
";",
"}",
"int",
"FI",
"=",
"MFI",
".",
"CreateFixedObject",
"(",
"GRLenInBytes",
",",
"VaArgOffset",
",",
"true",
")",
";",
"LoongArchFI",
"->",
"setVarArgsFrameIndex",
"(",
"FI",
")",
";",
"if",
"(",
"Idx",
"%",
"<NUM_LIT>",
")",
"{",
"MFI",
".",
"CreateFixedObject",
"(",
"GRLenInBytes",
",",
"VaArgOffset",
"-",
"(",
"int",
")",
"GRLenInBytes",
",",
"true",
")",
";",
"VarArgsSaveSize",
"+=",
"GRLenInBytes",
";",
"}",
"for",
"(",
"unsigned",
"I",
"=",
"Idx",
";",
"I",
"<",
"ArgRegs",
".",
"size",
"(",
")",
";",
"++",
"I",
",",
"VaArgOffset",
"+=",
"GRLenInBytes",
")",
"{",
"const",
"Register",
"Reg",
"=",
"RegInfo",
".",
"createVirtualRegister",
"(",
"RC",
")",
";",
"RegInfo",
".",
"addLiveIn",
"(",
"ArgRegs",
"[",
"I",
"]",
",",
"Reg",
")",
";",
"SDValue",
"ArgValue",
"=",
"DAG",
".",
"getCopyFromReg",
"(",
"Chain",
",",
"DL",
",",
"Reg",
",",
"GRLenVT",
")",
";",
"FI",
"=",
"MFI",
".",
"CreateFixedObject",
"(",
"GRLenInBytes",
",",
"VaArgOffset",
",",
"true",
")",
";",
"SDValue",
"PtrOff",
"=",
"DAG",
".",
"getFrameIndex",
"(",
"FI",
",",
"getPointerTy",
"(",
"DAG",
".",
"getDataLayout",
"(",
")",
")",
")",
";",
"SDValue",
"Store",
"=",
"DAG",
".",
"getStore",
"(",
"Chain",
",",
"DL",
",",
"ArgValue",
",",
"PtrOff",
",",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"MF",
",",
"FI",
")",
")",
";",
"cast",
"<",
"StoreSDNode",
">",
"(",
"Store",
".",
"getNode",
"(",
")",
")",
"->",
"getMemOperand",
"(",
")",
"->",
"setValue",
"(",
"(",
"Value",
"*",
")",
"nullptr",
")",
";",
"OutChains",
".",
"push_back",
"(",
"Store",
")",
";",
"}",
"LoongArchFI",
"->",
"setVarArgsSaveSize",
"(",
"VarArgsSaveSize",
")",
";",
"}",
"if",
"(",
"!",
"OutChains",
".",
"empty",
"(",
")",
")",
"{",
"OutChains",
".",
"push_back",
"(",
"Chain",
")",
";",
"Chain",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"TokenFactor",
",",
"DL",
",",
"MVT",
"::",
"Other",
",",
"OutChains",
")",
";",
"}",
"return",
"Chain",
";",
"}"
] | [
"This",
"hook",
"must",
"be",
"implemented",
"to",
"lower",
"the",
"incoming",
"(",
"formal",
")",
"arguments",
",",
"described",
"by",
"the",
"Ins",
"array",
",",
"into",
"the",
"specified",
"DAG",
"."
] |
LLVM | XCore | CPP | stmt_completion | MPU | 622,619 | [
"false",
";"
] | [
"for",
"(",
"Value",
"::",
"use_iterator",
"UI",
"=",
"GV",
"->",
"use_begin",
"(",
")",
",",
"E",
"=",
"GV",
"->",
"use_end",
"(",
")",
";",
"UI",
"!=",
"E",
";",
"++",
"UI",
")",
"if",
"(",
"!",
"isa",
"<",
"Instruction",
">",
"(",
"*",
"UI",
")",
")",
"return",
"true",
";",
"return"
] |
GCC | i386 | CPP | stmt_completion | CPU | 622,620 | [
"(",
"_",
"_",
"v4sf",
")",
"_",
"_",
"B",
")",
";"
] | [
"static",
"_",
"_",
"inline",
"_",
"_",
"m128",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"always_inline__",
")",
")",
"_",
"mm_add_ss",
"(",
"_",
"_",
"m128",
"_",
"_",
"A",
",",
"_",
"_",
"m128",
"_",
"_",
"B",
")",
"{",
"return",
"(",
"_",
"_",
"m128",
")",
"_",
"_",
"builtin_ia32_addss",
"(",
"(",
"_",
"_",
"v4sf",
")",
"_",
"_",
"A",
","
] |
GCC | sparc | MD | stmt_completion | CPU | 622,621 | [
"<STR_LIT>",
")",
")"
] | [
"(",
"define_attr",
"<STR_LIT>",
"<STR_LIT>",
"(",
"symbol_ref"
] |
GCC | rs6000 | MD | program_repair | CPU | 622,622 | [
"<FIXS>",
"<STR_LIT>",
"<FIXE>"
] | [
"(",
"match_operand",
":",
"SF",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"match_dup",
"<NUM_LIT>",
")",
")",
")",
"]",
"<BUGS>",
"<STR_LIT>",
"<BUGE>",
"<STR_LIT>"
] |
GCC | cr16 | CPP | next_suggestion | MPU | 622,623 | [
"else",
"if",
"(",
"(",
"mode",
"==",
"SFmode",
")",
"||",
"(",
"mode",
"==",
"DFmode",
")",
")",
"cum",
"->",
"ints",
"+=",
"l",
";"
] | [
"if",
"(",
"!",
"cum",
"->",
"last_parm_in_reg",
")",
"return",
";",
"if",
"(",
"targetm",
".",
"calls",
".",
"must_pass_in_stack",
"(",
"mode",
",",
"type",
")",
"||",
"(",
"cum",
"->",
"ints",
"<",
"<NUM_LIT>",
")",
")",
"return",
";",
"if",
"(",
"(",
"mode",
"==",
"SImode",
")",
"||",
"(",
"mode",
"==",
"HImode",
")",
"||",
"(",
"mode",
"==",
"QImode",
")",
"||",
"(",
"mode",
"==",
"DImode",
")",
")",
"{",
"if",
"(",
"l",
"<=",
"<NUM_LIT>",
")",
"cum",
"->",
"ints",
"+=",
"<NUM_LIT>",
";",
"else",
"cum",
"->",
"ints",
"+=",
"l",
";",
"}"
] |
LLVM | ARM | CPP | stmt_completion | CPU | 622,624 | [
")",
";"
] | [
"static",
"bool",
"hasRAWHazard",
"(",
"MachineInstr",
"*",
"DefMI",
",",
"MachineInstr",
"*",
"MI",
",",
"const",
"TargetRegisterInfo",
"&",
"TRI",
")",
"{",
"const",
"MCInstrDesc",
"&",
"MCID",
"=",
"MI",
"->",
"getDesc",
"(",
")",
";",
"unsigned",
"Domain",
"=",
"MCID",
".",
"TSFlags",
"&",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"if",
"(",
"MI",
"->",
"mayStore",
"(",
")",
")",
"return",
"false",
";",
"unsigned",
"Opcode",
"=",
"MCID",
".",
"getOpcode",
"("
] |
GCC | h8300 | CPP | next_suggestion | MPU | 622,625 | [
"}"
] | [
"tmp",
"=",
"gen_rtx_COMPARE",
"(",
"VOIDmode",
",",
"op0",
",",
"op1",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"cc0_rtx",
",",
"tmp",
")",
")",
";",
"tmp",
"=",
"gen_rtx_fmt_ee",
"(",
"code",
",",
"GET_MODE",
"(",
"dest",
")",
",",
"cc0_rtx",
",",
"const0_rtx",
")",
";",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"dest",
",",
"tmp",
")",
")",
";"
] |
GCC | aarch64 | CPP | stmt_completion | CPU | 622,626 | [
")",
";"
] | [
"return",
"_",
"_",
"builtin_aarch64_reduc_smax_scal_v2df",
"(",
"a"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 622,627 | [
"(",
")",
",",
"Result",
")",
";"
] | [
"unsigned",
"WrapperKind",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"CodeModel",
"::",
"Model",
"M",
"=",
"getTargetMachine",
"(",
")",
".",
"getCodeModel",
"(",
")",
";",
"if",
"(",
"Subtarget",
"->",
"isPICStyleRIPRel",
"(",
")",
"&&",
"(",
"M",
"==",
"CodeModel",
"::",
"Small",
"||",
"M",
"==",
"CodeModel",
"::",
"Kernel",
")",
")",
"WrapperKind",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"else",
"if",
"(",
"Subtarget",
"->",
"isPICStyleGOT",
"(",
")",
")",
"OpFlag",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"else",
"if",
"(",
"Subtarget",
"->",
"isPICStyleStubPIC",
"(",
")",
")",
"OpFlag",
"=",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"SDValue",
"Result",
"=",
"DAG",
".",
"getTargetExternalSymbol",
"(",
"Sym",
",",
"getPointerTy",
"(",
")",
",",
"OpFlag",
")",
";",
"DebugLoc",
"DL",
"=",
"Op",
".",
"getDebugLoc",
"(",
")",
";",
"Result",
"=",
"DAG",
".",
"getNode",
"(",
"WrapperKind",
",",
"DL",
",",
"getPointerTy"
] |
GCC | arm | MD | stmt_completion | CPU | 622,628 | [
"<STR_LIT>",
")",
")"
] | [
"(",
"eq_attr",
"<STR_LIT>"
] |
LLVM | AMDGPU | CPP | next_suggestion | GPU | 622,629 | [
"return",
"DAG",
".",
"getMemIntrinsicNode",
"(",
"Opc",
",",
"DL",
",",
"Op",
"->",
"getVTList",
"(",
")",
",",
"Ops",
",",
"M",
"->",
"getMemoryVT",
"(",
")",
",",
"M",
"->",
"getMemOperand",
"(",
")",
")",
";"
] | [
"EVT",
"VDataVT",
"=",
"VData",
".",
"getValueType",
"(",
")",
";",
"EVT",
"EltType",
"=",
"VDataVT",
".",
"getScalarType",
"(",
")",
";",
"bool",
"IsD16",
"=",
"IsFormat",
"&&",
"(",
"EltType",
".",
"getSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
")",
";",
"if",
"(",
"IsD16",
")",
"{",
"VData",
"=",
"handleD16VData",
"(",
"VData",
",",
"DAG",
")",
";",
"VDataVT",
"=",
"VData",
".",
"getValueType",
"(",
")",
";",
"}",
"if",
"(",
"!",
"isTypeLegal",
"(",
"VDataVT",
")",
")",
"{",
"VData",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BITCAST",
",",
"DL",
",",
"getEquivalentMemType",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"VDataVT",
")",
",",
"VData",
")",
";",
"}",
"auto",
"Offsets",
"=",
"splitBufferOffsets",
"(",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"DAG",
")",
";",
"SDValue",
"Ops",
"[",
"]",
"=",
"{",
"Chain",
",",
"VData",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"DAG",
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"MVT",
"::",
"i32",
")",
",",
"Offsets",
".",
"first",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Offsets",
".",
"second",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"DAG",
".",
"getTargetConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"MVT",
"::",
"i1",
")",
",",
"}",
";",
"unsigned",
"Opc",
"=",
"IsFormat",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"Opc",
"=",
"IsD16",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"Opc",
";",
"MemSDNode",
"*",
"M",
"=",
"cast",
"<",
"MemSDNode",
">",
"(",
"Op",
")",
";",
"updateBufferMMO",
"(",
"M",
"->",
"getMemOperand",
"(",
")",
",",
"Ops",
"[",
"<NUM_LIT>",
"]",
",",
"Ops",
"[",
"<NUM_LIT>",
"]",
",",
"Ops",
"[",
"<NUM_LIT>",
"]",
")",
";",
"if",
"(",
"!",
"IsD16",
"&&",
"!",
"VDataVT",
".",
"isVector",
"(",
")",
"&&",
"EltType",
".",
"getSizeInBits",
"(",
")",
"<",
"<NUM_LIT>",
")",
"return",
"handleByteShortBufferStores",
"(",
"DAG",
",",
"VDataVT",
",",
"DL",
",",
"Ops",
",",
"M",
")",
";",
"return",
"DAG",
".",
"getMemIntrinsicNode",
"(",
"Opc",
",",
"DL",
",",
"Op",
"->",
"getVTList",
"(",
")",
",",
"Ops",
",",
"M",
"->",
"getMemoryVT",
"(",
")",
",",
"M",
"->",
"getMemOperand",
"(",
")",
")",
";",
"}",
"case",
"Intrinsic",
"::",
"amdgcn_struct_buffer_store",
":",
"case",
"Intrinsic",
"::",
"amdgcn_struct_buffer_store_format",
":",
"{",
"const",
"bool",
"IsFormat",
"=",
"IntrinsicID",
"==",
"Intrinsic",
"::",
"amdgcn_struct_buffer_store_format",
";",
"SDValue",
"VData",
"=",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
";",
"EVT",
"VDataVT",
"=",
"VData",
".",
"getValueType",
"(",
")",
";",
"EVT",
"EltType",
"=",
"VDataVT",
".",
"getScalarType",
"(",
")",
";",
"bool",
"IsD16",
"=",
"IsFormat",
"&&",
"(",
"EltType",
".",
"getSizeInBits",
"(",
")",
"==",
"<NUM_LIT>",
")",
";",
"if",
"(",
"IsD16",
")",
"{",
"VData",
"=",
"handleD16VData",
"(",
"VData",
",",
"DAG",
")",
";",
"VDataVT",
"=",
"VData",
".",
"getValueType",
"(",
")",
";",
"}",
"if",
"(",
"!",
"isTypeLegal",
"(",
"VDataVT",
")",
")",
"{",
"VData",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BITCAST",
",",
"DL",
",",
"getEquivalentMemType",
"(",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"VDataVT",
")",
",",
"VData",
")",
";",
"}",
"auto",
"Offsets",
"=",
"splitBufferOffsets",
"(",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"DAG",
")",
";",
"SDValue",
"Ops",
"[",
"]",
"=",
"{",
"Chain",
",",
"VData",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Offsets",
".",
"first",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"Offsets",
".",
"second",
",",
"Op",
".",
"getOperand",
"(",
"<NUM_LIT>",
")",
",",
"DAG",
".",
"getTargetConstant",
"(",
"<NUM_LIT>",
",",
"DL",
",",
"MVT",
"::",
"i1",
")",
",",
"}",
";",
"unsigned",
"Opc",
"=",
"IntrinsicID",
"==",
"Intrinsic",
"::",
"amdgcn_struct_buffer_store",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"Opc",
"=",
"IsD16",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"Opc",
";",
"MemSDNode",
"*",
"M",
"=",
"cast",
"<",
"MemSDNode",
">",
"(",
"Op",
")",
";",
"updateBufferMMO",
"(",
"M",
"->",
"getMemOperand",
"(",
")",
",",
"Ops",
"[",
"<NUM_LIT>",
"]",
",",
"Ops",
"[",
"<NUM_LIT>",
"]",
",",
"Ops",
"[",
"<NUM_LIT>",
"]",
",",
"Ops",
"[",
"<NUM_LIT>",
"]",
")",
";",
"EVT",
"VDataType",
"=",
"VData",
".",
"getValueType",
"(",
")",
".",
"getScalarType",
"(",
")",
";",
"if",
"(",
"!",
"IsD16",
"&&",
"!",
"VDataVT",
".",
"isVector",
"(",
")",
"&&",
"EltType",
".",
"getSizeInBits",
"(",
")",
"<",
"<NUM_LIT>",
")",
"return",
"handleByteShortBufferStores",
"(",
"DAG",
",",
"VDataType",
",",
"DL",
",",
"Ops",
",",
"M",
")",
";"
] |
GCC | sh | CPP | code_generation | CPU | 622,630 | [
"static",
"bool",
"sh_legitimate_combined_insn",
"(",
"rtx_insn",
"*",
"insn",
")",
"{",
"rtx",
"p",
"=",
"PATTERN",
"(",
"insn",
")",
";",
"if",
"(",
"GET_CODE",
"(",
"p",
")",
"==",
"SET",
"&&",
"REG_P",
"(",
"XEXP",
"(",
"p",
",",
"<NUM_LIT>",
")",
")",
"&&",
"GET_MODE",
"(",
"XEXP",
"(",
"p",
",",
"<NUM_LIT>",
")",
")",
"==",
"SImode",
"&&",
"GET_CODE",
"(",
"XEXP",
"(",
"p",
",",
"<NUM_LIT>",
")",
")",
"==",
"ZERO_EXTEND",
"&&",
"MEM_P",
"(",
"XEXP",
"(",
"XEXP",
"(",
"p",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}"
] | [
"This",
"function",
"implements",
"the",
"legitimate_combined_insn",
"target",
"hook",
",",
"which",
"the",
"combine",
"pass",
"uses",
"to",
"early",
"reject",
"combined",
"insns",
",",
"before",
"it",
"tries",
"to",
"recog",
"the",
"insn",
"and",
"determine",
"its",
"cost",
"."
] |
LLVM | Hexagon | CPP | stmt_completion | DSP | 622,631 | [
"true",
";"
] | [
"bool",
"restoreCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"MutableArrayRef",
"<",
"CalleeSavedInfo",
">",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"override",
"{",
"return"
] |
LLVM | X86 | CPP | next_suggestion | CPU | 622,632 | [
"return",
"<STR_LIT>",
"::",
"<STR_LIT>",
"(",
"RegNo",
",",
"Start",
",",
"End",
",",
"true",
",",
"OffsetOfLoc",
",",
"Identifier",
",",
"Decl",
")",
";"
] | [
"const",
"AsmToken",
"&",
"Tok",
"=",
"Parser",
".",
"getTok",
"(",
")",
";",
"SMLoc",
"OffsetOfLoc",
"=",
"Tok",
".",
"getLoc",
"(",
")",
";",
"Parser",
".",
"Lex",
"(",
")",
";",
"const",
"MCExpr",
"*",
"Val",
";",
"InlineAsmIdentifierInfo",
"Info",
";",
"SMLoc",
"Start",
"=",
"Tok",
".",
"getLoc",
"(",
")",
",",
"End",
";",
"StringRef",
"Identifier",
"=",
"Tok",
".",
"getString",
"(",
")",
";",
"if",
"(",
"ParseIntelInlineAsmIdentifier",
"(",
"Val",
",",
"Identifier",
",",
"Info",
",",
"false",
",",
"End",
")",
")",
"return",
"nullptr",
";",
"void",
"*",
"Decl",
"=",
"nullptr",
";",
"if",
"(",
"Info",
".",
"isKind",
"(",
"InlineAsmIdentifierInfo",
"::",
"IK_EnumVal",
")",
")",
"return",
"ErrorOperand",
"(",
"Start",
",",
"<STR_LIT>",
"offset operator cannot yet handle constants",
"<STR_LIT>",
")",
";",
"else",
"if",
"(",
"Info",
".",
"isKind",
"(",
"InlineAsmIdentifierInfo",
"::",
"IK_Var",
")",
")",
"Decl",
"=",
"Info",
".",
"Var",
".",
"Decl",
";",
"InstInfo",
"->",
"AsmRewrites",
"->",
"emplace_back",
"(",
"AOK_Skip",
",",
"OffsetOfLoc",
",",
"<NUM_LIT>",
")",
";",
"bool",
"Parse32",
"=",
"is32BitMode",
"(",
")",
"||",
"Code16GCC",
";",
"unsigned",
"RegNo",
"=",
"is64BitMode",
"(",
")",
"?",
"X86",
"::",
"RBX",
":",
"(",
"Parse32",
"?",
"X86",
"::",
"EBX",
":",
"X86",
"::",
"BX",
")",
";"
] |
GCC | rs6000 | CPP | next_suggestion | CPU | 622,633 | [
"HOST_WIDE_INT",
"extra",
"=",
"TARGET_POWERPC64",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
";"
] | [
"case",
"PLUS",
":",
"if",
"(",
"XEXP",
"(",
"addr",
",",
"<NUM_LIT>",
")",
"!=",
"virtual_stack_vars_rtx",
"&&",
"XEXP",
"(",
"addr",
",",
"<NUM_LIT>",
")",
"!=",
"arg_pointer_rtx",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"addr",
",",
"<NUM_LIT>",
")",
")",
")",
"{",
"HOST_WIDE_INT",
"val",
"=",
"INTVAL",
"(",
"XEXP",
"(",
"addr",
",",
"<NUM_LIT>",
")",
")",
";"
] |
LLVM | ARM | CPP | program_repair | CPU | 622,634 | [
"<FIXS>",
"auto",
"*",
"CPV",
"=",
"static_cast",
"ARMConstantPoolValue",
"*",
">",
"(",
"Constants",
"[",
"i",
"]",
".",
"Val",
".",
"MachineCPVal",
")",
";",
"<FIXE>"
] | [
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"Constants",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"Constants",
"[",
"i",
"]",
".",
"isMachineConstantPoolEntry",
"(",
")",
"&&",
"(",
"Constants",
"[",
"i",
"]",
".",
"getAlignment",
"(",
")",
"&",
"AlignMask",
")",
"==",
"<NUM_LIT>",
")",
"{",
"<BUGS>",
"ARMConstantPoolValue",
"*",
"CPV",
"=",
"(",
"ARMConstantPoolValue",
"*",
")",
"Constants",
"[",
"i",
"]",
".",
"Val",
".",
"MachineCPVal",
";",
"<BUGE>",
"if",
"(",
"Derived",
"*",
"APC",
"=",
"dyn_cast",
"Derived",
">",
"(",
"CPV",
")",
")",
"if",
"(",
"cast",
"Derived",
">",
"(",
"this",
")",
"->",
"equals",
"(",
"APC",
")",
")",
"return",
"i",
";"
] |
GCC | alpha | CPP | stmt_completion | MPU | 622,635 | [
"fp_add",
";"
] | [
"int",
"code",
"=",
"GET_CODE",
"(",
"x",
")",
";",
"bool",
"float_mode_p",
"=",
"FLOAT_MODE_P",
"(",
"mode",
")",
";",
"const",
"struct",
"alpha_rtx_cost_data",
"*",
"cost_data",
";",
"if",
"(",
"!",
"speed",
")",
"cost_data",
"=",
"&",
"alpha_rtx_cost_size",
";",
"else",
"cost_data",
"=",
"&",
"alpha_rtx_cost_data",
"[",
"alpha_tune",
"]",
";",
"switch",
"(",
"code",
")",
"{",
"case",
"CONST_INT",
":",
"if",
"(",
"INTVAL",
"(",
"x",
")",
">=",
"<NUM_LIT>",
"&&",
"INTVAL",
"(",
"x",
")",
"<",
"<NUM_LIT>",
")",
"{",
"*",
"total",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"}",
"case",
"CONST_DOUBLE",
":",
"case",
"CONST_WIDE_INT",
":",
"if",
"(",
"x",
"==",
"CONST0_RTX",
"(",
"mode",
")",
")",
"*",
"total",
"=",
"<NUM_LIT>",
";",
"else",
"if",
"(",
"(",
"outer_code",
"==",
"PLUS",
"&&",
"add_operand",
"(",
"x",
",",
"VOIDmode",
")",
")",
"||",
"(",
"outer_code",
"==",
"AND",
"&&",
"and",
"_",
"operand",
"(",
"x",
",",
"VOIDmode",
")",
")",
")",
"*",
"total",
"=",
"<NUM_LIT>",
";",
"else",
"if",
"(",
"add_operand",
"(",
"x",
",",
"VOIDmode",
")",
"||",
"and",
"_",
"operand",
"(",
"x",
",",
"VOIDmode",
")",
")",
"*",
"total",
"=",
"<NUM_LIT>",
";",
"else",
"*",
"total",
"=",
"COSTS_N_INSNS",
"(",
"<NUM_LIT>",
")",
";",
"return",
"true",
";",
"case",
"CONST",
":",
"case",
"SYMBOL_REF",
":",
"case",
"LABEL_REF",
":",
"if",
"(",
"TARGET_EXPLICIT_RELOCS",
"&&",
"small_symbolic_operand",
"(",
"x",
",",
"VOIDmode",
")",
")",
"*",
"total",
"=",
"COSTS_N_INSNS",
"(",
"outer_code",
"!=",
"MEM",
")",
";",
"else",
"if",
"(",
"TARGET_EXPLICIT_RELOCS",
"&&",
"local_symbolic_operand",
"(",
"x",
",",
"VOIDmode",
")",
")",
"*",
"total",
"=",
"COSTS_N_INSNS",
"(",
"<NUM_LIT>",
"+",
"(",
"outer_code",
"!=",
"MEM",
")",
")",
";",
"else",
"if",
"(",
"tls_symbolic_operand_type",
"(",
"x",
")",
")",
"*",
"total",
"=",
"COSTS_N_INSNS",
"(",
"<NUM_LIT>",
")",
";",
"else",
"*",
"total",
"=",
"COSTS_N_INSNS",
"(",
"!",
"speed",
"?",
"<NUM_LIT>",
":",
"alpha_memory_latency",
")",
";",
"return",
"true",
";",
"case",
"HIGH",
":",
"*",
"total",
"=",
"<NUM_LIT>",
";",
"return",
"true",
";",
"case",
"PLUS",
":",
"case",
"MINUS",
":",
"if",
"(",
"float_mode_p",
")",
"*",
"total",
"=",
"cost_data",
"->",
"fp_add",
";",
"else",
"if",
"(",
"GET_CODE",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"==",
"MULT",
"&&",
"const48_operand",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
",",
"VOIDmode",
")",
")",
"{",
"*",
"total",
"=",
"(",
"rtx_cost",
"(",
"XEXP",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
",",
"<NUM_LIT>",
")",
",",
"mode",
",",
"(",
"enum",
"rtx_code",
")",
"outer_code",
",",
"opno",
",",
"speed",
")",
"+",
"rtx_cost",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
",",
"mode",
",",
"(",
"enum",
"rtx_code",
")",
"outer_code",
",",
"opno",
",",
"speed",
")",
"+",
"COSTS_N_INSNS",
"(",
"<NUM_LIT>",
")",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"case",
"MULT",
":",
"if",
"(",
"float_mode_p",
")",
"*",
"total",
"=",
"cost_data",
"->",
"fp_mult",
";",
"else",
"if",
"(",
"mode",
"==",
"DImode",
")",
"*",
"total",
"=",
"cost_data",
"->",
"int_mult_di",
";",
"else",
"*",
"total",
"=",
"cost_data",
"->",
"int_mult_si",
";",
"return",
"false",
";",
"case",
"ASHIFT",
":",
"if",
"(",
"CONST_INT_P",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"&&",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"<=",
"<NUM_LIT>",
")",
"{",
"*",
"total",
"=",
"COSTS_N_INSNS",
"(",
"<NUM_LIT>",
")",
";",
"return",
"false",
";",
"}",
"case",
"ASHIFTRT",
":",
"case",
"LSHIFTRT",
":",
"*",
"total",
"=",
"cost_data",
"->",
"int_shift",
";",
"return",
"false",
";",
"case",
"IF_THEN_ELSE",
":",
"if",
"(",
"float_mode_p",
")",
"*",
"total",
"=",
"cost_data",
"->"
] |
LLVM | WebAssembly | CPP | stmt_completion | Virtual ISA | 622,636 | [
"MF",
")",
";"
] | [
"bool",
"Changed",
"=",
"false",
";",
"Changed",
"|=",
"removeUnnecessaryUnreachables",
"(",
"MF",
")",
";",
"Changed",
"|=",
"addRethrows",
"(",
"MF",
")",
";",
"if",
"(",
"!",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasPersonalityFn",
"(",
")",
")",
"return",
"Changed",
";",
"Changed",
"|=",
"replaceFuncletReturns",
"(",
"MF",
")",
";",
"Changed",
"|=",
"hoistCatches",
"(",
"MF",
")",
";",
"Changed",
"|=",
"addCatchAlls",
"(",
"MF",
")",
";",
"Changed",
"|=",
"ensureSingleBBTermPads",
"(",
"MF",
")",
";",
"Changed",
"|=",
"mergeTerminatePads",
"(",
"MF",
")",
";",
"Changed",
"|=",
"addCatchAllTerminatePads",
"("
] |
LLVM | TOY | CPP | next_suggestion | CPU | 622,637 | [
"}"
] | [
"bool",
"mayNeedRelaxation",
"(",
"const",
"MCInst",
"&",
"Inst",
")",
"const",
"{",
"return",
"false",
";"
] |
LLVM | BPF | CPP | code_generation | Virtual ISA | 622,638 | [
"void",
"BPFAsmBackend",
"::",
"applyFixup",
"(",
"const",
"MCAssembler",
"&",
"Asm",
",",
"const",
"MCFixup",
"&",
"Fixup",
",",
"const",
"MCValue",
"&",
"Target",
",",
"MutableArrayRef",
"<",
"char",
">",
"Data",
",",
"uint64_t",
"Value",
",",
"bool",
"IsResolved",
",",
"const",
"MCSubtargetInfo",
"*",
"STI",
")",
"const",
"{",
"if",
"(",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"FK_SecRel_8",
")",
"{",
"assert",
"(",
"Value",
"<=",
"UINT32_MAX",
")",
";",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint32_t",
">",
"(",
"&",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"<NUM_LIT>",
"]",
",",
"static_cast",
"<",
"uint32_t",
">",
"(",
"Value",
")",
",",
"Endian",
")",
";",
"}",
"else",
"if",
"(",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"FK_Data_4",
")",
"{",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint32_t",
">",
"(",
"&",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"]",
",",
"Value",
",",
"Endian",
")",
";",
"}",
"else",
"if",
"(",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"FK_Data_8",
")",
"{",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint64_t",
">",
"(",
"&",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"]",
",",
"Value",
",",
"Endian",
")",
";",
"}",
"else",
"if",
"(",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"FK_PCRel_4",
")",
"{",
"Value",
"=",
"(",
"uint32_t",
")",
"(",
"(",
"Value",
"-",
"<NUM_LIT>",
")",
"/",
"<NUM_LIT>",
")",
";",
"if",
"(",
"Endian",
"==",
"support",
"::",
"little",
")",
"{",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"<NUM_LIT>",
"]",
"=",
"<NUM_LIT>",
";",
"support",
"::",
"endian",
"::",
"write32le",
"(",
"&",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"<NUM_LIT>",
"]",
",",
"Value",
")",
";",
"}",
"else",
"{",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"<NUM_LIT>",
"]",
"=",
"<NUM_LIT>",
";",
"support",
"::",
"endian",
"::",
"write32be",
"(",
"&",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"<NUM_LIT>",
"]",
",",
"Value",
")",
";",
"}",
"}",
"else",
"{",
"assert",
"(",
"Fixup",
".",
"getKind",
"(",
")",
"==",
"FK_PCRel_2",
")",
";",
"int64_t",
"ByteOff",
"=",
"(",
"int64_t",
")",
"Value",
"-",
"<NUM_LIT>",
";",
"if",
"(",
"ByteOff",
">",
"INT16_MAX",
"*",
"<NUM_LIT>",
"||",
"ByteOff",
"<",
"INT16_MIN",
"*",
"<NUM_LIT>",
")",
"report_fatal_error",
"(",
"<STR_LIT>",
"Branch target out of insn range",
"<STR_LIT>",
")",
";",
"Value",
"=",
"(",
"uint16_t",
")",
"(",
"(",
"Value",
"-",
"<NUM_LIT>",
")",
"/",
"<NUM_LIT>",
")",
";",
"support",
"::",
"endian",
"::",
"write",
"<",
"uint16_t",
">",
"(",
"&",
"Data",
"[",
"Fixup",
".",
"getOffset",
"(",
")",
"+",
"<NUM_LIT>",
"]",
",",
"Value",
",",
"Endian",
")",
";",
"}",
"}"
] | [
"Apply",
"the",
"Value",
"for",
"given",
"Fixup",
"into",
"the",
"provided",
"data",
"fragment",
",",
"at",
"the",
"offset",
"specified",
"by",
"the",
"fixup",
"and",
"following",
"the",
"fixup",
"kind",
"as",
"appropriate",
"."
] |
LLVM | Mips | CPP | next_suggestion | CPU | 622,639 | [
"}"
] | [
"if",
"(",
"Parser",
".",
"parseExpression",
"(",
"DummyNumber",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected number after comma",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"DummyNumber",
"->",
"EvaluateAsAbsolute",
"(",
"DummyNumberVal",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected an absolute expression after comma",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"unexpected token, expected end of statement",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"MCSymbol",
"*",
"Sym",
"=",
"getContext",
"(",
")",
".",
"GetOrCreateSymbol",
"(",
"SymbolName",
")",
";",
"getTargetStreamer",
"(",
")",
".",
"emitDirectiveEnt",
"(",
"*",
"Sym",
")",
";",
"CurrentFn",
"=",
"Sym",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"<STR_LIT>",
".end",
"<STR_LIT>",
")",
"{",
"StringRef",
"SymbolName",
";",
"if",
"(",
"Parser",
".",
"parseIdentifier",
"(",
"SymbolName",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected identifier after .end",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"unexpected token, expected end of statement",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"CurrentFn",
"==",
"nullptr",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
".end used without .ent",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"(",
"SymbolName",
"!=",
"CurrentFn",
"->",
"getName",
"(",
")",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
".end symbol does not match .ent symbol",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"getTargetStreamer",
"(",
")",
".",
"emitDirectiveEnd",
"(",
"SymbolName",
")",
";",
"CurrentFn",
"=",
"nullptr",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"<STR_LIT>",
".frame",
"<STR_LIT>",
")",
"{",
"SmallVector",
"<",
"std",
"::",
"unique_ptr",
"<",
"MCParsedAsmOperand",
">",
",",
"<NUM_LIT>",
">",
"TmpReg",
";",
"OperandMatchResultTy",
"ResTy",
"=",
"parseAnyRegister",
"(",
"TmpReg",
")",
";",
"if",
"(",
"ResTy",
"==",
"MatchOperand_NoMatch",
"||",
"ResTy",
"==",
"MatchOperand_ParseFail",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected stack register",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"MipsOperand",
"&",
"StackRegOpnd",
"=",
"static_cast",
"<",
"MipsOperand",
"&",
">",
"(",
"*",
"TmpReg",
"[",
"<NUM_LIT>",
"]",
")",
";",
"if",
"(",
"!",
"StackRegOpnd",
".",
"isGPRAsmReg",
"(",
")",
")",
"{",
"reportParseError",
"(",
"StackRegOpnd",
".",
"getStartLoc",
"(",
")",
",",
"<STR_LIT>",
"expected general purpose register",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"unsigned",
"StackReg",
"=",
"StackRegOpnd",
".",
"getGPR32Reg",
"(",
")",
";",
"if",
"(",
"Parser",
".",
"getTok",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Comma",
")",
")",
"Parser",
".",
"Lex",
"(",
")",
";",
"else",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"unexpected token, expected comma",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"const",
"MCExpr",
"*",
"FrameSize",
";",
"int64_t",
"FrameSizeVal",
";",
"if",
"(",
"Parser",
".",
"parseExpression",
"(",
"FrameSize",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected frame size value",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"FrameSize",
"->",
"EvaluateAsAbsolute",
"(",
"FrameSizeVal",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"frame size not an absolute expression",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"Parser",
".",
"getTok",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Comma",
")",
")",
"Parser",
".",
"Lex",
"(",
")",
";",
"else",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"unexpected token, expected comma",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"TmpReg",
".",
"clear",
"(",
")",
";",
"ResTy",
"=",
"parseAnyRegister",
"(",
"TmpReg",
")",
";",
"if",
"(",
"ResTy",
"==",
"MatchOperand_NoMatch",
"||",
"ResTy",
"==",
"MatchOperand_ParseFail",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected return register",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"MipsOperand",
"&",
"ReturnRegOpnd",
"=",
"static_cast",
"<",
"MipsOperand",
"&",
">",
"(",
"*",
"TmpReg",
"[",
"<NUM_LIT>",
"]",
")",
";",
"if",
"(",
"!",
"ReturnRegOpnd",
".",
"isGPRAsmReg",
"(",
")",
")",
"{",
"reportParseError",
"(",
"ReturnRegOpnd",
".",
"getStartLoc",
"(",
")",
",",
"<STR_LIT>",
"expected general purpose register",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"unexpected token, expected end of statement",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"getTargetStreamer",
"(",
")",
".",
"emitFrame",
"(",
"StackReg",
",",
"FrameSizeVal",
",",
"ReturnRegOpnd",
".",
"getGPR32Reg",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"<STR_LIT>",
".set",
"<STR_LIT>",
")",
"{",
"return",
"parseDirectiveSet",
"(",
")",
";",
"}",
"if",
"(",
"IDVal",
"==",
"<STR_LIT>",
".mask",
"<STR_LIT>",
"||",
"IDVal",
"==",
"<STR_LIT>",
".fmask",
"<STR_LIT>",
")",
"{",
"const",
"MCExpr",
"*",
"BitMask",
";",
"int64_t",
"BitMaskVal",
";",
"if",
"(",
"Parser",
".",
"parseExpression",
"(",
"BitMask",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected bitmask value",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"BitMask",
"->",
"EvaluateAsAbsolute",
"(",
"BitMaskVal",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"bitmask not an absolute expression",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"Parser",
".",
"getTok",
"(",
")",
".",
"is",
"(",
"AsmToken",
"::",
"Comma",
")",
")",
"Parser",
".",
"Lex",
"(",
")",
";",
"else",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"unexpected token, expected comma",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"const",
"MCExpr",
"*",
"FrameOffset",
";",
"int64_t",
"FrameOffsetVal",
";",
"if",
"(",
"Parser",
".",
"parseExpression",
"(",
"FrameOffset",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"expected frame offset value",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"FrameOffset",
"->",
"EvaluateAsAbsolute",
"(",
"FrameOffsetVal",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"frame offset not an absolute expression",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"getLexer",
"(",
")",
".",
"isNot",
"(",
"AsmToken",
"::",
"EndOfStatement",
")",
")",
"{",
"reportParseError",
"(",
"<STR_LIT>",
"unexpected token, expected end of statement",
"<STR_LIT>",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"<STR_LIT>",
".mask",
"<STR_LIT>",
")",
"getTargetStreamer",
"(",
")",
".",
"emitMask",
"(",
"BitMaskVal",
",",
"FrameOffsetVal",
")",
";",
"else",
"getTargetStreamer",
"(",
")",
".",
"emitFMask",
"(",
"BitMaskVal",
",",
"FrameOffsetVal",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"IDVal",
"==",
"<STR_LIT>",
".nan",
"<STR_LIT>",
")",
"return",
"parseDirectiveNaN",
"(",
")",
";",
"if",
"(",
"IDVal",
"==",
"<STR_LIT>",
".gpword",
"<STR_LIT>",
")",
"{",
"parseDirectiveGpWord",
"(",
")",
";",
"return",
"false",
";"
] |
GCC | aarch64 | CPP | next_suggestion | CPU | 622,640 | [
"error_at",
"(",
"location",
",",
"<STR_LIT>",
"ACLE function %qD requires ISA extension %qs",
"<STR_LIT>",
",",
"fndecl",
",",
"extension",
")",
";"
] | [
"static",
"void",
"report_missing_extension",
"(",
"location_t",
"location",
",",
"tree",
"fndecl",
",",
"const",
"char",
"*",
"extension",
")",
"{",
"if",
"(",
"reported_missing_extension_p",
")",
"return",
";"
] |
GCC | i386 | CPP | stmt_completion | CPU | 622,641 | [
"_",
"N",
")",
";"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"m128i",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_insert_epi16",
"(",
"_",
"_",
"m128i",
"const",
"_",
"_",
"A",
",",
"int",
"const",
"_",
"_",
"D",
",",
"int",
"const",
"_",
"_",
"N",
")",
"{",
"return",
"(",
"_",
"_",
"m128i",
")",
"_",
"_",
"builtin_ia32_vec_set_v8hi",
"(",
"(",
"_",
"_",
"v8hi",
")",
"_",
"_",
"A",
",",
"_",
"_",
"D",
",",
"_"
] |
LLVM | AArch64 | TD | next_suggestion | CPU | 622,642 | [
"}"
] | [
"def",
"movw_symbol_g1",
":",
"Operand",
"<",
"i32",
">",
"{",
"let",
"ParserMatchClass",
"=",
"MovWSymbolG1AsmOperand",
";"
] |
GCC | powerpcspe | CPP | next_suggestion | CPU | 622,643 | [
"}"
] | [
"switch",
"(",
"DEFAULT_ABI",
")",
"{",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"case",
"ABI_AIX",
":",
"{",
"rtx",
"fnmem",
",",
"fn_reg",
",",
"toc_reg",
";",
"if",
"(",
"!",
"TARGET_POINTERS_TO_NESTED_FUNCTIONS",
")",
"error",
"(",
"<STR_LIT>",
"You cannot take the address of a nested function if you use ",
"<STR_LIT>",
"<STR_LIT>",
"the -mno-pointers-to-nested-functions option.",
"<STR_LIT>",
")",
";",
"fnmem",
"=",
"gen_const_mem",
"(",
"Pmode",
",",
"force_reg",
"(",
"Pmode",
",",
"fnaddr",
")",
")",
";",
"fn_reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"toc_reg",
"=",
"gen_reg_rtx",
"(",
"Pmode",
")",
";",
"m_tramp",
"=",
"replace_equiv_address",
"(",
"m_tramp",
",",
"addr",
")",
";",
"emit_move_insn",
"(",
"fn_reg",
",",
"MEM_PLUS",
"(",
"fnmem",
",",
"<NUM_LIT>",
")",
")",
";",
"emit_move_insn",
"(",
"toc_reg",
",",
"MEM_PLUS",
"(",
"fnmem",
",",
"regsize",
")",
")",
";",
"emit_move_insn",
"(",
"MEM_PLUS",
"(",
"m_tramp",
",",
"<NUM_LIT>",
")",
",",
"fn_reg",
")",
";",
"emit_move_insn",
"(",
"MEM_PLUS",
"(",
"m_tramp",
",",
"regsize",
")",
",",
"toc_reg",
")",
";",
"emit_move_insn",
"(",
"MEM_PLUS",
"(",
"m_tramp",
",",
"<NUM_LIT>",
"*",
"regsize",
")",
",",
"ctx_reg",
")",
";",
"}",
"break",
";",
"case",
"ABI_ELFv2",
":",
"case",
"ABI_DARWIN",
":",
"case",
"ABI_V4",
":",
"emit_library_call",
"(",
"gen_rtx_SYMBOL_REF",
"(",
"Pmode",
",",
"<STR_LIT>",
"__trampoline_setup",
"<STR_LIT>",
")",
",",
"LCT_NORMAL",
",",
"VOIDmode",
",",
"addr",
",",
"Pmode",
",",
"GEN_INT",
"(",
"rs6000_trampoline_size",
"(",
")",
")",
",",
"SImode",
",",
"fnaddr",
",",
"Pmode",
",",
"ctx_reg",
",",
"Pmode",
")",
";",
"break",
";"
] |
LLVM | X86 | CPP | code_generation | CPU | 622,644 | [
"bool",
"X86DomainReassignment",
"::",
"runOnMachineFunction",
"(",
"MachineFunction",
"&",
"MF",
")",
"{",
"if",
"(",
"skipFunction",
"(",
"MF",
".",
"getFunction",
"(",
")",
")",
")",
"return",
"false",
";",
"if",
"(",
"DisableX86DomainReassignment",
")",
"return",
"false",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"***** Machine Function before Domain Reassignment *****\\n",
"<STR_LIT>",
")",
";",
"LLVM_DEBUG",
"(",
"MF",
".",
"print",
"(",
"dbgs",
"(",
")",
")",
")",
";",
"STI",
"=",
"&",
"MF",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")",
";",
"if",
"(",
"!",
"STI",
"->",
"hasAVX512",
"(",
")",
")",
"return",
"false",
";",
"MRI",
"=",
"&",
"MF",
".",
"getRegInfo",
"(",
")",
";",
"assert",
"(",
"MRI",
"->",
"isSSA",
"(",
")",
"&&",
"<STR_LIT>",
"Expected MIR to be in SSA form",
"<STR_LIT>",
")",
";",
"TII",
"=",
"STI",
"->",
"getInstrInfo",
"(",
")",
";",
"initConverters",
"(",
")",
";",
"bool",
"Changed",
"=",
"false",
";",
"EnclosedEdges",
".",
"clear",
"(",
")",
";",
"EnclosedInstrs",
".",
"clear",
"(",
")",
";",
"std",
"::",
"vector",
"<",
"Closure",
">",
"Closures",
";",
"unsigned",
"ClosureID",
"=",
"<NUM_LIT>",
";",
"for",
"(",
"unsigned",
"Idx",
"=",
"<NUM_LIT>",
";",
"Idx",
"<",
"MRI",
"->",
"getNumVirtRegs",
"(",
")",
";",
"++",
"Idx",
")",
"{",
"unsigned",
"Reg",
"=",
"TargetRegisterInfo",
"::",
"index2VirtReg",
"(",
"Idx",
")",
";",
"if",
"(",
"!",
"isGPR",
"(",
"MRI",
"->",
"getRegClass",
"(",
"Reg",
")",
")",
")",
"continue",
";",
"if",
"(",
"EnclosedEdges",
".",
"count",
"(",
"Reg",
")",
")",
"continue",
";",
"Closure",
"C",
"(",
"ClosureID",
"++",
",",
"{",
"MaskDomain",
"}",
")",
";",
"buildClosure",
"(",
"C",
",",
"Reg",
")",
";",
"if",
"(",
"!",
"C",
".",
"empty",
"(",
")",
"&&",
"C",
".",
"isLegal",
"(",
"MaskDomain",
")",
")",
"Closures",
".",
"push_back",
"(",
"std",
"::",
"move",
"(",
"C",
")",
")",
";",
"}",
"for",
"(",
"Closure",
"&",
"C",
":",
"Closures",
")",
"{",
"LLVM_DEBUG",
"(",
"C",
".",
"dump",
"(",
"MRI",
")",
")",
";",
"if",
"(",
"isReassignmentProfitable",
"(",
"C",
",",
"MaskDomain",
")",
")",
"{",
"reassign",
"(",
"C",
",",
"MaskDomain",
")",
";",
"++",
"NumClosuresConverted",
";",
"Changed",
"=",
"true",
";",
"}",
"}",
"DeleteContainerSeconds",
"(",
"Converters",
")",
";",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
"***** Machine Function after Domain Reassignment *****\\n",
"<STR_LIT>",
")",
";",
"LLVM_DEBUG",
"(",
"MF",
".",
"print",
"(",
"dbgs",
"(",
")",
")",
")",
";",
"return",
"Changed",
";",
"}"
] | [
"runOnMachineFunction",
"-",
"Emit",
"the",
"function",
"body",
"."
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 622,645 | [
"<STR_LIT>",
";"
] | [
"case",
"ISD",
"::",
"FMAXNUM",
":",
"case",
"ISD",
"::",
"FMAXNUM_IEEE",
":",
"return",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"case",
"ISD",
"::",
"SMAX",
":",
"return",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"case",
"ISD",
"::",
"UMAX",
":",
"return",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"case",
"ISD",
"::",
"FMINNUM",
":",
"case",
"ISD",
"::",
"FMINNUM_IEEE",
":",
"return",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"case",
"ISD",
"::",
"SMIN",
":",
"return",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"case",
"ISD",
"::",
"UMIN",
":",
"return",
"<STR_LIT>",
"::"
] |
GCC | i386 | MD | next_suggestion | CPU | 622,646 | [
"<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>",
"<STR_LIT>",
")",
")",
")"
] |
LLVM | WebAssembly | CPP | next_suggestion | Virtual ISA | 622,647 | [
"return",
"false",
";"
] | [
"static",
"bool",
"IsOnStack",
"(",
"const",
"SmallVectorImpl",
"<",
"std",
"::",
"pair",
"<",
"MachineBasicBlock",
"*",
",",
"bool",
">>",
"&",
"Stack",
",",
"const",
"MachineBasicBlock",
"*",
"MBB",
")",
"{",
"for",
"(",
"const",
"auto",
"&",
"Pair",
":",
"Stack",
")",
"if",
"(",
"Pair",
".",
"first",
"==",
"MBB",
")",
"return",
"true",
";"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 622,648 | [
"(",
")",
")",
"->",
"getZExtValue",
"(",
")",
";"
] | [
"if",
"(",
"!",
"isa",
"<",
"ConstantSDNode",
">",
"(",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getNode",
"(",
")",
")",
")",
"llvm_unreachable",
"(",
"<STR_LIT>",
"Illegal insert subvector for VINSERT",
"<STR_LIT>",
")",
";",
"uint64_t",
"Index",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"N",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
".",
"getNode"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 622,649 | [
"getReg",
"(",
")",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";"
] | [
"unsigned",
"ScalarLoadOp",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"getPhysRegClass",
"(",
"SuperReg",
")",
";",
"if",
"(",
"SpillToSMEM",
"&&",
"isSGPRClass",
"(",
"RC",
")",
")",
"{",
"std",
"::",
"tie",
"(",
"EltSize",
",",
"ScalarLoadOp",
")",
"=",
"getSpillEltSize",
"(",
"getRegSizeInBits",
"(",
"*",
"RC",
")",
"/",
"<NUM_LIT>",
",",
"false",
")",
";",
"}",
"ArrayRef",
"<",
"int16_t",
">",
"SplitParts",
"=",
"getRegSplitParts",
"(",
"RC",
",",
"EltSize",
")",
";",
"unsigned",
"NumSubRegs",
"=",
"SplitParts",
".",
"empty",
"(",
")",
"?",
"<NUM_LIT>",
":",
"SplitParts",
".",
"size",
"(",
")",
";",
"int64_t",
"FrOffset",
"=",
"FrameInfo",
".",
"getObjectOffset",
"(",
"Index",
")",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"NumSubRegs",
";",
"i",
"<",
"e",
";",
"++",
"i",
")",
"{",
"unsigned",
"SubReg",
"=",
"NumSubRegs",
"==",
"<NUM_LIT>",
"?",
"SuperReg",
":",
"getSubReg",
"(",
"SuperReg",
",",
"SplitParts",
"[",
"i",
"]",
")",
";",
"if",
"(",
"SpillToSMEM",
")",
"{",
"unsigned",
"Align",
"=",
"FrameInfo",
".",
"getObjectAlignment",
"(",
"Index",
")",
";",
"MachinePointerInfo",
"PtrInfo",
"=",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"*",
"MF",
",",
"Index",
",",
"EltSize",
"*",
"i",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
"->",
"getMachineMemOperand",
"(",
"PtrInfo",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"EltSize",
",",
"MinAlign",
"(",
"Align",
",",
"EltSize",
"*",
"i",
")",
")",
";",
"int64_t",
"Offset",
"=",
"(",
"ST",
".",
"getWavefrontSize",
"(",
")",
"*",
"FrOffset",
")",
"+",
"(",
"EltSize",
"*",
"i",
")",
";",
"if",
"(",
"Offset",
"!=",
"<NUM_LIT>",
")",
"{",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_ADD_U32",
")",
",",
"OffsetReg",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getFrameOffsetReg",
"(",
")",
")",
".",
"addImm",
"(",
"Offset",
")",
";",
"}",
"else",
"{",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"S_MOV_B32",
")",
",",
"OffsetReg",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getFrameOffsetReg",
"(",
")",
")",
";",
"}",
"auto",
"MIB",
"=",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"ScalarLoadOp",
")",
",",
"SubReg",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
")",
".",
"addReg",
"(",
"OffsetReg",
",",
"RegState",
"::",
"Kill",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"if",
"(",
"NumSubRegs",
">",
"<NUM_LIT>",
")",
"MIB",
".",
"addReg",
"(",
"SuperReg",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";",
"continue",
";",
"}",
"if",
"(",
"SpillToVGPR",
")",
"{",
"SIMachineFunctionInfo",
"::",
"SpilledReg",
"Spill",
"=",
"VGPRSpills",
"[",
"i",
"]",
";",
"auto",
"MIB",
"=",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"getMCOpcodeFromPseudo",
"(",
"AMDGPU",
"::",
"V_READLANE_B32",
")",
",",
"SubReg",
")",
".",
"addReg",
"(",
"Spill",
".",
"VGPR",
")",
".",
"addImm",
"(",
"Spill",
".",
"Lane",
")",
";",
"if",
"(",
"NumSubRegs",
">",
"<NUM_LIT>",
")",
"MIB",
".",
"addReg",
"(",
"SuperReg",
",",
"RegState",
"::",
"ImplicitDefine",
")",
";",
"}",
"else",
"{",
"if",
"(",
"OnlyToVGPR",
")",
"return",
"false",
";",
"unsigned",
"TmpReg",
"=",
"MRI",
".",
"createVirtualRegister",
"(",
"&",
"AMDGPU",
"::",
"VGPR_32RegClass",
")",
";",
"unsigned",
"Align",
"=",
"FrameInfo",
".",
"getObjectAlignment",
"(",
"Index",
")",
";",
"MachinePointerInfo",
"PtrInfo",
"=",
"MachinePointerInfo",
"::",
"getFixedStack",
"(",
"*",
"MF",
",",
"Index",
",",
"EltSize",
"*",
"i",
")",
";",
"MachineMemOperand",
"*",
"MMO",
"=",
"MF",
"->",
"getMachineMemOperand",
"(",
"PtrInfo",
",",
"MachineMemOperand",
"::",
"MOLoad",
",",
"EltSize",
",",
"MinAlign",
"(",
"Align",
",",
"EltSize",
"*",
"i",
")",
")",
";",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"SI_SPILL_V32_RESTORE",
")",
",",
"TmpReg",
")",
".",
"addFrameIndex",
"(",
"Index",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getScratchRSrcReg",
"(",
")",
")",
".",
"addReg",
"(",
"MFI",
"->",
"getFrameOffsetReg",
"(",
")",
")",
".",
"addImm",
"(",
"i",
"*",
"<NUM_LIT>",
")",
".",
"addMemOperand",
"(",
"MMO",
")",
";",
"auto",
"MIB",
"=",
"BuildMI",
"(",
"*",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
"->",
"get",
"(",
"AMDGPU",
"::",
"V_READFIRSTLANE_B32",
")",
",",
"SubReg",
")",
".",
"addReg",
"(",
"TmpReg",
",",
"RegState",
"::",
"Kill",
")",
";",
"if",
"(",
"NumSubRegs",
">",
"<NUM_LIT>",
")",
"MIB",
".",
"addReg",
"(",
"MI",
"->",
"getOperand",
"(",
"<NUM_LIT>",
")",
"."
] |
LLVM | ARM64 | TD | stmt_completion | CPU | 622,650 | [
"<STR_LIT>",
";"
] | [
"def",
"SImm7s16Operand",
":",
"AsmOperandClass",
"{",
"let",
"Name",
"=",
"<STR_LIT>",
";",
"let",
"DiagnosticType",
"="
] |
GCC | i386 | CPP | program_repair | CPU | 622,651 | [
"<FIXS>",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"mask",
",",
"gen_rtx_AND",
"(",
"mode",
",",
"mask",
",",
"one",
")",
")",
")",
";",
"<FIXE>"
] | [
"mask",
"=",
"ix86_expand_sse_compare_mask",
"(",
"UNGT",
",",
"res",
",",
"xa",
",",
"false",
")",
";",
"<BUGS>",
"emit_insn",
"(",
"gen_rtx_SET",
"(",
"VOIDmode",
",",
"mask",
",",
"gen_rtx_AND",
"(",
"mode",
",",
"mask",
",",
"one",
")",
")",
")",
";",
"<BUGE>",
"tmp",
"=",
"expand_simple_binop",
"(",
"mode",
",",
"MINUS",
",",
"res",
",",
"mask",
",",
"NULL_RTX",
",",
"<NUM_LIT>",
",",
"OPTAB_DIRECT",
")",
";",
"emit_move_insn",
"(",
"res",
",",
"tmp",
")",
";"
] |
LLVM | Mips | CPP | stmt_completion | CPU | 622,652 | [
"(",
")",
")",
")",
";"
] | [
"assert",
"(",
"DstRegOp",
".",
"isReg",
"(",
")",
"&&",
"<STR_LIT>",
"expected register operand kind",
"<STR_LIT>",
")",
";",
"int",
"ImmValue",
"=",
"ImmOp",
".",
"getImm",
"(",
")",
";",
"if",
"(",
"-",
"<NUM_LIT>",
"<=",
"ImmValue",
"&&",
"ImmValue",
"<=",
"<NUM_LIT>",
")",
"{",
"tmpInst",
".",
"setOpcode",
"(",
"Mips",
"::",
"ADDiu",
")",
";",
"tmpInst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"CreateReg",
"(",
"DstRegOp",
".",
"getReg",
"(",
")",
")",
")",
";",
"tmpInst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"CreateReg",
"(",
"SrcRegOp",
".",
"getReg",
"(",
")",
")",
")",
";",
"tmpInst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"CreateImm",
"(",
"ImmValue",
")",
")",
";",
"Instructions",
".",
"push_back",
"(",
"tmpInst",
")",
";",
"}",
"else",
"{",
"tmpInst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"CreateReg",
"(",
"DstRegOp",
".",
"getReg",
"(",
")",
")",
")",
";",
"tmpInst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"CreateImm",
"(",
"(",
"ImmValue",
"&",
"<NUM_LIT>",
")",
">>",
"<NUM_LIT>",
")",
")",
";",
"Instructions",
".",
"push_back",
"(",
"tmpInst",
")",
";",
"tmpInst",
".",
"clear",
"(",
")",
";",
"tmpInst",
".",
"setOpcode",
"(",
"Mips",
"::",
"ORi",
")",
";",
"tmpInst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"CreateReg",
"(",
"DstRegOp",
".",
"getReg",
"(",
")",
")",
")",
";",
"tmpInst",
".",
"addOperand",
"(",
"MCOperand",
"::",
"CreateReg",
"(",
"DstRegOp",
".",
"getReg"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 622,653 | [
":",
":",
"FeatureTRACEV8_4",
"}",
"}",
"]",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"Encoding",
";",
"let",
"Encoding",
"=",
"encoding",
";",
"code",
"Requires",
"=",
"[",
"{",
"{",
"AArch64"
] |
GCC | rs6000 | MD | next_suggestion | CPU | 622,654 | [
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")"
] | [
"(",
"and",
"(",
"ior",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"and",
"(",
"eq_attr",
"<STR_LIT>",
"<STR_LIT>",
")"
] |
LLVM | XCore | CPP | code_generation | MPU | 622,655 | [
"bool",
"XCoreFrameLowering",
"::",
"spillCalleeSavedRegisters",
"(",
"MachineBasicBlock",
"&",
"MBB",
",",
"MachineBasicBlock",
"::",
"iterator",
"MI",
",",
"const",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"&",
"CSI",
",",
"const",
"TargetRegisterInfo",
"*",
"TRI",
")",
"const",
"{",
"if",
"(",
"CSI",
".",
"empty",
"(",
")",
")",
"return",
"true",
";",
"MachineFunction",
"*",
"MF",
"=",
"MBB",
".",
"getParent",
"(",
")",
";",
"const",
"TargetInstrInfo",
"&",
"TII",
"=",
"*",
"MF",
"->",
"getTarget",
"(",
")",
".",
"getInstrInfo",
"(",
")",
";",
"XCoreFunctionInfo",
"*",
"XFI",
"=",
"MF",
"->",
"getInfo",
"<",
"XCoreFunctionInfo",
">",
"(",
")",
";",
"bool",
"emitFrameMoves",
"=",
"XCoreRegisterInfo",
"::",
"needsFrameMoves",
"(",
"*",
"MF",
")",
";",
"DebugLoc",
"DL",
";",
"if",
"(",
"MI",
"!=",
"MBB",
".",
"end",
"(",
")",
"&&",
"!",
"MI",
"->",
"isDebugValue",
"(",
")",
")",
"DL",
"=",
"MI",
"->",
"getDebugLoc",
"(",
")",
";",
"for",
"(",
"std",
"::",
"vector",
"<",
"CalleeSavedInfo",
">",
"::",
"const_iterator",
"it",
"=",
"CSI",
".",
"begin",
"(",
")",
";",
"it",
"!=",
"CSI",
".",
"end",
"(",
")",
";",
"++",
"it",
")",
"{",
"unsigned",
"Reg",
"=",
"it",
"->",
"getReg",
"(",
")",
";",
"assert",
"(",
"Reg",
"!=",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"!",
"(",
"Reg",
"==",
"<STR_LIT>",
"::",
"<STR_LIT>",
"&&",
"hasFP",
"(",
"*",
"MF",
")",
")",
"&&",
"<STR_LIT>",
"LR & FP are always handled in emitPrologue",
"<STR_LIT>",
")",
";",
"MBB",
".",
"addLiveIn",
"(",
"Reg",
")",
";",
"const",
"TargetRegisterClass",
"*",
"RC",
"=",
"TRI",
"->",
"getMinimalPhysRegClass",
"(",
"Reg",
")",
";",
"TII",
".",
"storeRegToStackSlot",
"(",
"MBB",
",",
"MI",
",",
"Reg",
",",
"true",
",",
"it",
"->",
"getFrameIdx",
"(",
")",
",",
"RC",
",",
"TRI",
")",
";",
"if",
"(",
"emitFrameMoves",
")",
"{",
"auto",
"Store",
"=",
"MI",
";",
"--",
"Store",
";",
"XFI",
"->",
"getSpillLabels",
"(",
")",
".",
"push_back",
"(",
"std",
"::",
"make_pair",
"(",
"Store",
",",
"*",
"it",
")",
")",
";",
"}",
"}",
"return",
"true",
";",
"}"
] | [
"spillCalleeSavedRegisters",
"-",
"Issues",
"instruction",
"(",
"s",
")",
"to",
"spill",
"all",
"callee",
"saved",
"registers",
"and",
"returns",
"true",
"if",
"it",
"is",
"n't",
"possible",
"/",
"profitable",
"to",
"do",
"so",
"by",
"issuing",
"a",
"series",
"of",
"store",
"instructions",
"via",
"storeRegToStackSlot",
"(",
")",
"."
] |
GCC | mips | CPP | stmt_completion | CPU | 622,656 | [
"<STR_LIT>",
")",
";"
] | [
"if",
"(",
"TARGET_64BIT",
")",
"d_add_builtin_version",
"(",
"<STR_LIT>",
"MIPS64",
"<STR_LIT>",
")",
";",
"else",
"d_add_builtin_version",
"(",
"<STR_LIT>",
"MIPS32",
"<STR_LIT>",
")",
";",
"if",
"(",
"mips_abi",
"==",
"ABI_32",
")",
"d_add_builtin_version",
"(",
"<STR_LIT>",
"MIPS_O32",
"<STR_LIT>",
")",
";",
"else",
"if",
"(",
"mips_abi",
"==",
"ABI_EABI",
")",
"d_add_builtin_version",
"(",
"<STR_LIT>",
"MIPS_EABI",
"<STR_LIT>",
")",
";",
"else",
"if",
"(",
"mips_abi",
"==",
"ABI_N32",
")",
"d_add_builtin_version",
"(",
"<STR_LIT>",
"MIPS_N32",
"<STR_LIT>",
")",
";",
"else",
"if",
"(",
"mips_abi",
"==",
"ABI_64",
")",
"d_add_builtin_version",
"(",
"<STR_LIT>",
"MIPS_N64",
"<STR_LIT>",
")",
";",
"else",
"if",
"(",
"mips_abi",
"==",
"ABI_O64",
")",
"d_add_builtin_version",
"(",
"<STR_LIT>",
"MIPS_O64",
"<STR_LIT>",
")",
";",
"if",
"(",
"TARGET_HARD_FLOAT_ABI",
")",
"{",
"d_add_builtin_version",
"(",
"<STR_LIT>",
"MIPS_HardFloat",
"<STR_LIT>",
")",
";",
"d_add_builtin_version",
"(",
"<STR_LIT>",
"D_HardFloat",
"<STR_LIT>",
")",
";",
"}",
"else",
"if",
"(",
"TARGET_SOFT_FLOAT_ABI",
")",
"{",
"d_add_builtin_version",
"(",
"<STR_LIT>",
"MIPS_SoftFloat"
] |
GCC | i386 | MD | program_repair | CPU | 622,657 | [
"<FIXS>",
"(",
"define_insn",
"<STR_LIT>",
"<FIXE>"
] | [
"operands",
"[",
"<NUM_LIT>",
"]",
")",
",",
"UNSPEC_VSIBADDR",
")",
"}",
")",
"<BUGS>",
"(",
"define_insn",
"<STR_LIT>",
"<BUGE>",
"[",
"(",
"unspec",
"[",
"(",
"match_operand",
":",
"avx512fmaskmode",
">",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"match_operator",
":",
"GATHER_SCATTER_SF_MEM_MODE",
">",
"<NUM_LIT>",
"<STR_LIT>"
] |
GCC | sparc | MD | next_suggestion | CPU | 622,658 | [
"UNSPEC_SETH44",
")",
")",
")",
"]"
] | [
"[",
"(",
"set",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"high",
":",
"DI",
"(",
"unspec",
":",
"DI",
"[",
"(",
"match_operand",
":",
"DI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"]"
] |
GCC | i386 | CPP | stmt_completion | CPU | 622,659 | [
"named_section",
"(",
"decl",
",",
"NULL",
",",
"<NUM_LIT>",
")",
";",
"break",
";",
"\\",
"case",
"in_drectve",
":",
"drectve_section",
"(",
")",
";",
"break",
";",
"\\",
"default",
":",
"abort",
"(",
")",
";",
"break",
";",
"\\",
"}",
"\\",
"}"
] | [
"void",
"\\",
"switch_to_section",
"(",
"enum",
"in_section",
"section",
",",
"tree",
"decl",
")",
"\\",
"{",
"\\",
"switch",
"(",
"section",
")",
"\\",
"{",
"\\",
"case",
"in_text",
":",
"text_section",
"(",
")",
";",
"break",
";",
"\\",
"case",
"in_unlikely_executed_text",
":",
"unlikely_text_section",
"(",
")",
";",
"break",
";",
"\\",
"case",
"in_data",
":",
"data_section",
"(",
")",
";",
"break",
";",
"\\",
"case",
"in_readonly_data",
":",
"readonly_data_section",
"(",
")",
";",
"break",
";",
"\\",
"case",
"in_named",
":"
] |
LLVM | AMDGPU | CPP | program_repair | GPU | 622,660 | [
"<FIXS>",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"amdgpu-work-group-id-x",
"<STR_LIT>",
")",
")",
"<FIXE>",
"<FIXS>",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"amdgpu-work-group-id-y",
"<STR_LIT>",
")",
")",
"WorkGroupIDY",
"=",
"true",
";",
"<FIXE>",
"<FIXS>",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"amdgpu-work-group-id-z",
"<STR_LIT>",
")",
")",
"WorkGroupIDZ",
"=",
"true",
";",
"<FIXE>",
"<FIXS>",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"amdgpu-work-item-id-x",
"<STR_LIT>",
")",
")",
"WorkItemIDX",
"=",
"true",
";",
"<FIXE>",
"<FIXS>",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"amdgpu-work-item-id-y",
"<STR_LIT>",
")",
")",
"WorkItemIDY",
"=",
"true",
";",
"<FIXE>",
"<FIXS>",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"amdgpu-work-item-id-z",
"<STR_LIT>",
")",
")",
"WorkItemIDZ",
"=",
"true",
";",
"<FIXE>"
] | [
"}",
"}",
"<BUGS>",
"if",
"(",
"ST",
".",
"debuggerEmitPrologue",
"(",
")",
")",
"{",
"<BUGE>",
"WorkGroupIDX",
"=",
"true",
";",
"<BUGS>",
"WorkGroupIDY",
"=",
"true",
";",
"WorkGroupIDZ",
"=",
"true",
";",
"WorkItemIDX",
"=",
"true",
";",
"WorkItemIDY",
"=",
"true",
";",
"WorkItemIDZ",
"=",
"true",
";",
"}",
"else",
"{",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"amdgpu-work-group-id-x",
"<STR_LIT>",
")",
")",
"WorkGroupIDX",
"=",
"true",
";",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"amdgpu-work-group-id-y",
"<STR_LIT>",
")",
")",
"WorkGroupIDY",
"=",
"true",
";",
"<BUGE>",
"<BUGS>",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"amdgpu-work-group-id-z",
"<STR_LIT>",
")",
")",
"WorkGroupIDZ",
"=",
"true",
";",
"<BUGE>",
"<BUGS>",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"amdgpu-work-item-id-x",
"<STR_LIT>",
")",
")",
"WorkItemIDX",
"=",
"true",
";",
"<BUGE>",
"<BUGS>",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"amdgpu-work-item-id-y",
"<STR_LIT>",
")",
")",
"WorkItemIDY",
"=",
"true",
";",
"<BUGE>",
"<BUGS>",
"if",
"(",
"F",
".",
"hasFnAttribute",
"(",
"<STR_LIT>",
"amdgpu-work-item-id-z",
"<STR_LIT>",
")",
")",
"WorkItemIDZ",
"=",
"true",
";",
"}",
"<BUGE>",
"const",
"MachineFrameInfo",
"&",
"FrameInfo",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
";",
"bool",
"HasStackObjects",
"=",
"FrameInfo",
".",
"hasStackObjects",
"(",
")",
";"
] |
GCC | i386 | CPP | stmt_completion | CPU | 622,661 | [
"v8hi",
")",
"_",
"_",
"A",
")",
";"
] | [
"extern",
"_",
"_",
"inline",
"_",
"_",
"mmask8",
"_",
"_",
"attribute__",
"(",
"(",
"_",
"_",
"gnu_inline__",
",",
"_",
"_",
"always_inline__",
",",
"_",
"_",
"artificial__",
")",
")",
"_",
"mm_movepi16_mask",
"(",
"_",
"_",
"m128i",
"_",
"_",
"A",
")",
"{",
"return",
"(",
"_",
"_",
"mmask8",
")",
"_",
"_",
"builtin_ia32_cvtw2mask128",
"(",
"(",
"_",
"_"
] |
GCC | mep | CPP | program_repair | CPU | 622,662 | [
"<FIXS>",
"SET_PREV_INSN",
"(",
"NEXT_INSN",
"(",
"not",
"e",
")",
")",
"=",
"PREV_INSN",
"(",
"not",
"e",
")",
";",
"SET_NEXT_INSN",
"(",
"PREV_INSN",
"(",
"not",
"e",
")",
")",
"=",
"NEXT_INSN",
"(",
"not",
"e",
")",
";",
"<FIXE>",
"<FIXS>",
"SET_NEXT_INSN",
"(",
"not",
"e",
")",
"=",
"first",
";",
"SET_PREV_INSN",
"(",
"not",
"e",
")",
"=",
"PREV_INSN",
"(",
"first",
")",
";",
"SET_NEXT_INSN",
"(",
"PREV_INSN",
"(",
"not",
"e",
")",
")",
"=",
"not",
"e",
";",
"SET_PREV_INSN",
"(",
"NEXT_INSN",
"(",
"not",
"e",
")",
")",
"=",
"not",
"e",
";",
"<FIXE>"
] | [
"if",
"(",
"NOTE_P",
"(",
"not",
"e",
")",
")",
"{",
"<BUGS>",
"PREV_INSN",
"(",
"NEXT_INSN",
"(",
"not",
"e",
")",
")",
"=",
"PREV_INSN",
"(",
"not",
"e",
")",
";",
"NEXT_INSN",
"(",
"PREV_INSN",
"(",
"not",
"e",
")",
")",
"=",
"NEXT_INSN",
"(",
"not",
"e",
")",
";",
"<BUGE>",
"<BUGS>",
"NEXT_INSN",
"(",
"not",
"e",
")",
"=",
"first",
";",
"PREV_INSN",
"(",
"not",
"e",
")",
"=",
"PREV_INSN",
"(",
"first",
")",
";",
"NEXT_INSN",
"(",
"PREV_INSN",
"(",
"not",
"e",
")",
")",
"=",
"not",
"e",
";",
"PREV_INSN",
"(",
"NEXT_INSN",
"(",
"not",
"e",
")",
")",
"=",
"not",
"e",
";",
"<BUGE>",
"}",
"not",
"e",
"=",
"prev",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 622,663 | [
"let",
"DecoderNamespace",
"=",
"<STR_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"addrMode",
"=",
"BaseLongOffset",
";",
"let",
"accessSize",
"=",
"ByteAccess",
";",
"let",
"mayLoad",
"=",
"<NUM_LIT>",
";",
"let",
"isExtended",
"=",
"<NUM_LIT>",
";",
"let",
"InputType",
"=",
"<STR_LIT>",
";"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 622,664 | [
")",
")",
";"
] | [
"setAvailableFeatures",
"(",
"ComputeAvailableFeatures",
"(",
"&",
"TM",
".",
"getSubtarget",
"<",
"X86Subtarget",
">",
"(",
")"
] |
LLVM | AMDGPU | CPP | stmt_completion | GPU | 622,665 | [
"->",
"getValueOperand",
"(",
")",
";"
] | [
"}",
"LLVM_DEBUG",
"(",
"dbgs",
"(",
")",
"<<",
"<STR_LIT>",
" Converting alloca to vector ",
"<STR_LIT>",
"<<",
"*",
"AllocaTy",
"<<",
"<STR_LIT>",
" -> ",
"<STR_LIT>",
"<<",
"*",
"VectorTy",
"<<",
"'",
"\\n",
"'",
")",
";",
"for",
"(",
"Value",
"*",
"V",
":",
"WorkList",
")",
"{",
"Instruction",
"*",
"Inst",
"=",
"cast",
"<",
"Instruction",
">",
"(",
"V",
")",
";",
"IRBuilder",
"<",
">",
"Builder",
"(",
"Inst",
")",
";",
"switch",
"(",
"Inst",
"->",
"getOpcode",
"(",
")",
")",
"{",
"case",
"Instruction",
"::",
"Load",
":",
"{",
"if",
"(",
"Inst",
"->",
"getType",
"(",
")",
"==",
"AllocaTy",
"||",
"Inst",
"->",
"getType",
"(",
")",
"->",
"isVectorTy",
"(",
")",
")",
"break",
";",
"Value",
"*",
"Ptr",
"=",
"cast",
"<",
"LoadInst",
">",
"(",
"Inst",
")",
"->",
"getPointerOperand",
"(",
")",
";",
"Value",
"*",
"Index",
"=",
"calculateVectorIndex",
"(",
"Ptr",
",",
"GEPVectorIdx",
")",
";",
"if",
"(",
"!",
"Index",
")",
"break",
";",
"Type",
"*",
"VecPtrTy",
"=",
"VectorTy",
"->",
"getPointerTo",
"(",
"AMDGPUAS",
"::",
"PRIVATE_ADDRESS",
")",
";",
"Value",
"*",
"BitCast",
"=",
"Builder",
".",
"CreateBitCast",
"(",
"Alloca",
",",
"VecPtrTy",
")",
";",
"Value",
"*",
"VecValue",
"=",
"Builder",
".",
"CreateLoad",
"(",
"VectorTy",
",",
"BitCast",
")",
";",
"Value",
"*",
"ExtractElement",
"=",
"Builder",
".",
"CreateExtractElement",
"(",
"VecValue",
",",
"Index",
")",
";",
"if",
"(",
"Inst",
"->",
"getType",
"(",
")",
"!=",
"VecEltTy",
")",
"ExtractElement",
"=",
"Builder",
".",
"CreateBitCast",
"(",
"ExtractElement",
",",
"Inst",
"->",
"getType",
"(",
")",
")",
";",
"Inst",
"->",
"replaceAllUsesWith",
"(",
"ExtractElement",
")",
";",
"Inst",
"->",
"eraseFromParent",
"(",
")",
";",
"break",
";",
"}",
"case",
"Instruction",
"::",
"Store",
":",
"{",
"StoreInst",
"*",
"SI",
"=",
"cast",
"<",
"StoreInst",
">",
"(",
"Inst",
")",
";",
"if",
"(",
"SI",
"->",
"getValueOperand",
"(",
")",
"->",
"getType",
"(",
")",
"==",
"AllocaTy",
"||",
"SI",
"->",
"getValueOperand",
"(",
")",
"->",
"getType",
"(",
")",
"->",
"isVectorTy",
"(",
")",
")",
"break",
";",
"Value",
"*",
"Ptr",
"=",
"SI",
"->",
"getPointerOperand",
"(",
")",
";",
"Value",
"*",
"Index",
"=",
"calculateVectorIndex",
"(",
"Ptr",
",",
"GEPVectorIdx",
")",
";",
"if",
"(",
"!",
"Index",
")",
"break",
";",
"Type",
"*",
"VecPtrTy",
"=",
"VectorTy",
"->",
"getPointerTo",
"(",
"AMDGPUAS",
"::",
"PRIVATE_ADDRESS",
")",
";",
"Value",
"*",
"BitCast",
"=",
"Builder",
".",
"CreateBitCast",
"(",
"Alloca",
",",
"VecPtrTy",
")",
";",
"Value",
"*",
"VecValue",
"=",
"Builder",
".",
"CreateLoad",
"(",
"VectorTy",
",",
"BitCast",
")",
";",
"Value",
"*",
"Elt",
"=",
"SI"
] |
LLVM | Hexagon | CPP | next_suggestion | DSP | 622,666 | [
"}"
] | [
"const",
"InstrStage",
"&",
"IS",
"=",
"*",
"II",
".",
"beginStage",
"(",
"MI",
".",
"getDesc",
"(",
")",
".",
"getSchedClass",
"(",
")",
")",
";",
"return",
"IS",
".",
"getUnits",
"(",
")",
";"
] |
GCC | aarch64 | CPP | stmt_completion | CPU | 622,667 | [
";"
] | [
"_",
"_",
"asm__",
"(",
"<STR_LIT>",
"mul %0.4h,%1.4h,%2.h[0]",
"<STR_LIT>",
":",
"<STR_LIT>",
"=w",
"<STR_LIT>",
"(",
"result",
")",
":",
"<STR_LIT>",
"w",
"<STR_LIT>",
"(",
"a",
")",
",",
"<STR_LIT>",
"x",
"<STR_LIT>",
"(",
"b",
")",
":",
")",
";",
"return",
"result"
] |
GCC | nios2 | CPP | stmt_completion | MPU | 622,668 | [
")",
";"
] | [
"rtx",
"mem",
",",
"addr",
";",
"struct",
"expand_operand",
"ops",
"[",
"MAX_RECOG_OPERANDS",
"]",
";",
"addr",
"=",
"expand_normal",
"(",
"CALL_EXPR_ARG",
"(",
"exp",
",",
"<NUM_LIT>",
")"
] |
GCC | csky | CPP | next_suggestion | CPU | 622,669 | [
"}"
] | [
"selected_cost",
"=",
"get_csky_barrier_cost",
"(",
"from",
")",
";",
"while",
"(",
"from",
"&&",
"count",
"<",
"max_count",
")",
"{",
"int",
"new",
"_",
"cost",
";",
"rtx_jump_table_data",
"*",
"table",
";",
"count",
"+=",
"get_attr_length",
"(",
"from",
")",
";",
"if",
"(",
"tablejump_p",
"(",
"from",
",",
"NULL",
",",
"&",
"table",
")",
")",
"{",
"count",
"+=",
"get_csky_jump_table_size",
"(",
"table",
")",
";",
"new",
"_",
"cost",
"=",
"get_csky_barrier_cost",
"(",
"from",
")",
";",
"if",
"(",
"count",
"<",
"max_count",
"&&",
"(",
"!",
"selected",
"||",
"new",
"_",
"cost",
"<=",
"selected_cost",
")",
")",
"{",
"selected",
"=",
"table",
";",
"selected_cost",
"=",
"new",
"_",
"cost",
";",
"selected_address",
"=",
"count",
";",
"}",
"from",
"=",
"NEXT_INSN",
"(",
"table",
")",
";",
"continue",
";",
"}",
"new",
"_",
"cost",
"=",
"get_csky_barrier_cost",
"(",
"from",
")",
";",
"if",
"(",
"count",
"<",
"max_count",
"&&",
"(",
"!",
"selected",
"||",
"new",
"_",
"cost",
"<=",
"selected_cost",
")",
")",
"{",
"selected",
"=",
"from",
";",
"selected_cost",
"=",
"new",
"_",
"cost",
";",
"selected_address",
"=",
"count",
";",
"}",
"from",
"=",
"NEXT_INSN",
"(",
"from",
")",
";"
] |
GCC | aarch64 | CPP | next_suggestion | CPU | 622,670 | [
"ret",
".",
"val",
"[",
"<NUM_LIT>",
"]",
"=",
"(",
"int8x8_t",
")",
"_",
"_",
"builtin_aarch64_get_dregxiv8qi",
"(",
"_",
"_",
"o",
",",
"<NUM_LIT>",
")",
";"
] | [
"_",
"_",
"o",
"=",
"_",
"_",
"builtin_aarch64_ld4rv8qi",
"(",
"(",
"const",
"_",
"_",
"builtin_aarch64_simd_qi",
"*",
")",
"_",
"_",
"a",
")",
";",
"ret",
".",
"val",
"[",
"<NUM_LIT>",
"]",
"=",
"(",
"int8x8_t",
")",
"_",
"_",
"builtin_aarch64_get_dregxiv8qi",
"(",
"_",
"_",
"o",
",",
"<NUM_LIT>",
")",
";",
"ret",
".",
"val",
"[",
"<NUM_LIT>",
"]",
"=",
"(",
"int8x8_t",
")",
"_",
"_",
"builtin_aarch64_get_dregxiv8qi",
"(",
"_",
"_",
"o",
",",
"<NUM_LIT>",
")",
";",
"ret",
".",
"val",
"[",
"<NUM_LIT>",
"]",
"=",
"(",
"int8x8_t",
")",
"_",
"_",
"builtin_aarch64_get_dregxiv8qi",
"(",
"_",
"_",
"o",
",",
"<NUM_LIT>",
")",
";"
] |
LLVM | Mips | CPP | stmt_completion | CPU | 622,671 | [
"<STR_LIT>",
")",
";"
] | [
"Register",
"Reg",
"=",
"StringSwitch",
"<",
"Register",
">",
"(",
"RegName",
")",
".",
"Case",
"(",
"<STR_LIT>",
"$28",
"<STR_LIT>",
",",
"Mips",
"::",
"GP",
")",
".",
"Default",
"(",
"Register",
"(",
")",
")",
";",
"if",
"(",
"Reg",
")",
"return",
"Reg",
";",
"}",
"report_fatal_error",
"(",
"<STR_LIT>",
"Invalid register name global variable"
] |
LLVM | Hexagon | CPP | stmt_completion | DSP | 622,672 | [
")",
")",
"return",
"SmallDataSection",
";"
] | [
"const",
"MCSection",
"*",
"HexagonTargetObjectFile",
"::",
"SelectSectionForGlobal",
"(",
"const",
"GlobalValue",
"*",
"GV",
",",
"SectionKind",
"Kind",
",",
"Mangler",
"&",
"Mang",
",",
"const",
"TargetMachine",
"&",
"TM",
")",
"const",
"{",
"if",
"(",
"Kind",
".",
"isBSS",
"(",
")",
"&&",
"IsGlobalInSmallSection",
"(",
"GV",
",",
"TM",
",",
"Kind",
")",
")",
"return",
"SmallBSSSection",
";",
"if",
"(",
"Kind",
".",
"isDataNoRel",
"(",
")",
"&&",
"IsGlobalInSmallSection",
"(",
"GV",
",",
"TM",
",",
"Kind"
] |
LLVM | ARM | CPP | next_suggestion | CPU | 622,673 | [
"ARMCCState",
"CCInfo",
"(",
"CalleeCC",
",",
"isVarArg",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"ArgLocs",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"Call",
")",
";"
] | [
"if",
"(",
"GlobalAddressSDNode",
"*",
"G",
"=",
"dyn_cast",
"<",
"GlobalAddressSDNode",
">",
"(",
"Callee",
")",
")",
"{",
"const",
"GlobalValue",
"*",
"GV",
"=",
"G",
"->",
"getGlobal",
"(",
")",
";",
"const",
"Triple",
"&",
"TT",
"=",
"getTargetMachine",
"(",
")",
".",
"getTargetTriple",
"(",
")",
";",
"if",
"(",
"GV",
"->",
"hasExternalWeakLinkage",
"(",
")",
"&&",
"(",
"!",
"TT",
".",
"isOSWindows",
"(",
")",
"||",
"TT",
".",
"isOSBinFormatELF",
"(",
")",
"||",
"TT",
".",
"isOSBinFormatMachO",
"(",
")",
")",
")",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"CCMatch",
")",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"<NUM_LIT>",
">",
"RVLocs1",
";",
"ARMCCState",
"CCInfo1",
"(",
"CalleeCC",
",",
"false",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"RVLocs1",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"Call",
")",
";",
"CCInfo1",
".",
"AnalyzeCallResult",
"(",
"Ins",
",",
"CCAssignFnForNode",
"(",
"CalleeCC",
",",
"true",
",",
"isVarArg",
")",
")",
";",
"SmallVector",
"<",
"CCValAssign",
",",
"<NUM_LIT>",
">",
"RVLocs2",
";",
"ARMCCState",
"CCInfo2",
"(",
"CallerCC",
",",
"false",
",",
"DAG",
".",
"getMachineFunction",
"(",
")",
",",
"RVLocs2",
",",
"*",
"DAG",
".",
"getContext",
"(",
")",
",",
"Call",
")",
";",
"CCInfo2",
".",
"AnalyzeCallResult",
"(",
"Ins",
",",
"CCAssignFnForNode",
"(",
"CallerCC",
",",
"true",
",",
"isVarArg",
")",
")",
";",
"if",
"(",
"RVLocs1",
".",
"size",
"(",
")",
"!=",
"RVLocs2",
".",
"size",
"(",
")",
")",
"return",
"false",
";",
"for",
"(",
"unsigned",
"i",
"=",
"<NUM_LIT>",
",",
"e",
"=",
"RVLocs1",
".",
"size",
"(",
")",
";",
"i",
"!=",
"e",
";",
"++",
"i",
")",
"{",
"if",
"(",
"RVLocs1",
"[",
"i",
"]",
".",
"isRegLoc",
"(",
")",
"!=",
"RVLocs2",
"[",
"i",
"]",
".",
"isRegLoc",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"RVLocs1",
"[",
"i",
"]",
".",
"getLocInfo",
"(",
")",
"!=",
"RVLocs2",
"[",
"i",
"]",
".",
"getLocInfo",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"RVLocs1",
"[",
"i",
"]",
".",
"isRegLoc",
"(",
")",
")",
"{",
"if",
"(",
"RVLocs1",
"[",
"i",
"]",
".",
"getLocReg",
"(",
")",
"!=",
"RVLocs2",
"[",
"i",
"]",
".",
"getLocReg",
"(",
")",
")",
"return",
"false",
";",
"}",
"else",
"{",
"if",
"(",
"RVLocs1",
"[",
"i",
"]",
".",
"getLocMemOffset",
"(",
")",
"!=",
"RVLocs2",
"[",
"i",
"]",
".",
"getLocMemOffset",
"(",
")",
")",
"return",
"false",
";",
"}",
"}",
"}",
"const",
"ARMFunctionInfo",
"*",
"AFI_Caller",
"=",
"DAG",
".",
"getMachineFunction",
"(",
")",
".",
"getInfo",
"<",
"ARMFunctionInfo",
">",
"(",
")",
";",
"if",
"(",
"AFI_Caller",
"->",
"getArgRegsSaveSize",
"(",
")",
")",
"return",
"false",
";",
"if",
"(",
"!",
"Outs",
".",
"empty",
"(",
")",
")",
"{",
"SmallVector",
"<",
"CCValAssign",
",",
"<NUM_LIT>",
">",
"ArgLocs",
";"
] |
GCC | m68k | MD | next_suggestion | MPU | 622,674 | [
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
")",
")",
"]"
] | [
"(",
"and",
":",
"SI",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"const_int",
"<NUM_LIT>",
")",
")",
")"
] |
GCC | frv | MD | stmt_completion | VLIW | 622,675 | [
"<NUM_LIT>",
")",
"]"
] | [
"[",
"(",
"const_int"
] |
LLVM | Patmos | TD | next_suggestion | VLIW | 622,676 | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"func",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"p",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"rd",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"rs1",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";"
] |
GCC | nios2 | MD | stmt_completion | MPU | 622,677 | [
"<STR_LIT>",
"<STR_LIT>",
")"
] | [
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>",
"<STR_LIT>",
"<STR_LIT>",
")",
"(",
"mem",
":",
"SI",
"(",
"plus",
":",
"SI",
"(",
"match_dup",
"<NUM_LIT>",
")",
"(",
"const_int",
"-",
"<NUM_LIT>",
")",
")",
")",
")",
"(",
"set",
"(",
"match_operand",
":",
"SI",
"<NUM_LIT>"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 622,678 | [
"}"
] | [
"def",
"A4_cmpbgtui",
":",
"HInst",
"<",
"(",
"outs",
"PredRegs",
":",
"$",
"Pd4",
")",
",",
"(",
"ins",
"IntRegs",
":",
"$",
"Rs32",
",",
"u32_0Imm",
":",
"$",
"Ii",
")",
",",
"<STR_LIT>",
",",
"tc_643b4717",
",",
"TypeALU64",
">",
",",
"Enc_02553a",
",",
"ImmRegRel",
"{",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"CextOpcode",
"=",
"<STR_LIT>",
";",
"let",
"InputType",
"=",
"<STR_LIT>",
";",
"let",
"isCompare",
"=",
"<NUM_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentAlign",
"=",
"<NUM_LIT>",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 622,679 | [
"let",
"opExtentAlign",
"=",
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"addrMode",
"=",
"AbsoluteSet",
";",
"let",
"accessSize",
"=",
"WordAccess",
";",
"let",
"mayLoad",
"=",
"<NUM_LIT>",
";",
"let",
"isExtended",
"=",
"<NUM_LIT>",
";",
"let",
"DecoderNamespace",
"=",
"<STR_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";"
] |
LLVM | PowerPC | CPP | stmt_completion | CPU | 622,680 | [
"InstructionFragment",
")",
";"
] | [
"MCELFStreamer",
"::",
"emitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"return",
";",
"}",
"emitCodeAlignment",
"(",
"<NUM_LIT>",
",",
"<NUM_LIT>",
")",
";",
"MCELFStreamer",
"::",
"emitInstruction",
"(",
"Inst",
",",
"STI",
")",
";",
"MCFragment",
"*",
"InstructionFragment",
"=",
"getCurrentFragment",
"(",
")",
";",
"SMLoc",
"InstLoc",
"=",
"Inst",
".",
"getLoc",
"(",
")",
";",
"if",
"(",
"LastLabel",
"&&",
"!",
"LastLabel",
"->",
"isUnset",
"(",
")",
"&&",
"LastLabelLoc",
".",
"isValid",
"(",
")",
"&&",
"InstLoc",
".",
"isValid",
"(",
")",
")",
"{",
"const",
"SourceMgr",
"*",
"SourceManager",
"=",
"getContext",
"(",
")",
".",
"getSourceManager",
"(",
")",
";",
"unsigned",
"InstLine",
"=",
"SourceManager",
"->",
"FindLineNumber",
"(",
"InstLoc",
")",
";",
"unsigned",
"LabelLine",
"=",
"SourceManager",
"->",
"FindLineNumber",
"(",
"LastLabelLoc",
")",
";",
"if",
"(",
"InstLine",
"==",
"LabelLine",
")",
"{",
"AssignFragment",
"(",
"LastLabel",
","
] |
LLVM | AArch64 | CPP | stmt_completion | CPU | 622,681 | [
")",
";"
] | [
"void",
"setupMF",
"(",
"MachineFunction",
"&",
"MF",
",",
"GISelKnownBits",
"*",
"KB",
",",
"CodeGenCoverage",
"&",
"CoverageInfo",
",",
"ProfileSummaryInfo",
"*",
"PSI",
",",
"BlockFrequencyInfo",
"*",
"BFI",
",",
"AAResults",
"*",
"AA",
")",
"override",
"{",
"InstructionSelector",
"::",
"setupMF",
"(",
"MF",
",",
"KB",
",",
"CoverageInfo",
",",
"PSI",
",",
"BFI",
",",
"AA",
")",
";",
"MIB",
".",
"setMF",
"(",
"MF",
")",
";",
"ProduceNonFlagSettingCondBr",
"=",
"!",
"MF",
".",
"getFunction",
"(",
")",
".",
"hasFnAttribute",
"(",
"Attribute",
"::",
"SpeculativeLoadHardening",
")",
";",
"MFReturnAddr",
"=",
"Register",
"("
] |
LLVM | Lanai | CPP | next_suggestion | CPU | 622,682 | [
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";"
] | [
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";",
"Reserved",
".",
"set",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
";"
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 622,683 | [
"}"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Mu2",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rt32",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rt32",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rx32",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rx32",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 622,684 | [
"}",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Ii",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Ii",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rs16",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rs16",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"n1",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"n1",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 622,685 | [
"<NUM_LIT>",
",",
"<NUM_LIT>",
">",
";"
] | [
"def",
"A2_combine_lh",
":",
"T_ALU32_combineh",
"<",
"<STR_LIT>",
",",
"<STR_LIT>",
",",
"<NUM_LIT>",
","
] |
LLVM | X86 | TD | next_suggestion | CPU | 622,686 | [
"}"
] | [
"let",
"Latency",
"=",
"<NUM_LIT>",
";",
"let",
"NumMicroOps",
"=",
"<NUM_LIT>",
";"
] |
LLVM | ARM | CPP | stmt_completion | CPU | 622,687 | [
"<NUM_LIT>",
";"
] | [
"int",
"FI",
"=",
"CSI",
"[",
"i",
"]",
".",
"getFrameIdx",
"(",
")",
";",
"MFI",
".",
"setObjectAlignment",
"(",
"FI",
",",
"DNum",
"%",
"<NUM_LIT>",
"?",
"Align",
"(",
"<NUM_LIT>",
")",
":",
"Align",
"(",
"<NUM_LIT>",
")",
")",
";",
"if",
"(",
"DNum",
"==",
"<NUM_LIT>",
")",
"MFI",
".",
"setObjectAlignment",
"(",
"FI",
",",
"MFI",
".",
"getMaxAlign",
"(",
")",
")",
";",
"}",
"bool",
"isThumb",
"=",
"AFI",
"->",
"isThumbFunction",
"(",
")",
";",
"assert",
"(",
"!",
"AFI",
"->",
"isThumb1OnlyFunction",
"(",
")",
"&&",
"<STR_LIT>",
"Can't realign stack for thumb1",
"<STR_LIT>",
")",
";",
"AFI",
"->",
"setShouldRestoreSPFromFP",
"(",
"true",
")",
";",
"unsigned",
"Opc",
"=",
"isThumb",
"?",
"ARM",
"::",
"t2SUBri",
":",
"ARM",
"::",
"SUBri",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"ARM",
"::",
"R4",
")",
".",
"addReg",
"(",
"ARM",
"::",
"SP",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
"*",
"NumAlignedDPRCS2Regs",
")",
".",
"add",
"(",
"predOps",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
".",
"add",
"(",
"condCodeOp",
"(",
")",
")",
";",
"Align",
"MaxAlign",
"=",
"MF",
".",
"getFrameInfo",
"(",
")",
".",
"getMaxAlign",
"(",
")",
";",
"emitAligningInstructions",
"(",
"MF",
",",
"AFI",
",",
"TII",
",",
"MBB",
",",
"MI",
",",
"DL",
",",
"ARM",
"::",
"R4",
",",
"MaxAlign",
",",
"true",
")",
";",
"Opc",
"=",
"isThumb",
"?",
"ARM",
"::",
"tMOVr",
":",
"ARM",
"::",
"MOVr",
";",
"MachineInstrBuilder",
"MIB",
"=",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"Opc",
")",
",",
"ARM",
"::",
"SP",
")",
".",
"addReg",
"(",
"ARM",
"::",
"R4",
")",
".",
"add",
"(",
"predOps",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"if",
"(",
"!",
"isThumb",
")",
"MIB",
".",
"add",
"(",
"condCodeOp",
"(",
")",
")",
";",
"unsigned",
"NextReg",
"=",
"ARM",
"::",
"D8",
";",
"if",
"(",
"NumAlignedDPRCS2Regs",
">=",
"<NUM_LIT>",
")",
"{",
"unsigned",
"SupReg",
"=",
"TRI",
"->",
"getMatchingSuperReg",
"(",
"NextReg",
",",
"ARM",
"::",
"dsub_0",
",",
"&",
"ARM",
"::",
"QQPRRegClass",
")",
";",
"MBB",
".",
"addLiveIn",
"(",
"SupReg",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"ARM",
"::",
"VST1d64Qwb_fixed",
")",
",",
"ARM",
"::",
"R4",
")",
".",
"addReg",
"(",
"ARM",
"::",
"R4",
",",
"RegState",
"::",
"Kill",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
".",
"addReg",
"(",
"NextReg",
")",
".",
"addReg",
"(",
"SupReg",
",",
"RegState",
"::",
"ImplicitKill",
")",
".",
"add",
"(",
"predOps",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"NextReg",
"+=",
"<NUM_LIT>",
";",
"NumAlignedDPRCS2Regs",
"-=",
"<NUM_LIT>",
";",
"}",
"unsigned",
"R4BaseReg",
"=",
"NextReg",
";",
"if",
"(",
"NumAlignedDPRCS2Regs",
">=",
"<NUM_LIT>",
")",
"{",
"unsigned",
"SupReg",
"=",
"TRI",
"->",
"getMatchingSuperReg",
"(",
"NextReg",
",",
"ARM",
"::",
"dsub_0",
",",
"&",
"ARM",
"::",
"QQPRRegClass",
")",
";",
"MBB",
".",
"addLiveIn",
"(",
"SupReg",
")",
";",
"BuildMI",
"(",
"MBB",
",",
"MI",
",",
"DL",
",",
"TII",
".",
"get",
"(",
"ARM",
"::",
"VST1d64Q",
")",
")",
".",
"addReg",
"(",
"ARM",
"::",
"R4",
")",
".",
"addImm",
"(",
"<NUM_LIT>",
")",
".",
"addReg",
"(",
"NextReg",
")",
".",
"addReg",
"(",
"SupReg",
",",
"RegState",
"::",
"ImplicitKill",
")",
".",
"add",
"(",
"predOps",
"(",
"<STR_LIT>",
"::",
"<STR_LIT>",
")",
")",
";",
"NextReg",
"+=",
"<NUM_LIT>",
";",
"NumAlignedDPRCS2Regs",
"-="
] |
GCC | c6x | CPP | next_suggestion | VLIW | 622,688 | [
"if",
"(",
"stdarg_p",
"(",
"fntype",
")",
")",
"cum",
"->",
"nregs",
"=",
"type_num_arguments",
"(",
"fntype",
")",
"-",
"<NUM_LIT>",
";"
] | [
"cum",
"->",
"nregs",
"=",
"<NUM_LIT>",
";",
"if",
"(",
"!",
"libname",
"&&",
"fntype",
")",
"{"
] |
LLVM | WDC65816 | CPP | next_suggestion | MPU | 622,689 | [
"}"
] | [
"virtual",
"const",
"WDC65816RegisterInfo",
"*",
"getRegisterInfo",
"(",
")",
"const",
"{",
"return",
"&",
"InstrInfo",
".",
"getRegisterInfo",
"(",
")",
";"
] |
LLVM | AArch64 | TD | stmt_completion | CPU | 622,690 | [
"<NUM_LIT>",
"}",
"=",
"Rd",
";"
] | [
"bits",
"<",
"<NUM_LIT>",
">",
"Rn",
";",
"bits",
"<",
"<NUM_LIT>",
">",
"Rm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rm",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"opcode",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"Rn",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-"
] |
LLVM | Hexagon | TD | stmt_completion | DSP | 622,691 | [
"<NUM_LIT>",
";"
] | [
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"Inst",
"{",
"<NUM_LIT>",
"-",
"<NUM_LIT>",
"}",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicated",
"=",
"<NUM_LIT>",
";",
"let",
"isPredicatedFalse",
"="
] |
GCC | iq2000 | MD | stmt_completion | CPU | 622,692 | [
")"
] | [
"<STR_LIT>",
"[",
"(",
"set_attr",
"<STR_LIT>",
"\t",
"<STR_LIT>",
")",
"(",
"set_attr",
"<STR_LIT>",
"\t",
"<STR_LIT>",
")",
"]"
] |
LLVM | Mips | CPP | stmt_completion | CPU | 622,693 | [
";"
] | [
"SDNode",
"*",
"MipsDAGToDAGISel",
"::",
"Select",
"(",
"SDNode",
"*",
"Node",
")",
"{",
"unsigned",
"Opcode",
"=",
"Node",
"->",
"getOpcode",
"(",
")",
";",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"<STR_LIT>",
"Selecting: ",
"<STR_LIT>",
";",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
";",
"errs",
"(",
")",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"if",
"(",
"Node",
"->",
"isMachineOpcode",
"(",
")",
")",
"{",
"DEBUG",
"(",
"errs",
"(",
")",
"<<",
"<STR_LIT>",
"== ",
"<STR_LIT>",
";",
"Node",
"->",
"dump",
"(",
"CurDAG",
")",
";",
"errs",
"(",
")",
"<<",
"<STR_LIT>",
"\\n",
"<STR_LIT>",
")",
";",
"Node",
"->",
"setNodeId",
"(",
"-",
"<NUM_LIT>",
")",
";",
"return",
"nullptr"
] |
GCC | aarch64 | CPP | next_suggestion | CPU | 622,694 | [
"tmp",
"=",
"val",
"&",
"(",
"val",
"+",
"first_one",
")",
";"
] | [
"bool",
"aarch64_bitmask_imm",
"(",
"HOST_WIDE_INT",
"val_in",
",",
"machine_mode",
"mode",
")",
"{",
"unsigned",
"HOST_WIDE_INT",
"val",
",",
"tmp",
",",
"mask",
",",
"first_one",
",",
"next_one",
";",
"int",
"bits",
";",
"val",
"=",
"(",
"unsigned",
"HOST_WIDE_INT",
")",
"val_in",
";",
"tmp",
"=",
"val",
"+",
"(",
"val",
"&",
"-",
"val",
")",
";",
"if",
"(",
"tmp",
"==",
"(",
"tmp",
"&",
"-",
"tmp",
")",
")",
"return",
"(",
"val",
"+",
"<NUM_LIT>",
")",
">",
"<NUM_LIT>",
";",
"if",
"(",
"mode",
"==",
"SImode",
")",
"val",
"=",
"(",
"val",
"<<",
"<NUM_LIT>",
")",
"|",
"(",
"val",
"&",
"<NUM_LIT>",
")",
";",
"if",
"(",
"val",
"&",
"<NUM_LIT>",
")",
"val",
"=",
"~",
"val",
";",
"first_one",
"=",
"val",
"&",
"-",
"val",
";"
] |
GCC | sh | CPP | code_generation | CPU | 622,695 | [
"static",
"rtx",
"sh_legitimize_address",
"(",
"rtx",
"x",
",",
"rtx",
"oldx",
",",
"machine_mode",
"mode",
")",
"{",
"if",
"(",
"flag_pic",
")",
"x",
"=",
"legitimize_pic_address",
"(",
"oldx",
",",
"mode",
",",
"NULL_RTX",
")",
";",
"if",
"(",
"(",
"TARGET_FPU_DOUBLE",
"&&",
"mode",
"==",
"DFmode",
")",
"||",
"(",
"TARGET_SH2E",
"&&",
"mode",
"==",
"SFmode",
")",
")",
"return",
"x",
";",
"if",
"(",
"GET_CODE",
"(",
"x",
")",
"==",
"PLUS",
"&&",
"CONST_INT_P",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
"&&",
"BASE_REGISTER_RTX_P",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
")",
"{",
"struct",
"disp_adjust",
"adj",
"=",
"sh_find_mov_disp_adjust",
"(",
"mode",
",",
"INTVAL",
"(",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
")",
")",
";",
"if",
"(",
"adj",
".",
"offset_adjust",
"!=",
"NULL_RTX",
"&&",
"adj",
".",
"mov_disp",
"!=",
"NULL_RTX",
")",
"{",
"rtx",
"sum",
"=",
"expand_binop",
"(",
"Pmode",
",",
"add_optab",
",",
"XEXP",
"(",
"x",
",",
"<NUM_LIT>",
")",
",",
"adj",
".",
"offset_adjust",
",",
"NULL_RTX",
",",
"<NUM_LIT>",
",",
"OPTAB_LIB_WIDEN",
")",
";",
"return",
"gen_rtx_PLUS",
"(",
"Pmode",
",",
"sum",
",",
"adj",
".",
"mov_disp",
")",
";",
"}",
"}",
"return",
"x",
";",
"}"
] | [
"Try",
"to",
"modify",
"an",
"illegitimate",
"address",
"and",
"make",
"it",
"legitimate",
".",
"If",
"we",
"find",
"one",
",",
"return",
"the",
"new",
",",
"valid",
"address",
".",
"Otherwise",
",",
"return",
"the",
"original",
"address",
"."
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 622,696 | [
"}"
] | [
"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",
"BaseOpcode",
"=",
"<STR_LIT>",
";"
] |
LLVM | X86 | CPP | stmt_completion | CPU | 622,697 | [
".",
"getConstant",
"(",
"<NUM_LIT>",
",",
"MVT",
"::",
"i32",
")",
")",
";"
] | [
"}",
"if",
"(",
"(",
"cc0",
"==",
"X86",
"::",
"COND_E",
"&&",
"cc1",
"==",
"X86",
"::",
"COND_NP",
")",
"||",
"(",
"cc0",
"==",
"X86",
"::",
"COND_NE",
"&&",
"cc1",
"==",
"X86",
"::",
"COND_P",
")",
")",
"{",
"bool",
"is64BitFP",
"=",
"(",
"CMP00",
".",
"getValueType",
"(",
")",
"==",
"MVT",
"::",
"f64",
")",
";",
"<STR_LIT>",
"::",
"<STR_LIT>",
"NTOperator",
"=",
"is64BitFP",
"?",
"<STR_LIT>",
"::",
"<STR_LIT>",
":",
"<STR_LIT>",
"::",
"<STR_LIT>",
";",
"unsigned",
"x86cc",
"=",
"(",
"cc0",
"==",
"X86",
"::",
"COND_E",
")",
"?",
"<NUM_LIT>",
":",
"<NUM_LIT>",
";",
"SDValue",
"OnesOrZeroesF",
"=",
"DAG",
".",
"getNode",
"(",
"NTOperator",
",",
"DL",
",",
"MVT",
"::",
"f32",
",",
"CMP00",
",",
"CMP01",
",",
"DAG",
".",
"getConstant",
"(",
"x86cc",
",",
"MVT",
"::",
"i8",
")",
")",
";",
"SDValue",
"OnesOrZeroesI",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"BITCAST",
",",
"DL",
",",
"MVT",
"::",
"i32",
",",
"OnesOrZeroesF",
")",
";",
"SDValue",
"ANDed",
"=",
"DAG",
".",
"getNode",
"(",
"ISD",
"::",
"AND",
",",
"DL",
",",
"MVT",
"::",
"i32",
",",
"OnesOrZeroesI",
",",
"DAG"
] |
LLVM | XCore | CPP | stmt_completion | MPU | 622,698 | [
"value",
")",
")",
"{"
] | [
"ConstantSDNode",
"*",
"N",
"=",
"cast",
"<",
"ConstantSDNode",
">",
"(",
"inN",
")",
";",
"uint32_t",
"value",
"=",
"(",
"uint32_t",
")",
"N",
"->",
"getZExtValue",
"(",
")",
";",
"if",
"(",
"!",
"isMask_32",
"("
] |
LLVM | Hexagon | TD | next_suggestion | DSP | 622,699 | [
"let",
"opExtentAlign",
"=",
"<NUM_LIT>",
";"
] | [
"let",
"isPredicatedNew",
"=",
"<NUM_LIT>",
";",
"let",
"CextOpcode",
"=",
"<STR_LIT>",
";",
"let",
"InputType",
"=",
"<STR_LIT>",
";",
"let",
"BaseOpcode",
"=",
"<STR_LIT>",
";",
"let",
"isMoveImm",
"=",
"<NUM_LIT>",
";",
"let",
"isExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"opExtendable",
"=",
"<NUM_LIT>",
";",
"let",
"isExtentSigned",
"=",
"<NUM_LIT>",
";",
"let",
"opExtentBits",
"=",
"<NUM_LIT>",
";"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.