{"ground_truth": ["<s>", "void", "GBZ80AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "GBZ80MCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "I", ";", "MCInstLowering", ".", "lowerInstruction", "(", "*", "MI", ",", "I", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "I", ")", ";", "}", "</s>"], "natrual_language": ["EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "."], "TS_V_token": ["GBZ80", "GB", "GB"], "File": "GBZ80AsmPrinter", "Func": "EmitInstruction", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17385, "Length": 42}
{"ground_truth": ["<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"GBZ80 Assembly Printer\"", ";", "}", "</s>"], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["GBZ80", "\"GBZ80 Assembly Printer\""], "File": "GBZ80AsmPrinter", "Func": "getPassName", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17386, "Length": 11}
{"ground_truth": ["<s>", "bool", "GBZ80AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "llvm_unreachable", "(", "\"This branch is not implemented yet\"", ")", ";", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "(", "void", ")", "MO", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"Unexpected inline asm memory operand\"", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "GB", "::", "R31R30", ")", "{", "O", "<<", "\"Z\"", ";", "}", "else", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "GB", "::", "R29R28", "&&", "\"Wrong register class for memory operand.\"", ")", ";", "O", "<<", "\"Y\"", ";", "}", "unsigned", "OpFlags", "=", "MI", "->", "getOperand", "(", "OpNum", "-", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumOpRegs", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "OpFlags", ")", ";", "if", "(", "NumOpRegs", "==", "2", ")", "{", "O", "<<", "'+'", "<<", "MI", "->", "getOperand", "(", "OpNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "."], "TS_V_token": ["GBZ80", "GB", "0", "\"This branch is not implemented yet\"", "\"Unexpected inline asm memory operand\"", "GB::R31R30", "\"Z\"", "GB::R29R28", "\"Wrong register class for memory operand.\"", "\"Y\"", "1", "2", "1"], "File": "GBZ80AsmPrinter", "Func": "PrintAsmMemoryOperand", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17387, "Length": 175}
{"ground_truth": ["<s>", "bool", "GBZ80AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "bool", "Error", "=", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "if", "(", "Error", ")", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80AsmPrinter", "Func": "PrintAsmOperand", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17388, "Length": 61}
{"ground_truth": ["<s>", "MCELFStreamer", "&", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "output", "streamer", "for", "the", "assembler", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80ELFStreamer", "Func": "getStreamer", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17389, "Length": 17}
{"ground_truth": ["<s>", "void", "GBZ80FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Cannot handle this call frame pseudo instruction\"", ")", ";", "case", "GBZ80", "::", "ADJCALLSTACKDOWN", ":", "case", "GBZ80", "::", "ADJCALLSTACKUP", ":", "break", ";", "}", "MBB", ".", "erase", "(", "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": ["GBZ80", "GB", "\"Cannot handle this call frame pseudo instruction\"", "GBZ80::ADJCALLSTACKDOWN", "GBZ80::ADJCALLSTACKUP"], "File": "GBZ80FrameLowering (2)", "Func": "eliminateCallFramePseudoInstr", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17390, "Length": 64}
{"ground_truth": ["<s>", "void", "GBZ80FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "GBZ80MachineFunctionInfo", "*", "GBZ80FI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "const", "GBZ80InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "GBZ80InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RetOpcode", "!=", "GBZ80", "::", "RET", ")", "llvm_unreachable", "(", "\"Can only insert epilog into returning blocks\"", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "CallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "uint64_t", "FrameSize", "=", "GBZ80FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "StackSize", "+", "CallFrameSize", "-", "FrameSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "GBZ80", "::", "POP16r", "&&", "!", "I", "->", "isTerminator", "(", ")", ")", "break", ";", "MBBI", "--", ";", "}", "if", "(", "NumBytes", ")", "{", "unsigned", "FP", "=", "TII", ".", "getRegisterInfo", "(", ")", ".", "getFrameRegister", "(", "MF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "GBZ80", "::", "LD16ri", ")", ",", "FP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "GBZ80", "::", "ADD16rSP", ")", ",", "FP", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "GBZ80", "::", "LD16SPr", ")", ")", ".", "addReg", "(", "FP", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "</s>"], "natrual_language": ["Insert", "epilog", "code", "into", "the", "function", "."], "TS_V_token": ["GBZ80", "GB", "GB", "GB", "GB", "GB", "GB", "GBZ80::RET", "\"Can only insert epilog into returning blocks\"", "GB", "GBZ80::POP16r", "GBZ80::LD16ri", "GBZ80::ADD16rSP", "GBZ80::LD16SPr"], "File": "GBZ80FrameLowering (2)", "Func": "emitEpilogue", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17391, "Length": 287}
{"ground_truth": ["<s>", "void", "GBZ80FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "GBZ80MachineFunctionInfo", "*", "GBZ80FI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "const", "GBZ80InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "GBZ80InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "CallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "uint64_t", "FrameSize", "=", "GBZ80FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "StackSize", "+", "CallFrameSize", "-", "FrameSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "GBZ80", "::", "PUSH16r", ")", ")", "MBBI", "++", ";", "if", "(", "NumBytes", "||", "GBZ80FI", "->", "isNeedFP", "(", ")", ")", "{", "unsigned", "FP", "=", "TII", ".", "getRegisterInfo", "(", ")", ".", "getFrameRegister", "(", "MF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "GBZ80", "::", "LD16ri", ")", ",", "FP", ")", ".", "addImm", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "GBZ80", "::", "ADD16rSP", ")", ",", "FP", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "GBZ80", "::", "LD16SPr", ")", ")", ".", "addReg", "(", "FP", ")", ";", "}", "}", "</s>"], "natrual_language": ["emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "."], "TS_V_token": ["GBZ80", "GB", "GB", "GB", "GB", "GB", "GB", "GB", "GBZ80::PUSH16r", "GB", "GBZ80::LD16ri", "GBZ80::ADD16rSP", "GBZ80::LD16SPr"], "File": "GBZ80FrameLowering (2)", "Func": "emitPrologue", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17392, "Length": 257}
{"ground_truth": ["<s>", "bool", "GBZ80FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "MFI", "->", "getMaxCallFrameSize", "(", ")", ">", "0", "||", "(", "MFI", "->", "getNumObjects", "(", ")", ">", "0", ")", ")", ";", "}", "</s>"], "natrual_language": ["hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "."], "TS_V_token": ["GBZ80", "GB", "0", "0"], "File": "GBZ80FrameLowering (2)", "Func": "hasFP", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17393, "Length": 45}
{"ground_truth": ["<s>", "bool", "GBZ80FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "TII", ".", "get", "(", "GBZ80", "::", "POP16r", ")", ",", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ")", ";", "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": ["GBZ80", "GB", "0", "GBZ80::POP16r"], "File": "GBZ80FrameLowering (2)", "Func": "restoreCalleeSavedRegisters", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17394, "Length": 143}
{"ground_truth": ["<s>", "bool", "GBZ80FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "GBZ80MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "i", "--", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "TII", ".", "get", "(", "GBZ80", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "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": ["GBZ80", "GB", "GB", "GB", "2", "0", "1", "GBZ80::PUSH16r"], "File": "GBZ80FrameLowering (2)", "Func": "spillCalleeSavedRegisters", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17395, "Length": 188}
{"ground_truth": ["<s>", "bool", "GBZ80FrameLowering", "::", "canSimplifyCallFramePseudos", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>"], "natrual_language": ["canSimplifyCallFramePseudos", "-", "If", "there", "is", "a", "reserved", "call", "frame", ",", "the", "call", "frame", "pseudos", "can", "be", "simplified", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80FrameLowering", "Func": "canSimplifyCallFramePseudos", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17396, "Length": 16}
{"ground_truth": ["<s>", "void", "GBZ80FrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "}", "</s>"], "natrual_language": ["This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80FrameLowering", "Func": "determineCalleeSaves", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17397, "Length": 31}
{"ground_truth": ["<s>", "MachineBasicBlock", "::", "iterator", "GBZ80FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "STI", ".", "getFrameLowering", "(", ")", ";", "const", "GBZ80InstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "int", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "MI", ")", ";", "assert", "(", "Amount", "==", "0", "&&", "\"call frame with stack not yet implemented!\"", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "assert", "(", "TFI", ".", "getStackAlignment", "(", ")", "==", "1", "&&", "\"Unsupported stack alignment\"", ")", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "true", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "unsigned", "addOpcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "Amount", ")", ")", "{", "addOpcode", "=", "GB", "::", "ADIWRdK", ";", "}", "else", "{", "addOpcode", "=", "GB", "::", "SUBIWRdK", ";", "Amount", "=", "-", "Amount", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "SPREAD", ")", ",", "GB", "::", "R31R30", ")", ".", "addReg", "(", "GB", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "addOpcode", ")", ",", "GB", "::", "R31R30", ")", ".", "addReg", "(", "GB", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Amount", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "SPWRITE", ")", ",", "GB", "::", "SP", ")", ".", "addReg", "(", "GB", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</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": ["GBZ80", "GB", "GB", "GB", "GB", "0", "\"call frame with stack not yet implemented!\"", "0", "1", "\"Unsupported stack alignment\"", "6", "GB::ADIWRdK", "GB::SUBIWRdK", "GB::SPREAD", "GB::R31R30", "GB::SP", "GB::R31R30", "GB::R31R30", "3", "GB::SPWRITE", "GB::SP", "GB::R31R30"], "File": "GBZ80FrameLowering", "Func": "eliminateCallFramePseudoInstr", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17398, "Length": 314}
{"ground_truth": ["<s>", "void", "GBZ80FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "CallingConv", "::", "ID", "CallConv", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "assert", "(", "MBBI", "->", "getDesc", "(", ")", ".", "isReturn", "(", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "GBZ80MachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "int", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", "-", "AFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "GBZ80InstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "FrameSize", ")", "{", "return", ";", "}", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "int", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "GB", "::", "POP", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "{", "break", ";", "}", "--", "MBBI", ";", "}", "while", "(", "FrameSize", "!=", "0", ")", "{", "int", "ToAdd", "=", "std", "::", "min", "(", "127", ",", "FrameSize", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "ADD_SP_e", ")", ")", ".", "addImm", "(", "ToAdd", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "MI", "->", "findRegisterDefOperand", "(", "GB", "::", "RF", ")", "->", "setIsDead", "(", ")", ";", "FrameSize", "-=", "ToAdd", ";", "}", "}", "</s>"], "natrual_language": ["Insert", "epilog", "code", "into", "the", "function", "."], "TS_V_token": ["GBZ80", "GB", "\"Can only insert epilog into returning blocks\"", "GB", "GB", "GB", "GB", "GB", "GB::POP", "0", "127", "GB::ADD_SP_e", "GB::RF"], "File": "GBZ80FrameLowering", "Func": "emitEpilogue", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17399, "Length": 267}
{"ground_truth": ["<s>", "void", "GBZ80FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "CallingConv", "::", "ID", "CallConv", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "DebugLoc", "DL", "=", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "GBZ80InstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "GBZ80MachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "int", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", "-", "AFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "GB", "::", "PUSH", ")", ")", "{", "++", "MBBI", ";", "}", "if", "(", "!", "FrameSize", ")", "{", "return", ";", "}", "while", "(", "FrameSize", "!=", "0", ")", "{", "int", "ToSubtract", "=", "std", "::", "min", "(", "128", ",", "FrameSize", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "ADD_SP_e", ")", ")", ".", "addImm", "(", "-", "ToSubtract", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "MI", "->", "findRegisterDefOperand", "(", "GB", "::", "RF", ")", "->", "setIsDead", "(", ")", ";", "FrameSize", "-=", "ToSubtract", ";", "}", "}", "</s>"], "natrual_language": ["emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "."], "TS_V_token": ["GBZ80", "GB", "GB", "GB", "GB", "GB", "GB", "GB::PUSH", "0", "128", "GB::ADD_SP_e", "GB::RF"], "File": "GBZ80FrameLowering", "Func": "emitPrologue", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17400, "Length": 258}
{"ground_truth": ["<s>", "StringRef", "getPassName", "(", ")", "const", "{", "return", "\"GBZ80 dynalloca stack pointer save/restore\"", ";", "}", "</s>"], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["GBZ80", "\"GBZ80 dynalloca stack pointer save/restore\""], "File": "GBZ80FrameLowering", "Func": "getPassName", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17401, "Length": 10}
{"ground_truth": ["<s>", "bool", "GBZ80FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>"], "natrual_language": ["hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80FrameLowering", "Func": "hasFP", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17402, "Length": 16}
{"ground_truth": ["<s>", "bool", "GBZ80FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</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": ["GBZ80", "GB"], "File": "GBZ80FrameLowering", "Func": "hasReservedCallFrame", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17403, "Length": 16}
{"ground_truth": ["<s>", "bool", "GBZ80FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "CCSI", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "CCSI", ".", "getReg", "(", ")", ";", "assert", "(", "TRI", "->", "getRegSizeInBits", "(", "*", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ")", "==", "16", "&&", "\"Invalid register size\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "POP", ")", ",", "Reg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "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": ["GBZ80", "GB", "GB", "GB", "16", "\"Invalid register size\"", "GB::POP"], "File": "GBZ80FrameLowering", "Func": "restoreCalleeSavedRegisters", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17404, "Length": 162}
{"ground_truth": ["<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ")", "{", "return", "false", ";", "}", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "EntryMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "EntryMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "unsigned", "SPCopy", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "GB", "::", "DREGSRegClass", ")", ";", "BuildMI", "(", "EntryMBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "COPY", ")", ",", "SPCopy", ")", ".", "addReg", "(", "GB", "::", "SP", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "if", "(", "!", "MBB", ".", "empty", "(", ")", "&&", "MBB", ".", "back", "(", ")", ".", "isReturn", "(", ")", ")", "{", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "COPY", ")", ",", "GB", "::", "SP", ")", ".", "addReg", "(", "SPCopy", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["GBZ80", "GB", "GB", "GB::DREGSRegClass", "GB::COPY", "GB::SP", "GB::COPY", "GB::SP"], "File": "GBZ80FrameLowering", "Func": "runOnMachineFunction", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17405, "Length": 209}
{"ground_truth": ["<s>", "bool", "GBZ80FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "unsigned", "CalleeFrameSize", "=", "0", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "GBZ80MachineFunctionInfo", "*", "GBZ80FI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "CCSI", ":", "reverse", "(", "CSI", ")", ")", "{", "unsigned", "Reg", "=", "CCSI", ".", "getReg", "(", ")", ";", "bool", "IsNotLiveIn", "=", "!", "MBB", ".", "isLiveIn", "(", "Reg", ")", ";", "assert", "(", "TRI", "->", "getRegSizeInBits", "(", "*", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ")", "==", "16", "&&", "\"Invalid register size\"", ")", ";", "if", "(", "IsNotLiveIn", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "GB", "::", "PUSH", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "IsNotLiveIn", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "CalleeFrameSize", "+=", "2", ";", "}", "GBZ80FI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "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": ["GBZ80", "GB", "0", "GB", "GB", "GB", "GB", "GB", "16", "\"Invalid register size\"", "GB::PUSH", "2", "GB"], "File": "GBZ80FrameLowering", "Func": "spillCalleeSavedRegisters", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17406, "Length": 226}
{"ground_truth": ["<s>", "void", "GBZ80InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "break", ";", "}", "}", "</s>"], "natrual_language": ["Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80InstPrinter", "Func": "printInst", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17407, "Length": 67}
{"ground_truth": ["<s>", "void", "GBZ80InstPrinter", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "int64_t", "Imm", "=", "Op", ".", "getImm", "(", ")", ";", "if", "(", "Imm", ">=", "0", ")", "O", "<<", "'+'", ";", "O", "<<", "Imm", ";", "}", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "\"Unknown pcrel immediate operand\"", ")", ";", "O", "<<", "*", "Op", ".", "getExpr", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["value", "(", "e.g", "."], "TS_V_token": ["GBZ80", "GB", "0", "\"Unknown pcrel immediate operand\""], "File": "GBZ80InstPrinter", "Func": "printPCRelImm", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17408, "Length": 87}
{"ground_truth": ["<s>", "MachineInstr", "*", "GBZ80InstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "case", "GBZ80", "::", "ADD8r", ":", "case", "GBZ80", "::", "ADD16r", ":", "case", "GBZ80", "::", "ADC8r", ":", "case", "GBZ80", "::", "ADC16r", ":", "case", "GBZ80", "::", "AND8r", ":", "case", "GBZ80", "::", "XOR8r", ":", "case", "GBZ80", "::", "OR8r", ":", "break", ";", "case", "GBZ80", "::", "ADD8i", ":", "case", "GBZ80", "::", "ADC8i", ":", "case", "GBZ80", "::", "AND8i", ":", "case", "GBZ80", "::", "XOR8i", ":", "case", "GBZ80", "::", "OR8i", ":", "return", "NULL", ";", "}", "assert", "(", "!", "NewMI", "&&", "\"Not implemented yet!\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "reg", "[", "2", "]", ",", "arg", "[", "]", "=", "{", "0", ",", "0", "}", ";", "MachineInstr", "*", "MILoadReg", "=", "MI", "->", "getPrevNode", "(", ")", ";", "if", "(", "MILoadReg", "==", "NULL", "||", "MILoadReg", "->", "getOpcode", "(", ")", "!=", "GBZ80", "::", "COPY", ")", "return", "NULL", ";", "MachineOperand", "&", "MO0", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "MO1", "=", "MILoadReg", "->", "getOperand", "(", "1", ")", ";", "reg", "[", "0", "]", "=", "MO0", ".", "getReg", "(", ")", ";", "reg", "[", "1", "]", "=", "MO1", ".", "getReg", "(", ")", ";", "unsigned", "PreferArg", "=", "-", "1", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "MFE", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "MFE", ";", "MFI", "++", ")", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MFI", "->", "begin", "(", ")", ";", "while", "(", "MBBI", "!=", "MFI", "->", "end", "(", ")", ")", "{", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "COPY", ")", "{", "if", "(", "MBBI", "->", "findRegisterDefOperand", "(", "reg", "[", "0", "]", ")", ")", "{", "arg", "[", "0", "]", "=", "MBBI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "RI", ".", "isPhysicalRegister", "(", "arg", "[", "0", "]", ")", ")", "PreferArg", "=", "0", ";", "}", "if", "(", "MBBI", "->", "findRegisterDefOperand", "(", "reg", "[", "1", "]", ")", ")", "{", "arg", "[", "1", "]", "=", "MBBI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "RI", ".", "isPhysicalRegister", "(", "arg", "[", "0", "]", ")", ")", "PreferArg", "=", "1", ";", "}", "if", "(", "arg", "[", "0", "]", "&&", "arg", "[", "1", "]", ")", "break", ";", "}", "MBBI", "++", ";", "}", "if", "(", "arg", "[", "0", "]", "&&", "arg", "[", "1", "]", ")", "break", ";", "}", "if", "(", "arg", "[", "0", "]", "==", "0", "||", "arg", "[", "1", "]", "==", "0", ")", "{", "return", "NULL", ";", "}", "if", "(", "PreferArg", "==", "0", ")", "{", "MO0", ".", "setReg", "(", "reg", "[", "1", "]", ")", ";", "MO1", ".", "setReg", "(", "reg", "[", "0", "]", ")", ";", "}", "else", "{", "}", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "."], "TS_V_token": ["GBZ80", "GB", "GBZ80::ADD8r", "GBZ80::ADD16r", "GBZ80::ADC8r", "GBZ80::ADC16r", "GBZ80::AND8r", "GBZ80::XOR8r", "GBZ80::OR8r", "GBZ80::ADD8i", "GBZ80::ADC8i", "GBZ80::AND8i", "GBZ80::XOR8i", "GBZ80::OR8i", "\"Not implemented yet!\"", "2", "0", "0", "GBZ80::COPY", "0", "1", "0", "1", "1", "0", "0", "1", "0", "0", "1", "1", "1", "0", "1", "0", "1", "0", "1", "0", "0", "1", "0", "0", "1", "0"], "File": "GBZ80InstrInfo (2)", "Func": "commuteInstruction", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17409, "Length": 473}
{"ground_truth": ["<s>", "void", "GBZ80InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "GBZ80", "::", "GR8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "GBZ80", "::", "LD8rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "else", "if", "(", "GBZ80", "::", "GR16RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "unsigned", "DestSubReg", ",", "SrcSubReg", ";", "DestSubReg", "=", "RI", ".", "getSubReg", "(", "DestReg", ",", "GBZ80", "::", "subreg_hi", ")", ";", "SrcSubReg", "=", "RI", ".", "getSubReg", "(", "SrcReg", ",", "GBZ80", "::", "subreg_hi", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "GBZ80", "::", "LD8rr", ")", ",", "DestSubReg", ")", ".", "addReg", "(", "SrcSubReg", ")", ";", "DestSubReg", "=", "RI", ".", "getSubReg", "(", "DestReg", ",", "GBZ80", "::", "subreg_lo", ")", ";", "SrcSubReg", "=", "RI", ".", "getSubReg", "(", "SrcReg", ",", "GBZ80", "::", "subreg_lo", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "GBZ80", "::", "LD8rr", ")", ",", "DestSubReg", ")", ".", "addReg", "(", "SrcSubReg", ")", ";", "if", "(", "KillSrc", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "GBZ80", "::", "KILL", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "else", "if", "(", "GBZ80", "::", "GR16RegClass", ".", "contains", "(", "DestReg", ")", "||", "GBZ80", "::", "GR16RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "GBZ80", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "GBZ80", "::", "POP16r", ")", ",", "DestReg", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Imposible reg-to-reg copy\"", ")", ";", "}", "</s>"], "natrual_language": ["}", "Branch", "Analysis", "&", "Modification"], "TS_V_token": ["GBZ80", "GB", "GBZ80::GR8RegClass", "GBZ80::LD8rr", "GBZ80::GR16RegClass", "GBZ80::subreg_hi", "GBZ80::subreg_hi", "GBZ80::LD8rr", "GBZ80::subreg_lo", "GBZ80::subreg_lo", "GBZ80::LD8rr", "GBZ80::KILL", "GBZ80::GR16RegClass", "GBZ80::GR16RegClass", "GBZ80::PUSH16r", "GBZ80::POP16r", "\"Imposible reg-to-reg copy\""], "File": "GBZ80InstrInfo (2)", "Func": "copyPhysReg", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17410, "Length": 294}
{"ground_truth": ["<s>", "bool", "GBZ80InstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetRegisterInfo", "&", "RI", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", ",", "Reg", ",", "Imm", ",", "FPReg", ",", "Idx", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "}", "unsigned", "Lo", ",", "Hi", ";", "Lo", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "GBZ80", "::", "subreg_lo", ")", ";", "Hi", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "GBZ80", "::", "subreg_hi", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "."], "TS_V_token": ["GBZ80", "GB", "GBZ80::subreg_lo", "GBZ80::subreg_hi"], "File": "GBZ80InstrInfo (2)", "Func": "expandPostRAPseudo", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17411, "Length": 126}
{"ground_truth": ["<s>", "virtual", "const", "GBZ80RegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>"], "natrual_language": ["getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80InstrInfo (2)", "Func": "getRegisterInfo", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17412, "Length": 13}
{"ground_truth": ["<s>", "void", "GBZ80InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "GBZ80", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "GBZ80", "::", "LD8rr", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "else", "if", "(", "RC", "==", "&", "GBZ80", "::", "GR16RegClass", "||", "GBZ80", "::", "GR16RegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "GBZ80", "::", "LD16rm", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>"], "natrual_language": ["Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "."], "TS_V_token": ["GBZ80", "GB", "GBZ80::GR8RegClass", "GBZ80::LD8rr", "0", "GBZ80::GR16RegClass", "GBZ80::GR16RegClass", "GBZ80::LD16rm", "0", "\"Can't load this register from stack slot\""], "File": "GBZ80InstrInfo (2)", "Func": "loadRegFromStackSlot", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17413, "Length": 146}
{"ground_truth": ["<s>", "void", "GBZ80InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "GBZ80", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "GBZ80", "::", "LD8rr", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "if", "(", "RC", "==", "&", "GBZ80", "::", "GR16RegClass", "||", "GBZ80", "::", "GR16RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "GBZ80", "::", "LD16mr", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>"], "natrual_language": ["Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "."], "TS_V_token": ["GBZ80", "GB", "GBZ80::GR8RegClass", "GBZ80::LD8rr", "0", "GBZ80::GR16RegClass", "GBZ80::GR16RegClass", "GBZ80::LD16mr", "0", "\"Can't store this register to stack slot\""], "File": "GBZ80InstrInfo (2)", "Func": "storeRegToStackSlot", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17414, "Length": 165}
{"ground_truth": ["<s>", "bool", "GBZ80InstrInfo", "::", "analyzeBranchPredicate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBranchPredicate", "&", "MBP", ",", "bool", "AllowModify", ")", "const", "{", "SmallVector", "<", "MachineOperand", ",", "4", ">", "Cond", ";", "MachineBasicBlock", "*", "FBB", "=", "nullptr", ",", "*", "TBB", "=", "nullptr", ";", "if", "(", "analyzeBranch", "(", "MBB", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ")", "return", "true", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", "and", "parse", "it", "into", "the", "MachineBranchPredicate", "structure", "if", "possible", "."], "TS_V_token": ["GBZ80", "GB", "4"], "File": "GBZ80InstrInfo", "Func": "analyzeBranchPredicate", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17415, "Length": 59}
{"ground_truth": ["<s>", "MachineInstr", "*", "GBZ80InstrInfo", "::", "commuteInstructionImpl", "(", "MachineInstr", "&", "MI", ",", "bool", "NewMI", ",", "unsigned", "OpIdx1", ",", "unsigned", "OpIdx2", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "MRI", ".", "getRegClass", "(", "MI", ".", "getOperand", "(", "OpIdx2", ")", ".", "getReg", "(", ")", ")", "->", "hasSuperClassEq", "(", "&", "GB", "::", "R8RegClass", ")", ")", "{", "if", "(", "!", "safeToCommute", "(", "MI", ",", "OpIdx1", ",", "OpIdx2", ")", ")", "return", "nullptr", ";", "}", "return", "TargetInstrInfo", "::", "commuteInstructionImpl", "(", "MI", ",", "NewMI", ",", "OpIdx1", ",", "OpIdx2", ")", ";", "}", "</s>"], "natrual_language": ["Commutes", "the", "operands", "in", "the", "given", "instruction", "by", "changing", "the", "operands", "order", "and/or", "changing", "the", "instruction", "'s", "opcode", "and/or", "the", "immediate", "value", "operand", "."], "TS_V_token": ["GBZ80", "GB", "GB::R8RegClass"], "File": "GBZ80InstrInfo", "Func": "commuteInstructionImpl", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17416, "Length": 97}
{"ground_truth": ["<s>", "void", "GBZ80InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "const", "GBZ80Subtarget", "&", "STI", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "GBZ80RegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "Opc", ";", "if", "(", "GB", "::", "R16RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "unsigned", "DestLo", ",", "DestHi", ",", "SrcLo", ",", "SrcHi", ";", "TRI", ".", "splitReg", "(", "DestReg", ",", "DestLo", ",", "DestHi", ")", ";", "TRI", ".", "splitReg", "(", "SrcReg", ",", "SrcLo", ",", "SrcHi", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "GB", "::", "LD_r_r", ")", ",", "DestLo", ")", ".", "addReg", "(", "SrcLo", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "GB", "::", "LD_r_r", ")", ",", "DestHi", ")", ".", "addReg", "(", "SrcHi", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "if", "(", "GB", "::", "R8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "GB", "::", "LD_r_r", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "if", "(", "DestReg", "==", "GB", "::", "SP", "&&", "SrcReg", "==", "GB", "::", "RHL", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "GB", "::", "LD_SP_HL", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "}", "</s>"], "natrual_language": ["}", "Branch", "Analysis", "&", "Modification"], "TS_V_token": ["GBZ80", "GB", "GB", "GB", "GB", "GB::R16RegClass", "GB::LD_r_r", "GB::LD_r_r", "GB::R8RegClass", "GB::LD_r_r", "GB::SP", "GB::RHL", "GB::LD_SP_HL", "\"Impossible reg-to-reg copy\""], "File": "GBZ80InstrInfo", "Func": "copyPhysReg", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17417, "Length": 263}
{"ground_truth": ["<s>", "unsigned", "GBZ80InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "const", "MCInstrDesc", "&", "Desc", "=", "get", "(", "Opcode", ")", ";", "return", "Desc", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "GBZ80TargetMachine", "&", "TM", "=", "static_cast", "<", "const", "GBZ80TargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "return", "TII", ".", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "."], "TS_V_token": ["GBZ80", "GB", "0", "GB", "GB", "GB", "GB", "0"], "File": "GBZ80InstrInfo", "Func": "getInstSizeInBytes", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17418, "Length": 164}
{"ground_truth": ["<s>", "const", "GBZ80RegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>"], "natrual_language": ["getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80InstrInfo", "Func": "getRegisterInfo", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17419, "Length": 12}
{"ground_truth": ["<s>", "int", "GBZ80InstrInfo", "::", "getSPAdjust", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "GB", "::", "PUSH", ":", "return", "-", "2", ";", "case", "GB", "::", "POP", ":", "return", "2", ";", "case", "GB", "::", "ADD_SP_e", ":", "return", "(", "int8_t", ")", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "}", "return", "TargetInstrInfo", "::", "getSPAdjust", "(", "MI", ")", ";", "}", "</s>"], "natrual_language": ["getSPAdjust", "-", "This", "returns", "the", "stack", "pointer", "adjustment", "made", "by", "this", "instruction", "."], "TS_V_token": ["GBZ80", "GB", "GB::PUSH", "2", "GB::POP", "2", "GB::ADD_SP_e", "0"], "File": "GBZ80InstrInfo", "Func": "getSPAdjust", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17420, "Length": 68}
{"ground_truth": ["<s>", "unsigned", "GBZ80InstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "0", ";", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "%", "2", "==", "0", ")", "&&", "\"GBZ80 branch conditions must have a multiple of two components!\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "auto", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "GB", "::", "JP_nn", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "return", "1", ";", "}", "unsigned", "Count", "=", "0", ";", "for", "(", "auto", "I", "=", "Cond", ".", "rbegin", "(", ")", ";", "I", "!=", "Cond", ".", "rend", "(", ")", ";", "++", "I", ")", "{", "bool", "IsTrueBranch", "=", "I", "->", "getImm", "(", ")", ";", "++", "I", ";", "GBCC", "::", "CondCodes", "CC", "=", "(", "GBCC", "::", "CondCodes", ")", "I", "->", "getImm", "(", ")", ";", "MachineBasicBlock", "*", "Dest", "=", "IsTrueBranch", "?", "TBB", ":", "FBB", ";", "if", "(", "!", "Dest", ")", "{", "Dest", "=", "MBB", ".", "getNextNode", "(", ")", ";", "assert", "(", "std", "::", "next", "(", "MBB", ".", "getIterator", "(", ")", ")", "!=", "MBB", ".", "getParent", "(", ")", "->", "end", "(", ")", "&&", "\"Fallthrough at the end of a function?\"", ")", ";", "}", "auto", "&", "CondMI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "GB", "::", "JP_cc_nn", ")", ")", ".", "addMBB", "(", "Dest", ")", ".", "addImm", "(", "(", "int", ")", "CC", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "CondMI", ")", ";", "++", "Count", ";", "}", "if", "(", "FBB", ")", "{", "auto", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "GB", "::", "JP_nn", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>"], "natrual_language": ["Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "."], "TS_V_token": ["GBZ80", "GB", "0", "\"insertBranch must not be told to insert a fallthrough\"", "2", "0", "\"GBZ80 branch conditions must have a multiple of two components!\"", "\"Unconditional branch with multiple successors!\"", "GB::JP_nn", "1", "0", "GBCC::CondCodes", "GBCC::CondCodes", "\"Fallthrough at the end of a function?\"", "GB::JP_cc_nn", "GB::JP_nn"], "File": "GBZ80InstrInfo", "Func": "insertBranch", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17421, "Length": 331}
{"ground_truth": ["<s>", "unsigned", "GBZ80InstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "NewDestBB", ",", "const", "DebugLoc", "&", "DL", ",", "int64_t", "BrOffset", ",", "RegScavenger", "*", "RS", ")", "const", "{", "auto", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "GB", "::", "JP_nn", ")", ")", ".", "addMBB", "(", "&", "NewDestBB", ")", ";", "return", "getInstSizeInBytes", "(", "MI", ")", ";", "}", "</s>"], "natrual_language": ["Insert", "an", "unconditional", "indirect", "branch", "at", "the", "end", "of", "MBB", "to", "NewDestBB", "."], "TS_V_token": ["GBZ80", "GB", "GB::JP_nn"], "File": "GBZ80InstrInfo", "Func": "insertIndirectBranch", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17422, "Length": 60}
{"ground_truth": ["<s>", "bool", "GBZ80InstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOp", ",", "int64_t", "BrOffset", ")", "const", "{", "switch", "(", "BranchOp", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unexpected opcode!\"", ")", ";", "case", "GB", "::", "CALL_cc_nn", ":", "case", "GB", "::", "CALL_nn", ":", "case", "GB", "::", "JP_cc_nn", ":", "case", "GB", "::", "JP_nn", ":", "return", "true", ";", "case", "GB", "::", "JR_cc_e", ":", "case", "GB", "::", "JR_e", ":", "return", "BrOffset", ">=", "-", "127", "&&", "BrOffset", "<=", "129", ";", "}", "}", "</s>"], "natrual_language": ["Determine", "if", "the", "branch", "target", "is", "in", "range", "."], "TS_V_token": ["GBZ80", "GB", "\"unexpected opcode!\"", "GB::CALL_cc_nn", "GB::CALL_nn", "GB::JP_cc_nn", "GB::JP_nn", "GB::JR_cc_e", "GB::JR_e", "127", "129"], "File": "GBZ80InstrInfo", "Func": "isBranchOffsetInRange", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17423, "Length": 70}
{"ground_truth": ["<s>", "bool", "GBZ80InstrInfo", "::", "isConditionalBranch", "(", "const", "MachineInstr", "&", "I", ")", "const", "{", "return", "I", ".", "getOpcode", "(", ")", "==", "GB", "::", "JP_cc_nn", "||", "I", ".", "getOpcode", "(", ")", "==", "GB", "::", "JR_cc_e", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "this", "is", "a", "branch", "which", "may", "fall", "through", "to", "the", "next", "instruction", "or", "may", "transfer", "control", "flow", "to", "some", "other", "block", "."], "TS_V_token": ["GBZ80", "GB", "GB::JP_cc_nn", "GB::JR_cc_e"], "File": "GBZ80InstrInfo", "Func": "isConditionalBranch", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17424, "Length": 34}
{"ground_truth": ["<s>", "unsigned", "GBZ80InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "GB", "::", "LD8_FI", ":", "{", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "."], "TS_V_token": ["GBZ80", "GB", "GB::LD8_FI", "1", "1", "0", "0"], "File": "GBZ80InstrInfo", "Func": "isLoadFromStackSlot", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17425, "Length": 83}
{"ground_truth": ["<s>", "bool", "GBZ80InstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "*", "AI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "GB", "::", "LD_r_n", ":", "case", "GB", "::", "LD_dd_nn", ":", "return", "true", ";", "}", "}", "</s>"], "natrual_language": ["For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "."], "TS_V_token": ["GBZ80", "GB", "GB::LD_r_n", "GB::LD_dd_nn"], "File": "GBZ80InstrInfo", "Func": "isReallyTriviallyReMaterializable", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17426, "Length": 45}
{"ground_truth": ["<s>", "unsigned", "GBZ80InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "GB", "::", "ST8_FI", ":", "{", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "."], "TS_V_token": ["GBZ80", "GB", "GB::ST8_FI", "1", "0", "1", "0"], "File": "GBZ80InstrInfo", "Func": "isStoreToStackSlot", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17427, "Length": 83}
{"ground_truth": ["<s>", "bool", "GBZ80InstrInfo", "::", "isUnconditionalBranch", "(", "const", "MachineInstr", "&", "I", ")", "const", "{", "return", "I", ".", "getOpcode", "(", ")", "==", "GB", "::", "JP_nn", "||", "I", ".", "getOpcode", "(", ")", "==", "GB", "::", "JR_e", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "this", "is", "a", "branch", "which", "always", "transfers", "control", "flow", "to", "some", "other", "block", "."], "TS_V_token": ["GBZ80", "GB", "GB::JP_nn", "GB::JR_e"], "File": "GBZ80InstrInfo", "Func": "isUnconditionalBranch", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17428, "Length": 34}
{"ground_truth": ["<s>", "void", "GBZ80InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "GB", "::", "LD8_FI", ";", "}", "else", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i16", ")", ")", "{", "assert", "(", "false", "&&", "\"not implemented\"", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot load this register from a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>"], "natrual_language": ["Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "."], "TS_V_token": ["GBZ80", "GB", "0", "MVT::i8", "GB::LD8_FI", "MVT::i16", "\"not implemented\"", "\"Cannot load this register from a stack slot!\""], "File": "GBZ80InstrInfo", "Func": "loadRegFromStackSlot", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17429, "Length": 199}
{"ground_truth": ["<s>", "void", "GBZ80InstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "&", "Orig", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "&", "Orig", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "MachineInstr", "&", "NewMI", "=", "*", "std", "::", "prev", "(", "I", ")", ";", "NewMI", ".", "substituteRegister", "(", "Orig", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "DestReg", ",", "SubIdx", ",", "TRI", ")", ";", "}", "</s>"], "natrual_language": ["Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "."], "TS_V_token": ["GBZ80", "GB", "0"], "File": "GBZ80InstrInfo", "Func": "reMaterialize", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17430, "Length": 92}
{"ground_truth": ["<s>", "unsigned", "GBZ80InstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "!", "isUnconditionalBranch", "(", "*", "I", ")", "&&", "!", "isConditionalBranch", "(", "*", "I", ")", ")", "{", "break", ";", "}", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "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": ["GBZ80", "GB", "0", "0"], "File": "GBZ80InstrInfo", "Func": "removeBranch", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17431, "Length": 121}
{"ground_truth": ["<s>", "bool", "GBZ80InstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "(", "Cond", ".", "size", "(", ")", "%", "2", "==", "0", ")", "&&", "\"Invalid GBZ80 branch condition!\"", ")", ";", "return", "!", "invertCondition", "(", "Cond", ")", ";", "}", "</s>"], "natrual_language": ["Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "."], "TS_V_token": ["GBZ80", "GB", "2", "0", "\"Invalid GBZ80 branch condition!\""], "File": "GBZ80InstrInfo", "Func": "reverseBranchCondition", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17432, "Length": 39}
{"ground_truth": ["<s>", "void", "GBZ80InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "GBZ80MachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "AFI", "->", "setHasSpills", "(", "true", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "GB", "::", "ST8_FI", ";", "}", "else", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i16", ")", ")", "{", "assert", "(", "false", "&&", "\"not implemented\"", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot store this register into a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>"], "natrual_language": ["Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "."], "TS_V_token": ["GBZ80", "GB", "GB", "GB", "0", "MVT::i8", "GB::ST8_FI", "MVT::i16", "\"not implemented\"", "\"Cannot store this register into a stack slot!\""], "File": "GBZ80InstrInfo", "Func": "storeRegToStackSlot", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17433, "Length": 230}
{"ground_truth": ["<s>", "SDNode", "*", "GBZ80DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "DebugLoc", "dl", "=", "Node", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "return", "ResNode", ";", "}", "</s>"], "natrual_language": ["Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80ISelDAGToDAG (2)", "Func": "Select", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17434, "Length": 47}
{"ground_truth": ["<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"GBZ80 DAG->DAG Instruction Selection\"", ";", "}", "</s>"], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["GBZ80", "\"GBZ80 DAG->DAG Instruction Selection\""], "File": "GBZ80ISelDAGToDAG", "Func": "getPassName", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17435, "Length": 11}
{"ground_truth": ["<s>", "bool", "GBZ80DAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["GBZ80", "GB", "GB"], "File": "GBZ80ISelDAGToDAG", "Func": "runOnMachineFunction", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17436, "Length": 31}
{"ground_truth": ["<s>", "void", "GBZ80DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "if", "(", "trySelect", "(", "N", ")", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", "</s>"], "natrual_language": ["Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "."], "TS_V_token": ["GBZ80", "GB", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1"], "File": "GBZ80ISelDAGToDAG", "Func": "Select", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17437, "Length": 89}
{"ground_truth": ["<s>", "MachineBasicBlock", "*", "GBZ80TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "GBZ80", "::", "SELECT8", ":", "case", "GBZ80", "::", "SELECT16", ":", "return", "EmitSelectInstr", "(", "MI", ",", "MBB", ")", ";", "case", "GBZ80", "::", "SHL8", ":", "case", "GBZ80", "::", "LSHR8", ":", "case", "GBZ80", "::", "ASHR8", ":", "case", "GBZ80", "::", "SHL16", ":", "case", "GBZ80", "::", "LSHR16", ":", "case", "GBZ80", "::", "ASHR16", ":", "return", "EmitShiftInstr", "(", "MI", ",", "MBB", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid Custom Inserter Instruction\"", ")", ";", "}", "}", "</s>"], "natrual_language": ["This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "."], "TS_V_token": ["GBZ80", "GB", "GBZ80::SELECT8", "GBZ80::SELECT16", "GBZ80::SHL8", "GBZ80::LSHR8", "GBZ80::ASHR8", "GBZ80::SHL16", "GBZ80::LSHR16", "GBZ80::ASHR16", "\"Invalid Custom Inserter Instruction\""], "File": "GBZ80ISelLowering (2)", "Func": "EmitInstrWithCustomInserter", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17438, "Length": 95}
{"ground_truth": ["<s>", "virtual", "MVT", "getScalarShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i8", ";", "}", "</s>"], "natrual_language": ["Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "."], "TS_V_token": ["GBZ80", "MVT::i8"], "File": "GBZ80ISelLowering (2)", "Func": "getScalarShiftAmountTy", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17439, "Length": 15}
{"ground_truth": ["<s>", "const", "char", "*", "GBZ80TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "NULL", ";", "case", "GBZ80ISD", "::", "WRAPPER", ":", "return", "\"GBZ80ISD::WRAPPER\"", ";", "case", "GBZ80ISD", "::", "SCF", ":", "return", "\"GBZ80ISD::SCF\"", ";", "case", "GBZ80ISD", "::", "CCF", ":", "return", "\"GBZ80ISD::CCF\"", ";", "case", "GBZ80ISD", "::", "RLC", ":", "return", "\"GBZ80ISD::RLC\"", ";", "case", "GBZ80ISD", "::", "RRC", ":", "return", "\"GBZ80ISD::RRC\"", ";", "case", "GBZ80ISD", "::", "RL", ":", "return", "\"GBZ80ISD::RL\"", ";", "case", "GBZ80ISD", "::", "RR", ":", "return", "\"GBZ80ISD::RR\"", ";", "case", "GBZ80ISD", "::", "SLA", ":", "return", "\"GBZ80ISD::SLA\"", ";", "case", "GBZ80ISD", "::", "SRA", ":", "return", "\"GBZ80ISD::SRA\"", ";", "case", "GBZ80ISD", "::", "SLL", ":", "return", "\"GBZ80ISD::SLL\"", ";", "case", "GBZ80ISD", "::", "SRL", ":", "return", "\"GBZ80ISD::SRL\"", ";", "case", "GBZ80ISD", "::", "SHL", ":", "return", "\"GBZ80ISD::SHL\"", ";", "case", "GBZ80ISD", "::", "LSHR", ":", "return", "\"GBZ80ISD::LSHR\"", ";", "case", "GBZ80ISD", "::", "ASHR", ":", "return", "\"GBZ80ISD::ASHR\"", ";", "case", "GBZ80ISD", "::", "CP", ":", "return", "\"GBZ80ISD::CP\"", ";", "case", "GBZ80ISD", "::", "SELECT_CC", ":", "return", "\"GBZ80ISD::SELECT_CC\"", ";", "case", "GBZ80ISD", "::", "BR_CC", ":", "return", "\"GBZ80ISD::BR_CC\"", ";", "case", "GBZ80ISD", "::", "CALL", ":", "return", "\"GBZ80ISD::CALL\"", ";", "case", "GBZ80ISD", "::", "RET", ":", "return", "\"GBZ80ISD::RET\"", ";", "}", "}", "</s>"], "natrual_language": ["getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific"], "TS_V_token": ["GBZ80", "GB", "GBZ80ISD::WRAPPER", "\"GBZ80ISD::WRAPPER\"", "GBZ80ISD::SCF", "\"GBZ80ISD::SCF\"", "GBZ80ISD::CCF", "\"GBZ80ISD::CCF\"", "GBZ80ISD::RLC", "\"GBZ80ISD::RLC\"", "GBZ80ISD::RRC", "\"GBZ80ISD::RRC\"", "GBZ80ISD::RL", "\"GBZ80ISD::RL\"", "GBZ80ISD::RR", "\"GBZ80ISD::RR\"", "GBZ80ISD::SLA", "\"GBZ80ISD::SLA\"", "GBZ80ISD::SRA", "\"GBZ80ISD::SRA\"", "GBZ80ISD::SLL", "\"GBZ80ISD::SLL\"", "GBZ80ISD::SRL", "\"GBZ80ISD::SRL\"", "GBZ80ISD::SHL", "\"GBZ80ISD::SHL\"", "GBZ80ISD::LSHR", "\"GBZ80ISD::LSHR\"", "GBZ80ISD::ASHR", "\"GBZ80ISD::ASHR\"", "GBZ80ISD::CP", "\"GBZ80ISD::CP\"", "GBZ80ISD::SELECT_CC", "\"GBZ80ISD::SELECT_CC\"", "GBZ80ISD::BR_CC", "\"GBZ80ISD::BR_CC\"", "GBZ80ISD::CALL", "\"GBZ80ISD::CALL\"", "GBZ80ISD::RET", "\"GBZ80ISD::RET\""], "File": "GBZ80ISelLowering (2)", "Func": "getTargetNodeName", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17440, "Length": 176}
{"ground_truth": ["<s>", "SDValue", "GBZ80TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "Flag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "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_GBZ80", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "Flag", ")", ".", "getValue", "(", "1", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "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": ["GBZ80", "GB", "ISD::InputArg", "16", "GB", "0", "1", "2", "0"], "File": "GBZ80ISelLowering (2)", "Func": "LowerCallResult", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17441, "Length": 170}
{"ground_truth": ["<s>", "SDValue", "GBZ80TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "GBZ80MachineFunctionInfo", "*", "GBZ80FI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_GBZ80", ")", ";", "assert", "(", "!", "isVarArg", "&&", "\"Varargs not supported yet!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "SDValue", "ArgValue", ";", "unsigned", "VReg", ";", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "switch", "(", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "{", "errs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "case", "MVT", "::", "i8", ":", "VReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "GBZ80", "::", "GR8RegClass", ")", ";", "MRI", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "break", ";", "case", "MVT", "::", "i16", ":", "VReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "GBZ80", "::", "GR16RegClass", ")", ";", "MRI", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "break", ";", "}", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "GBZ80FI", "->", "setNeedFP", "(", ")", ";", "SDValue", "InVal", ";", "unsigned", "Size", "=", "VA", ".", "getLocVT", "(", ")", ".", "getStoreSize", "(", ")", ";", "if", "(", "Size", ">", "2", ")", "errs", "(", ")", "<<", "\"LowerFormalArguments unhandled argument type: \"", "<<", "EVT", "(", "VA", ".", "getLocVT", "(", ")", ")", ".", "getEVTString", "(", ")", "<<", "\"\\n\"", ";", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "Size", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "true", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i16", ")", ";", "InVal", "=", "DAG", ".", "getLoad", "(", "VA", ".", "getLocVT", "(", ")", ",", "dl", ",", "Chain", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "false", ",", "false", ",", "false", ",", "0", ")", ";", "InVals", ".", "push_back", "(", "InVal", ")", ";", "}", "}", "return", "Chain", ";", "}", "</s>"], "natrual_language": ["This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "."], "TS_V_token": ["GBZ80", "GB", "ISD::InputArg", "GB", "GB", "GB", "16", "GB", "\"Varargs not supported yet!\"", "0", "\"LowerFormalArguments Unhandled argument type: \"", "\"\\n\"", "0", "MVT::i8", "GBZ80::GR8RegClass", "MVT::i16", "GBZ80::GR16RegClass", "GB", "2", "\"LowerFormalArguments unhandled argument type: \"", "\"\\n\"", "MVT::i16", "0"], "File": "GBZ80ISelLowering (2)", "Func": "LowerFormalArguments", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17442, "Length": 474}
{"ground_truth": ["<s>", "SDValue", "GBZ80TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "LowerZExt", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSExt", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "SUBC", ":", "return", "LowerSUB", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "ROTL", ":", "case", "ISD", "::", "ROTR", ":", "return", "LowerShifts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "return", "LowerBinaryOp", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSelectCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBrCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerStore", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLoad", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operation\"", ")", ";", "}", "}", "</s>"], "natrual_language": ["LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "."], "TS_V_token": ["GBZ80", "GB", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::SUB", "ISD::SUBC", "ISD::SRL", "ISD::SHL", "ISD::SRA", "ISD::ROTL", "ISD::ROTR", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::SELECT_CC", "ISD::BR_CC", "ISD::GlobalAddress", "ISD::STORE", "ISD::LOAD", "\"unimplemented operation\""], "File": "GBZ80ISelLowering (2)", "Func": "LowerOperation", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17443, "Length": 197}
{"ground_truth": ["<s>", "SDValue", "GBZ80TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_GBZ80", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "i", "++", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "GBZ80ISD", "::", "RET", ",", "dl", ",", "MVT", "::", "Other", ")", ";", "}", "</s>"], "natrual_language": ["This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "."], "TS_V_token": ["GBZ80", "GB", "ISD::OutputArg", "16", "GB", "4", "1", "0", "\"Can only return in registers!\"", "1", "0", "GBZ80ISD::RET", "MVT::Other"], "File": "GBZ80ISelLowering (2)", "Func": "LowerReturn", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17444, "Length": 233}
{"ground_truth": ["<s>", "bool", "GBZ80TargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "CCFunction", ")", ";", "}", "</s>"], "natrual_language": ["This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "."], "TS_V_token": ["GBZ80", "GB", "ISD::OutputArg", "16"], "File": "GBZ80ISelLowering", "Func": "CanLowerReturn", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17445, "Length": 74}
{"ground_truth": ["<s>", "CCAssignFn", "*", "GBZ80TargetLowering", "::", "CCAssignFnForReturn", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "switch", "(", "CC", ")", "{", "default", ":", "return", "RetCC_GBZ80", ";", "}", "}", "</s>"], "natrual_language": ["Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "."], "TS_V_token": ["GBZ80", "GB", "GB"], "File": "GBZ80ISelLowering", "Func": "CCAssignFnForReturn", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17446, "Length": 25}
{"ground_truth": ["<s>", "MachineBasicBlock", "*", "GBZ80TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "llvm_unreachable", "(", "\"Custom inserters are disabled.\"", ")", ";", "return", "nullptr", ";", "}", "</s>"], "natrual_language": ["This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "."], "TS_V_token": ["GBZ80", "GB", "\"Custom inserters are disabled.\""], "File": "GBZ80ISelLowering", "Func": "EmitInstrWithCustomInserter", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17447, "Length": 25}
{"ground_truth": ["<s>", "MVT", "::", "SimpleValueType", "getCmpLibcallReturnType", "(", ")", "const", "override", "{", "return", "MVT", "::", "i8", ";", "}", "</s>"], "natrual_language": ["Return", "the", "ValueType", "for", "comparison", "libcalls", "."], "TS_V_token": ["GBZ80", "MVT::SimpleValueType", "MVT::i8"], "File": "GBZ80ISelLowering", "Func": "getCmpLibcallReturnType", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17448, "Length": 15}
{"ground_truth": ["<s>", "static", "StringRef", "getFunctionName", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ")", "{", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "if", "(", "const", "ExternalSymbolSDNode", "*", "G", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "{", "return", "G", "->", "getSymbol", "(", ")", ";", "}", "if", "(", "const", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "return", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "}", "llvm_unreachable", "(", "\"don't know how to get the name for this callee\"", ")", ";", "}", "</s>"], "natrual_language": ["Get", "the", "entire", "name", "of", "this", "function", "."], "TS_V_token": ["GBZ80", "\"don't know how to get the name for this callee\""], "File": "GBZ80ISelLowering", "Func": "getFunctionName", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17449, "Length": 76}
{"ground_truth": ["<s>", "bool", "GBZ80TargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", ";", "SDLoc", "DL", "(", "N", ")", ";", "if", "(", "const", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "if", "(", "LD", "->", "getExtensionType", "(", ")", "!=", "ISD", "::", "NON_EXTLOAD", ")", "return", "false", ";", "}", "else", "if", "(", "const", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "}", "else", "{", "return", "false", ";", "}", "if", "(", "VT", "!=", "MVT", "::", "i8", ")", "{", "return", "false", ";", "}", "if", "(", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", "&&", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "SUB", ")", "{", "return", "false", ";", "}", "if", "(", "const", "ConstantSDNode", "*", "RHS", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ")", "{", "int", "RHSC", "=", "RHS", "->", "getSExtValue", "(", ")", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", ")", "RHSC", "=", "-", "RHSC", ";", "if", "(", "RHSC", "==", "1", ")", "{", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "Offset", "=", "DAG", ".", "getConstant", "(", "RHSC", ",", "DL", ",", "MVT", "::", "i16", ")", ";", "AM", "=", "ISD", "::", "POST_INC", ";", "return", "true", ";", "}", "else", "if", "(", "RHSC", "==", "-", "1", ")", "{", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "Offset", "=", "DAG", ".", "getConstant", "(", "RHSC", ",", "DL", ",", "MVT", "::", "i16", ")", ";", "AM", "=", "ISD", "::", "POST_DEC", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "."], "TS_V_token": ["GBZ80", "GB", "ISD::MemIndexedMode", "ISD::NON_EXTLOAD", "MVT::i8", "ISD::ADD", "ISD::SUB", "1", "ISD::SUB", "1", "0", "MVT::i16", "ISD::POST_INC", "1", "0", "MVT::i16", "ISD::POST_DEC"], "File": "GBZ80ISelLowering", "Func": "getPostIndexedAddressParts", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17450, "Length": 290}
{"ground_truth": ["<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", "LHSTy", ")", "const", "override", "{", "return", "MVT", "::", "i8", ";", "}", "</s>"], "natrual_language": ["Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "."], "TS_V_token": ["GBZ80", "MVT::i8"], "File": "GBZ80ISelLowering", "Func": "getScalarShiftAmountTy", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17451, "Length": 19}
{"ground_truth": ["<s>", "EVT", "GBZ80TargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "assert", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "\"No GBZ80 SetCC type for vectors!\"", ")", ";", "return", "MVT", "::", "i8", ";", "}", "</s>"], "natrual_language": ["Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "."], "TS_V_token": ["GBZ80", "GB", "\"No GBZ80 SetCC type for vectors!\"", "MVT::i8"], "File": "GBZ80ISelLowering", "Func": "getSetCCResultType", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17452, "Length": 36}
{"ground_truth": ["<s>", "const", "char", "*", "GBZ80TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "GBISD", "::", "name", ":", "\\", "return", "#", "name", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "NODE", "(", "RET_FLAG", ")", ";", "NODE", "(", "RETI_FLAG", ")", ";", "NODE", "(", "CALL", ")", ";", "NODE", "(", "WRAPPER", ")", ";", "NODE", "(", "FI", ")", ";", "NODE", "(", "LSL", ")", ";", "NODE", "(", "LSR", ")", ";", "NODE", "(", "ROL", ")", ";", "NODE", "(", "ROR", ")", ";", "NODE", "(", "ASR", ")", ";", "NODE", "(", "LSLLOOP", ")", ";", "NODE", "(", "LSRLOOP", ")", ";", "NODE", "(", "ASRLOOP", ")", ";", "NODE", "(", "BRCOND", ")", ";", "NODE", "(", "CMP", ")", ";", "NODE", "(", "CMPC", ")", ";", "NODE", "(", "TST", ")", ";", "NODE", "(", "SELECT_CC", ")", ";", "NODE", "(", "SELECT_BR", ")", ";", "NODE", "(", "BR16", ")", ";", "}", "</s>"], "natrual_language": ["getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific"], "TS_V_token": ["GBZ80", "GB", "GBISD::name"], "File": "GBZ80ISelLowering", "Func": "getTargetNodeName", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17453, "Length": 132}
{"ground_truth": ["<s>", "bool", "GBZ80TargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "int64_t", "Offs", "=", "AM", ".", "BaseOffs", ";", "if", "(", "AM", ".", "BaseGV", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "Offs", "==", "0", ")", "{", "return", "true", ";", "}", "if", "(", "!", "AM", ".", "BaseGV", "&&", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "Offs", "==", "0", ")", "{", "return", "true", ";", "}", "if", "(", "!", "AM", ".", "BaseGV", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "1", "&&", "Offs", "==", "0", ")", "{", "return", "true", ";", "}", "if", "(", "!", "AM", ".", "BaseGV", "&&", "!", "AM", ".", "HasBaseReg", "&&", "Offs", ">=", "0xFF00", ")", "{", "return", "(", "AM", ".", "Scale", "==", "1", "&&", "Offs", "==", "0xFF00", ")", "||", "(", "AM", ".", "Scale", "==", "0", "&&", "Offs", "<=", "0xFFFF", ")", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "."], "TS_V_token": ["GBZ80", "GB", "0", "0", "0", "0", "1", "0", "0xFF00", "1", "0xFF00", "0", "0xFFFF"], "File": "GBZ80ISelLowering", "Func": "isLegalAddressingMode", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17454, "Length": 161}
{"ground_truth": ["<s>", "bool", "GBZ80TargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80ISelLowering", "Func": "isOffsetFoldingLegal", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17455, "Length": 16}
{"ground_truth": ["<s>", "SDValue", "GBZ80TargetLowering", "::", "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", "(", ")", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "CCFunction", ")", ";", "if", "(", "RVLocs", ".", "size", "(", ")", ">", "1", ")", "{", "std", "::", "reverse", "(", "RVLocs", ".", "begin", "(", ")", ",", "RVLocs", ".", "end", "(", ")", ")", ";", "}", "for", "(", "CCValAssign", "const", "&", "RVLoc", ":", "RVLocs", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLoc", ".", "getLocReg", "(", ")", ",", "RVLoc", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "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": ["GBZ80", "GB", "ISD::InputArg", "16", "1", "1", "2", "0"], "File": "GBZ80ISelLowering", "Func": "LowerCallResult", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17456, "Length": 190}
{"ground_truth": ["<s>", "SDValue", "GBZ80TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom lower this!\"", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "ROTL", ":", "case", "ISD", "::", "ROTR", ":", "return", "LowerShifts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerDivRem", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>"], "natrual_language": ["LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "."], "TS_V_token": ["GBZ80", "GB", "\"Don't know how to custom lower this!\"", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::ROTL", "ISD::ROTR", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::FrameIndex", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VASTART", "ISD::SDIVREM", "ISD::UDIVREM", "ISD::LOAD"], "File": "GBZ80ISelLowering", "Func": "LowerOperation", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17457, "Length": 192}
{"ground_truth": ["<s>", "SDValue", "GBZ80TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCFunction", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "if", "(", "e", ">", "1", ")", "{", "std", "::", "reverse", "(", "RVLocs", ".", "begin", "(", ")", ",", "RVLocs", ".", "end", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "Attribute", "::", "Naked", ")", ")", "{", "return", "Chain", ";", "}", "unsigned", "RetOpc", "=", "GBISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "RetOpc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>"], "natrual_language": ["This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "."], "TS_V_token": ["GBZ80", "GB", "ISD::OutputArg", "16", "1", "4", "1", "0", "\"Can only return in registers!\"", "1", "GBISD::RET_FLAG", "0", "MVT::Other"], "File": "GBZ80ISelLowering", "Func": "LowerReturn", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17458, "Length": 320}
{"ground_truth": ["<s>", "SDValue", "GBZ80TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ")", ";", "}", "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": ["GBZ80", "GB", "ISD::ADD"], "File": "GBZ80ISelLowering", "Func": "PerformDAGCombine", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17459, "Length": 48}
{"ground_truth": ["<s>", "void", "GBZ80TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ADD", ":", "{", "if", "(", "const", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", ")", "{", "SDValue", "Sub", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "N", "->", "getValueType", "(", "0", ")", ",", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ".", "getConstant", "(", "-", "C", "->", "getAPIntValue", "(", ")", ",", "DL", ",", "C", "->", "getValueType", "(", "0", ")", ")", ")", ";", "Results", ".", "push_back", "(", "Sub", ")", ";", "}", "break", ";", "}", "default", ":", "{", "SDValue", "Res", "=", "LowerOperation", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Res", "->", "getNumValues", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "I", ")", ")", ";", "break", ";", "}", "}", "}", "</s>"], "natrual_language": ["ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "."], "TS_V_token": ["GBZ80", "GB", "ISD::ADD", "1", "ISD::SUB", "0", "0", "0", "0", "0"], "File": "GBZ80ISelLowering", "Func": "ReplaceNodeResults", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17460, "Length": 181}
{"ground_truth": ["<s>", "void", "GBZ80MCCodeEmitter", "::", "emitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", "{", "const", "uint16_t", "*", "Words", "=", "reinterpret_cast", "<", "uint16_t", "const", "*", ">", "(", "&", "Val", ")", ";", "size_t", "WordCount", "=", "Size", "/", "2", ";", "for", "(", "int64_t", "i", "=", "WordCount", "-", "1", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "uint16_t", "Word", "=", "Words", "[", "i", "]", ";", "OS", "<<", "(", "uint8_t", ")", "(", "(", "Word", "&", "0x00ff", ")", ">>", "0", ")", ";", "OS", "<<", "(", "uint8_t", ")", "(", "(", "Word", "&", "0xff00", ")", ">>", "8", ")", ";", "}", "}", "</s>"], "natrual_language": ["Targets", "should", "implement", "this", "to", "emit", "instructions", "."], "TS_V_token": ["GBZ80", "GB", "2", "1", "0", "0x00ff", "0", "0xff00", "8"], "File": "GBZ80MCCodeEmitter", "Func": "emitInstruction", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17461, "Length": 102}
{"ground_truth": ["<s>", "void", "GBZ80MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "assert", "(", "Size", ">", "0", "&&", "\"Instruction size cannot be zero\"", ")", ";", "uint64_t", "BinaryOpCode", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "emitInstruction", "(", "BinaryOpCode", ",", "Size", ",", "STI", ",", "OS", ")", ";", "}", "</s>"], "natrual_language": ["Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "."], "TS_V_token": ["GBZ80", "GB", "0", "\"Instruction size cannot be zero\""], "File": "GBZ80MCCodeEmitter", "Func": "encodeInstruction", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17462, "Length": 86}
{"ground_truth": ["<s>", "unsigned", "GBZ80MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "return", "getExprOpValue", "(", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "}", "</s>"], "natrual_language": ["getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "."], "TS_V_token": ["GBZ80", "GB", "32"], "File": "GBZ80MCCodeEmitter", "Func": "getMachineOpValue", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17463, "Length": 135}
{"ground_truth": ["<s>", "static", "bool", "classof", "(", "const", "MCExpr", "*", "E", ")", "{", "return", "E", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Target", ";", "}", "</s>"], "natrual_language": ["Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":"], "TS_V_token": ["GBZ80"], "File": "GBZ80MCExpr", "Func": "classof", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17464, "Length": 22}
{"ground_truth": ["<s>", "const", "GBZ80MCExpr", "*", "GBZ80MCExpr", "::", "create", "(", "VariantKind", "Kind", ",", "const", "MCExpr", "*", "Expr", ",", "bool", "Negated", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "GBZ80MCExpr", "(", "Kind", ",", "Expr", ",", "Negated", ")", ";", "}", "</s>"], "natrual_language": ["This", "creates", "an", "identified", "struct", "."], "TS_V_token": ["GBZ80", "GB", "GB", "GB"], "File": "GBZ80MCExpr", "Func": "create", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17465, "Length": 38}
{"ground_truth": ["<s>", "bool", "GBZ80MCExpr", "::", "evaluateAsConstant", "(", "int64_t", "&", "Result", ")", "const", "{", "MCValue", "Value", ";", "bool", "isRelocatable", "=", "getSubExpr", "(", ")", "->", "evaluateAsRelocatable", "(", "Value", ",", "nullptr", ",", "nullptr", ")", ";", "if", "(", "!", "isRelocatable", ")", "return", "false", ";", "if", "(", "Value", ".", "isAbsolute", "(", ")", ")", "{", "Result", "=", "evaluateAsInt64", "(", "Value", ".", "getConstant", "(", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Evaluates", "the", "fixup", "as", "a", "constant", "value", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80MCExpr", "Func": "evaluateAsConstant", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17466, "Length": 66}
{"ground_truth": ["<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>"], "natrual_language": ["Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80MCExpr", "Func": "findAssociatedFragment", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17467, "Length": 18}
{"ground_truth": ["<s>", "GB", "::", "Fixups", "GBZ80MCExpr", "::", "getFixupKind", "(", ")", "const", "{", "GB", "::", "Fixups", "Kind", "=", "GB", "::", "Fixups", "::", "LastTargetFixupKind", ";", "switch", "(", "getKind", "(", ")", ")", "{", "case", "VK_GBZ80_LO8", ":", "Kind", "=", "isNegated", "(", ")", "?", "GB", "::", "fixup_lo8_ldi_neg", ":", "GB", "::", "fixup_lo8_ldi", ";", "break", ";", "case", "VK_GBZ80_HI8", ":", "Kind", "=", "isNegated", "(", ")", "?", "GB", "::", "fixup_hi8_ldi_neg", ":", "GB", "::", "fixup_hi8_ldi", ";", "break", ";", "case", "VK_GBZ80_HH8", ":", "Kind", "=", "isNegated", "(", ")", "?", "GB", "::", "fixup_hh8_ldi_neg", ":", "GB", "::", "fixup_hh8_ldi", ";", "break", ";", "case", "VK_GBZ80_HHI8", ":", "Kind", "=", "isNegated", "(", ")", "?", "GB", "::", "fixup_ms8_ldi_neg", ":", "GB", "::", "fixup_ms8_ldi", ";", "break", ";", "case", "VK_GBZ80_PM_LO8", ":", "Kind", "=", "isNegated", "(", ")", "?", "GB", "::", "fixup_lo8_ldi_pm_neg", ":", "GB", "::", "fixup_lo8_ldi_pm", ";", "break", ";", "case", "VK_GBZ80_PM_HI8", ":", "Kind", "=", "isNegated", "(", ")", "?", "GB", "::", "fixup_hi8_ldi_pm_neg", ":", "GB", "::", "fixup_hi8_ldi_pm", ";", "break", ";", "case", "VK_GBZ80_PM_HH8", ":", "Kind", "=", "isNegated", "(", ")", "?", "GB", "::", "fixup_hh8_ldi_pm_neg", ":", "GB", "::", "fixup_hh8_ldi_pm", ";", "break", ";", "case", "VK_GBZ80_None", ":", "llvm_unreachable", "(", "\"Uninitialized expression\"", ")", ";", "}", "return", "Kind", ";", "}", "</s>"], "natrual_language": ["getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "."], "TS_V_token": ["GBZ80", "GB::Fixups", "GB", "GB::Fixups", "GB::Fixups", "GB", "GB::fixup_lo8_ldi_neg", "GB::fixup_lo8_ldi", "GB", "GB::fixup_hi8_ldi_neg", "GB::fixup_hi8_ldi", "GB", "GB::fixup_hh8_ldi_neg", "GB::fixup_hh8_ldi", "GB", "GB::fixup_ms8_ldi_neg", "GB::fixup_ms8_ldi", "GB", "GB::fixup_lo8_ldi_pm_neg", "GB::fixup_lo8_ldi_pm", "GB", "GB::fixup_hi8_ldi_pm_neg", "GB::fixup_hi8_ldi_pm", "GB", "GB::fixup_hh8_ldi_pm_neg", "GB::fixup_hh8_ldi_pm", "GB", "\"Uninitialized expression\""], "File": "GBZ80MCExpr", "Func": "getFixupKind", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17468, "Length": 174}
{"ground_truth": ["<s>", "VariantKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "Kind", "of", "lane", "offset", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80MCExpr", "Func": "getKind", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17469, "Length": 10}
{"ground_truth": ["<s>", "const", "char", "*", "GBZ80MCExpr", "::", "getName", "(", ")", "const", "{", "const", "auto", "&", "Modifier", "=", "std", "::", "find_if", "(", "std", "::", "begin", "(", "ModifierNames", ")", ",", "std", "::", "end", "(", "ModifierNames", ")", ",", "[", "this", "]", "(", "ModifierEntry", "const", "&", "Mod", ")", "{", "return", "Mod", ".", "VariantKind", "==", "Kind", ";", "}", ")", ";", "if", "(", "Modifier", "!=", "std", "::", "end", "(", "ModifierNames", ")", ")", "{", "return", "Modifier", "->", "Spelling", ";", "}", "return", "nullptr", ";", "}", "</s>"], "natrual_language": ["Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80MCExpr", "Func": "getName", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17470, "Length": 75}
{"ground_truth": ["<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "SubExpr", ";", "}", "</s>"], "natrual_language": ["getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80MCExpr", "Func": "getSubExpr", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17471, "Length": 12}
{"ground_truth": ["<s>", "void", "GBZ80MCInstLower", "::", "lowerInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "MachineOperand", "const", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "MI", ".", "print", "(", "errs", "(", ")", ")", ";", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "continue", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "continue", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>"], "natrual_language": ["Lowers", "a", "MachineInstr", "into", "a", "MCInst", "."], "TS_V_token": ["GBZ80", "GB", "\"unknown operand type\""], "File": "GBZ80MCInstLower", "Func": "lowerInstruction", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17472, "Length": 292}
{"ground_truth": ["<s>", "void", "canonicalize", "(", ")", "{", "if", "(", "!", "isLHSReg", "(", ")", "&&", "isRHSReg", "(", ")", ")", "{", "std", "::", "swap", "(", "LHSReg", ",", "RHSReg", ")", ";", "std", "::", "swap", "(", "LHSImm", ",", "RHSImm", ")", ";", "CC", "=", "ISD", "::", "getSetCCSwappedOperands", "(", "CC", ")", ";", "}", "}", "</s>"], "natrual_language": ["Form", "a", "canonical", "key", "for", "the", "specified", "mangling", "."], "TS_V_token": ["GBZ80", "ISD::getSetCCSwappedOperands"], "File": "GBZ80PostISel", "Func": "canonicalize", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17473, "Length": 46}
{"ground_truth": ["<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "PASS_NAME", ";", "}", "</s>"], "natrual_language": ["getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80PostISel", "Func": "getPassName", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17474, "Length": 11}
{"ground_truth": ["<s>", "void", "initialize", "(", "unsigned", "LHS", ",", "unsigned", "RHS", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "True", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "LHSReg", "=", "LHS", ";", "RHSReg", "=", "RHS", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "LHS", ")", ")", "{", "MachineInstr", "*", "DefI", "=", "MRI", ".", "getVRegDef", "(", "LHS", ")", ";", "if", "(", "DefI", "->", "getOpcode", "(", ")", "==", "GB", "::", "LD_dd_nn", ")", "{", "LHSReg", "=", "0", ";", "LHSImm", "=", "DefI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "}", "}", "if", "(", "!", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "RHSReg", ")", ")", "{", "MachineInstr", "*", "DefI", "=", "MRI", ".", "getVRegDef", "(", "RHSReg", ")", ";", "if", "(", "DefI", "->", "getOpcode", "(", ")", "==", "GB", "::", "LD_dd_nn", ")", "{", "RHSReg", "=", "0", ";", "RHSImm", "=", "DefI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "}", "}", "canonicalize", "(", ")", ";", "}", "</s>"], "natrual_language": ["Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "."], "TS_V_token": ["GBZ80", "GB::LD_dd_nn", "0", "1", "GB::LD_dd_nn", "0", "1"], "File": "GBZ80PostISel", "Func": "initialize", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17475, "Length": 145}
{"ground_truth": ["<s>", "bool", "GBZ80PostISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "Modified", "|=", "expandShiftLoop16", "(", ")", ";", "Modified", "|=", "expandPseudos", "(", ")", ";", "Modified", "|=", "expandBranch16", "(", ")", ";", "Modified", "|=", "optimizeCP", "(", ")", ";", "return", "Modified", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["GBZ80", "GB", "GB", "GB"], "File": "GBZ80PostISel", "Func": "runOnMachineFunction", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17476, "Length": 89}
{"ground_truth": ["<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "LiveIntervals", ">", "(", ")", ";", "}", "</s>"], "natrual_language": ["getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80PostPEI", "Func": "getAnalysisUsage", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17477, "Length": 27}
{"ground_truth": ["<s>", "bool", "GBZ80PostPEI", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "RS", "=", "new", "RegScavenger", "(", ")", ";", "Accesses", ".", "clear", "(", ")", ";", "OutgoingAdjustments", ".", "clear", "(", ")", ";", "CollectFrameAccesses", "(", ")", ";", "for", "(", "auto", "&", "A", ":", "Accesses", ")", "{", "A", ".", "MI", "->", "dump", "(", ")", ";", "errs", "(", ")", "<<", "\"Stack adj: \"", "<<", "A", ".", "StackAdjustment", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"Must save: \"", "<<", "A", ".", "MustSaveHL", "<<", "\"\\n\\n\"", ";", "}", "TransformFrameAccesses", "(", ")", ";", "delete", "RS", ";", "return", "!", "Accesses", ".", "empty", "(", ")", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["GBZ80", "GB", "GB", "GB", "\"Stack adj: \"", "\"\\n\"", "\"Must save: \"", "\"\\n\\n\""], "File": "GBZ80PostPEI", "Func": "runOnMachineFunction", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17478, "Length": 143}
{"ground_truth": ["<s>", "bool", "GBZ80PostRA", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "Modified", "|=", "expandPostRAPseudos", "(", ")", ";", "return", "Modified", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["GBZ80", "GB", "GB", "GB"], "File": "GBZ80PostRA", "Func": "runOnMachineFunction", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17479, "Length": 71}
{"ground_truth": ["<s>", "bool", "GBZ80PreEmit", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "return", "Modified", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["GBZ80", "GB", "GB", "GB"], "File": "GBZ80PreEmit", "Func": "runOnMachineFunction", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17480, "Length": 49}
{"ground_truth": ["<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "}", "</s>"], "natrual_language": ["getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80PreRA", "Func": "getAnalysisUsage", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17481, "Length": 33}
{"ground_truth": ["<s>", "bool", "GBZ80PreRA", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "Modified", "|=", "combinePostIncMemAccs", "(", ")", ";", "if", "(", "WidenRegClasses", ")", "Modified", "|=", "widenConstrainedRegClasses", "(", ")", ";", "return", "Modified", ";", "}", "</s>"], "natrual_language": ["runOnMachineFunction", "-", "Emit", "the", "function", "body", "."], "TS_V_token": ["GBZ80", "GB", "GB", "GB"], "File": "GBZ80PreRA", "Func": "runOnMachineFunction", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17482, "Length": 91}
{"ground_truth": ["<s>", "const", "uint16_t", "*", "GBZ80RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "GBZ80", "::", "BC", ",", "GBZ80", "::", "DE", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>"], "natrual_language": ["Code", "Generation", "virtual", "methods", "..."], "TS_V_token": ["GBZ80", "GB", "GBZ80::BC", "GBZ80::DE", "0"], "File": "GBZ80RegisterInfo (2)", "Func": "getCalleeSavedRegs", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17483, "Length": 37}
{"ground_truth": ["<s>", "const", "uint32_t", "*", "GBZ80RegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CallConv", ")", "const", "{", "return", "CSR_16_RegMask", ";", "}", "</s>"], "natrual_language": ["Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80RegisterInfo (2)", "Func": "getCallPreservedMask", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17484, "Length": 18}
{"ground_truth": ["<s>", "BitVector", "GBZ80RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "GBZ80", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "GBZ80", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "GBZ80", "::", "FLAGS", ")", ";", "Reserved", ".", "set", "(", "getFrameRegister", "(", "MF", ")", ")", ";", "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": ["GBZ80", "GB", "GBZ80::PC", "GBZ80::SP", "GBZ80::FLAGS"], "File": "GBZ80RegisterInfo (2)", "Func": "getReservedRegs", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17485, "Length": 61}
{"ground_truth": ["<s>", "void", "GBZ80RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected SPAdj value\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "GBZ80TargetMachine", "&", "TM", "=", "(", "const", "GBZ80TargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getFrameLowering", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";", "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "GB", "::", "FRMIDX", "||", "MI", ".", "getOpcode", "(", ")", "==", "GB", "::", "LD8_FI", "||", "MI", ".", "getOpcode", "(", ")", "==", "GB", "::", "ST8_FI", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>"], "natrual_language": ["This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "."], "TS_V_token": ["GBZ80", "GB", "0", "\"Unexpected SPAdj value\"", "GB", "GB", "GB::FRMIDX", "GB::LD8_FI", "GB::ST8_FI"], "File": "GBZ80RegisterInfo", "Func": "eliminateFrameIndex", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17486, "Length": 212}
{"ground_truth": ["<s>", "const", "uint16_t", "*", "GBZ80RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getFunctionType", "(", ")", "->", "getNumParams", "(", ")", "<=", "1", ")", "return", "CSR_0_1_SaveList", ";", "else", "return", "CSR_2_SaveList", ";", "}", "</s>"], "natrual_language": ["Code", "Generation", "virtual", "methods", "..."], "TS_V_token": ["GBZ80", "GB", "1"], "File": "GBZ80RegisterInfo", "Func": "getCalleeSavedRegs", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17487, "Length": 40}
{"ground_truth": ["<s>", "const", "uint32_t", "*", "GBZ80RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getFunctionType", "(", ")", "->", "getNumParams", "(", ")", "<=", "1", ")", "return", "CSR_0_1_RegMask", ";", "else", "return", "CSR_2_RegMask", ";", "}", "</s>"], "natrual_language": ["Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "."], "TS_V_token": ["GBZ80", "GB", "1"], "File": "GBZ80RegisterInfo", "Func": "getCallPreservedMask", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17488, "Length": 45}
{"ground_truth": ["<s>", "const", "TargetRegisterClass", "*", "GBZ80RegisterInfo", "::", "getCrossCopyRegClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "RC", "==", "&", "GB", "::", "R8_GPRRegClass", ")", "return", "&", "GB", "::", "R8RegClass", ";", "else", "if", "(", "RC", "==", "&", "GB", "::", "R16_HLRegClass", "||", "RC", "==", "&", "GB", "::", "R16_BCDERegClass", ")", "return", "&", "GB", "::", "R16RegClass", ";", "return", "RC", ";", "}", "</s>"], "natrual_language": ["getCrossCopyRegClass", "-", "Returns", "a", "legal", "register", "class", "to", "copy", "a", "register", "in", "the", "specified", "class", "to", "or", "from", "."], "TS_V_token": ["GBZ80", "GB", "GB::R8_GPRRegClass", "GB::R8RegClass", "GB::R16_HLRegClass", "GB::R16_BCDERegClass", "GB::R16RegClass"], "File": "GBZ80RegisterInfo", "Func": "getCrossCopyRegClass", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17489, "Length": 56}
{"ground_truth": ["<s>", "unsigned", "GBZ80RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "GB", "::", "SP", ";", "}", "</s>"], "natrual_language": ["Debug", "information", "queries", "."], "TS_V_token": ["GBZ80", "GB", "GB::SP"], "File": "GBZ80RegisterInfo", "Func": "getFrameRegister", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17490, "Length": 18}
{"ground_truth": ["<s>", "const", "TargetRegisterClass", "*", "GBZ80RegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "RC", "==", "&", "GB", "::", "R8_GPRRegClass", "||", "RC", "==", "&", "GB", "::", "R8RegClass", ")", "{", "return", "&", "GB", "::", "R8RegClass", ";", "}", "if", "(", "RC", "==", "&", "GB", "::", "R16_HLRegClass", "||", "RC", "==", "&", "GB", "::", "R16_BCDERegClass", "||", "RC", "==", "&", "GB", "::", "R16RegClass", ")", "{", "return", "&", "GB", "::", "R16RegClass", ";", "}", "return", "RC", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "."], "TS_V_token": ["GBZ80", "GB", "GB::R8_GPRRegClass", "GB::R8RegClass", "GB::R8RegClass", "GB::R16_HLRegClass", "GB::R16_BCDERegClass", "GB::R16RegClass", "GB::R16RegClass"], "File": "GBZ80RegisterInfo", "Func": "getLargestLegalSuperClass", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17491, "Length": 93}
{"ground_truth": ["<s>", "const", "TargetRegisterClass", "*", "GBZ80RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "GB", "::", "R16RegClass", ";", "}", "</s>"], "natrual_language": ["getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "."], "TS_V_token": ["GBZ80", "GB", "GB::R16RegClass"], "File": "GBZ80RegisterInfo", "Func": "getPointerRegClass", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17492, "Length": 24}
{"ground_truth": ["<s>", "BitVector", "GBZ80RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "GB", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "GB", "::", "IME", ")", ";", "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": ["GBZ80", "GB", "GB::SP", "GB::IME"], "File": "GBZ80RegisterInfo", "Func": "getReservedRegs", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17493, "Length": 42}
{"ground_truth": ["<s>", "bool", "GBZ80RegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "return", "true", ";", "}", "</s>"], "natrual_language": ["Subtarget", "Hooks", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80RegisterInfo", "Func": "shouldCoalesce", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17494, "Length": 40}
{"ground_truth": ["<s>", "void", "GBZ80RegisterInfo", "::", "splitReg", "(", "unsigned", "Reg", ",", "unsigned", "&", "LoReg", ",", "unsigned", "&", "HiReg", ")", "const", "{", "assert", "(", "GB", "::", "R16RegClass", ".", "contains", "(", "Reg", ")", "&&", "\"can only split 16-bit registers\"", ")", ";", "LoReg", "=", "getSubReg", "(", "Reg", ",", "GB", "::", "sub_lo", ")", ";", "HiReg", "=", "getSubReg", "(", "Reg", ",", "GB", "::", "sub_hi", ")", ";", "}", "</s>"], "natrual_language": ["Splits", "a", "16-bit", "DREGS", "register", "into", "the", "lo/hi", "register", "pair", "."], "TS_V_token": ["GBZ80", "GB", "GB::R16RegClass", "\"can only split 16-bit registers\"", "GB::sub_lo", "GB::sub_hi"], "File": "GBZ80RegisterInfo", "Func": "splitReg", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17495, "Length": 55}
{"ground_truth": ["<s>", "bool", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>"], "natrual_language": ["Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80RegisterInfo", "Func": "trackLivenessAfterRegAlloc", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17496, "Length": 15}
{"ground_truth": ["<s>", "bool", "enableSubRegLiveness", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>"], "natrual_language": ["Enable", "tracking", "of", "subregister", "liveness", "in", "register", "allocator", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80Subtarget", "Func": "enableSubRegLiveness", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17497, "Length": 11}
{"ground_truth": ["<s>", "const", "GBZ80InstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>"], "natrual_language": ["TargetInstrInfo", "getter", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80Subtarget", "Func": "getInstrInfo", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17498, "Length": 14}
{"ground_truth": ["<s>", "const", "GBZ80RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>"], "natrual_language": ["getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80Subtarget", "Func": "getRegisterInfo", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17499, "Length": 18}
{"ground_truth": ["<s>", "bool", "GBZ80PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createGBZ80ISelDAG", "(", "getGBZ80TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "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": ["GBZ80", "GB", "GB", "GB"], "File": "GBZ80TargetMachine (2)", "Func": "addInstSelector", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17500, "Length": 25}
{"ground_truth": ["<s>", "TargetPassConfig", "*", "GBZ80TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "GBZ80PassConfig", "(", "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": ["GBZ80", "GB", "GB"], "File": "GBZ80TargetMachine (2)", "Func": "createPassConfig", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17501, "Length": 21}
{"ground_truth": ["<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "&", "DL", ";", "}", "</s>"], "natrual_language": ["Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80TargetMachine (2)", "Func": "getDataLayout", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17502, "Length": 14}
{"ground_truth": ["<s>", "virtual", "const", "GBZ80InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>"], "natrual_language": ["TargetInstrInfo", "getter", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80TargetMachine (2)", "Func": "getInstrInfo", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17503, "Length": 14}
{"ground_truth": ["<s>", "virtual", "const", "GBZ80RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "getInstrInfo", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>"], "natrual_language": ["getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80TargetMachine (2)", "Func": "getRegisterInfo", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17504, "Length": 20}
{"ground_truth": ["<s>", "bool", "GBZ80PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createGBZ80ISelDag", "(", "getGBZ80TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "addPass", "(", "createGBZ80PostISelPass", "(", ")", ")", ";", "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": ["GBZ80", "GB", "GB", "GB", "GB"], "File": "GBZ80TargetMachine", "Func": "addInstSelector", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17505, "Length": 32}
{"ground_truth": ["<s>", "void", "GBZ80PassConfig", "::", "addPostRegAlloc", "(", ")", "{", "addPass", "(", "createGBZ80PostRAPass", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "."], "TS_V_token": ["GBZ80", "GB", "GB"], "File": "GBZ80TargetMachine", "Func": "addPostRegAlloc", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17506, "Length": 15}
{"ground_truth": ["<s>", "void", "GBZ80PassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createGBZ80PreEmitPass", "(", ")", ")", ";", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>"], "natrual_language": ["This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "."], "TS_V_token": ["GBZ80", "GB", "GB"], "File": "GBZ80TargetMachine", "Func": "addPreEmitPass", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17507, "Length": 21}
{"ground_truth": ["<s>", "void", "GBZ80PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createGBZ80PreRAPass", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "."], "TS_V_token": ["GBZ80", "GB", "GB"], "File": "GBZ80TargetMachine", "Func": "addPreRegAlloc", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17508, "Length": 15}
{"ground_truth": ["<s>", "void", "GBZ80PassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createGBZ80PostPEIPass", "(", ")", ")", ";", "}", "</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": ["GBZ80", "GB", "GB"], "File": "GBZ80TargetMachine", "Func": "addPreSched2", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17509, "Length": 15}
{"ground_truth": ["<s>", "TargetPassConfig", "*", "GBZ80TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "GBZ80PassConfig", "(", "*", "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": ["GBZ80", "GB", "GB"], "File": "GBZ80TargetMachine", "Func": "createPassConfig", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17510, "Length": 22}
{"ground_truth": ["<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "this", "->", "TLOF", ".", "get", "(", ")", ";", "}", "</s>"], "natrual_language": ["Return", "information", "about", "object", "file", "lowering", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80TargetMachine", "Func": "getObjFileLowering", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17511, "Length": 18}
{"ground_truth": ["<s>", "const", "GBZ80Subtarget", "*", "GBZ80TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", ")", "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": ["GBZ80", "GB", "GB"], "File": "GBZ80TargetMachine", "Func": "getSubtargetImpl", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17512, "Length": 18}
{"ground_truth": ["<s>", "bool", "isMachineVerifierClean", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>"], "natrual_language": ["Returns", "true", "if", "the", "target", "is", "expected", "to", "pass", "all", "machine", "verifier", "checks", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80TargetMachine", "Func": "isMachineVerifierClean", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17513, "Length": 11}
{"ground_truth": ["<s>", "static", "bool", "classof", "(", "const", "MCSection", "*", "S", ")", "{", "return", "S", "->", "getVariant", "(", ")", "==", "SV_GBZ80", ";", "}", "</s>"], "natrual_language": ["Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":"], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80TargetObjectFile", "Func": "classof", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17514, "Length": 20}
{"ground_truth": ["<s>", "bool", "GBZ80SectionData", "::", "get", "(", "StringRef", "Specifier", ",", "GBZ80SectionData", "&", "Data", ")", "{", "Data", ".", "Type", "=", "ST_NONE", ";", "Data", ".", "Address", "=", "0", ";", "Data", ".", "Bank", "=", "~", "0U", ";", "Data", ".", "Alignment", "=", "1", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Get", "the", "generated", "Value", "for", "a", "given", "VPValue", "and", "given", "Part", "and", "Lane", "."], "TS_V_token": ["GBZ80", "GB", "GB", "0", "0U", "1"], "File": "GBZ80TargetObjectFile", "Func": "get", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17515, "Length": 42}
{"ground_truth": ["<s>", "uint16_t", "getAddress", "(", ")", "const", "{", "return", "Address", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "address", "of", "this", "pointer", "in", "this", "block", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80TargetObjectFile", "Func": "getAddress", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17516, "Length": 10}
{"ground_truth": ["<s>", "unsigned", "getAlignment", "(", ")", "const", "{", "return", "Alignment", ";", "}", "</s>"], "natrual_language": ["getAlignment", "-", "Return", "the", "alignment", "of", "the", "function", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80TargetObjectFile", "Func": "getAlignment", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17517, "Length": 10}
{"ground_truth": ["<s>", "void", "GBZ80SectionData", "::", "getAsString", "(", "SmallVectorImpl", "<", "char", ">", "&", "Str", ")", "const", "{", "raw_svector_ostream", "O", "(", "Str", ")", ";", "if", "(", "SectionName", ".", "empty", "(", ")", ")", "O", "<<", "\"SECTION @,\"", ";", "else", "O", "<<", "\"SECTION \\\"\"", "<<", "SectionName", "<<", "\"\\\",\"", ";", "switch", "(", "Type", ")", "{", "case", "ST_ROM0", ":", "O", "<<", "\"ROM0\"", ";", "break", ";", "case", "ST_ROMX", ":", "O", "<<", "\"ROMX\"", ";", "break", ";", "case", "ST_VRAM", ":", "O", "<<", "\"VRAM\"", ";", "break", ";", "case", "ST_SRAM", ":", "O", "<<", "\"SRAM\"", ";", "break", ";", "case", "ST_WRAM0", ":", "O", "<<", "\"WRAM0\"", ";", "break", ";", "case", "ST_WRAMX", ":", "O", "<<", "\"WRAMX\"", ";", "break", ";", "case", "ST_OAM", ":", "O", "<<", "\"OAM\"", ";", "break", ";", "case", "ST_HRAM", ":", "O", "<<", "\"HRAM\"", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Tried to print an invalid section!\"", ")", ";", "}", "if", "(", "hasAddress", "(", ")", ")", "O", "<<", "\"[$\"", "<<", "format", "(", "\"%04x\"", ",", "Address", ")", "<<", "\"]\"", ";", "if", "(", "hasBank", "(", ")", ")", "O", "<<", "\",BANK[\"", "<<", "Bank", "<<", "\"]\"", ";", "if", "(", "hasAlignment", "(", ")", ")", "O", "<<", "\",ALIGN[\"", "<<", "Log2_32_Ceil", "(", "Alignment", ")", "<<", "\"]\"", ";", "}", "</s>"], "natrual_language": ["Retrieve", "a", "string", "representation", "of", "the", "version", "number", "."], "TS_V_token": ["GBZ80", "GB", "\"SECTION @,\"", "\"SECTION \\\"\"", "\"\\\",\"", "\"ROM0\"", "\"ROMX\"", "\"VRAM\"", "\"SRAM\"", "\"WRAM0\"", "\"WRAMX\"", "\"OAM\"", "\"HRAM\"", "\"Tried to print an invalid section!\"", "\"[$\"", "\"%04x\"", "\"]\"", "\",BANK[\"", "\"]\"", "\",ALIGN[\"", "\"]\""], "File": "GBZ80TargetObjectFile", "Func": "getAsString", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17518, "Length": 177}
{"ground_truth": ["<s>", "MCSection", "*", "GBZ80TargetObjectFile", "::", "getExplicitSectionGlobal", "(", "const", "GlobalObject", "*", "GO", ",", "SectionKind", "Kind", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "llvm_unreachable", "(", "\"getExplicitSectionGlobal not yet implemented!\"", ")", ";", "}", "</s>"], "natrual_language": ["Targets", "should", "implement", "this", "method", "to", "assign", "a", "section", "to", "globals", "with", "an", "explicit", "section", "specfied", "."], "TS_V_token": ["GBZ80", "GB", "\"getExplicitSectionGlobal not yet implemented!\""], "File": "GBZ80TargetObjectFile", "Func": "getExplicitSectionGlobal", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17519, "Length": 27}
{"ground_truth": ["<s>", "StringRef", "getName", "(", ")", "const", "{", "return", "SectionName", ";", "}", "</s>"], "natrual_language": ["Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80TargetObjectFile", "Func": "getName", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17520, "Length": 10}
{"ground_truth": ["<s>", "MCSectionGBZ80", "*", "GBZ80TargetObjectFile", "::", "getSection", "(", "SectionKind", "Kind", ",", "StringRef", "N", ",", "GBSectionType", "T", ",", "uint16_t", "A", ",", "unsigned", "B", ",", "unsigned", "Align", ",", "const", "GlobalObject", "*", "GO", ")", "const", "{", "GBZ80SectionData", "Data", "(", "N", ",", "T", ",", "A", ",", "B", ",", "Align", ",", "GO", ")", ";", "if", "(", "Sections", ".", "count", "(", "Data", ")", ")", "return", "Sections", "[", "Data", "]", ";", "MCSectionGBZ80", "*", "Section", "=", "new", "MCSectionGBZ80", "(", "Kind", ",", "Data", ",", "nullptr", ")", ";", "Sections", "[", "Data", "]", "=", "Section", ";", "return", "Section", ";", "}", "</s>"], "natrual_language": ["Get", "the", "section", "associated", "with", "a", "defined", ",", "non-absolute", "symbol", "."], "TS_V_token": ["GBZ80", "GB", "GB", "GB", "GB", "GB", "GB"], "File": "GBZ80TargetObjectFile", "Func": "getSection", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17521, "Length": 87}
{"ground_truth": ["<s>", "MCSection", "*", "GBZ80TargetObjectFile", "::", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ",", "unsigned", "&", "Align", ")", "const", "{", "assert", "(", "Kind", ".", "isReadOnly", "(", ")", "&&", "\"Writeable constant?\"", ")", ";", "return", "getSection", "(", "Kind", ",", "StringRef", "(", ")", ",", "ST_ROM0", ",", "0", ",", "~", "0U", ",", "Align", ",", "nullptr", ")", ";", "}", "</s>"], "natrual_language": ["Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "."], "TS_V_token": ["GBZ80", "GB", "\"Writeable constant?\"", "0", "0U"], "File": "GBZ80TargetObjectFile", "Func": "getSectionForConstant", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17522, "Length": 58}
{"ground_truth": ["<s>", "GBSectionType", "getType", "(", ")", "const", "{", "return", "Type", ";", "}", "</s>"], "natrual_language": ["Overload", "to", "return", "most", "specific", "vector", "type", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80TargetObjectFile", "Func": "getType", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17523, "Length": 10}
{"ground_truth": ["<s>", "void", "GBZ80TargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "Base", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "TextSection", "=", "getSection", "(", "SectionKind", "::", "getText", "(", ")", ",", "StringRef", "(", "\".text\"", ")", ",", "GBSectionType", "::", "ST_ROM0", ",", "0", ",", "~", "0U", ",", "1", ",", "nullptr", ")", ";", "DataSection", "=", "getSection", "(", "SectionKind", "::", "getText", "(", ")", ",", "StringRef", "(", "\".data\"", ")", ",", "GBSectionType", "::", "ST_WRAM0", ",", "0", ",", "~", "0U", ",", "1", ",", "nullptr", ")", ";", "BSSSection", "=", "getSection", "(", "SectionKind", "::", "getText", "(", ")", ",", "StringRef", "(", "\".bss\"", ")", ",", "GBSectionType", "::", "ST_WRAM0", ",", "0", ",", "~", "0U", ",", "1", ",", "nullptr", ")", ";", "ReadOnlySection", "=", "getSection", "(", "SectionKind", "::", "getText", "(", ")", ",", "StringRef", "(", "\".readonly\"", ")", ",", "GBSectionType", "::", "ST_ROM0", ",", "0", ",", "~", "0U", ",", "1", ",", "nullptr", ")", ";", "}", "</s>"], "natrual_language": ["This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "."], "TS_V_token": ["GBZ80", "GB", "\".text\"", "GBSectionType::ST_ROM0", "0", "0U", "1", "\".data\"", "GBSectionType::ST_WRAM0", "0", "0U", "1", "\".bss\"", "GBSectionType::ST_WRAM0", "0", "0U", "1", "\".readonly\"", "GBSectionType::ST_ROM0", "0", "0U", "1"], "File": "GBZ80TargetObjectFile", "Func": "Initialize", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17524, "Length": 141}
{"ground_truth": ["<s>", "bool", "MCSectionGBZ80", "::", "isVirtualSection", "(", ")", "const", "{", "return", "false", ";", "}", "</s>"], "natrual_language": ["Check", "whether", "this", "section", "is", "``", "virtual", "''", ",", "that", "is", "has", "no", "actual", "object", "file", "contents", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80TargetObjectFile", "Func": "isVirtualSection", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17525, "Length": 12}
{"ground_truth": ["<s>", "void", "setAlignment", "(", "unsigned", "Align", ")", "{", "Alignment", "=", "Align", ";", "}", "</s>"], "natrual_language": ["setAlignment", "-", "Set", "the", "alignment", "of", "the", "function", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80TargetObjectFile", "Func": "setAlignment", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17526, "Length": 12}
{"ground_truth": ["<s>", "void", "setName", "(", "StringRef", "N", ")", "{", "SectionName", "=", "N", ";", "}", "</s>"], "natrual_language": ["Change", "the", "name", "of", "this", "type", "to", "the", "specified", "name", ",", "or", "to", "a", "name", "with", "a", "suffix", "if", "there", "is", "a", "collision", "."], "TS_V_token": ["GBZ80"], "File": "GBZ80TargetObjectFile", "Func": "setName", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17527, "Length": 12}
{"ground_truth": ["<s>", "void", "setType", "(", "GBSectionType", "T", ")", "{", "Type", "=", "T", ";", "}", "</s>"], "natrual_language": ["Set", "the", "low-level", "type", "of", "VReg", "to", "Ty", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80TargetObjectFile", "Func": "setType", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17528, "Length": 12}
{"ground_truth": ["<s>", "void", "GBZ80TargetStreamer", "::", "finish", "(", ")", "{", "}", "</s>"], "natrual_language": ["finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "."], "TS_V_token": ["GBZ80", "GB"], "File": "GBZ80TargetStreamer", "Func": "finish", "Target": "GBZ80", "Target_Clf": "MPU", "Compiler_Type": "LLVM", "Idx": 17529, "Length": 8}