{"ground_truth": ["<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "unsigned", "Size", "=", "1", "<<", "getFixupKindLog2Size", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "assert", "(", "isIntN", "(", "Size", "*", "8", "+", "1", ",", "Value", ")", "&&", "\"Value does not fit in the Fixup field\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "i", "]", "=", "uint8_t", "(", "Value", ">>", "(", "(", "Size", "-", "i", "-", "1", ")", "*", "8", ")", ")", ";", "}", "</s>"], "natrual_language": ["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", "."], "TS_V_token": ["M680x0", "1", "\"Invalid fixup offset!\"", "8", "1", "\"Value does not fit in the Fixup field\"", "0", "1", "8"], "File": "M680x0AsmBackend", "Func": "applyFixup", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23524, "Length": 130}
{"ground_truth": ["<s>", "bool", "M680x0AsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "if", "(", "int64_t", "(", "Value", ")", "!=", "int64_t", "(", "int16_t", "(", "Value", ")", ")", ")", "{", "llvm_unreachable", "(", "\"Cannot relax the instruction, value does not fit\"", ")", ";", "}", "return", "Value", "==", "0", "||", "int64_t", "(", "Value", ")", "!=", "int64_t", "(", "int8_t", "(", "Value", ")", ")", ";", "}", "</s>"], "natrual_language": ["Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "."], "TS_V_token": ["M680x0", "M680x0", "\"Cannot relax the instruction, value does not fit\"", "0"], "File": "M680x0AsmBackend", "Func": "fixupNeedsRelaxation", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23525, "Length": 66}
{"ground_truth": ["<s>", "unsigned", "getMinimumNopSize", "(", ")", "const", "override", "{", "return", "2", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "minimum", "size", "of", "a", "nop", "in", "bytes", "on", "this", "target", "."], "TS_V_token": ["M680x0", "2"], "File": "M680x0AsmBackend", "Func": "getMinimumNopSize", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23526, "Length": 11}
{"ground_truth": ["<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "llvm", "::", "M680x0", "::", "NumTargetFixupKinds", ";", "}", "</s>"], "natrual_language": ["Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "."], "TS_V_token": ["M680x0", "M680x0::NumTargetFixupKinds"], "File": "M680x0AsmBackend", "Func": "getNumFixupKinds", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23527, "Length": 15}
{"ground_truth": ["<s>", "bool", "M680x0AsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "getRelaxedOpcodeBranch", "(", "Inst", ")", "!=", "Inst", ".", "getOpcode", "(", ")", ")", "return", "true", ";", "if", "(", "getRelaxedOpcodeArith", "(", "Inst", ")", "==", "Inst", ".", "getOpcode", "(", ")", ")", "return", "false", ";", "unsigned", "RelaxableOp", "=", "Inst", ".", "getNumOperands", "(", ")", "-", "1", ";", "if", "(", "Inst", ".", "getOperand", "(", "RelaxableOp", ")", ".", "isExpr", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "."], "TS_V_token": ["M680x0", "M680x0", "1"], "File": "M680x0AsmBackend", "Func": "mayNeedRelaxation", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23528, "Length": 80}
{"ground_truth": ["<s>", "void", "M680x0AsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "{", "unsigned", "RelaxedOp", "=", "getRelaxedOpcode", "(", "Inst", ")", ";", "if", "(", "RelaxedOp", "==", "Inst", ".", "getOpcode", "(", ")", ")", "{", "SmallString", "<", "256", ">", "Tmp", ";", "raw_svector_ostream", "OS", "(", "Tmp", ")", ";", "Inst", ".", "dump_pretty", "(", "OS", ")", ";", "OS", "<<", "\"\\n\"", ";", "report_fatal_error", "(", "\"unexpected instruction to relax: \"", "+", "OS", ".", "str", "(", ")", ")", ";", "}", "Res", "=", "Inst", ";", "Res", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "}", "</s>"], "natrual_language": ["Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "."], "TS_V_token": ["M680x0", "M680x0", "256", "\"\\n\"", "\"unexpected instruction to relax: \""], "File": "M680x0AsmBackend", "Func": "relaxInstruction", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23529, "Length": 87}
{"ground_truth": ["<s>", "bool", "M680x0AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "if", "(", "Count", "%", "2", "!=", "0", ")", "return", "false", ";", "uint64_t", "NumNops", "=", "Count", "/", "2", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "{", "OS", "<<", "\"\\x4E\\x71\"", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "."], "TS_V_token": ["M680x0", "M680x0", "2", "0", "2", "0", "\"\\x4E\\x71\""], "File": "M680x0AsmBackend", "Func": "writeNopData", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23530, "Length": 56}
{"ground_truth": ["<s>", "void", "M680x0AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "{", "if", "(", "MI", "->", "isPseudo", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Pseudo opcode(\"", "<<", "MI", "->", "getOpcode", "(", ")", "<<", "\") found in EmitInstruction()\\n\"", ")", ";", "llvm_unreachable", "(", "\"Cannot proceed\"", ")", ";", "}", "break", ";", "}", "case", "M680x0", "::", "TAILJMPj", ":", "case", "M680x0", "::", "TAILJMPq", ":", "OutStreamer", "->", "AddComment", "(", "\"TAILCALL\"", ")", ";", "break", ";", "}", "MCInst", "TmpInst0", ";", "MCInstLowering", "->", "Lower", "(", "MI", ",", "TmpInst0", ")", ";", "OutStreamer", "->", "EmitInstruction", "(", "TmpInst0", ",", "getSubtargetInfo", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "."], "TS_V_token": ["M680x0", "M680x0", "\"Pseudo opcode(\"", "\") found in EmitInstruction()\\n\"", "\"Cannot proceed\"", "M680x0::TAILJMPj", "M680x0::TAILJMPq", "\"TAILCALL\""], "File": "M680x0AsmPrinter", "Func": "EmitInstruction", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23531, "Length": 102}
{"ground_truth": ["<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"M680x0 Assembly Printer\"", ";", "}", "</s>"], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["M680x0", "\"M680x0 Assembly Printer\""], "File": "M680x0AsmPrinter", "Func": "getPassName", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23532, "Length": 11}
{"ground_truth": ["<s>", "bool", "M680x0AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MMFI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "MCInstLowering", "=", "make_unique", "<", "M680x0MCInstLower", ">", "(", "MF", ",", "*", "this", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "M680x0"], "File": "M680x0AsmPrinter", "Func": "runOnMachineFunction", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23533, "Length": 45}
{"ground_truth": ["<s>", "void", "Finish", "(", "MachineBasicBlock", "&", "MBB", ",", "MOVEMState", "&", "State", ")", "{", "auto", "MI", "=", "State", ".", "GetBegin", "(", ")", ";", "auto", "End", "=", "State", ".", "GetEnd", "(", ")", ";", "auto", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "std", "::", "next", "(", "MI", ")", "==", "End", ")", "{", "State", "=", "MOVEMState", "(", ")", ";", "return", ";", "}", "while", "(", "MI", "!=", "End", ")", "{", "auto", "Next", "=", "std", "::", "next", "(", "MI", ")", ";", "MBB", ".", "erase", "(", "MI", ")", ";", "MI", "=", "Next", ";", "}", "if", "(", "State", ".", "IsLoad", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "End", ",", "DL", ",", "TII", "->", "get", "(", "M680x0", "::", "MOVM32mp", ")", ")", ".", "addImm", "(", "State", ".", "GetMask", "(", ")", ")", ".", "addImm", "(", "State", ".", "GetFinalOffset", "(", ")", ")", ".", "addReg", "(", "State", ".", "GetBase", "(", ")", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "End", ",", "DL", ",", "TII", "->", "get", "(", "M680x0", "::", "MOVM32pm", ")", ")", ".", "addImm", "(", "State", ".", "GetFinalOffset", "(", ")", ")", ".", "addReg", "(", "State", ".", "GetBase", "(", ")", ")", ".", "addImm", "(", "State", ".", "GetMask", "(", ")", ")", ";", "}", "State", "=", "MOVEMState", "(", ")", ";", "}", "</s>"], "natrual_language": ["Finish", "-", "Do", "final", "processing", "and", "write", "the", "object", "to", "the", "output", "stream", "."], "TS_V_token": ["M680x0", "M680x0::MOVM32mp", "M680x0::MOVM32pm"], "File": "M680x0CollapseMOVEMPass", "Func": "Finish", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23534, "Length": 199}
{"ground_truth": ["<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"M680x0 MOVEM collapser pass\"", ";", "}", "</s>"], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["M680x0", "\"M680x0 MOVEM collapser pass\""], "File": "M680x0CollapseMOVEMPass", "Func": "getPassName", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23535, "Length": 11}
{"ground_truth": ["<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "STI", "=", "&", "static_cast", "<", "const", "M680x0Subtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MFI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "FL", "=", "STI", "->", "getFrameLowering", "(", ")", ";", "bool", "Modified", "=", "false", ";", "MOVEMState", "State", ";", "unsigned", "Mask", "=", "0", ";", "unsigned", "Reg", "=", "0", ";", "int", "Offset", "=", "0", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "auto", "MI", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "MI", "!=", "E", ")", "{", "auto", "NMI", "=", "std", "::", "next", "(", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "if", "(", "State", ".", "HasBase", "(", ")", ")", "{", "State", ".", "SetEnd", "(", "MI", ")", ";", "Finish", "(", "MBB", ",", "State", ")", ";", "Modified", "=", "true", ";", "}", "break", ";", "case", "M680x0", "::", "MOVM32jm", ":", "Mask", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "0", ";", "Modified", "|=", "ProcessMI", "(", "MBB", ",", "MI", ",", "State", ",", "Mask", ",", "Offset", ",", "Reg", ",", "true", ")", ";", "break", ";", "case", "M680x0", "::", "MOVM32pm", ":", "Mask", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Modified", "|=", "ProcessMI", "(", "MBB", ",", "MI", ",", "State", ",", "Mask", ",", "Offset", ",", "Reg", ",", "true", ")", ";", "break", ";", "case", "M680x0", "::", "MOVM32mj", ":", "Mask", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "0", ";", "Modified", "|=", "ProcessMI", "(", "MBB", ",", "MI", ",", "State", ",", "Mask", ",", "Offset", ",", "Reg", ",", "false", ")", ";", "break", ";", "case", "M680x0", "::", "MOVM32mp", ":", "Mask", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Modified", "|=", "ProcessMI", "(", "MBB", ",", "MI", ",", "State", ",", "Mask", ",", "Offset", ",", "Reg", ",", "false", ")", ";", "break", ";", "}", "MI", "=", "NMI", ";", "}", "if", "(", "State", ".", "HasBase", "(", ")", ")", "{", "State", ".", "SetEnd", "(", "MI", ")", ";", "Finish", "(", "MBB", ",", "State", ")", ";", "}", "}", "return", "Modified", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "0", "0", "0", "M680x0::MOVM32jm", "1", "0", "0", "M680x0::MOVM32pm", "2", "1", "0", "M680x0::MOVM32mj", "0", "1", "0", "M680x0::MOVM32mp", "0", "2", "1"], "File": "M680x0CollapseMOVEMPass", "Func": "runOnMachineFunction", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23536, "Length": 445}
{"ground_truth": ["<s>", "static", "M680x0RelType", "getType", "(", "unsigned", "Kind", ",", "MCSymbolRefExpr", "::", "VariantKind", "&", "Modifier", ",", "bool", "&", "IsPCRel", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "case", "FK_Data_4", ":", "case", "FK_PCRel_4", ":", "return", "RT_32", ";", "case", "FK_PCRel_2", ":", "case", "FK_Data_2", ":", "return", "RT_16", ";", "case", "FK_PCRel_1", ":", "case", "FK_Data_1", ":", "return", "RT_8", ";", "}", "}", "</s>"], "natrual_language": ["Overload", "to", "return", "most", "specific", "vector", "type", "."], "TS_V_token": ["M680x0", "M680x0", "\"Unimplemented\""], "File": "M680x0ELFObjectWriter", "Func": "getType", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23537, "Length": 59}
{"ground_truth": ["<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addPreservedID", "(", "MachineLoopInfoID", ")", ";", "AU", ".", "addPreservedID", "(", "MachineDominatorsID", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>"], "natrual_language": ["getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "."], "TS_V_token": ["M680x0"], "File": "M680x0ExpandPseudo", "Func": "getAnalysisUsage", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23538, "Length": 38}
{"ground_truth": ["<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"M680x0 pseudo instruction expansion pass\"", ";", "}", "</s>"], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["M680x0", "\"M680x0 pseudo instruction expansion pass\""], "File": "M680x0ExpandPseudo", "Func": "getPassName", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23539, "Length": 11}
{"ground_truth": ["<s>", "bool", "M680x0ExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "STI", "=", "&", "static_cast", "<", "const", "M680x0Subtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MFI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "FL", "=", "STI", "->", "getFrameLowering", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "ExpandMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "M680x0"], "File": "M680x0ExpandPseudo", "Func": "runOnMachineFunction", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23540, "Length": 86}
{"ground_truth": ["<s>", "bool", "M680x0FrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "M680x0MachineFunctionInfo", "*", "M680x0FI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "int", "SpillSlotOffset", "=", "getOffsetOfLocalArea", "(", ")", "+", "M680x0FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", ".", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "unsigned", "FPReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "TRI", "->", "regsOverlap", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ",", "FPReg", ")", ")", "{", "CSI", ".", "erase", "(", "CSI", ".", "begin", "(", ")", "+", "i", ")", ";", "break", ";", "}", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "M680x0", "M680x0", "M680x0", "0"], "File": "M680x0FrameLowering", "Func": "assignCalleeSavedSpillSlots", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23541, "Length": 152}
{"ground_truth": ["<s>", "void", "M680x0FrameLowering", "::", "BuildCFI", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "const", "MCCFIInstruction", "&", "CFIInst", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "CFIInst", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>"], "natrual_language": ["Wraps", "up", "getting", "a", "CFI", "index", "and", "building", "a", "MachineInstr", "for", "it", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0FrameLowering", "Func": "BuildCFI", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23542, "Length": 71}
{"ground_truth": ["<s>", "bool", "M680x0FrameLowering", "::", "canSimplifyCallFramePseudos", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "hasReservedCallFrame", "(", "MF", ")", "||", "(", "hasFP", "(", "MF", ")", "&&", "!", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "||", "TRI", "->", "hasBasePointer", "(", "MF", ")", ";", "}", "</s>"], "natrual_language": ["canSimplifyCallFramePseudos", "-", "If", "there", "is", "a", "reserved", "call", "frame", ",", "the", "call", "frame", "pseudos", "can", "be", "simplified", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0FrameLowering", "Func": "canSimplifyCallFramePseudos", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23543, "Length": 41}
{"ground_truth": ["<s>", "void", "M680x0FrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "M680x0MachineFunctionInfo", "*", "M680x0FI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "int64_t", "TailCallReturnAddrDelta", "=", "M680x0FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "TailCallReturnAddrDelta", "<", "0", ")", "{", "MFI", ".", "CreateFixedObject", "(", "-", "TailCallReturnAddrDelta", ",", "TailCallReturnAddrDelta", "-", "SlotSize", ",", "true", ")", ";", "}", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "SavedRegs", ".", "set", "(", "TRI", "->", "getBaseRegister", "(", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "M680x0", "M680x0", "M680x0", "0"], "File": "M680x0FrameLowering", "Func": "determineCalleeSaves", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23544, "Length": 107}
{"ground_truth": ["<s>", "MachineBasicBlock", "::", "iterator", "M680x0FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reserveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "&&", "Amount", ")", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "StackAlign", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "auto", "&", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "DwarfCFI", "=", "MMI", ".", "hasDebugInfo", "(", ")", "||", "Fn", ".", "needsUnwindTableEntry", "(", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "MF", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "isDestroy", "&&", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "{", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "}", "if", "(", "Amount", "==", "0", ")", "return", "I", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "isDestroy", "&&", "InternalAmt", "&&", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "-", "InternalAmt", ")", ")", ";", "int64_t", "StackAdjustment", "=", "isDestroy", "?", "Amount", ":", "-", "Amount", ";", "int64_t", "CfaAdjustment", "=", "-", "StackAdjustment", ";", "if", "(", "StackAdjustment", ")", "{", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "I", ",", "true", ")", ";", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "I", ",", "false", ")", ";", "if", "(", "StackAdjustment", ")", "{", "BuildStackAdjustment", "(", "MBB", ",", "I", ",", "DL", ",", "StackAdjustment", ",", "false", ")", ";", "}", "}", "if", "(", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "CfaAdjustment", ")", "{", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "CfaAdjustment", ")", ")", ";", "}", "}", "return", "I", ";", "}", "if", "(", "isDestroy", "&&", "InternalAmt", ")", "{", "MachineBasicBlock", "::", "iterator", "CI", "=", "I", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "CI", "!=", "B", "&&", "!", "std", "::", "prev", "(", "CI", ")", "->", "isCall", "(", ")", ")", "--", "CI", ";", "BuildStackAdjustment", "(", "MBB", ",", "CI", ",", "DL", ",", "-", "InternalAmt", ",", "false", ")", ";", "}", "return", "I", ";", "}", "</s>"], "natrual_language": ["This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "."], "TS_V_token": ["M680x0", "M680x0", "0", "0", "1", "0", "M680x0", "0"], "File": "M680x0FrameLowering", "Func": "eliminateCallFramePseudoInstr", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23545, "Length": 435}
{"ground_truth": ["<s>", "void", "M680x0FrameLowering", "::", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "int64_t", "NumBytes", ",", "bool", "InEpilogue", ")", "const", "{", "bool", "isSub", "=", "NumBytes", "<", "0", ";", "uint64_t", "Offset", "=", "isSub", "?", "-", "NumBytes", ":", "NumBytes", ";", "uint64_t", "Chunk", "=", "(", "1LL", "<<", "31", ")", "-", "1", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "while", "(", "Offset", ")", "{", "if", "(", "Offset", ">", "Chunk", ")", "{", "unsigned", "Reg", "=", "0", ";", "if", "(", "isSub", "&&", "!", "isRegLiveIn", "(", "MBB", ",", "M680x0", "::", "D0", ")", ")", "Reg", "=", "(", "unsigned", ")", "(", "M680x0", "::", "D0", ")", ";", "else", "Reg", "=", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ",", "TRI", ")", ";", "if", "(", "Reg", ")", "{", "unsigned", "Opc", "=", "M680x0", "::", "MOV32ri", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "addImm", "(", "Offset", ")", ";", "Opc", "=", "isSub", "?", "getSUBrrOpcode", "(", ")", ":", "getADDrrOpcode", "(", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addReg", "(", "Reg", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "Offset", "=", "0", ";", "continue", ";", "}", "}", "uint64_t", "ThisVal", "=", "std", "::", "min", "(", "Offset", ",", "Chunk", ")", ";", "MachineInstrBuilder", "MI", "=", "BuildStackAdjustment", "(", "MBB", ",", "MBBI", ",", "DL", ",", "isSub", "?", "-", "ThisVal", ":", "ThisVal", ",", "InEpilogue", ")", ";", "if", "(", "isSub", ")", "MI", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "else", "MI", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "Offset", "-=", "ThisVal", ";", "}", "}", "</s>"], "natrual_language": ["Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "."], "TS_V_token": ["M680x0", "M680x0", "0", "1LL", "31", "1", "0", "M680x0::D0", "M680x0::D0", "M680x0::MOV32ri", "3", "0"], "File": "M680x0FrameLowering", "Func": "emitSPUpdate", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23546, "Length": 275}
{"ground_truth": ["<s>", "static", "unsigned", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "M680x0RegisterInfo", "*", "TRI", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", "->", "callsEHReturn", "(", ")", ")", "return", "0", ";", "const", "TargetRegisterClass", "&", "AvailableRegs", "=", "*", "TRI", "->", "getRegsForTailCall", "(", "*", "MF", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "switch", "(", "MBBI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "TargetOpcode", "::", "PATCHABLE_RET", ":", "case", "M680x0", "::", "RET", ":", "{", "SmallSet", "<", "uint16_t", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "Reg", ",", "TRI", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Uses", ".", "insert", "(", "*", "AI", ")", ";", "}", "for", "(", "auto", "CS", ":", "AvailableRegs", ")", "if", "(", "!", "Uses", ".", "count", "(", "CS", ")", ")", "return", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "."], "TS_V_token": ["M680x0", "M680x0", "0", "0", "0", "M680x0::RET", "8", "0", "0"], "File": "M680x0FrameLowering", "Func": "findDeadCallerSavedReg", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23547, "Length": 225}
{"ground_truth": ["<s>", "int", "M680x0FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "FrameReg", "=", "TRI", "->", "getBaseRegister", "(", ")", ";", "else", "if", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "FrameReg", "=", "TRI", "->", "getStackRegister", "(", ")", ";", "else", "FrameReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", ";", "const", "M680x0MachineFunctionInfo", "*", "MMFI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "assert", "(", "HasFP", "&&", "\"VLAs and dynamic stack realign, but no FP?!\"", ")", ";", "if", "(", "FI", "<", "0", ")", "{", "return", "Offset", "+", "SlotSize", ";", "}", "else", "{", "assert", "(", "(", "-", "(", "Offset", "+", "StackSize", ")", ")", "%", "MFI", ".", "getObjectAlignment", "(", "FI", ")", "==", "0", ")", ";", "return", "Offset", "+", "StackSize", ";", "}", "}", "else", "if", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "if", "(", "FI", "<", "0", ")", "{", "return", "Offset", "+", "SlotSize", ";", "}", "else", "{", "assert", "(", "(", "-", "(", "Offset", "+", "StackSize", ")", ")", "%", "MFI", ".", "getObjectAlignment", "(", "FI", ")", "==", "0", ")", ";", "return", "Offset", "+", "StackSize", ";", "}", "}", "else", "{", "if", "(", "!", "HasFP", ")", "return", "Offset", "+", "StackSize", ";", "Offset", "+=", "SlotSize", ";", "int", "TailCallReturnAddrDelta", "=", "MMFI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "TailCallReturnAddrDelta", "<", "0", ")", "Offset", "-=", "TailCallReturnAddrDelta", ";", "}", "return", "Offset", ";", "}", "</s>"], "natrual_language": ["getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "M680x0", "\"VLAs and dynamic stack realign, but no FP?!\"", "0", "0", "0", "0", "0"], "File": "M680x0FrameLowering", "Func": "getFrameIndexReference", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23548, "Length": 274}
{"ground_truth": ["<s>", "bool", "M680x0FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ";", "}", "</s>"], "natrual_language": ["hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0FrameLowering", "Func": "hasFP", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23549, "Length": 68}
{"ground_truth": ["<s>", "bool", "M680x0FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", "&&", "!", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ";", "}", "</s>"], "natrual_language": ["hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0"], "File": "M680x0FrameLowering", "Func": "hasReservedCallFrame", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23550, "Length": 39}
{"ground_truth": ["<s>", "int", "M680x0FrameLowering", "::", "mergeSPUpdates", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "bool", "doMergeWithPrevious", ")", "const", "{", "if", "(", "(", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "begin", "(", ")", ")", "||", "(", "!", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", ")", "return", "0", ";", "MachineBasicBlock", "::", "iterator", "PI", "=", "doMergeWithPrevious", "?", "std", "::", "prev", "(", "MBBI", ")", ":", "MBBI", ";", "MachineBasicBlock", "::", "iterator", "NI", "=", "doMergeWithPrevious", "?", "nullptr", ":", "std", "::", "next", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "int", "Offset", "=", "0", ";", "if", "(", "!", "doMergeWithPrevious", "&&", "NI", "!=", "MBB", ".", "end", "(", ")", "&&", "NI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", "{", "return", "Offset", ";", "}", "if", "(", "Opc", "==", "M680x0", "::", "ADD32ri", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "+=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "else", "if", "(", "Opc", "==", "M680x0", "::", "SUB32ri", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "-=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "return", "Offset", ";", "}", "</s>"], "natrual_language": ["Check", "the", "instruction", "before/after", "the", "passed", "instruction", "."], "TS_V_token": ["M680x0", "M680x0", "0", "0", "M680x0::ADD32ri", "0", "1", "2", "M680x0::SUB32ri", "0", "1", "2"], "File": "M680x0FrameLowering", "Func": "mergeSPUpdates", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23551, "Length": 265}
{"ground_truth": ["<s>", "bool", "M680x0FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "auto", "&", "MRI", "=", "*", "static_cast", "<", "const", "M680x0RegisterInfo", "*", ">", "(", "TRI", ")", ";", "auto", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "FI", "=", "0", ";", "unsigned", "Mask", "=", "0", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "FI", "=", "std", "::", "max", "(", "FI", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "unsigned", "Shift", "=", "MRI", ".", "getSpillRegisterOrder", "(", "Reg", ")", ";", "Mask", "|=", "1", "<<", "Shift", ";", "}", "auto", "I", "=", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "M680x0", "::", "MOVM32mp", ")", ")", ".", "addImm", "(", "Mask", ")", ",", "FI", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "I", ".", "addReg", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ",", "RegState", "::", "ImplicitDefine", ")", ";", "addMemOperand", "(", "I", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "0", ")", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "0", "0", "0", "1", "M680x0::MOVM32mp", "0", "0"], "File": "M680x0FrameLowering", "Func": "restoreCalleeSavedRegisters", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23552, "Length": 227}
{"ground_truth": ["<s>", "bool", "M680x0FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "auto", "&", "MRI", "=", "*", "static_cast", "<", "const", "M680x0RegisterInfo", "*", ">", "(", "TRI", ")", ";", "auto", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "FI", "=", "0", ";", "unsigned", "Mask", "=", "0", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "FI", "=", "std", "::", "max", "(", "FI", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "unsigned", "Shift", "=", "MRI", ".", "getSpillRegisterOrder", "(", "Reg", ")", ";", "Mask", "|=", "1", "<<", "Shift", ";", "}", "auto", "I", "=", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "M680x0", "::", "MOVM32pm", ")", ")", ",", "FI", ")", ".", "addImm", "(", "Mask", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "RI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "isLiveIn", "=", "RI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "isLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "I", ".", "addReg", "(", "Reg", ",", "isLiveIn", "?", "RegState", "::", "Implicit", ":", "RegState", "::", "ImplicitKill", ")", ";", "addMemOperand", "(", "I", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "0", ")", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["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", "(", ")", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "0", "0", "0", "1", "M680x0::MOVM32pm", "0", "0"], "File": "M680x0FrameLowering", "Func": "spillCalleeSavedRegisters", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23553, "Length": 284}
{"ground_truth": ["<s>", "void", "M680x0InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>"], "natrual_language": ["Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0InstPrinter", "Func": "printInst", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23554, "Length": 50}
{"ground_truth": ["<s>", "void", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "int", "opNum", ",", "raw_ostream", "&", "O", ")", "{", "printOperand", "(", "MI", ",", "opNum", ",", "O", ")", ";", "}", "</s>"], "natrual_language": ["value", "(", "e.g", "."], "TS_V_token": ["M680x0"], "File": "M680x0InstPrinter", "Func": "printPCRelImm", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23555, "Length": 26}
{"ground_truth": ["<s>", "void", "M680x0InstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "\"%\"", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ";", "}", "</s>"], "natrual_language": ["Print", "the", "assembler", "register", "name", "."], "TS_V_token": ["M680x0", "M680x0", "\"%\""], "File": "M680x0InstPrinter", "Func": "printRegName", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23556, "Length": 27}
{"ground_truth": ["<s>", "static", "inline", "const", "MachineInstrBuilder", "&", "addMemOperand", "(", "const", "MachineInstrBuilder", "&", "MIB", ",", "int", "FI", ",", "int", "Offset", "=", "0", ")", "{", "MachineInstr", "*", "MI", "=", "MIB", ";", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "auto", "Flags", "=", "MachineMemOperand", "::", "MONone", ";", "if", "(", "MCID", ".", "mayLoad", "(", ")", ")", "Flags", "|=", "MachineMemOperand", "::", "MOLoad", ";", "if", "(", "MCID", ".", "mayStore", "(", ")", ")", "Flags", "|=", "MachineMemOperand", "::", "MOStore", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ",", "Offset", ")", ",", "Flags", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "return", "MIB", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>"], "natrual_language": ["Add", "a", "MachineMemOperand", "to", "the", "machine", "instruction", "."], "TS_V_token": ["M680x0", "0"], "File": "M680x0InstrBuilder", "Func": "addMemOperand", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23557, "Length": 143}
{"ground_truth": ["<s>", "void", "M680x0InstrInfo", "::", "AddSExt", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "Reg", ",", "MVT", "From", ",", "MVT", "To", ")", "const", "{", "if", "(", "From", "==", "MVT", "::", "i8", ")", "{", "unsigned", "R", "=", "Reg", ";", "if", "(", "To", "==", "MVT", "::", "i32", ")", "{", "R", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "M680x0", "::", "MxSubRegIndex16Lo", ")", ";", "assert", "(", "R", "&&", "\"No viable SUB register available\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "M680x0", "::", "EXT16", ")", ",", "R", ")", ".", "addReg", "(", "R", ")", ";", "}", "if", "(", "To", "==", "MVT", "::", "i32", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "M680x0", "::", "EXT32", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ")", ";", "}", "}", "</s>"], "natrual_language": ["Add", "appropriate", "SExt", "nodes", "."], "TS_V_token": ["M680x0", "M680x0", "MVT::i8", "MVT::i32", "M680x0::MxSubRegIndex16Lo", "\"No viable SUB register available\"", "M680x0::EXT16", "MVT::i32", "M680x0::EXT32"], "File": "M680x0InstrInfo", "Func": "AddSExt", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23558, "Length": 130}
{"ground_truth": ["<s>", "void", "M680x0InstrInfo", "::", "AddZExt", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "Reg", ",", "MVT", "From", ",", "MVT", "To", ")", "const", "{", "unsigned", "Mask", ",", "And", ";", "if", "(", "From", "==", "MVT", "::", "i8", ")", "{", "Mask", "=", "0xFF", ";", "}", "else", "{", "Mask", "=", "0xFFFF", ";", "}", "if", "(", "To", "==", "MVT", "::", "i16", ")", "{", "And", "=", "M680x0", "::", "AND16di", ";", "}", "else", "{", "And", "=", "M680x0", "::", "AND32di", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "And", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ")", ".", "addImm", "(", "Mask", ")", ";", "}", "</s>"], "natrual_language": ["Add", "appropriate", "ZExt", "nodes", "."], "TS_V_token": ["M680x0", "M680x0", "MVT::i8", "0xFF", "0xFFFF", "MVT::i16", "M680x0::AND16di", "M680x0::AND32di"], "File": "M680x0InstrInfo", "Func": "AddZExt", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23559, "Length": 106}
{"ground_truth": ["<s>", "bool", "M680x0InstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "return", "AnalyzeBranchImpl", "(", "MBB", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ";", "}", "</s>"], "natrual_language": ["analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0InstrInfo", "Func": "analyzeBranch", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23560, "Length": 46}
{"ground_truth": ["<s>", "void", "M680x0InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DstReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", "=", "0", ";", "if", "(", "M680x0", "::", "XR32RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "M680x0", "::", "MOV32rr", ";", "else", "if", "(", "M680x0", "::", "XR16RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "M680x0", "::", "MOV16rr", ";", "else", "if", "(", "M680x0", "::", "DR8RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "M680x0", "::", "MOV8dd", ";", "}", "if", "(", "Opc", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "MachineInstrBuilder", "MIB", "(", "*", "MBB", ".", "getParent", "(", ")", ",", "MI", ")", ";", "if", "(", "M680x0", "::", "DR8RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "M680x0", "::", "XR16RegClass", ".", "contains", "(", "DstReg", ")", ")", "{", "Opc", "=", "M680x0", "::", "MOVXd16d8", ";", "}", "else", "if", "(", "M680x0", "::", "XR32RegClass", ".", "contains", "(", "DstReg", ")", ")", "{", "Opc", "=", "M680x0", "::", "MOVXd32d8", ";", "}", "}", "else", "if", "(", "M680x0", "::", "XR16RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "M680x0", "::", "XR32RegClass", ".", "contains", "(", "DstReg", ")", ")", "{", "Opc", "=", "M680x0", "::", "MOVXd32d16", ";", "}", "}", "if", "(", "Opc", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "bool", "FromCCR", "=", "SrcReg", "==", "M680x0", "::", "CCR", ";", "bool", "FromSR", "=", "SrcReg", "==", "M680x0", "::", "SR", ";", "bool", "ToCCR", "=", "DstReg", "==", "M680x0", "::", "CCR", ";", "bool", "ToSR", "=", "DstReg", "==", "M680x0", "::", "SR", ";", "if", "(", "FromCCR", ")", "{", "assert", "(", "M680x0", "::", "DR8RegClass", ".", "contains", "(", "DstReg", ")", "&&", "\"Need DR8 register to copy CCR\"", ")", ";", "Opc", "=", "M680x0", "::", "MOV8dc", ";", "}", "else", "if", "(", "ToCCR", ")", "{", "assert", "(", "M680x0", "::", "DR8RegClass", ".", "contains", "(", "SrcReg", ")", "&&", "\"Need DR8 register to copy CCR\"", ")", ";", "Opc", "=", "M680x0", "::", "MOV8cd", ";", "}", "else", "if", "(", "FromSR", "||", "ToSR", ")", "{", "llvm_unreachable", "(", "\"Cannot emit SR copy instruction\"", ")", ";", "}", "if", "(", "Opc", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cannot copy \"", "<<", "RI", ".", "getName", "(", "SrcReg", ")", "<<", "\" to \"", "<<", "RI", ".", "getName", "(", "DstReg", ")", "<<", "'\\n'", ")", ";", "llvm_unreachable", "(", "\"Cannot emit physreg copy instruction\"", ")", ";", "}", "</s>"], "natrual_language": ["}", "Branch", "Analysis", "&", "Modification"], "TS_V_token": ["M680x0", "M680x0", "0", "M680x0::XR32RegClass", "M680x0::MOV32rr", "M680x0::XR16RegClass", "M680x0::MOV16rr", "M680x0::DR8RegClass", "M680x0::MOV8dd", "M680x0::DR8RegClass", "M680x0::XR16RegClass", "M680x0::MOVXd16d8", "M680x0::XR32RegClass", "M680x0::MOVXd32d8", "M680x0::XR16RegClass", "M680x0::XR32RegClass", "M680x0::MOVXd32d16", "M680x0::CCR", "M680x0::SR", "M680x0::CCR", "M680x0::SR", "M680x0::DR8RegClass", "\"Need DR8 register to copy CCR\"", "M680x0::MOV8dc", "M680x0::DR8RegClass", "\"Need DR8 register to copy CCR\"", "M680x0::MOV8cd", "\"Cannot emit SR copy instruction\"", "\"Cannot copy \"", "\" to \"", "\"Cannot emit physreg copy instruction\""], "File": "M680x0InstrInfo", "Func": "copyPhysReg", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23561, "Length": 432}
{"ground_truth": ["<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "M680x0InstrInfo", "::", "decomposeMachineOperandsTargetFlags", "(", "unsigned", "TF", ")", "const", "{", "return", "std", "::", "make_pair", "(", "TF", ",", "0u", ")", ";", "}", "</s>"], "natrual_language": ["Decompose", "the", "machine", "operand", "'s", "target", "flags", "into", "two", "values", "-", "the", "direct", "target", "flag", "value", "and", "any", "of", "bit", "flags", "that", "are", "applied", "."], "TS_V_token": ["M680x0", "M680x0", "0u"], "File": "M680x0InstrInfo", "Func": "decomposeMachineOperandsTargetFlags", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23562, "Length": 28}
{"ground_truth": ["<s>", "bool", "M680x0InstrInfo", "::", "ExpandCCR", "(", "MachineInstrBuilder", "&", "MIB", ",", "bool", "isToCCR", ")", "const", "{", "if", "(", "isToCCR", ")", "{", "MIB", "->", "setDesc", "(", "get", "(", "M680x0", "::", "MOV16cd", ")", ")", ";", "}", "else", "{", "MIB", "->", "setDesc", "(", "get", "(", "M680x0", "::", "MOV16dc", ")", ")", ";", "}", "auto", "&", "Opd", "=", "MIB", "->", "getOperand", "(", "1", ")", ";", "Opd", ".", "setReg", "(", "getRegisterInfo", "(", ")", ".", "getMatchingSuperReg", "(", "Opd", ".", "getReg", "(", ")", ",", "M680x0", "::", "MxSubRegIndex8Lo", ",", "&", "M680x0", "::", "DR16RegClass", ")", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Moves", "to/from", "CCR", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0::MOV16cd", "M680x0::MOV16dc", "1", "M680x0::MxSubRegIndex8Lo", "M680x0::DR16RegClass"], "File": "M680x0InstrInfo", "Func": "ExpandCCR", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23563, "Length": 89}
{"ground_truth": ["<s>", "bool", "M680x0InstrInfo", "::", "ExpandMOVEM", "(", "MachineInstrBuilder", "&", "MIB", ",", "const", "MCInstrDesc", "&", "Desc", ",", "bool", "isRM", ")", "const", "{", "int", "Reg", "=", "0", ",", "Offset", "=", "0", ",", "Base", "=", "0", ";", "auto", "XR32", "=", "RI", ".", "getRegClass", "(", "M680x0", "::", "XR32RegClassID", ")", ";", "auto", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "auto", "MI", "=", "MIB", ".", "getInstr", "(", ")", ";", "auto", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "if", "(", "isRM", ")", "{", "Reg", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "MIB", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Base", "=", "MIB", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "else", "{", "Offset", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Base", "=", "MIB", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Reg", "=", "MIB", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "if", "(", "!", "XR32", "->", "contains", "(", "Reg", ")", ")", "{", "Reg", "=", "RI", ".", "getMatchingMegaReg", "(", "Reg", ",", "XR32", ")", ";", "assert", "(", "Reg", "&&", "\"Has not meaningful MEGA register\"", ")", ";", "}", "unsigned", "Mask", "=", "1", "<<", "RI", ".", "getSpillRegisterOrder", "(", "Reg", ")", ";", "if", "(", "isRM", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "Desc", ")", ".", "addImm", "(", "Mask", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "Base", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ".", "copyImplicitOps", "(", "*", "MIB", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "Desc", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "Base", ")", ".", "addImm", "(", "Mask", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Implicit", ")", ".", "copyImplicitOps", "(", "*", "MIB", ")", ";", "}", "MIB", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Expand", "all", "MOVEM", "pseudos", "into", "real", "MOVEMs", "."], "TS_V_token": ["M680x0", "M680x0", "0", "0", "0", "M680x0::XR32RegClassID", "0", "1", "2", "0", "1", "2", "\"Has not meaningful MEGA register\"", "1"], "File": "M680x0InstrInfo", "Func": "ExpandMOVEM", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23564, "Length": 303}
{"ground_truth": ["<s>", "bool", "M680x0InstrInfo", "::", "ExpandMOVSZX_RM", "(", "MachineInstrBuilder", "&", "MIB", ",", "bool", "isSigned", ",", "const", "MCInstrDesc", "&", "Desc", ",", "MVT", "MVTDst", ",", "MVT", "MVTSrc", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Expand \"", "<<", "*", "MIB", ".", "getInstr", "(", ")", "<<", "\" to LOAD and \"", ")", ";", "unsigned", "Dst", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "SubDst", "=", "RI", ".", "getSubReg", "(", "Dst", ",", "MVTSrc", "==", "MVT", "::", "i8", "?", "M680x0", "::", "MxSubRegIndex8Lo", ":", "M680x0", "::", "MxSubRegIndex16Lo", ")", ";", "assert", "(", "SubDst", "&&", "\"No viable SUB register available\"", ")", ";", "MIB", "->", "setDesc", "(", "Desc", ")", ";", "MIB", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "SubDst", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MIB", ".", "getInstr", "(", ")", ";", "I", "++", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isSigned", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Sign Extend\"", "<<", "'\\n'", ")", ";", "AddSExt", "(", "MBB", ",", "I", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Zero Extend\"", "<<", "'\\n'", ")", ";", "AddZExt", "(", "MBB", ",", "I", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Move", "from", "memory", "and", "extend", "."], "TS_V_token": ["M680x0", "M680x0", "\"Expand \"", "\" to LOAD and \"", "0", "MVT::i8", "M680x0::MxSubRegIndex8Lo", "M680x0::MxSubRegIndex16Lo", "\"No viable SUB register available\"", "0", "\"Sign Extend\"", "\"Zero Extend\""], "File": "M680x0InstrInfo", "Func": "ExpandMOVSZX_RM", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23565, "Length": 206}
{"ground_truth": ["<s>", "bool", "M680x0InstrInfo", "::", "ExpandMOVSZX_RR", "(", "MachineInstrBuilder", "&", "MIB", ",", "bool", "isSigned", ",", "MVT", "MVTDst", ",", "MVT", "MVTSrc", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Expand \"", "<<", "*", "MIB", ".", "getInstr", "(", ")", "<<", "\" to \"", ")", ";", "unsigned", "Move", ";", "if", "(", "MVTDst", "==", "MVT", "::", "i16", ")", "{", "Move", "=", "M680x0", "::", "MOV16rr", ";", "}", "else", "{", "Move", "=", "M680x0", "::", "MOV32rr", ";", "}", "unsigned", "Dst", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Src", "=", "MIB", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "assert", "(", "Dst", "!=", "Src", "&&", "\"You cannot use the same Regs with MOVSX_RR\"", ")", ";", "auto", "TRI", "=", "getRegisterInfo", "(", ")", ";", "auto", "RCDst", "=", "TRI", ".", "getMaximalPhysRegClass", "(", "Dst", ",", "MVTDst", ")", ";", "auto", "RCSrc", "=", "TRI", ".", "getMaximalPhysRegClass", "(", "Src", ",", "MVTSrc", ")", ";", "assert", "(", "RCDst", "&&", "RCSrc", "&&", "\"Wrong use of MOVSX_RR\"", ")", ";", "assert", "(", "RCDst", "!=", "RCSrc", "&&", "\"You cannot use the same Reg Classes with MOVSX_RR\"", ")", ";", "unsigned", "SSrc", "=", "RI", ".", "getMatchingMegaReg", "(", "Src", ",", "RCDst", ")", ";", "assert", "(", "SSrc", "&&", "\"No viable MEGA register available\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "if", "(", "Dst", "!=", "SSrc", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Move and \"", "<<", "'\\n'", ")", ";", "BuildMI", "(", "MBB", ",", "MIB", ".", "getInstr", "(", ")", ",", "DL", ",", "get", "(", "Move", ")", ",", "Dst", ")", ".", "addReg", "(", "SSrc", ")", ";", "}", "if", "(", "isSigned", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Sign Extend\"", "<<", "'\\n'", ")", ";", "AddSExt", "(", "MBB", ",", "MIB", ".", "getInstr", "(", ")", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Zero Extend\"", "<<", "'\\n'", ")", ";", "AddZExt", "(", "MBB", ",", "MIB", ".", "getInstr", "(", ")", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "MIB", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Move", "from", "register", "and", "extend", "."], "TS_V_token": ["M680x0", "M680x0", "\"Expand \"", "\" to \"", "MVT::i16", "M680x0::MOV16rr", "M680x0::MOV32rr", "0", "1", "\"You cannot use the same Regs with MOVSX_RR\"", "\"Wrong use of MOVSX_RR\"", "\"You cannot use the same Reg Classes with MOVSX_RR\"", "\"No viable MEGA register available\"", "\"Move and \"", "\"Sign Extend\"", "\"Zero Extend\""], "File": "M680x0InstrInfo", "Func": "ExpandMOVSZX_RR", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23566, "Length": 314}
{"ground_truth": ["<s>", "bool", "M680x0InstrInfo", "::", "ExpandMOVX_RR", "(", "MachineInstrBuilder", "&", "MIB", ",", "MVT", "MVTDst", ",", "MVT", "MVTSrc", ")", "const", "{", "unsigned", "SubIdx", ";", "unsigned", "Move", "=", "MVTDst", "==", "MVT", "::", "i16", "?", "M680x0", "::", "MOV16rr", ":", "M680x0", "::", "MOV32rr", ";", "if", "(", "MVTSrc", "==", "MVT", "::", "i8", ")", "{", "SubIdx", "=", "M680x0", "::", "MxSubRegIndex8Lo", ";", "}", "else", "{", "SubIdx", "=", "M680x0", "::", "MxSubRegIndex16Lo", ";", "}", "unsigned", "Dst", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Src", "=", "MIB", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "assert", "(", "Dst", "!=", "Src", "&&", "\"You cannot use the same Regs with MOVX_RR\"", ")", ";", "auto", "TRI", "=", "getRegisterInfo", "(", ")", ";", "auto", "RCDst", "=", "TRI", ".", "getMaximalPhysRegClass", "(", "Dst", ",", "MVTDst", ")", ";", "auto", "RCSrc", "=", "TRI", ".", "getMaximalPhysRegClass", "(", "Src", ",", "MVTSrc", ")", ";", "assert", "(", "RCDst", "&&", "RCSrc", "&&", "\"Wrong use of MOVX_RR\"", ")", ";", "assert", "(", "RCDst", "!=", "RCSrc", "&&", "\"You cannot use the same Reg Classes with MOVX_RR\"", ")", ";", "unsigned", "SSrc", "=", "RI", ".", "getMatchingMegaReg", "(", "Src", ",", "RCDst", ")", ";", "assert", "(", "SSrc", "&&", "\"No viable MEGA register available\"", ")", ";", "DebugLoc", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "if", "(", "Dst", "==", "SSrc", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Remove \"", "<<", "*", "MIB", ".", "getInstr", "(", ")", "<<", "'\\n'", ")", ";", "MIB", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Expand \"", "<<", "*", "MIB", ".", "getInstr", "(", ")", "<<", "\" to MOV\\n\"", ")", ";", "MIB", "->", "setDesc", "(", "get", "(", "Move", ")", ")", ";", "MIB", "->", "getOperand", "(", "1", ")", ".", "setReg", "(", "SSrc", ")", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Move", "across", "register", "classes", "without", "extension", "."], "TS_V_token": ["M680x0", "M680x0", "MVT::i16", "M680x0::MOV16rr", "M680x0::MOV32rr", "MVT::i8", "M680x0::MxSubRegIndex8Lo", "M680x0::MxSubRegIndex16Lo", "0", "1", "\"You cannot use the same Regs with MOVX_RR\"", "\"Wrong use of MOVX_RR\"", "\"You cannot use the same Reg Classes with MOVX_RR\"", "\"No viable MEGA register available\"", "\"Remove \"", "\"Expand \"", "\" to MOV\\n\"", "1"], "File": "M680x0InstrInfo", "Func": "ExpandMOVX_RR", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23567, "Length": 255}
{"ground_truth": ["<s>", "bool", "M680x0InstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "MachineInstrBuilder", "MIB", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "M680x0", "::", "PUSH8d", ":", "return", "ExpandPUSH_POP", "(", "MIB", ",", "get", "(", "M680x0", "::", "MOV8ed", ")", ",", "true", ")", ";", "case", "M680x0", "::", "PUSH16d", ":", "return", "ExpandPUSH_POP", "(", "MIB", ",", "get", "(", "M680x0", "::", "MOV16er", ")", ",", "true", ")", ";", "case", "M680x0", "::", "PUSH32r", ":", "return", "ExpandPUSH_POP", "(", "MIB", ",", "get", "(", "M680x0", "::", "MOV32er", ")", ",", "true", ")", ";", "case", "M680x0", "::", "POP8d", ":", "return", "ExpandPUSH_POP", "(", "MIB", ",", "get", "(", "M680x0", "::", "MOV8do", ")", ",", "false", ")", ";", "case", "M680x0", "::", "POP16d", ":", "return", "ExpandPUSH_POP", "(", "MIB", ",", "get", "(", "M680x0", "::", "MOV16ro", ")", ",", "false", ")", ";", "case", "M680x0", "::", "POP32r", ":", "return", "ExpandPUSH_POP", "(", "MIB", ",", "get", "(", "M680x0", "::", "MOV32ro", ")", ",", "false", ")", ";", "case", "M680x0", "::", "SETCS_C8d", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "M680x0", "::", "SUBX8dd", ")", ")", ";", "case", "M680x0", "::", "SETCS_C16d", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "M680x0", "::", "SUBX16dd", ")", ")", ";", "case", "M680x0", "::", "SETCS_C32d", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "M680x0", "::", "SUBX32dd", ")", ")", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0::PUSH8d", "M680x0::MOV8ed", "M680x0::PUSH16d", "M680x0::MOV16er", "M680x0::PUSH32r", "M680x0::MOV32er", "M680x0::POP8d", "M680x0::MOV8do", "M680x0::POP16d", "M680x0::MOV16ro", "M680x0::POP32r", "M680x0::MOV32ro", "M680x0::SETCS_C8d", "M680x0::SUBX8dd", "M680x0::SETCS_C16d", "M680x0::SUBX16dd", "M680x0::SETCS_C32d", "M680x0::SUBX32dd"], "File": "M680x0InstrInfo", "Func": "expandPostRAPseudo", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23568, "Length": 216}
{"ground_truth": ["<s>", "bool", "M680x0InstrInfo", "::", "ExpandPUSH_POP", "(", "MachineInstrBuilder", "&", "MIB", ",", "const", "MCInstrDesc", "&", "Desc", ",", "bool", "isPush", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MIB", ".", "getInstr", "(", ")", ";", "I", "++", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "MachineOperand", "MO", "=", "MIB", "->", "getOperand", "(", "0", ")", ";", "DebugLoc", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isPush", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "Desc", ")", ".", "addReg", "(", "RI", ".", "getStackRegister", "(", ")", ")", ".", "add", "(", "MO", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "Desc", ",", "MO", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "RI", ".", "getStackRegister", "(", ")", ")", ";", "}", "MIB", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Push/Pop", "to/from", "stack", "."], "TS_V_token": ["M680x0", "M680x0", "0"], "File": "M680x0InstrInfo", "Func": "ExpandPUSH_POP", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23569, "Length": 133}
{"ground_truth": ["<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>"], "natrual_language": ["getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "."], "TS_V_token": ["M680x0"], "File": "M680x0InstrInfo", "Func": "getAnalysisUsage", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23570, "Length": 24}
{"ground_truth": ["<s>", "unsigned", "M680x0InstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "M680x0MachineFunctionInfo", "*", "MxFI", "=", "MF", "->", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "MxFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "M680x0", "::", "AR32_NOSPRegClass", ")", ";", "MxFI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>"], "natrual_language": ["getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "M680x0", "0", "M680x0::AR32_NOSPRegClass"], "File": "M680x0InstrInfo", "Func": "getGlobalBaseReg", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23571, "Length": 75}
{"ground_truth": ["<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"M680x0 PIC Global Base Reg Initialization\"", ";", "}", "</s>"], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["M680x0", "\"M680x0 PIC Global Base Reg Initialization\""], "File": "M680x0InstrInfo", "Func": "getPassName", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23572, "Length": 11}
{"ground_truth": ["<s>", "const", "M680x0RegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>"], "natrual_language": ["getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0InstrInfo", "Func": "getRegisterInfo", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23573, "Length": 12}
{"ground_truth": ["<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "M680x0InstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "M680x0II", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_ABSOLUTE_ADDRESS", ",", "\"M680x0-absolute\"", "}", ",", "{", "MO_PC_RELATIVE_ADDRESS", ",", "\"M680x0-pcrel\"", "}", ",", "{", "MO_GOT", ",", "\"M680x0-got\"", "}", ",", "{", "MO_GOTOFF", ",", "\"M680x0-gotoff\"", "}", ",", "{", "MO_GOTPCREL", ",", "\"M680x0-gotpcrel\"", "}", ",", "{", "MO_PLT", ",", "\"M680x0-plt\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>"], "natrual_language": ["Return", "an", "array", "that", "contains", "the", "direct", "target", "flag", "values", "and", "their", "names", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "\"M680x0-absolute\"", "\"M680x0-pcrel\"", "\"M680x0-got\"", "\"M680x0-gotoff\"", "\"M680x0-gotpcrel\"", "\"M680x0-plt\""], "File": "M680x0InstrInfo", "Func": "getSerializableDirectMachineOperandTargetFlags", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23574, "Length": 84}
{"ground_truth": ["<s>", "bool", "M680x0InstrInfo", "::", "getStackSlotRange", "(", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "SubIdx", ",", "unsigned", "&", "Size", ",", "unsigned", "&", "Offset", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "Size", "=", "4", ";", "Offset", "=", "0", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Compute", "the", "size", "in", "bytes", "and", "offset", "within", "a", "stack", "slot", "of", "a", "spilled", "register", "or", "subregister", "."], "TS_V_token": ["M680x0", "M680x0", "4", "0"], "File": "M680x0InstrInfo", "Func": "getStackSlotRange", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23575, "Length": 40}
{"ground_truth": ["<s>", "unsigned", "M680x0InstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"InsertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "1", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"M680x0 branch conditions have one component!\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "M680x0", "::", "BRA8", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "bool", "FallThru", "=", "FBB", "==", "nullptr", ";", "unsigned", "Count", "=", "0", ";", "M680x0", "::", "CondCode", "CC", "=", "(", "M680x0", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "Opc", "=", "GetCondBranchFromCond", "(", "CC", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "++", "Count", ";", "if", "(", "!", "FallThru", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "M680x0", "::", "BRA8", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>"], "natrual_language": ["Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "."], "TS_V_token": ["M680x0", "M680x0", "\"InsertBranch must not be told to insert a fallthrough\"", "1", "0", "\"M680x0 branch conditions have one component!\"", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "M680x0::BRA8", "1", "0", "M680x0::CondCode", "M680x0::CondCode", "0", "M680x0::BRA8"], "File": "M680x0InstrInfo", "Func": "insertBranch", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23576, "Length": 207}
{"ground_truth": ["<s>", "void", "M680x0InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DstReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "assert", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIndex", ")", "==", "4", "&&", "\"Stack slot too small for store\"", ")", ";", "unsigned", "Opc", "=", "getLoadRegOpcode", "(", "DstReg", ",", "RC", ",", "TRI", ",", "Subtarget", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ",", "FrameIndex", ")", ";", "}", "</s>"], "natrual_language": ["Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "."], "TS_V_token": ["M680x0", "M680x0", "4", "\"Stack slot too small for store\""], "File": "M680x0InstrInfo", "Func": "loadRegFromStackSlot", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23577, "Length": 108}
{"ground_truth": ["<s>", "unsigned", "M680x0InstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "M680x0", "::", "BRA8", "&&", "getCondFromBranchOpc", "(", "I", "->", "getOpcode", "(", ")", ")", "==", "M680x0", "::", "COND_INVALID", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>"], "natrual_language": ["Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "."], "TS_V_token": ["M680x0", "M680x0", "\"code size not handled\"", "0", "M680x0::BRA8", "M680x0::COND_INVALID"], "File": "M680x0InstrInfo", "Func": "removeBranch", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23578, "Length": 112}
{"ground_truth": ["<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "M680x0Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "M680x0Subtarget", ">", "(", ")", ";", "M680x0MachineFunctionInfo", "*", "MxFI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "MxFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "==", "0", ")", "return", "false", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "FirstMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "const", "M680x0InstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "M680x0", "::", "LEA32q", ")", ",", "GlobalBaseReg", ")", ".", "addExternalSymbol", "(", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "M680x0II", "::", "MO_GOTPCREL", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "M680x0", "M680x0", "0", "M680x0", "M680x0::LEA32q", "\"_GLOBAL_OFFSET_TABLE_\"", "M680x0II::MO_GOTPCREL"], "File": "M680x0InstrInfo", "Func": "runOnMachineFunction", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23579, "Length": 129}
{"ground_truth": ["<s>", "void", "M680x0InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "assert", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIndex", ")", "==", "4", "&&", "\"Stack slot too small for store\"", ")", ";", "unsigned", "Opc", "=", "getStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "TRI", ",", "Subtarget", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ",", "FrameIndex", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>"], "natrual_language": ["Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "."], "TS_V_token": ["M680x0", "M680x0", "4", "\"Stack slot too small for store\""], "File": "M680x0InstrInfo", "Func": "storeRegToStackSlot", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23580, "Length": 119}
{"ground_truth": ["<s>", "void", "dump", "(", ")", "{", "dbgs", "(", ")", "<<", "\"M680x0ISelAddressMode \"", "<<", "this", ";", "dbgs", "(", ")", "<<", "\"\\nDisp: \"", "<<", "Disp", ";", "dbgs", "(", ")", "<<", "\", BaseReg: \"", ";", "if", "(", "BaseReg", ".", "getNode", "(", ")", ")", "BaseReg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"null\"", ";", "dbgs", "(", ")", "<<", "\", BaseFI: \"", "<<", "BaseFrameIndex", ";", "dbgs", "(", ")", "<<", "\", IndexReg: \"", ";", "if", "(", "IndexReg", ".", "getNode", "(", ")", ")", "{", "IndexReg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"null\"", ";", "dbgs", "(", ")", "<<", "\", Scale: \"", "<<", "Scale", ";", "}", "dbgs", "(", ")", "<<", "'\\n'", ";", "}", "</s>"], "natrual_language": ["Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "."], "TS_V_token": ["M680x0", "\"M680x0ISelAddressMode \"", "\"\\nDisp: \"", "\", BaseReg: \"", "\"null\"", "\", BaseFI: \"", "\", IndexReg: \"", "\"null\"", "\", Scale: \""], "File": "M680x0ISelDAGToDAG", "Func": "dump", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23581, "Length": 110}
{"ground_truth": ["<s>", "SDNode", "*", "M680x0DAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "auto", "&", "DL", "=", "MF", "->", "getDataLayout", "(", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", "->", "getPointerTy", "(", "DL", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>"], "natrual_language": ["getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0ISelDAGToDAG", "Func": "getGlobalBaseReg", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23582, "Length": 50}
{"ground_truth": ["<s>", "const", "M680x0InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "}", "</s>"], "natrual_language": ["TargetInstrInfo", "getter", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0ISelDAGToDAG", "Func": "getInstrInfo", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23583, "Length": 16}
{"ground_truth": ["<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"M680X0 DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>"], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["M680x0", "\"M680X0 DAG->DAG Pattern Instruction Selection\""], "File": "M680x0ISelDAGToDAG", "Func": "getPassName", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23584, "Length": 11}
{"ground_truth": ["<s>", "const", "M680x0TargetMachine", "&", "getTargetMachine", "(", ")", "{", "return", "static_cast", "<", "const", "M680x0TargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "target", "machine", "(", "if", "available", ")", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0"], "File": "M680x0ISelDAGToDAG", "Func": "getTargetMachine", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23585, "Length": 19}
{"ground_truth": ["<s>", "bool", "M680x0DAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "static_cast", "<", "const", "M680x0Subtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0"], "File": "M680x0ISelDAGToDAG", "Func": "runOnMachineFunction", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23586, "Length": 36}
{"ground_truth": ["<s>", "void", "M680x0DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "SDLoc", "DL", "(", "Node", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "M680x0ISD", "::", "GlobalBaseReg", ":", "ReplaceNode", "(", "Node", ",", "getGlobalBaseReg", "(", ")", ")", ";", "return", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>"], "natrual_language": ["Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "."], "TS_V_token": ["M680x0", "M680x0", "\"Selecting: \"", "\"== \"", "1", "M680x0ISD::GlobalBaseReg"], "File": "M680x0ISelDAGToDAG", "Func": "Select", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23587, "Length": 121}
{"ground_truth": ["<s>", "MachineBasicBlock", "*", "M680x0TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "M680x0", "::", "CMOV8d", ":", "case", "M680x0", "::", "CMOV16d", ":", "case", "M680x0", "::", "CMOV32r", ":", "return", "EmitLoweredSelect", "(", "MI", ",", "BB", ")", ";", "case", "M680x0", "::", "SALLOCA", ":", "return", "EmitLoweredSegAlloca", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>"], "natrual_language": ["This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "."], "TS_V_token": ["M680x0", "M680x0", "\"Unexpected instr type to insert\"", "M680x0::CMOV8d", "M680x0::CMOV16d", "M680x0::CMOV32r", "M680x0::SALLOCA"], "File": "M680x0ISelLowering", "Func": "EmitInstrWithCustomInserter", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23588, "Length": 70}
{"ground_truth": ["<s>", "unsigned", "M680x0TargetLowering", "::", "getJumpTableEncoding", "(", ")", "const", "{", "return", "Subtarget", ".", "getJumpTableEncoding", "(", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0ISelLowering", "Func": "getJumpTableEncoding", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23589, "Length": 16}
{"ground_truth": ["<s>", "SDValue", "M680x0TargetLowering", "::", "getPICJumpTableRelocBase", "(", "SDValue", "Table", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "getJumpTableEncoding", "(", ")", "==", "MachineJumpTableInfo", "::", "EK_Custom32", ")", "return", "DAG", ".", "getNode", "(", "M680x0ISD", "::", "GlobalBaseReg", ",", "SDLoc", "(", ")", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "return", "Table", ";", "}", "</s>"], "natrual_language": ["Returns", "relocation", "base", "for", "the", "given", "PIC", "jumptable", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0ISD::GlobalBaseReg"], "File": "M680x0ISelLowering", "Func": "getPICJumpTableRelocBase", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23590, "Length": 51}
{"ground_truth": ["<s>", "const", "MCExpr", "*", "M680x0TargetLowering", "::", "getPICJumpTableRelocBaseExpr", "(", "const", "MachineFunction", "*", "MF", ",", "unsigned", "JTI", ",", "MCContext", "&", "Ctx", ")", "const", "{", "return", "MCSymbolRefExpr", "::", "create", "(", "MF", "->", "getJTISymbol", "(", "JTI", ",", "Ctx", ")", ",", "Ctx", ")", ";", "}", "</s>"], "natrual_language": ["This", "returns", "the", "relocation", "base", "for", "the", "given", "PIC", "jumptable", ",", "the", "same", "as", "getPICJumpTableRelocBase", ",", "but", "as", "an", "MCExpr", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0ISelLowering", "Func": "getPICJumpTableRelocBaseExpr", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23591, "Length": 39}
{"ground_truth": ["<s>", "MVT", "M680x0TargetLowering", "::", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", "DL", ",", "EVT", "Ty", ")", "const", "{", "if", "(", "Ty", ".", "isSimple", "(", ")", ")", "{", "return", "Ty", ".", "getSimpleVT", "(", ")", ";", "}", "return", "MVT", "::", "getIntegerVT", "(", "8", "*", "DL", ".", "getPointerSize", "(", "0", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "."], "TS_V_token": ["M680x0", "M680x0", "MVT::getIntegerVT", "8", "0"], "File": "M680x0ISelLowering", "Func": "getScalarShiftAmountTy", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23592, "Length": 48}
{"ground_truth": ["<s>", "EVT", "M680x0TargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i8", ";", "}", "</s>"], "natrual_language": ["Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "."], "TS_V_token": ["M680x0", "M680x0", "MVT::i8"], "File": "M680x0ISelLowering", "Func": "getSetCCResultType", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23593, "Length": 25}
{"ground_truth": ["<s>", "const", "char", "*", "M680x0TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "M680x0ISD", "::", "CALL", ":", "return", "\"M680x0ISD::CALL\"", ";", "case", "M680x0ISD", "::", "TAIL_CALL", ":", "return", "\"M680x0ISD::TAIL_CALL\"", ";", "case", "M680x0ISD", "::", "RET", ":", "return", "\"M680x0ISD::RET\"", ";", "case", "M680x0ISD", "::", "TC_RETURN", ":", "return", "\"M680x0ISD::TC_RETURN\"", ";", "case", "M680x0ISD", "::", "ADD", ":", "return", "\"M680x0ISD::ADD\"", ";", "case", "M680x0ISD", "::", "SUB", ":", "return", "\"M680x0ISD::SUB\"", ";", "case", "M680x0ISD", "::", "ADDX", ":", "return", "\"M680x0ISD::ADDX\"", ";", "case", "M680x0ISD", "::", "SUBX", ":", "return", "\"M680x0ISD::SUBX\"", ";", "case", "M680x0ISD", "::", "SMUL", ":", "return", "\"M680x0ISD::SMUL\"", ";", "case", "M680x0ISD", "::", "UMUL", ":", "return", "\"M680x0ISD::UMUL\"", ";", "case", "M680x0ISD", "::", "OR", ":", "return", "\"M680x0ISD::OR\"", ";", "case", "M680x0ISD", "::", "XOR", ":", "return", "\"M680x0ISD::XOR\"", ";", "case", "M680x0ISD", "::", "AND", ":", "return", "\"M680x0ISD::AND\"", ";", "case", "M680x0ISD", "::", "CMP", ":", "return", "\"M680x0ISD::CMP\"", ";", "case", "M680x0ISD", "::", "BT", ":", "return", "\"M680x0ISD::BT\"", ";", "case", "M680x0ISD", "::", "SELECT", ":", "return", "\"M680x0ISD::SELECT\"", ";", "case", "M680x0ISD", "::", "CMOV", ":", "return", "\"M680x0ISD::CMOV\"", ";", "case", "M680x0ISD", "::", "BRCOND", ":", "return", "\"M680x0ISD::BRCOND\"", ";", "case", "M680x0ISD", "::", "SETCC", ":", "return", "\"M680x0ISD::SETCC\"", ";", "case", "M680x0ISD", "::", "SETCC_CARRY", ":", "return", "\"M680x0ISD::SETCC_CARRY\"", ";", "case", "M680x0ISD", "::", "GlobalBaseReg", ":", "return", "\"M680x0ISD::GlobalBaseReg\"", ";", "case", "M680x0ISD", "::", "Wrapper", ":", "return", "\"M680x0ISD::Wrapper\"", ";", "case", "M680x0ISD", "::", "WrapperPC", ":", "return", "\"M680x0ISD::WrapperPC\"", ";", "case", "M680x0ISD", "::", "SEG_ALLOCA", ":", "return", "\"M680x0ISD::SEG_ALLOCA\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>"], "natrual_language": ["getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific"], "TS_V_token": ["M680x0", "M680x0", "M680x0ISD::CALL", "\"M680x0ISD::CALL\"", "M680x0ISD::TAIL_CALL", "\"M680x0ISD::TAIL_CALL\"", "M680x0ISD::RET", "\"M680x0ISD::RET\"", "M680x0ISD::TC_RETURN", "\"M680x0ISD::TC_RETURN\"", "M680x0ISD::ADD", "\"M680x0ISD::ADD\"", "M680x0ISD::SUB", "\"M680x0ISD::SUB\"", "M680x0ISD::ADDX", "\"M680x0ISD::ADDX\"", "M680x0ISD::SUBX", "\"M680x0ISD::SUBX\"", "M680x0ISD::SMUL", "\"M680x0ISD::SMUL\"", "M680x0ISD::UMUL", "\"M680x0ISD::UMUL\"", "M680x0ISD::OR", "\"M680x0ISD::OR\"", "M680x0ISD::XOR", "\"M680x0ISD::XOR\"", "M680x0ISD::AND", "\"M680x0ISD::AND\"", "M680x0ISD::CMP", "\"M680x0ISD::CMP\"", "M680x0ISD::BT", "\"M680x0ISD::BT\"", "M680x0ISD::SELECT", "\"M680x0ISD::SELECT\"", "M680x0ISD::CMOV", "\"M680x0ISD::CMOV\"", "M680x0ISD::BRCOND", "\"M680x0ISD::BRCOND\"", "M680x0ISD::SETCC", "\"M680x0ISD::SETCC\"", "M680x0ISD::SETCC_CARRY", "\"M680x0ISD::SETCC_CARRY\"", "M680x0ISD::GlobalBaseReg", "\"M680x0ISD::GlobalBaseReg\"", "M680x0ISD::Wrapper", "\"M680x0ISD::Wrapper\"", "M680x0ISD::WrapperPC", "\"M680x0ISD::WrapperPC\"", "M680x0ISD::SEG_ALLOCA", "\"M680x0ISD::SEG_ALLOCA\""], "File": "M680x0ISelLowering", "Func": "getTargetNodeName", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23594, "Length": 216}
{"ground_truth": ["<s>", "SDValue", "M680x0TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_M680x0", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "CopyVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "CopyVT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "SDValue", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "if", "(", "VA", ".", "isExtInLoc", "(", ")", "&&", "VA", ".", "getValVT", "(", ")", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>"], "natrual_language": ["LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "."], "TS_V_token": ["M680x0", "M680x0", "ISD::InputArg", "16", "M680x0", "0", "1", "0", "MVT::i1", "ISD::TRUNCATE", "2"], "File": "M680x0ISelLowering", "Func": "LowerCallResult", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23595, "Length": 228}
{"ground_truth": ["<s>", "SDValue", "M680x0TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SADDO", ":", "case", "ISD", "::", "UADDO", ":", "case", "ISD", "::", "SSUBO", ":", "case", "ISD", "::", "USUBO", ":", "case", "ISD", "::", "SMULO", ":", "case", "ISD", "::", "UMULO", ":", "return", "LowerXALUO", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCCCARRY", ":", "return", "LowerSETCCCARRY", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADDC", ":", "case", "ISD", "::", "ADDE", ":", "case", "ISD", "::", "SUBC", ":", "case", "ISD", "::", "SUBE", ":", "return", "LowerADDC_ADDE_SUBC_SUBE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>"], "natrual_language": ["LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "."], "TS_V_token": ["M680x0", "M680x0", "\"Should not custom lower this!\"", "ISD::MUL", "ISD::SADDO", "ISD::UADDO", "ISD::SSUBO", "ISD::USUBO", "ISD::SMULO", "ISD::UMULO", "ISD::SETCC", "ISD::SETCCCARRY", "ISD::SELECT", "ISD::BRCOND", "ISD::ADDC", "ISD::ADDE", "ISD::SUBC", "ISD::SUBE", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::BlockAddress", "ISD::JumpTable", "ISD::VASTART", "ISD::DYNAMIC_STACKALLOC"], "File": "M680x0ISelLowering", "Func": "LowerOperation", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23596, "Length": 254}
{"ground_truth": ["<s>", "SDValue", "M680x0TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "M680x0ISD", "::", "SUBX", ":", "return", "combineSUBX", "(", "N", ",", "DAG", ")", ";", "case", "M680x0ISD", "::", "ADDX", ":", "return", "combineADDX", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "M680x0ISD", "::", "SETCC", ":", "return", "combineM680x0SetCC", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "M680x0ISD", "::", "BRCOND", ":", "return", "combineM680x0BrCond", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>"], "natrual_language": ["This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0ISD::SUBX", "M680x0ISD::ADDX", "M680x0ISD::SETCC", "M680x0", "M680x0ISD::BRCOND", "M680x0"], "File": "M680x0ISelLowering", "Func": "PerformDAGCombine", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23597, "Length": 97}
{"ground_truth": ["<s>", "unsigned", "getGlobalBaseReg", "(", ")", "const", "{", "return", "GlobalBaseReg", ";", "}", "</s>"], "natrual_language": ["getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "."], "TS_V_token": ["M680x0"], "File": "M680x0MachineFunction", "Func": "getGlobalBaseReg", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23598, "Length": 10}
{"ground_truth": ["<s>", "void", "M680x0MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "Opcode", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"EncodeInstruction: \"", "<<", "MCII", ".", "getName", "(", "Opcode", ")", "<<", "\"(\"", "<<", "Opcode", "<<", "\")\\n\"", ")", ";", "const", "uint8_t", "*", "Beads", "=", "getGenInstrBeads", "(", "MI", ")", ";", "if", "(", "!", "*", "Beads", ")", "{", "llvm_unreachable", "(", "\"*** Instruction does not have Beads defined\"", ")", ";", "}", "uint64_t", "Buffer", "=", "0", ";", "unsigned", "Offset", "=", "0", ";", "unsigned", "ThisByte", "=", "0", ";", "while", "(", "*", "Beads", ")", "{", "uint8_t", "Bead", "=", "*", "Beads", ";", "Beads", "++", ";", "if", "(", "!", "(", "Bead", "&", "0xF", ")", ")", "{", "switch", "(", "Bead", ">>", "4", ")", "{", "case", "M680x0Beads", "::", "Ignore", ":", "continue", ";", "}", "}", "switch", "(", "Bead", "&", "0xF", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown Bead code\"", ")", ";", "break", ";", "case", "M680x0Beads", "::", "Bits1", ":", "case", "M680x0Beads", "::", "Bits2", ":", "case", "M680x0Beads", "::", "Bits3", ":", "case", "M680x0Beads", "::", "Bits4", ":", "Offset", "+=", "EncodeBits", "(", "ThisByte", ",", "Bead", ",", "MI", ",", "Desc", ",", "Buffer", ",", "Offset", ",", "Fixups", ",", "STI", ")", ";", "break", ";", "case", "M680x0Beads", "::", "DAReg", ":", "case", "M680x0Beads", "::", "DA", ":", "case", "M680x0Beads", "::", "Reg", ":", "Offset", "+=", "EncodeReg", "(", "ThisByte", ",", "Bead", ",", "MI", ",", "Desc", ",", "Buffer", ",", "Offset", ",", "Fixups", ",", "STI", ")", ";", "break", ";", "case", "M680x0Beads", "::", "Disp8", ":", "case", "M680x0Beads", "::", "Imm8", ":", "case", "M680x0Beads", "::", "Imm16", ":", "case", "M680x0Beads", "::", "Imm32", ":", "case", "M680x0Beads", "::", "Imm3", ":", "Offset", "+=", "EncodeImm", "(", "ThisByte", ",", "Bead", ",", "MI", ",", "Desc", ",", "Buffer", ",", "Offset", ",", "Fixups", ",", "STI", ")", ";", "break", ";", "}", "while", "(", "Offset", "/", "16", ")", "{", "OS", ".", "write", "(", "(", "char", ")", "(", "(", "Buffer", ">>", "8", ")", "&", "0xFF", ")", ")", ";", "OS", ".", "write", "(", "(", "char", ")", "(", "(", "Buffer", ">>", "0", ")", "&", "0xFF", ")", ")", ";", "Buffer", ">>=", "16", ";", "Offset", "-=", "16", ";", "ThisByte", "+=", "2", ";", "}", "}", "assert", "(", "Offset", "==", "0", "&&", "\"M680x0 Instructions are % 2 bytes\"", ")", ";", "assert", "(", "(", "ThisByte", "&&", "!", "(", "ThisByte", "%", "2", ")", ")", "&&", "\"M680x0 Instructions are % 2 bytes\"", ")", ";", "}", "</s>"], "natrual_language": ["Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "."], "TS_V_token": ["M680x0", "M680x0", "\"EncodeInstruction: \"", "\"(\"", "\")\\n\"", "\"*** Instruction does not have Beads defined\"", "0", "0", "0", "0xF", "4", "M680x0Beads::Ignore", "0xF", "\"Unknown Bead code\"", "M680x0Beads::Bits1", "M680x0Beads::Bits2", "M680x0Beads::Bits3", "M680x0Beads::Bits4", "M680x0Beads::DAReg", "M680x0Beads::DA", "M680x0Beads::Reg", "M680x0Beads::Disp8", "M680x0Beads::Imm8", "M680x0Beads::Imm16", "M680x0Beads::Imm32", "M680x0Beads::Imm3", "16", "8", "0xFF", "0", "0xFF", "16", "16", "2", "0", "\"M680x0 Instructions are % 2 bytes\"", "2", "\"M680x0 Instructions are % 2 bytes\""], "File": "M680x0MCCodeEmitter", "Func": "encodeInstruction", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23599, "Length": 379}
{"ground_truth": ["<s>", "MCSymbol", "*", "M680x0MCInstLower", "::", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "assert", "(", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", "||", "MO", ".", "isMBB", "(", ")", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "MCSymbol", "*", "Sym", "=", "nullptr", ";", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Suffix", ";", "if", "(", "!", "Suffix", ".", "empty", "(", ")", ")", "Name", "+=", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "AsmPrinter", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ")", ";", "}", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "Mangler", "::", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ",", "DL", ")", ";", "}", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "{", "assert", "(", "Suffix", ".", "empty", "(", ")", ")", ";", "Sym", "=", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ";", "}", "Name", "+=", "Suffix", ";", "if", "(", "!", "Sym", ")", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Name", ")", ";", "return", "Sym", ";", "}", "</s>"], "natrual_language": ["Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "."], "TS_V_token": ["M680x0", "M680x0", "\"Isn't a symbol reference\"", "128"], "File": "M680x0MCInstLower", "Func": "GetSymbolFromOperand", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23600, "Length": 191}
{"ground_truth": ["<s>", "bool", "M680x0RegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "TargetRegisterInfo", "::", "canRealignStack", "(", "MF", ")", ")", "return", "false", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "MRI", "->", "canReserveReg", "(", "FramePtr", ")", ")", "return", "false", ";", "if", "(", "CantUseSP", "(", "MFI", ")", ")", "return", "MRI", "->", "canReserveReg", "(", "BasePtr", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0RegisterInfo", "Func": "canRealignStack", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23601, "Length": 80}
{"ground_truth": ["<s>", "void", "M680x0RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "M680x0FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "MachineOperand", "&", "Disp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", "-", "1", ")", ";", "MachineOperand", "&", "Base", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "Imm", "=", "(", "int", ")", "(", "Disp", ".", "getImm", "(", ")", ")", ";", "int", "FIndex", "=", "(", "int", ")", "(", "Base", ".", "getIndex", "(", ")", ")", ";", "bool", "AfterFPPop", "=", "false", ";", "unsigned", "BasePtr", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "BasePtr", "=", "(", "FIndex", "<", "0", "?", "FramePtr", ":", "getBaseRegister", "(", ")", ")", ";", "else", "if", "(", "needsStackRealignment", "(", "MF", ")", ")", "BasePtr", "=", "(", "FIndex", "<", "0", "?", "FramePtr", ":", "StackPtr", ")", ";", "else", "if", "(", "AfterFPPop", ")", "BasePtr", "=", "StackPtr", ";", "else", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ")", ";", "Base", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "FIOffset", ";", "unsigned", "IgnoredFrameReg", ";", "if", "(", "AfterFPPop", ")", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FIOffset", "=", "MFI", ".", "getObjectOffset", "(", "FIndex", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";", "}", "else", "{", "FIOffset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FIndex", ",", "IgnoredFrameReg", ")", ";", "}", "if", "(", "BasePtr", "==", "StackPtr", ")", "FIOffset", "+=", "SPAdj", ";", "long", "long", "Offset", "=", "FIOffset", "+", "Imm", ";", "Disp", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>"], "natrual_language": ["This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "1", "0", "0"], "File": "M680x0RegisterInfo", "Func": "eliminateFrameIndex", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23602, "Length": 269}
{"ground_truth": ["<s>", "const", "MCPhysReg", "*", "M680x0RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_STD_SaveList", ";", "}", "</s>"], "natrual_language": ["Code", "Generation", "virtual", "methods", "..."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0RegisterInfo", "Func": "getCalleeSavedRegs", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23603, "Length": 18}
{"ground_truth": ["<s>", "const", "uint32_t", "*", "M680x0RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", ")", "const", "{", "return", "CSR_STD_RegMask", ";", "}", "</s>"], "natrual_language": ["Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0RegisterInfo", "Func": "getCallPreservedMask", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23604, "Length": 22}
{"ground_truth": ["<s>", "unsigned", "M680x0RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ";", "}", "</s>"], "natrual_language": ["Debug", "information", "queries", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0RegisterInfo", "Func": "getFrameRegister", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23605, "Length": 40}
{"ground_truth": ["<s>", "unsigned", "M680x0RegisterInfo", "::", "getMatchingMegaReg", "(", "unsigned", "Reg", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "for", "(", "MCSuperRegIterator", "Super", "(", "Reg", ",", "this", ")", ";", "Super", ".", "isValid", "(", ")", ";", "++", "Super", ")", "if", "(", "RC", "->", "contains", "(", "*", "Super", ")", ")", "return", "*", "Super", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "a", "mega-register", "of", "the", "specified", "register", "Reg", "so", "its", "sub-register", "of", "index", "SubIdx", "is", "Reg", ",", "its", "super", "(", "or", "mega", ")", "Reg", "."], "TS_V_token": ["M680x0", "M680x0", "0"], "File": "M680x0RegisterInfo", "Func": "getMatchingMegaReg", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23606, "Length": 52}
{"ground_truth": ["<s>", "const", "TargetRegisterClass", "*", "M680x0RegisterInfo", "::", "getMaximalPhysRegClass", "(", "unsigned", "reg", ",", "MVT", "VT", ")", "const", "{", "assert", "(", "isPhysicalRegister", "(", "reg", ")", "&&", "\"reg must be a physical register\"", ")", ";", "const", "TargetRegisterClass", "*", "BestRC", "=", "nullptr", ";", "for", "(", "regclass_iterator", "I", "=", "regclass_begin", "(", ")", ",", "E", "=", "regclass_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "*", "I", ";", "if", "(", "(", "VT", "==", "MVT", "::", "Other", "||", "isTypeLegalForClass", "(", "*", "RC", ",", "VT", ")", ")", "&&", "RC", "->", "contains", "(", "reg", ")", "&&", "(", "!", "BestRC", "||", "(", "BestRC", "->", "hasSubClass", "(", "RC", ")", "&&", "RC", "->", "getNumRegs", "(", ")", ">", "BestRC", "->", "getNumRegs", "(", ")", ")", ")", ")", "BestRC", "=", "RC", ";", "}", "assert", "(", "BestRC", "&&", "\"Couldn't find the register class\"", ")", ";", "return", "BestRC", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "Register", "Class", "of", "a", "physical", "register", "of", "the", "given", "type", ",", "picking", "the", "biggest", "register", "class", "of", "the", "right", "type", "that", "contains", "this", "physreg", "."], "TS_V_token": ["M680x0", "M680x0", "\"reg must be a physical register\"", "MVT::Other", "\"Couldn't find the register class\""], "File": "M680x0RegisterInfo", "Func": "getMaximalPhysRegClass", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23607, "Length": 130}
{"ground_truth": ["<s>", "int", "M680x0RegisterInfo", "::", "getRegisterOrder", "(", "unsigned", "Reg", ",", "const", "TargetRegisterClass", "&", "TRC", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "TRC", ".", "getNumRegs", "(", ")", ";", "++", "i", ")", "{", "if", "(", "regsOverlap", "(", "Reg", ",", "TRC", ".", "getRegister", "(", "i", ")", ")", ")", "{", "return", "i", ";", "}", "}", "return", "-", "1", ";", "}", "</s>"], "natrual_language": ["Return", "index", "of", "a", "register", "within", "a", "register", "class", ",", "otherwise", "return", "-1", "."], "TS_V_token": ["M680x0", "M680x0", "0", "1"], "File": "M680x0RegisterInfo", "Func": "getRegisterOrder", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23608, "Length": 59}
{"ground_truth": ["<s>", "const", "TargetRegisterClass", "*", "M680x0RegisterInfo", "::", "getRegsForTailCall", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "&", "M680x0", "::", "XR32_TCRegClass", ";", "}", "</s>"], "natrual_language": ["Returns", "a", "register", "class", "with", "registers", "that", "can", "be", "used", "in", "forming", "tail", "calls", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0::XR32_TCRegClass"], "File": "M680x0RegisterInfo", "Func": "getRegsForTailCall", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23609, "Length": 21}
{"ground_truth": ["<s>", "BitVector", "M680x0RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "M680x0FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "auto", "setBitVector", "=", "[", "&", "Reserved", ",", "this", "]", "(", "unsigned", "Reg", ")", "{", "for", "(", "MCRegAliasIterator", "I", "(", "Reg", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "for", "(", "MCSubRegIterator", "I", "(", "Reg", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "}", ";", "setBitVector", "(", "M680x0", "::", "PC", ")", ";", "setBitVector", "(", "M680x0", "::", "SP", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "setBitVector", "(", "FramePtr", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "CallingConv", "::", "ID", "CC", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "getCallPreservedMask", "(", "MF", ",", "CC", ")", ";", "if", "(", "MachineOperand", "::", "clobbersPhysReg", "(", "RegMask", ",", "getBaseRegister", "(", ")", ")", ")", "report_fatal_error", "(", "\"Stack realignment in presence of dynamic allocas is \"", "\"not supported with\"", "\"this calling convention.\"", ")", ";", "setBitVector", "(", "getBaseRegister", "(", ")", ")", ";", "}", "return", "Reserved", ";", "}", "</s>"], "natrual_language": ["getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "M680x0::PC", "M680x0::SP", "\"Stack realignment in presence of dynamic allocas is \"", "\"not supported with\"", "\"this calling convention.\""], "File": "M680x0RegisterInfo", "Func": "getReservedRegs", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23610, "Length": 205}
{"ground_truth": ["<s>", "int", "M680x0RegisterInfo", "::", "getSpillRegisterOrder", "(", "unsigned", "Reg", ")", "const", "{", "int", "Result", "=", "getRegisterOrder", "(", "Reg", ",", "*", "getRegClass", "(", "M680x0", "::", "SPILLRegClassID", ")", ")", ";", "if", "(", "Result", "<", "0", ")", "{", "llvm_unreachable", "(", "\"Cannot determine spill order\"", ")", ";", "}", "return", "Result", ";", "}", "</s>"], "natrual_language": ["Return", "spill", "order", "index", "of", "a", "register", ",", "if", "there", "is", "none", "then", "trap", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0::SPILLRegClassID", "0", "\"Cannot determine spill order\""], "File": "M680x0RegisterInfo", "Func": "getSpillRegisterOrder", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23611, "Length": 43}
{"ground_truth": ["<s>", "unsigned", "getSpillSize", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "override", "{", "return", "4", ";", "}", "</s>"], "natrual_language": ["Return", "the", "size", "in", "bytes", "of", "the", "stack", "slot", "allocated", "to", "hold", "a", "spilled", "copy", "of", "a", "register", "from", "class", "RC", "."], "TS_V_token": ["M680x0", "4"], "File": "M680x0RegisterInfo", "Func": "getSpillSize", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23612, "Length": 15}
{"ground_truth": ["<s>", "const", "TargetRegisterClass", "*", "M680x0RegisterInfo", "::", "intRegClass", "(", "unsigned", "size", ")", "const", "{", "return", "&", "M680x0", "::", "DR32RegClass", ";", "}", "</s>"], "natrual_language": ["Return", "GPR", "register", "class", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0::DR32RegClass"], "File": "M680x0RegisterInfo", "Func": "intRegClass", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23613, "Length": 19}
{"ground_truth": ["<s>", "bool", "M680x0RegisterInfo", "::", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>"], "natrual_language": ["Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0RegisterInfo", "Func": "requiresRegisterScavenging", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23614, "Length": 16}
{"ground_truth": ["<s>", "bool", "M680x0RegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>"], "natrual_language": ["Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0RegisterInfo", "Func": "trackLivenessAfterRegAlloc", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23615, "Length": 16}
{"ground_truth": ["<s>", "unsigned", "char", "M680x0Subtarget", "::", "classifyBlockAddressReference", "(", ")", "const", "{", "return", "M680x0II", "::", "MO_PC_RELATIVE_ADDRESS", ";", "}", "</s>"], "natrual_language": ["Classify", "a", "blockaddress", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0II::MO_PC_RELATIVE_ADDRESS"], "File": "M680x0Subtarget", "Func": "classifyBlockAddressReference", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23616, "Length": 15}
{"ground_truth": ["<s>", "unsigned", "char", "M680x0Subtarget", "::", "classifyExternalReference", "(", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "nullptr", ")", ")", "return", "classifyLocalReference", "(", "nullptr", ")", ";", "if", "(", "isPositionIndependent", "(", ")", ")", "{", "return", "M680x0II", "::", "MO_GOTPCREL", ";", "}", "else", "{", "return", "M680x0II", "::", "MO_GOT", ";", "}", "}", "</s>"], "natrual_language": ["Classify", "a", "external", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0II::MO_GOTPCREL", "M680x0II::MO_GOT"], "File": "M680x0Subtarget", "Func": "classifyExternalReference", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23617, "Length": 52}
{"ground_truth": ["<s>", "unsigned", "char", "M680x0Subtarget", "::", "classifyGlobalFunctionReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "M680x0II", "::", "MO_NO_FLAG", ";", "auto", "*", "F", "=", "dyn_cast_or_null", "<", "Function", ">", "(", "GV", ")", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", ")", "{", "return", "M680x0II", "::", "MO_GOTPCREL", ";", "}", "return", "M680x0II", "::", "MO_PLT", ";", "}", "</s>"], "natrual_language": ["Classify", "a", "global", "function", "reference", "for", "the", "current", "subtarget", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0II::MO_NO_FLAG", "M680x0II::MO_GOTPCREL", "M680x0II::MO_PLT"], "File": "M680x0Subtarget", "Func": "classifyGlobalFunctionReference", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23618, "Length": 72}
{"ground_truth": ["<s>", "unsigned", "char", "M680x0Subtarget", "::", "classifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "classifyLocalReference", "(", "GV", ")", ";", "switch", "(", "TM", ".", "getCodeModel", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported code model\"", ")", ";", "case", "CodeModel", "::", "Small", ":", "case", "CodeModel", "::", "Kernel", ":", "{", "if", "(", "isPositionIndependent", "(", ")", ")", "{", "return", "M680x0II", "::", "MO_GOTPCREL", ";", "}", "else", "{", "return", "M680x0II", "::", "MO_PC_RELATIVE_ADDRESS", ";", "}", "}", "case", "CodeModel", "::", "Medium", ":", "{", "if", "(", "isPositionIndependent", "(", ")", ")", "{", "return", "M680x0II", "::", "MO_GOTPCREL", ";", "}", "else", "{", "if", "(", "IsM68020", ")", "{", "return", "M680x0II", "::", "MO_PC_RELATIVE_ADDRESS", ";", "}", "return", "M680x0II", "::", "MO_ABSOLUTE_ADDRESS", ";", "}", "}", "}", "}", "</s>"], "natrual_language": ["Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "."], "TS_V_token": ["M680x0", "M680x0", "\"Unsupported code model\"", "M680x0II::MO_GOTPCREL", "M680x0II::MO_PC_RELATIVE_ADDRESS", "M680x0II::MO_GOTPCREL", "M680x0II::MO_PC_RELATIVE_ADDRESS", "M680x0II::MO_ABSOLUTE_ADDRESS"], "File": "M680x0Subtarget", "Func": "classifyGlobalReference", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23619, "Length": 125}
{"ground_truth": ["<s>", "unsigned", "char", "M680x0Subtarget", "::", "classifyLocalReference", "(", "const", "GlobalValue", "*", "GV", ")", "const", "{", "switch", "(", "TM", ".", "getCodeModel", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported code model\"", ")", ";", "case", "CodeModel", "::", "Small", ":", "case", "CodeModel", "::", "Kernel", ":", "{", "return", "M680x0II", "::", "MO_PC_RELATIVE_ADDRESS", ";", "}", "case", "CodeModel", "::", "Medium", ":", "{", "if", "(", "isPositionIndependent", "(", ")", ")", "{", "if", "(", "IsM68020", ")", "{", "return", "M680x0II", "::", "MO_PC_RELATIVE_ADDRESS", ";", "}", "return", "M680x0II", "::", "MO_GOTOFF", ";", "}", "else", "{", "if", "(", "IsM68020", ")", "{", "return", "M680x0II", "::", "MO_PC_RELATIVE_ADDRESS", ";", "}", "return", "M680x0II", "::", "MO_ABSOLUTE_ADDRESS", ";", "}", "}", "}", "}", "</s>"], "natrual_language": ["Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "."], "TS_V_token": ["M680x0", "M680x0", "\"Unsupported code model\"", "M680x0II::MO_PC_RELATIVE_ADDRESS", "M680x0II::MO_PC_RELATIVE_ADDRESS", "M680x0II::MO_GOTOFF", "M680x0II::MO_PC_RELATIVE_ADDRESS", "M680x0II::MO_ABSOLUTE_ADDRESS"], "File": "M680x0Subtarget", "Func": "classifyLocalReference", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23620, "Length": 98}
{"ground_truth": ["<s>", "const", "M680x0InstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>"], "natrual_language": ["TargetInstrInfo", "getter", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0Subtarget", "Func": "getInstrInfo", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23621, "Length": 14}
{"ground_truth": ["<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "override", "{", "return", "&", "InstrItins", ";", "}", "</s>"], "natrual_language": ["getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "."], "TS_V_token": ["M680x0"], "File": "M680x0Subtarget", "Func": "getInstrItineraryData", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23622, "Length": 14}
{"ground_truth": ["<s>", "unsigned", "M680x0Subtarget", "::", "getJumpTableEncoding", "(", ")", "const", "{", "if", "(", "isPositionIndependent", "(", ")", ")", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Medium", "&&", "!", "isM68020", "(", ")", ")", "return", "MachineJumpTableInfo", "::", "EK_Custom32", ";", "return", "MachineJumpTableInfo", "::", "EK_LabelDifference32", ";", "}", "return", "MachineJumpTableInfo", "::", "EK_BlockAddress", ";", "}", "</s>"], "natrual_language": ["Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0Subtarget", "Func": "getJumpTableEncoding", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23623, "Length": 49}
{"ground_truth": ["<s>", "const", "M680x0RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>"], "natrual_language": ["getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0Subtarget", "Func": "getRegisterInfo", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23624, "Length": 18}
{"ground_truth": ["<s>", "unsigned", "getSlotSize", "(", ")", "const", "{", "return", "4", ";", "}", "</s>"], "natrual_language": ["getSlotSize", "-", "Stack", "slot", "size", "in", "bytes", "."], "TS_V_token": ["M680x0", "4"], "File": "M680x0Subtarget", "Func": "getSlotSize", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23625, "Length": 10}
{"ground_truth": ["<s>", "unsigned", "getStackAlignment", "(", ")", "const", "{", "return", "stackAlignment", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "minimum", "alignment", "known", "to", "hold", "of", "the", "stack", "frame", "on", "entry", "to", "the", "function", "and", "which", "must", "be", "maintained", "by", "every", "function", "for", "this", "subtarget", "."], "TS_V_token": ["M680x0"], "File": "M680x0Subtarget", "Func": "getStackAlignment", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23626, "Length": 10}
{"ground_truth": ["<s>", "const", "Triple", "&", "getTargetTriple", "(", ")", "const", "{", "return", "TargetTriple", ";", "}", "</s>"], "natrual_language": ["Get", "the", "target", "triple", "which", "is", "a", "string", "describing", "the", "target", "host", "."], "TS_V_token": ["M680x0"], "File": "M680x0Subtarget", "Func": "getTargetTriple", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23627, "Length": 12}
{"ground_truth": ["<s>", "M680x0Subtarget", "&", "M680x0Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "Triple", "TT", ",", "StringRef", "FS", ",", "const", "M680x0TargetMachine", "&", "TM", ")", "{", "std", "::", "string", "CPUName", "=", "selectM680x0CPU", "(", "TT", ",", "CPU", ")", ";", "IsM68000", "=", "true", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "stackAlignment", "=", "8", ";", "return", "*", "this", ";", "}", "</s>"], "natrual_language": ["initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "M680x0", "M680x0", "8"], "File": "M680x0Subtarget", "Func": "initializeSubtargetDependencies", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23628, "Length": 53}
{"ground_truth": ["<s>", "bool", "M680x0Subtarget", "::", "isLegalToCallImmediateAddr", "(", ")", "const", "{", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "the", "subtarget", "allows", "calls", "to", "immediate", "address", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0Subtarget", "Func": "isLegalToCallImmediateAddr", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23629, "Length": 12}
{"ground_truth": ["<s>", "bool", "M680x0PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createM680x0ISelDag", "(", "getM680x0TargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createM680x0GlobalBaseRegPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "M680x0", "M680x0"], "File": "M680x0TargetMachine", "Func": "addInstSelector", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23630, "Length": 28}
{"ground_truth": ["<s>", "void", "M680x0PassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createM680x0CollapseMOVEMPass", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0"], "File": "M680x0TargetMachine", "Func": "addPreEmitPass", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23631, "Length": 15}
{"ground_truth": ["<s>", "void", "M680x0PassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createM680x0ExpandPseudoPass", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0"], "File": "M680x0TargetMachine", "Func": "addPreSched2", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23632, "Length": 15}
{"ground_truth": ["<s>", "TargetPassConfig", "*", "M680x0TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "M680x0PassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>"], "natrual_language": ["Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0"], "File": "M680x0TargetMachine", "Func": "createPassConfig", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23633, "Length": 22}
{"ground_truth": ["<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>"], "natrual_language": ["Return", "information", "about", "object", "file", "lowering", "."], "TS_V_token": ["M680x0"], "File": "M680x0TargetMachine", "Func": "getObjFileLowering", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23634, "Length": 16}
{"ground_truth": ["<s>", "const", "M680x0Subtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>"], "natrual_language": ["Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "."], "TS_V_token": ["M680x0", "M680x0"], "File": "M680x0TargetMachine", "Func": "getSubtargetImpl", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23635, "Length": 13}
{"ground_truth": ["<s>", "void", "M680x0ELFTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "this", "->", "TM", "=", "&", "static_cast", "<", "const", "M680x0TargetMachine", "&", ">", "(", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "}", "</s>"], "natrual_language": ["This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "."], "TS_V_token": ["M680x0", "M680x0", "M680x0", "\".sdata\"", "\".sbss\""], "File": "M680x0TargetObjectFile", "Func": "Initialize", "Target": "M680x0", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 23636, "Length": 95}