Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "note_invalid_constants", "(", "rtx", "insn", ",", "HOST_WIDE_INT", "address", ",", "int", "do_pushes", ")", "{", "bool", "result", "=", "false", ";", "int", "opno", ";", "extract_insn", "(", "insn", ")", ";", "if", "(", "!", "constrain_operands", "(", "1", ")", ")", "fatal_insn_not_found", "(", "insn", ")", ";", "if", "(", "recog_data", ".", "n_alternatives", "==", "0", ")", "return", "false", ";", "preprocess_constraints", "(", ")", ";", "for", "(", "opno", "=", "0", ";", "opno", "<", "recog_data", ".", "n_operands", ";", "opno", "++", ")", "{", "if", "(", "recog_data", ".", "operand_type", "[", "opno", "]", "!=", "OP_IN", ")", "continue", ";", "if", "(", "recog_op_alt", "[", "opno", "]", "[", "which_alternative", "]", ".", "memory_ok", ")", "{", "rtx", "op", "=", "recog_data", ".", "operand", "[", "opno", "]", ";", "if", "(", "CONSTANT_P", "(", "op", ")", ")", "{", "if", "(", "do_pushes", ")", "push_minipool_fix", "(", "insn", ",", "address", ",", "recog_data", ".", "operand_loc", "[", "opno", "]", ",", "recog_data", ".", "operand_mode", "[", "opno", "]", ",", "op", ")", ";", "result", "=", "true", ";", "}", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "XEXP", "(", "op", ",", "0", ")", ")", ")", "{", "if", "(", "do_pushes", ")", "{", "rtx", "cop", "=", "avoid_constant_pool_reference", "(", "op", ")", ";", "if", "(", "op", "==", "cop", ")", "cop", "=", "get_pool_constant", "(", "XEXP", "(", "op", ",", "0", ")", ")", ";", "push_minipool_fix", "(", "insn", ",", "address", ",", "recog_data", ".", "operand_loc", "[", "opno", "]", ",", "recog_data", ".", "operand_mode", "[", "opno", "]", ",", "cop", ")", ";", "}", "result", "=", "true", ";", "}", "}", "}", "return", "result", ";", "}", "</s>" ]

[ "Scan", "INSN", "and", "note", "any", "of", "its", "operands", "that", "need", "fixing", ".", "If", "DO_PUSHES", "is", "false", "we", "do", "not", "actually", "push", "any", "of", "the", "fixups", "needed", ".", "The", "function", "returns", "TRUE", "if", "any", "fixups", "were", "needed/pushed", ".", "This", "is", "used", "by", "arm_memory_load_p", "(", ")", "which", "needs", "to", "know", "about", "loads", "of", "constants", "that", "will", "be", "converted", "into", "minipool", "loads", "." ]

[ "arm", "1", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "nvptx_output_skip", "(", "FILE", "*", ",", "unsigned", "HOST_WIDE_INT", "size", ")", "{", "if", "(", "init_frag", ".", "offset", ")", "{", "unsigned", "part", "=", "init_frag", ".", "size", "-", "init_frag", ".", "offset", ";", "if", "(", "part", ">", "size", ")", "part", "=", "(", "unsigned", ")", "size", ";", "size", "-=", "part", ";", "nvptx_assemble_value", "(", "0", ",", "part", ")", ";", "}", "if", "(", "size", "<", "init_frag", ".", "remaining", "*", "init_frag", ".", "size", ")", "{", "while", "(", "size", ">=", "init_frag", ".", "size", ")", "{", "size", "-=", "init_frag", ".", "size", ";", "output_init_frag", "(", "NULL_RTX", ")", ";", "}", "if", "(", "size", ")", "nvptx_assemble_value", "(", "0", ",", "size", ")", ";", "}", "}", "</s>" ]

[ "Output", "SIZE", "zero", "bytes", ".", "We", "ignore", "the", "FILE", "argument", "since", "the", "functions", "we", "'re", "calling", "to", "perform", "the", "output", "just", "use", "asm_out_file", "." ]

[ "nvptx", "0", "0" ]

[]

[ "<s>", "bool", "NVPTXInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "return", "false", ";", "MachineInstr", "&", "LastInst", "=", "*", "I", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "{", "if", "(", "LastInst", ".", "getOpcode", "(", ")", "==", "NVPTX", "::", "GOTO", ")", "{", "TBB", "=", "LastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "else", "if", "(", "LastInst", ".", "getOpcode", "(", ")", "==", "NVPTX", "::", "CBranch", ")", "{", "TBB", "=", "LastInst", ".", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "LastInst", ".", "getOperand", "(", "0", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "MachineInstr", "&", "SecondLastInst", "=", "*", "I", ";", "if", "(", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "isUnpredicatedTerminator", "(", "*", "--", "I", ")", ")", "return", "true", ";", "if", "(", "SecondLastInst", ".", "getOpcode", "(", ")", "==", "NVPTX", "::", "CBranch", "&&", "LastInst", ".", "getOpcode", "(", ")", "==", "NVPTX", "::", "GOTO", ")", "{", "TBB", "=", "SecondLastInst", ".", "getOperand", "(", "1", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "SecondLastInst", ".", "getOperand", "(", "0", ")", ")", ";", "FBB", "=", "LastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "SecondLastInst", ".", "getOpcode", "(", ")", "==", "NVPTX", "::", "GOTO", "&&", "LastInst", ".", "getOpcode", "(", ")", "==", "NVPTX", "::", "GOTO", ")", "{", "TBB", "=", "SecondLastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "I", "=", "LastInst", ";", "if", "(", "AllowModify", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "NVPTX", "NVPTX", "NVPTX::GOTO", "0", "NVPTX::CBranch", "1", "0", "NVPTX::CBranch", "NVPTX::GOTO", "1", "0", "0", "NVPTX::GOTO", "NVPTX::GOTO", "0" ]

[]

[ "<s>", "bool", "AMDGPUCFGStructurizer", "::", "isReturnBlock", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "MachineInstr", "*", "MI", "=", "getReturnInstr", "(", "MBB", ")", ";", "bool", "IsReturn", "=", "(", "MBB", "->", "succ_size", "(", ")", "==", "0", ")", ";", "if", "(", "MI", ")", "assert", "(", "IsReturn", ")", ";", "else", "if", "(", "IsReturn", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"BB\"", "<<", "MBB", "->", "getNumber", "(", ")", "<<", "\" is return block without RETURN instr\\n\"", ";", ")", ";", "return", "IsReturn", ";", "}", "</s>" ]

[ "Convenience", "function", "that", "returns", "true", "if", "the", "block", "ends", "in", "a", "return", "instruction", "." ]

[ "AMDGPU", "AMDGPU", "0", "\"BB\"", "\" is return block without RETURN instr\\n\"" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "predictBranchSizeForIfCvt", "(", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2Bcc", "&&", "findCMPToFoldIntoCBZ", "(", "&", "MI", ",", "&", "getRegisterInfo", "(", ")", ")", ")", "return", "0", ";", "unsigned", "Size", "=", "getInstSizeInBytes", "(", "MI", ")", ";", "if", "(", "Subtarget", ".", "isThumb2", "(", ")", ")", "Size", "/=", "2", ";", "return", "Size", ";", "}", "</s>" ]

[ "Return", "an", "estimate", "for", "the", "code", "size", "reduction", "(", "in", "bytes", ")", "which", "will", "be", "caused", "by", "removing", "the", "given", "branch", "instruction", "during", "if-conversion", "." ]

[ "ARM", "ARM", "ARM::t2Bcc", "0", "2" ]

[]

[ "<s>", "MCELFStreamer", "&", "M88kTargetELFStreamer", "::", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";", "}", "</s>" ]

[ "Return", "the", "output", "streamer", "for", "the", "assembler", "." ]

[ "M88k", "M88k" ]

[]

[ "<s>", "static", "bool", "ft32_fixed_condition_code_regs", "(", "unsigned", "int", "*", "p1", ",", "unsigned", "int", "*", "p2", ")", "{", "*", "p1", "=", "CC_REG", ";", "*", "p2", "=", "INVALID_REGNUM", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "the", "fixed", "registers", "used", "for", "condition", "codes", "." ]

[ "ft32" ]

[]

[ "<s>", "static", "tree", "ix86_handle_fentry_name", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "==", "FUNCTION_DECL", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "STRING_CST", ")", ";", "else", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute ignored\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "fentry_name", "/", "fentry_section", "attribute", "." ]

[ "i386", "\"%qE attribute ignored\"" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16rm", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8rm", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "MSP430", "MSP430", "MSP430::GR16RegClass", "MSP430::MOV16rm", "0", "MSP430::GR8RegClass", "MSP430::MOV8rm", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "void", "MipsTargetMachine", "::", "resetSubtarget", "(", "MachineFunction", "*", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"resetSubtarget\\n\"", ")", ";", "Subtarget", "=", "const_cast", "<", "MipsSubtarget", "*", ">", "(", "getSubtargetImpl", "(", "*", "MF", "->", "getFunction", "(", ")", ")", ")", ";", "MF", "->", "setSubtarget", "(", "Subtarget", ")", ";", "}", "</s>" ]

[ "Reset", "the", "subtarget", "for", "the", "Mips", "target", "." ]

[ "Mips", "Mips", "\"resetSubtarget\\n\"", "Mips" ]

[]

[ "<s>", "enum", "rtx_code", "pru_noteq_condition", "(", "enum", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "GT", ":", "return", "GT", ";", "case", "GTU", ":", "return", "GTU", ";", "case", "GE", ":", "return", "GT", ";", "case", "GEU", ":", "return", "GTU", ";", "case", "LT", ":", "return", "LT", ";", "case", "LTU", ":", "return", "LTU", ";", "case", "LE", ":", "return", "LT", ";", "case", "LEU", ":", "return", "LTU", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Given", "a", "comparison", "CODE", ",", "return", "a", "similar", "comparison", "but", "without", "the", "``", "equals", "''", "condition", ".", "In", "other", "words", ",", "it", "strips", "GE/GEU/LE/LEU", "and", "instead", "returns", "GT/GTU/LT/LTU", "." ]

[ "pru" ]

[]

[ "<s>", "const", "unsigned", "*", "MBlazeRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "unsigned", "CalleeSavedRegs", "[", "]", "=", "{", "MBlaze", "::", "R20", ",", "MBlaze", "::", "R21", ",", "MBlaze", "::", "R22", ",", "MBlaze", "::", "R23", ",", "MBlaze", "::", "R24", ",", "MBlaze", "::", "R25", ",", "MBlaze", "::", "R26", ",", "MBlaze", "::", "R27", ",", "MBlaze", "::", "R28", ",", "MBlaze", "::", "R29", ",", "MBlaze", "::", "R30", ",", "MBlaze", "::", "R31", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "MBlaze", "MBlaze", "MBlaze::R20", "MBlaze::R21", "MBlaze::R22", "MBlaze::R23", "MBlaze::R24", "MBlaze::R25", "MBlaze::R26", "MBlaze::R27", "MBlaze::R28", "MBlaze::R29", "MBlaze::R30", "MBlaze::R31", "0" ]

[]

[ "<s>", "unsigned", "int", "nds32_local_alignment", "(", "tree", "local", "ATTRIBUTE_UNUSED", ",", "unsigned", "int", "basic_align", ")", "{", "bool", "at_least_align_to_word", "=", "false", ";", "switch", "(", "TREE_CODE", "(", "local", ")", ")", "{", "case", "ARRAY_TYPE", ":", "case", "RECORD_TYPE", ":", "case", "UNION_TYPE", ":", "at_least_align_to_word", "=", "true", ";", "break", ";", "default", ":", "at_least_align_to_word", "=", "false", ";", "break", ";", "}", "if", "(", "at_least_align_to_word", "&&", "(", "basic_align", "<", "BITS_PER_WORD", ")", ")", "return", "BITS_PER_WORD", ";", "else", "return", "basic_align", ";", "}", "</s>" ]

[ "Return", "alignment", "for", "local", "variable", "." ]

[ "nds32" ]

[]

[ "<s>", "OffsetRange", "&", "intersect", "(", "OffsetRange", "A", ")", "{", "if", "(", "Align", "<", "A", ".", "Align", ")", "std", "::", "swap", "(", "*", "this", ",", "A", ")", ";", "if", "(", "Offset", ">=", "A", ".", "Offset", "&&", "(", "Offset", "-", "A", ".", "Offset", ")", "%", "A", ".", "Align", "==", "0", ")", "{", "Min", "=", "adjustUp", "(", "std", "::", "max", "(", "Min", ",", "A", ".", "Min", ")", ",", "Align", ",", "Offset", ")", ";", "Max", "=", "adjustDown", "(", "std", "::", "min", "(", "Max", ",", "A", ".", "Max", ")", ",", "Align", ",", "Offset", ")", ";", "}", "else", "{", "Min", "=", "0", ";", "Max", "=", "-", "1", ";", "}", "if", "(", "Min", ">", "Max", ")", "std", "::", "tie", "(", "Min", ",", "Max", ",", "Align", ")", "=", "std", "::", "make_tuple", "(", "0", ",", "-", "1", ",", "1", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "Intersect", "this", "set", "with", "a", "temporary", "other", "set", "in", "place", "." ]

[ "Hexagon", "0", "0", "1", "0", "1", "1" ]

[]

[ "<s>", "DFAPacketizer", "*", "rvexInstrInfo", "::", "CreateTargetScheduleState", "(", "const", "TargetMachine", "*", "TM", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Voor DFA!\\n\"", ")", ";", "const", "InstrItineraryData", "*", "II", "=", "TM", "->", "getInstrItineraryData", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Na DFA!\\n\"", ")", ";", "DFAPacketizer", "*", "temp", "=", "TM", "->", "getSubtarget", "<", "rvexGenSubtargetInfo", ">", "(", ")", ".", "createDFAPacketizer", "(", "II", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Na na DFA!\\n\"", ")", ";", "return", "temp", ";", "}", "</s>" ]

[ "Create", "machine", "specific", "model", "for", "scheduling", "." ]

[ "rvex", "rvex", "\"Voor DFA!\\n\"", "\"Na DFA!\\n\"", "rvex", "\"Na na DFA!\\n\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "SystemZRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "SystemZSubtarget", "*", "Subtarget", "=", "&", "MF", "->", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "SystemZCallingConventionRegisters", "*", "Regs", "=", "Subtarget", "->", "getSpecialRegisters", "(", ")", ";", "return", "Regs", "->", "getCalleeSavedRegs", "(", "MF", ")", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "swiftAsyncContextIsDynamicallySet", "(", ")", "const", "{", "const", "Triple", "&", "TT", "=", "getTargetTriple", "(", ")", ";", "unsigned", "Major", ",", "Minor", ",", "Micro", ";", "TT", ".", "getOSVersion", "(", "Major", ",", "Minor", ",", "Micro", ")", ";", "switch", "(", "TT", ".", "getOS", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Triple", "::", "IOS", ":", "case", "Triple", "::", "TvOS", ":", "return", "Major", "<", "15", ";", "case", "Triple", "::", "WatchOS", ":", "return", "Major", "<", "8", ";", "case", "Triple", "::", "MacOSX", ":", "case", "Triple", "::", "Darwin", ":", "return", "Major", "<", "12", ";", "}", "}", "</s>" ]

[ "Return", "whether", "FrameLowering", "should", "always", "set", "the", "``", "extended", "frame", "present", "''", "bit", "in", "FP", ",", "or", "set", "it", "based", "on", "a", "symbol", "in", "the", "runtime", "." ]

[ "X86", "15", "8", "12" ]

[]

[ "<s>", "static", "int", "flags_needed_for_conditional", "(", "rtx", "cond", ")", "{", "switch", "(", "GET_CODE", "(", "cond", ")", ")", "{", "case", "LE", ":", "case", "GT", ":", "return", "FLAGS_OSZ", ";", "case", "LEU", ":", "case", "GTU", ":", "return", "FLAGS_ZC", ";", "case", "LT", ":", "case", "GE", ":", "return", "FLAGS_OS", ";", "case", "LTU", ":", "case", "GEU", ":", "return", "FLAGS_C", ";", "case", "EQ", ":", "case", "NE", ":", "return", "FLAGS_Z", ";", "default", ":", "return", "FLAGS_N", ";", "}", "}", "</s>" ]

[ "Indicate", "which", "flags", "must", "be", "properly", "set", "for", "a", "given", "conditional", "." ]

[ "m32c" ]

[]

[ "<s>", "bool", "shouldOmitSectionDirective", "(", "StringRef", "SectionName", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", ".section", "directive", "should", "be", "omitted", "when", "emitting", "SectionName", "." ]

[ "NVPTX" ]

[]

[ "<s>", "bool", "DCPU16FrameLowering", "::", "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", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "DCPU16", "::", "POP16r", ")", ",", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "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", "(", ")", "." ]

[ "Dcpu16", "DCPU16", "0", "DCPU16::POP16r" ]

[]

[ "<s>", "static", "void", "mips_multi_copy_insn", "(", "unsigned", "int", "i", ")", "{", "struct", "mips_multi_member", "*", "member", ";", "member", "=", "mips_multi_add", "(", ")", ";", "memcpy", "(", "member", ",", "&", "mips_multi_members", "[", "i", "]", ",", "sizeof", "(", "*", "member", ")", ")", ";", "gcc_assert", "(", "!", "member", "->", "is_label_p", ")", ";", "}", "</s>" ]

[ "Add", "a", "copy", "of", "an", "existing", "instruction", "to", "the", "current", "multi-insn", "sequence", ".", "I", "is", "the", "index", "of", "the", "instruction", "that", "should", "be", "copied", "." ]

[ "mips" ]

[]

[ "<s>", "EVT", "ARMTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "getPointerTy", "(", "DL", ")", ";", "if", "(", "(", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v4i32", "||", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v16i8", ")", ")", "||", "(", "Subtarget", "->", "hasMVEFloatOps", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v4f32", "||", "VT", "==", "MVT", "::", "v8f16", ")", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "VT", ".", "getVectorElementCount", "(", ")", ")", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "ARM", "ARM", "MVT::v4i32", "MVT::v8i16", "MVT::v16i8", "MVT::v4f32", "MVT::v8f16", "MVT::getVectorVT", "MVT::i1" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ",", "int", "incoming", ",", "int", "libcall", ",", "int", "n_named_args", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ",", "machine_mode", "return_mode", "ATTRIBUTE_UNUSED", ")", "{", "static", "CUMULATIVE_ARGS", "zero_cumulative", ";", "*", "cum", "=", "zero_cumulative", ";", "cum", "->", "words", "=", "0", ";", "cum", "->", "fregno", "=", "FP_ARG_MIN_REG", ";", "cum", "->", "vregno", "=", "ALTIVEC_ARG_MIN_REG", ";", "cum", "->", "prototype", "=", "(", "fntype", "&&", "prototype_p", "(", "fntype", ")", ")", ";", "cum", "->", "call_cookie", "=", "(", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "libcall", ")", "?", "CALL_LIBCALL", ":", "CALL_NORMAL", ")", ";", "cum", "->", "sysv_gregno", "=", "GP_ARG_MIN_REG", ";", "cum", "->", "stdarg", "=", "stdarg_p", "(", "fntype", ")", ";", "cum", "->", "nargs_prototype", "=", "0", ";", "if", "(", "incoming", "||", "cum", "->", "prototype", ")", "cum", "->", "nargs_prototype", "=", "n_named_args", ";", "if", "(", "(", "!", "fntype", "&&", "rs6000_default_long_calls", ")", "||", "(", "fntype", "&&", "lookup_attribute", "(", "\"longcall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", "&&", "!", "lookup_attribute", "(", "\"shortcall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ")", ")", "cum", "->", "call_cookie", "|=", "CALL_LONG", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "{", "fprintf", "(", "stderr", ",", "\"\\ninit_cumulative_args:\"", ")", ";", "if", "(", "fntype", ")", "{", "tree", "ret_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "fprintf", "(", "stderr", ",", "\" ret code = %s,\"", ",", "get_tree_code_name", "(", "TREE_CODE", "(", "ret_type", ")", ")", ")", ";", "}", "if", "(", "cum", "->", "call_cookie", "&", "CALL_LONG", ")", "fprintf", "(", "stderr", ",", "\" longcall,\"", ")", ";", "fprintf", "(", "stderr", ",", "\" proto = %d, nargs = %d\\n\"", ",", "cum", "->", "prototype", ",", "cum", "->", "nargs_prototype", ")", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", ")", "{", "cum", "->", "escapes", "=", "call_ABI_of_interest", "(", "fndecl", ")", ";", "if", "(", "cum", "->", "escapes", ")", "{", "tree", "return_type", ";", "if", "(", "fntype", ")", "{", "return_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "return_mode", "=", "TYPE_MODE", "(", "return_type", ")", ";", "}", "else", "return_type", "=", "lang_hooks", ".", "types", ".", "type_for_mode", "(", "return_mode", ",", "0", ")", ";", "if", "(", "return_type", "!=", "NULL", ")", "{", "if", "(", "TREE_CODE", "(", "return_type", ")", "==", "RECORD_TYPE", "&&", "TYPE_TRANSPARENT_AGGR", "(", "return_type", ")", ")", "{", "return_type", "=", "TREE_TYPE", "(", "first_field", "(", "return_type", ")", ")", ";", "return_mode", "=", "TYPE_MODE", "(", "return_type", ")", ";", "}", "if", "(", "AGGREGATE_TYPE_P", "(", "return_type", ")", "&&", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "return_type", ")", "<=", "8", ")", ")", "rs6000_returns_struct", "=", "true", ";", "}", "if", "(", "SCALAR_FLOAT_MODE_P", "(", "return_mode", ")", ")", "rs6000_passes_float", "=", "true", ";", "else", "if", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "return_mode", ")", "||", "SPE_VECTOR_MODE", "(", "return_mode", ")", ")", "rs6000_passes_vector", "=", "true", ";", "}", "}", "if", "(", "fntype", "&&", "!", "TARGET_ALTIVEC", "&&", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "fntype", ")", ")", ")", ")", "{", "error", "(", "\"cannot return value in vector register because\"", "\" altivec instructions are disabled, use -maltivec\"", "\" to enable them\"", ")", ";", "}", "}", "</s>" ]

[ "Handle", "the", "INIT_CUMULATIVE_ARGS", "macro", ".", "Initialize", "a", "variable", "CUM", "of", "type", "CUMULATIVE_ARGS", "for", "a", "call", "to", "a", "function", "whose", "data", "type", "is", "FNTYPE", ".", "For", "a", "library", "call", ",", "FNTYPE", "is", "0", "." ]

[ "rs6000", "0", "0", "\"longcall\"", "\"shortcall\"", "\"\\ninit_cumulative_args:\"", "\" ret code = %s,\"", "\" longcall,\"", "\" proto = %d, nargs = %d\\n\"", "0", "8", "\"cannot return value in vector register because\"", "\" altivec instructions are disabled, use -maltivec\"", "\" to enable them\"" ]

[]

[ "<s>", "CCAssignFn", "*", "AArch64TargetLowering", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "const", "{", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention.\"", ")", ";", "case", "CallingConv", "::", "WebKit_JS", ":", "return", "CC_AArch64_WebKit_JS", ";", "case", "CallingConv", "::", "GHC", ":", "return", "CC_AArch64_GHC", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "PreserveMost", ":", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "!", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "return", "CC_AArch64_AAPCS", ";", "return", "IsVarArg", "?", "CC_AArch64_DarwinPCS_VarArg", ":", "CC_AArch64_DarwinPCS", ";", "}", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "AArch64", "AArch64", "\"Unsupported calling convention.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", "=", "0", ",", "unsigned", "Align", "=", "1", ",", "bool", "*", "Fast", "=", "nullptr", ")", "const", "override", "{", "if", "(", "RequireStrictAlign", ")", "return", "false", ";", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "AArch64", "0", "1" ]

[]

[ "<s>", "bool", "SPIRVInstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ")", "{", "assert", "(", "I", ".", "getParent", "(", ")", "&&", "\"Instruction should be in a basic block!\"", ")", ";", "assert", "(", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "&&", "\"Instruction should be in a function!\"", ")", ";", "Register", "Opcode", "=", "I", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opcode", ")", ")", "{", "if", "(", "Opcode", "==", "SPIRV", "::", "ASSIGN_TYPE", ")", "{", "auto", "*", "Def", "=", "MRI", "->", "getVRegDef", "(", "I", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "isTypeFoldingSupported", "(", "Def", "->", "getOpcode", "(", ")", ")", ")", "{", "auto", "Res", "=", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ";", "assert", "(", "Res", "||", "Def", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_CONSTANT", ")", ";", "if", "(", "Res", ")", "return", "Res", ";", "}", "MRI", "->", "replaceRegWith", "(", "I", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "I", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "I", ".", "removeFromParent", "(", ")", ";", "}", "else", "if", "(", "I", ".", "getNumDefs", "(", ")", "==", "1", ")", "{", "MRI", "->", "setType", "(", "I", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "LLT", "::", "scalar", "(", "32", ")", ")", ";", "}", "return", "true", ";", "}", "if", "(", "I", ".", "getNumOperands", "(", ")", "!=", "I", ".", "getNumExplicitOperands", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Generic instr has unexpected implicit operands\\n\"", ")", ";", "return", "false", ";", "}", "bool", "HasDefs", "=", "I", ".", "getNumDefs", "(", ")", ">", "0", ";", "Register", "ResVReg", "=", "HasDefs", "?", "I", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ":", "Register", "(", "0", ")", ";", "SPIRVType", "*", "ResType", "=", "HasDefs", "?", "GR", ".", "getSPIRVTypeForVReg", "(", "ResVReg", ")", ":", "nullptr", ";", "assert", "(", "!", "HasDefs", "||", "ResType", "||", "I", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_GLOBAL_VALUE", ")", ";", "if", "(", "spvSelect", "(", "ResVReg", ",", "ResType", ",", "I", ")", ")", "{", "if", "(", "HasDefs", ")", "MRI", "->", "setType", "(", "ResVReg", ",", "LLT", "::", "scalar", "(", "32", ")", ")", ";", "I", ".", "removeFromParent", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "SPIRV", "SPIRV", "\"Instruction should be in a basic block!\"", "\"Instruction should be in a function!\"", "SPIRV::ASSIGN_TYPE", "1", "1", "0", "1", "0", "32", "\"Generic instr has unexpected implicit operands\\n\"", "0", "0", "0", "SPIRV", "SPIRV", "32" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "Register", "&&", "Reg", ".", "Modifiers", "==", "-", "1", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "R600", "1" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Mips Native Client Rewrite Pass\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "Mips", "\"Mips Native Client Rewrite Pass\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM Instruction Selection\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "ARM", "\"ARM Instruction Selection\"" ]

[]

[ "<s>", "int", "s390_O_constraint_str", "(", "const", "char", "c", ",", "HOST_WIDE_INT", "value", ")", "{", "if", "(", "!", "TARGET_EXTIMM", ")", "return", "0", ";", "switch", "(", "c", ")", "{", "case", "'s'", ":", "return", "trunc_int_for_mode", "(", "value", ",", "SImode", ")", "==", "value", ";", "case", "'p'", ":", "return", "value", "==", "0", "||", "s390_single_part", "(", "GEN_INT", "(", "value", ")", ",", "DImode", ",", "SImode", ",", "0", ")", "==", "1", ";", "case", "'n'", ":", "return", "s390_single_part", "(", "GEN_INT", "(", "value", "-", "1", ")", ",", "DImode", ",", "SImode", ",", "-", "1", ")", "==", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Evaluates", "constraint", "strings", "starting", "with", "letter", "O", ".", "Input", "parameter", "C", "is", "the", "second", "letter", "following", "the", "``", "O", "''", "in", "the", "constraint", "string", ".", "Returns", "1", "if", "VALUE", "meets", "the", "respective", "constraint", "and", "0", "otherwise", "." ]

[ "s390", "0", "0", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "const", "TOYRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "TOY", "TOY" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "BPF" ]

[]

[ "<s>", "static", "void", "mep_reload_pointer", "(", "int", "regno", ",", "const", "char", "*", "symbol", ")", "{", "rtx", "reg", ",", "sym", ";", "if", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", "&&", "crtl", "->", "is_leaf", ")", "return", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "sym", "=", "gen_rtx_SYMBOL_REF", "(", "SImode", ",", "symbol", ")", ";", "emit_insn", "(", "gen_movsi_topsym_s", "(", "reg", ",", "sym", ")", ")", ";", "emit_insn", "(", "gen_movsi_botsym_s", "(", "reg", ",", "reg", ",", "sym", ")", ")", ";", "}", "</s>" ]

[ "Used", "for", "interrupt", "functions", ",", "which", "ca", "n't", "assume", "that", "$", "tp", "and", "$", "gp", "contain", "the", "correct", "pointers", "." ]

[ "mep" ]

[]

[ "<s>", "static", "void", "nvptx_assemble_decl_begin", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "const", "char", "*", "section", ",", "const_tree", "type", ",", "HOST_WIDE_INT", "size", ",", "unsigned", "align", ")", "{", "while", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "unsigned", "elt_size", "=", "int_size_in_bytes", "(", "type", ")", ";", "machine_mode", "elt_mode", "=", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", "?", "Pmode", ":", "DImode", ";", "elt_size", "|=", "GET_MODE_SIZE", "(", "elt_mode", ")", ";", "elt_size", "&=", "-", "elt_size", ";", "init_frag", ".", "size", "=", "elt_size", ";", "init_frag", ".", "mask", "=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "2", "<<", "(", "elt_size", "*", "BITS_PER_UNIT", "-", "1", ")", ")", "-", "1", ";", "init_frag", ".", "val", "=", "0", ";", "init_frag", ".", "offset", "=", "0", ";", "init_frag", ".", "started", "=", "false", ";", "init_frag", ".", "remaining", "=", "(", "size", "+", "elt_size", "-", "1", ")", "/", "elt_size", ";", "fprintf", "(", "file", ",", "\"%s .align %d .u%d \"", ",", "section", ",", "align", "/", "BITS_PER_UNIT", ",", "elt_size", "*", "BITS_PER_UNIT", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "if", "(", "size", ")", "fprintf", "(", "file", ",", "\"[\"", "HOST_WIDE_INT_PRINT_DEC", "\"]\"", ",", "init_frag", ".", "remaining", ")", ";", "}", "</s>" ]

[ "Emit", "a", "PTX", "variable", "decl", "and", "prepare", "for", "emission", "of", "its", "initializer", ".", "NAME", "is", "the", "symbol", "name", "and", "SETION", "the", "PTX", "data", "area", ".", "The", "type", "is", "TYPE", ",", "object", "size", "SIZE", "and", "alignment", "is", "ALIGN", ".", "The", "caller", "has", "already", "emitted", "any", "indentation", "and", "linkage", "specifier", ".", "It", "is", "responsible", "for", "any", "initializer", ",", "terminating", ";", "and", "newline", ".", "SIZE", "is", "in", "bytes", ",", "ALIGN", "is", "in", "bits", "--", "confusingly", "this", "is", "the", "opposite", "way", "round", "that", "PTX", "wants", "them", "!" ]

[ "nvptx", "2", "1", "1", "0", "0", "1", "\"%s .align %d .u%d \"", "\"[\"", "\"]\"" ]

[]

[ "<s>", "MachineInstr", "*", "X86InstrInfo", "::", "optimizeLoadInstr", "(", "MachineInstr", "&", "MI", ",", "const", "MachineRegisterInfo", "*", "MRI", ",", "unsigned", "&", "FoldAsLoadDefReg", ",", "MachineInstr", "*", "&", "DefMI", ")", "const", "{", "if", "(", "FoldAsLoadDefReg", "==", "0", ")", "return", "nullptr", ";", "if", "(", "MI", ".", "mayLoad", "(", ")", ")", "{", "FoldAsLoadDefReg", "=", "0", ";", "return", "nullptr", ";", "}", "DefMI", "=", "MRI", "->", "getVRegDef", "(", "FoldAsLoadDefReg", ")", ";", "assert", "(", "DefMI", ")", ";", "bool", "SawStore", "=", "false", ";", "if", "(", "!", "DefMI", "->", "isSafeToMove", "(", "nullptr", ",", "SawStore", ")", ")", "return", "nullptr", ";", "unsigned", "SrcOperandId", "=", "0", ";", "bool", "FoundSrcOperand", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "FoldAsLoadDefReg", ")", "continue", ";", "if", "(", "MO", ".", "getSubReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", "||", "FoundSrcOperand", ")", "return", "nullptr", ";", "SrcOperandId", "=", "i", ";", "FoundSrcOperand", "=", "true", ";", "}", "if", "(", "!", "FoundSrcOperand", ")", "return", "nullptr", ";", "if", "(", "MachineInstr", "*", "FoldMI", "=", "foldMemoryOperand", "(", "MI", ",", "SrcOperandId", ",", "*", "DefMI", ")", ")", "{", "FoldAsLoadDefReg", "=", "0", ";", "return", "FoldMI", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "optimizeLoadInstr", "-", "Try", "to", "remove", "the", "load", "by", "folding", "it", "to", "a", "register", "operand", "at", "the", "use", "." ]

[ "X86", "X86", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "ix86_emit_cmove", "(", "rtx", "dst", ",", "rtx", "src", ",", "enum", "rtx_code", "code", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "rtx", "t", ";", "if", "(", "TARGET_CMOVE", ")", "{", "t", "=", "ix86_expand_compare", "(", "code", ",", "op1", ",", "op2", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "dst", ")", ",", "t", ",", "src", ",", "dst", ")", ")", ")", ";", "}", "else", "{", "rtx", "nomove", "=", "gen_label_rtx", "(", ")", ";", "emit_cmp_and_jump_insns", "(", "op1", ",", "op2", ",", "reverse_condition", "(", "code", ")", ",", "const0_rtx", ",", "GET_MODE", "(", "op1", ")", ",", "1", ",", "nomove", ")", ";", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "emit_label", "(", "nomove", ")", ";", "}", "}", "</s>" ]

[ "Emit", "conditional", "move", "of", "SRC", "to", "DST", "with", "condition", "OP1", "CODE", "OP2", "." ]

[ "i386", "1" ]

[]

[ "<s>", "unsigned", "MipsInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "MI", ".", "getDesc", "(", ")", ".", "getSize", "(", ")", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "case", "Mips", "::", "CONSTPOOL_ENTRY", ":", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "Mips", "Mips", "0", "Mips::CONSTPOOL_ENTRY", "2" ]

[]

[ "<s>", "bool", "AArch64AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "const", "MCObjectFileInfo", "::", "Environment", "Format", "=", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", "->", "getObjectFileType", "(", ")", ";", "bool", "IsMachO", "=", "Format", "==", "MCObjectFileInfo", "::", "IsMachO", ";", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "SMLoc", "Loc", "=", "DirectiveID", ".", "getLoc", "(", ")", ";", "if", "(", "IDVal", "==", "\".arch\"", ")", "parseDirectiveArch", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".cpu\"", ")", "parseDirectiveCPU", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".tlsdesccall\"", ")", "parseDirectiveTLSDescCall", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".ltorg\"", "||", "IDVal", "==", "\".pool\"", ")", "parseDirectiveLtorg", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".unreq\"", ")", "parseDirectiveUnreq", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".inst\"", ")", "parseDirectiveInst", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".cfi_negate_ra_state\"", ")", "parseDirectiveCFINegateRAState", "(", ")", ";", "else", "if", "(", "IsMachO", ")", "{", "if", "(", "IDVal", "==", "MCLOHDirectiveName", "(", ")", ")", "parseDirectiveLOH", "(", "IDVal", ",", "Loc", ")", ";", "else", "return", "true", ";", "}", "else", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "AArch64", "AArch64", "\".arch\"", "\".cpu\"", "\".tlsdesccall\"", "\".ltorg\"", "\".pool\"", "\".unreq\"", "\".inst\"", "\".cfi_negate_ra_state\"" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "override", "{", "return", "isMEMrri", "(", ")", "||", "isMEMrii", "(", ")", "||", "isMEMzri", "(", ")", "||", "isMEMzii", "(", ")", "||", "isMEMri", "(", ")", "||", "isMEMzi", "(", ")", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "VE" ]

[]

[ "<s>", "EVT", "MipsTargetLowering", "::", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "Mips", "Mips", "MVT::i32" ]

[]

[ "<s>", "SMRange", "getLocRange", "(", ")", "const", "{", "return", "SMRange", "(", "StartLoc", ",", "EndLoc", ")", ";", "}", "</s>" ]

[ "getLocRange", "-", "Get", "the", "range", "between", "the", "first", "and", "last", "token", "of", "this", "operand", "." ]

[ "TPC" ]

[]

[ "<s>", "virtual", "EVT", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "SystemZ", "MVT::i32" ]

[]

[ "<s>", "unsigned", "MSP430RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "FP", ":", "MSP430", "::", "SP", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "MSP430", "MSP430", "MSP430::FP", "MSP430::SP" ]

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "getPreferredVectorAction", "(", "EVT", "VT", ")", "const", "override", "{", "if", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "%", "8", "==", "0", ")", "return", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "SystemZ", "8", "0" ]

[]

[ "<s>", "bool", "system_reg_operand", "(", "rtx", "op", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "REGNO", "(", "op", ")", ")", "{", "case", "PR_REG", ":", "case", "MACL_REG", ":", "case", "MACH_REG", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "1", "if", "OP", "is", "MACL", ",", "MACH", "or", "PR", ".", "The", "input", "must", "be", "a", "REG", "rtx", ".", "Used", "only", "in", "general_movsrc_operand", "." ]

[ "sh" ]

[]

[ "<s>", "void", "MipsInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Mips", "::", "RDHWR", ":", "case", "Mips", "::", "RDHWR64", ":", "O", "<<", "\"\\t.set\\tpush\\n\"", ";", "O", "<<", "\"\\t.set\\tmips32r2\\n\"", ";", "break", ";", "case", "Mips", "::", "Save16", ":", "O", "<<", "\"\\tsave\\t\"", ";", "printSaveRestore", "(", "MI", ",", "O", ")", ";", "O", "<<", "\" # 16 bit inst\\n\"", ";", "return", ";", "case", "Mips", "::", "SaveX16", ":", "O", "<<", "\"\\tsave\\t\"", ";", "printSaveRestore", "(", "MI", ",", "O", ")", ";", "O", "<<", "\"\\n\"", ";", "return", ";", "case", "Mips", "::", "Restore16", ":", "O", "<<", "\"\\trestore\\t\"", ";", "printSaveRestore", "(", "MI", ",", "O", ")", ";", "O", "<<", "\" # 16 bit inst\\n\"", ";", "return", ";", "case", "Mips", "::", "RestoreX16", ":", "O", "<<", "\"\\trestore\\t\"", ";", "printSaveRestore", "(", "MI", ",", "O", ")", ";", "O", "<<", "\"\\n\"", ";", "return", ";", "}", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "Address", ",", "O", ")", "&&", "!", "printAlias", "(", "*", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "Address", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Mips", "::", "RDHWR", ":", "case", "Mips", "::", "RDHWR64", ":", "O", "<<", "\"\\n\\t.set\\tpop\"", ";", "}", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "Mips", "Mips", "Mips::RDHWR", "Mips::RDHWR64", "\"\\t.set\\tpush\\n\"", "\"\\t.set\\tmips32r2\\n\"", "Mips::Save16", "\"\\tsave\\t\"", "\" # 16 bit inst\\n\"", "Mips::SaveX16", "\"\\tsave\\t\"", "\"\\n\"", "Mips::Restore16", "\"\\trestore\\t\"", "\" # 16 bit inst\\n\"", "Mips::RestoreX16", "\"\\trestore\\t\"", "\"\\n\"", "Mips::RDHWR", "Mips::RDHWR64", "\"\\n\\t.set\\tpop\"" ]

[]

[ "<s>", "bool", "PatmosInstPrinter", "::", "isBundled", "(", "const", "MCInst", "*", "MI", ")", "const", "{", "return", "MI", "->", "getOperand", "(", "MI", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getImm", "(", ")", ">", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "part", "of", "a", "bundle", "." ]

[ "Patmos", "Patmos", "1", "0" ]

[]

[ "<s>", "static", "void", "hwloop_fail", "(", "hwloop_info", "loop", ")", "{", "rtx", "test", ";", "rtx_insn", "*", "insn", "=", "loop", "->", "loop_end", ";", "emit_insn_before", "(", "gen_addsi3", "(", "loop", "->", "iter_reg", ",", "loop", "->", "iter_reg", ",", "constm1_rtx", ")", ",", "loop", "->", "loop_end", ")", ";", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "loop", "->", "iter_reg", ",", "const0_rtx", ")", ";", "insn", "=", "emit_jump_insn_before", "(", "gen_cbranchsi4", "(", "test", ",", "loop", "->", "iter_reg", ",", "const0_rtx", ",", "loop", "->", "start_label", ")", ",", "loop", "->", "loop_end", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "loop", "->", "start_label", ";", "LABEL_NUSES", "(", "loop", "->", "start_label", ")", "++", ";", "delete_insn", "(", "loop", "->", "loop_end", ")", ";", "}", "</s>" ]

[ "A", "callback", "for", "the", "hw-doloop", "pass", ".", "Called", "when", "a", "loop", "we", "have", "discovered", "turns", "out", "not", "to", "be", "optimizable", ";", "we", "have", "to", "split", "the", "doloop_end", "pattern", "into", "a", "subtract", "and", "a", "test", "." ]

[ "xtensa" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "&", "MIa", ",", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "MachineOperand", "*", "BaseOpA", "=", "nullptr", ",", "*", "BaseOpB", "=", "nullptr", ";", "int64_t", "OffsetA", "=", "0", ",", "OffsetB", "=", "0", ";", "unsigned", "WidthA", "=", "0", ",", "WidthB", "=", "0", ";", "assert", "(", "MIa", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIa must be a load or store.\"", ")", ";", "assert", "(", "MIb", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIb must be a load or store.\"", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "getMemOperandWithOffsetWidth", "(", "MIa", ",", "BaseOpA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getMemOperandWithOffsetWidth", "(", "MIb", ",", "BaseOpB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseOpA", "->", "isIdenticalTo", "(", "*", "BaseOpB", ")", ")", "{", "int", "LowOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetA", ":", "OffsetB", ";", "int", "HighOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetB", ":", "OffsetA", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "AArch64", "AArch64", "0", "0", "0", "0", "\"MIa must be a load or store.\"", "\"MIb must be a load or store.\"" ]

[]

[ "<s>", "PreservedAnalyses", "BPFAdjustOptPass", "::", "run", "(", "Module", "&", "M", ",", "ModuleAnalysisManager", "&", "AM", ")", "{", "return", "BPFAdjustOptImpl", "(", "&", "M", ")", ".", "run", "(", ")", "?", "PreservedAnalyses", "::", "none", "(", ")", ":", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "BPF", "BPF", "BPF" ]

[]

[ "<s>", "const", "char", "*", "output_h8sx_shift", "(", "rtx", "*", "operands", ",", "int", "suffix", ",", "int", "optype", ")", "{", "static", "char", "buffer", "[", "16", "]", ";", "const", "char", "*", "stem", ";", "switch", "(", "GET_CODE", "(", "operands", "[", "3", "]", ")", ")", "{", "case", "ASHIFT", ":", "stem", "=", "\"shll\"", ";", "break", ";", "case", "ASHIFTRT", ":", "stem", "=", "\"shar\"", ";", "break", ";", "case", "LSHIFTRT", ":", "stem", "=", "\"shlr\"", ";", "break", ";", "case", "ROTATE", ":", "stem", "=", "\"rotl\"", ";", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "2", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ";", "stem", "=", "\"rotr\"", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "operands", "[", "2", "]", "==", "const1_rtx", ")", "sprintf", "(", "buffer", ",", "\"%s.%c\\t%%%c0\"", ",", "stem", ",", "suffix", ",", "optype", ")", ";", "else", "sprintf", "(", "buffer", ",", "\"%s.%c\\t%%X2,%%%c0\"", ",", "stem", ",", "suffix", ",", "optype", ")", ";", "return", "buffer", ";", "}", "</s>" ]

[ "Return", "the", "asm", "template", "for", "a", "single", "h8sx", "shift", "instruction", ".", "OPERANDS", "[", "0", "]", "and", "OPERANDS", "[", "1", "]", "are", "the", "destination", ",", "OPERANDS", "[", "2", "]", "is", "the", "source", "and", "OPERANDS", "[", "3", "]", "is", "the", "shift", ".", "SUFFIX", "is", "the", "size", "suffix", "(", "'", "b", "'", ",", "'", "w", "'", "or", "'", "l", "'", ")", "and", "OPTYPE", "is", "the", "print_operand", "prefix", "for", "the", "destination", "operand", "." ]

[ "h8300", "16", "3", "\"shll\"", "\"shar\"", "\"shlr\"", "\"rotl\"", "2", "2", "2", "0", "2", "\"rotr\"", "2", "\"%s.%c\\t%%%c0\"", "\"%s.%c\\t%%X2,%%%c0\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM Instruction Selection\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "ARM", "\"ARM Instruction Selection\"" ]

[]

[ "<s>", "static", "rtx", "mips16e_save_restore_reg", "(", "bool", "restore_p", ",", "bool", "reg_parm_p", ",", "HOST_WIDE_INT", "offset", ",", "unsigned", "int", "regno", ")", "{", "rtx", "reg", ",", "mem", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "if", "(", "restore_p", ")", "{", "mips_add_cfa_restore", "(", "reg", ")", ";", "return", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ";", "}", "if", "(", "reg_parm_p", ")", "return", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "reg", ")", ";", "return", "mips_frame_set", "(", "mem", ",", "reg", ")", ";", "}", "</s>" ]

[ "Return", "a", "move", "between", "register", "REGNO", "and", "memory", "location", "SP", "+", "OFFSET", ".", "REG_PARM_P", "is", "true", "if", "SP", "+", "OFFSET", "belongs", "to", "REG_PARM_STACK_SPACE", ".", "Make", "the", "move", "a", "load", "if", "RESTORE_P", ",", "otherwise", "make", "it", "a", "store", "." ]

[ "mips" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "TRI", "->", "getRegSizeInBits", "(", "RISCV", "::", "GPRRegClass", ")", "==", "32", "?", "RISCV", "::", "LW", ":", "RISCV", "::", "LD", ";", "else", "if", "(", "RISCV", "::", "FPR16RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FLH", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FLW", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FLD", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "RI5CY", "RISCV", "RISCV::GPRRegClass", "RISCV::GPRRegClass", "32", "RISCV::LW", "RISCV::LD", "RISCV::FPR16RegClass", "RISCV::FLH", "RISCV::FPR32RegClass", "RISCV::FLW", "RISCV::FPR64RegClass", "RISCV::FLD", "\"Can't load this register from stack slot\"", "0" ]

[]

[ "<s>", "bool", "WebAssemblyPrepareForLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Prepare For LiveIntervals **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "*", "MF", ".", "begin", "(", ")", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "\"LiveIntervals shouldn't be active yet!\"", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "i", ")", ";", "if", "(", "MRI", ".", "use_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "if", "(", "HasArgumentDef", "(", "Reg", ",", "MRI", ")", ")", "continue", ";", "BuildMI", "(", "Entry", ",", "Entry", ".", "begin", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "IMPLICIT_DEF", ")", ",", "Reg", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "auto", "MII", "=", "Entry", ".", "begin", "(", ")", ",", "MIE", "=", "Entry", ".", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "MII", "++", ";", "if", "(", "IsArgument", "(", "MI", ")", ")", "{", "MI", "->", "removeFromParent", "(", ")", ";", "Entry", ".", "insert", "(", "Entry", ".", "begin", "(", ")", ",", "MI", ")", ";", "}", "}", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "TracksLiveness", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "WebAssembly", "WebAssembly", "\"********** Prepare For LiveIntervals **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"LiveIntervals shouldn't be active yet!\"", "0", "WebAssembly::IMPLICIT_DEF" ]

[]

[ "<s>", "void", "X86AsmPrinter", "::", "emitFunctionBodyStart", "(", ")", "{", "if", "(", "EmitFPOData", ")", "{", "if", "(", "auto", "*", "XTS", "=", "static_cast", "<", "X86TargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ")", "XTS", "->", "emitFPOProc", "(", "CurrentFnSym", ",", "MF", "->", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getArgumentStackSize", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "before", "the", "first", "basic", "block", "in", "the", "function", "." ]

[ "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ",", "const", "TargetMachine", "*", "TM", "=", "0", ")", "const", "{", "if", "(", "isReg", "(", ")", ")", "{", "OS", "<<", "PrintReg", "(", "getReg", "(", ")", ")", ";", "}", "if", "(", "isImm", "(", ")", ")", "{", "OS", "<<", "getImm", "(", ")", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "Hexagon", "0" ]

[]

[ "<s>", "static", "bool", "ix86_optab_supported_p", "(", "int", "op", ",", "machine_mode", "mode1", ",", "machine_mode", ",", "optimization_type", "opt_type", ")", "{", "switch", "(", "op", ")", "{", "case", "asin_optab", ":", "case", "acos_optab", ":", "case", "log1p_optab", ":", "case", "exp_optab", ":", "case", "exp10_optab", ":", "case", "exp2_optab", ":", "case", "expm1_optab", ":", "case", "ldexp_optab", ":", "case", "scalb_optab", ":", "case", "round_optab", ":", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", ";", "case", "rint_optab", ":", "if", "(", "SSE_FLOAT_MODE_P", "(", "mode1", ")", "&&", "TARGET_SSE_MATH", "&&", "!", "flag_trapping_math", "&&", "!", "TARGET_SSE4_1", "&&", "mode1", "!=", "HFmode", ")", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", ";", "return", "true", ";", "case", "floor_optab", ":", "case", "ceil_optab", ":", "case", "btrunc_optab", ":", "if", "(", "(", "(", "SSE_FLOAT_MODE_P", "(", "mode1", ")", "&&", "TARGET_SSE_MATH", "&&", "TARGET_SSE4_1", ")", "||", "mode1", "==", "HFmode", ")", "&&", "!", "flag_trapping_math", ")", "return", "true", ";", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", ";", "case", "rsqrt_optab", ":", "return", "opt_type", "==", "OPTIMIZE_FOR_SPEED", "&&", "use_rsqrt_p", "(", "mode1", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "the", "TARGET_OPTAB_SUPPORTED_P", "hook", "." ]

[ "i386" ]

[]

[ "<s>", "poly_int64", "riscv_v_adjust_bytesize", "(", "machine_mode", "mode", ",", "int", "scale", ")", "{", "if", "(", "riscv_v_ext_vector_mode_p", "(", "mode", ")", ")", "{", "poly_uint16", "mode_size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "maybe_eq", "(", "mode_size", ",", "(", "uint16_t", ")", "-", "1", ")", ")", "mode_size", "=", "riscv_vector_chunks", "*", "scale", ";", "if", "(", "known_gt", "(", "mode_size", ",", "BYTES_PER_RISCV_VECTOR", ")", ")", "mode_size", "=", "BYTES_PER_RISCV_VECTOR", ";", "return", "mode_size", ";", "}", "return", "scale", ";", "}", "</s>" ]

[ "Call", "from", "ADJUST_BYTESIZE", "in", "riscv-modes.def", ".", "Return", "the", "correct", "BYTE", "size", "for", "corresponding", "machine_mode", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "M68k" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "SAVEri", "=", "SP", "::", "SAVEri", ";", "unsigned", "SAVErr", "=", "SP", "::", "SAVErr", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "SAVEri", "=", "SP", "::", "ADDri", ";", "SAVErr", "=", "SP", "::", "ADDrr", ";", "}", "NumBytes", "=", "-", "SubTarget", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "if", "(", "NumBytes", ">=", "-", "4096", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SAVEri", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "else", "{", "unsigned", "OffHi", "=", "(", "unsigned", ")", "NumBytes", ">>", "10U", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SETHIi", ")", ",", "SP", "::", "G1", ")", ".", "addImm", "(", "OffHi", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "ORri", ")", ",", "SP", "::", "G1", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ".", "addImm", "(", "NumBytes", "&", "(", "(", "1", "<<", "10", ")", "-", "1", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SAVErr", ")", ",", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "O6", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ";", "}", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MCSymbol", "*", "FrameLabel", "=", "MMI", ".", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "PROLOG_LABEL", ")", ")", ".", "addSym", "(", "FrameLabel", ")", ";", "unsigned", "regFP", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I6", ",", "true", ")", ";", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "FrameLabel", ",", "regFP", ")", ")", ";", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createWindowSave", "(", "FrameLabel", ")", ")", ";", "unsigned", "regInRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I7", ",", "true", ")", ";", "unsigned", "regOutRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "O7", ",", "true", ")", ";", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createRegister", "(", "FrameLabel", ",", "regOutRA", ",", "regInRA", ")", ")", ";", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::SAVEri", "SP::SAVErr", "0", "SP::ADDri", "SP::ADDrr", "4096", "SP::O6", "SP::O6", "10U", "SP::SETHIi", "SP::G1", "SP::ORri", "SP::G1", "SP::G1", "1", "10", "1", "SP::O6", "SP::O6", "SP::G1", "SP::PROLOG_LABEL", "SP::I6", "SP::I7", "SP::O7" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "READ_REGISTER", ":", "ExpandREAD_REGISTER", "(", "N", ",", "Results", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SHL", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SREM", ":", "case", "ISD", "::", "UREM", ":", "Res", "=", "LowerREM", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "Res", "=", "LowerDivRem", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "assert", "(", "Res", ".", "getNumOperands", "(", ")", "==", "2", "&&", "\"DivRem needs two values\"", ")", ";", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "0", ")", ")", ";", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "1", ")", ")", ";", "return", ";", "case", "ISD", "::", "SADDSAT", ":", "case", "ISD", "::", "SSUBSAT", ":", "Res", "=", "LowerSADDSUBSAT", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "ReplaceREADCYCLECOUNTER", "(", "N", ",", "Results", ",", "DAG", ",", "Subtarget", ")", ";", "return", ";", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "SDIV", ":", "assert", "(", "Subtarget", "->", "isTargetWindows", "(", ")", "&&", "\"can only expand DIV on Windows\"", ")", ";", "return", "ExpandDIV_Windows", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ",", "Results", ")", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "ReplaceCMP_SWAP_64Results", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "ReplaceLongIntrinsic", "(", "N", ",", "Results", ",", "DAG", ")", ";", "case", "ISD", "::", "ABS", ":", "lowerABS", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "ISD", "::", "LOAD", ":", "LowerLOAD", "(", "N", ",", "Results", ",", "DAG", ")", ";", "break", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::READ_REGISTER", "ISD::BITCAST", "ISD::SRL", "ISD::SRA", "ISD::SHL", "ISD::SREM", "ISD::UREM", "ISD::SDIVREM", "ISD::UDIVREM", "0", "2", "\"DivRem needs two values\"", "0", "1", "ISD::SADDSAT", "ISD::SSUBSAT", "0", "ISD::READCYCLECOUNTER", "ISD::UDIV", "ISD::SDIV", "\"can only expand DIV on Windows\"", "0", "ISD::SDIV", "ISD::ATOMIC_CMP_SWAP", "ISD::INTRINSIC_WO_CHAIN", "ISD::ABS", "ISD::LOAD" ]

[]

[ "<s>", "BitVector", "WebAssemblyRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "auto", "Reg", ":", "{", "WebAssembly", "::", "SP32", ",", "WebAssembly", "::", "SP64", ",", "WebAssembly", "::", "FP32", ",", "WebAssembly", "::", "FP64", "}", ")", "Reserved", ".", "set", "(", "Reg", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "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", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::SP32", "WebAssembly::SP64", "WebAssembly::FP32", "WebAssembly::FP64" ]

[]

[ "<s>", "bool", "ARMInstrInfo", "::", "SubsumesPredicate", "(", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred1", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred2", ")", "const", "{", "if", "(", "Pred1", ".", "size", "(", ")", ">", "2", "||", "Pred2", ".", "size", "(", ")", ">", "2", ")", "return", "false", ";", "ARMCC", "::", "CondCodes", "CC1", "=", "(", "ARMCC", "::", "CondCodes", ")", "Pred1", "[", "0", "]", ".", "getImm", "(", ")", ";", "ARMCC", "::", "CondCodes", "CC2", "=", "(", "ARMCC", "::", "CondCodes", ")", "Pred2", "[", "0", "]", ".", "getImm", "(", ")", ";", "if", "(", "CC1", "==", "CC2", ")", "return", "true", ";", "switch", "(", "CC1", ")", "{", "default", ":", "return", "false", ";", "case", "ARMCC", "::", "AL", ":", "return", "true", ";", "case", "ARMCC", "::", "HS", ":", "return", "CC2", "==", "ARMCC", "::", "HI", ";", "case", "ARMCC", "::", "LS", ":", "return", "CC2", "==", "ARMCC", "::", "LO", "||", "CC2", "==", "ARMCC", "::", "EQ", ";", "case", "ARMCC", "::", "GE", ":", "return", "CC2", "==", "ARMCC", "::", "GT", ";", "case", "ARMCC", "::", "LE", ":", "return", "CC2", "==", "ARMCC", "::", "LT", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "the", "first", "specified", "predicate", "subsumes", "the", "second", ",", "e.g", "." ]

[ "ARM", "ARM", "2", "2", "ARMCC::CondCodes", "ARMCC::CondCodes", "0", "ARMCC::CondCodes", "ARMCC::CondCodes", "0", "ARMCC::AL", "ARMCC::HS", "ARMCC::HI", "ARMCC::LS", "ARMCC::LO", "ARMCC::EQ", "ARMCC::GE", "ARMCC::GT", "ARMCC::LE", "ARMCC::LT" ]

[]

[ "<s>", "void", "PPCELFStreamer", "::", "emitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "PPCMCCodeEmitter", "*", "Emitter", "=", "static_cast", "<", "PPCMCCodeEmitter", "*", ">", "(", "getAssembler", "(", ")", ".", "getEmitterPtr", "(", ")", ")", ";", "Optional", "<", "bool", ">", "IsPartOfGOTToPCRelPair", "=", "isPartOfGOTToPCRelPair", "(", "Inst", ",", "STI", ")", ";", "if", "(", "IsPartOfGOTToPCRelPair", ".", "hasValue", "(", ")", "&&", "!", "IsPartOfGOTToPCRelPair", ".", "getValue", "(", ")", ")", "emitGOTToPCRelReloc", "(", "Inst", ")", ";", "if", "(", "!", "Emitter", "->", "isPrefixedInstruction", "(", "Inst", ")", ")", "{", "MCELFStreamer", "::", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", ";", "}", "emitPrefixedInstruction", "(", "Inst", ",", "STI", ")", ";", "if", "(", "IsPartOfGOTToPCRelPair", ".", "hasValue", "(", ")", "&&", "IsPartOfGOTToPCRelPair", ".", "getValue", "(", ")", ")", "emitGOTToPCRelLabel", "(", "Inst", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "PowerPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "PadShortFunc", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "optForSize", "(", ")", ")", "{", "return", "false", ";", "}", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "padShortFunctions", "(", ")", ")", "return", "false", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "ReturnBBs", ".", "clear", "(", ")", ";", "VisitedBBs", ".", "clear", "(", ")", ";", "findReturns", "(", "&", "MF", ".", "front", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "MachineBasicBlock", "*", "MBB", ";", "unsigned", "int", "Cycles", "=", "0", ";", "for", "(", "DenseMap", "<", "MachineBasicBlock", "*", ",", "unsigned", "int", ">", "::", "iterator", "I", "=", "ReturnBBs", ".", "begin", "(", ")", ";", "I", "!=", "ReturnBBs", ".", "end", "(", ")", ";", "++", "I", ")", "{", "MBB", "=", "I", "->", "first", ";", "Cycles", "=", "I", "->", "second", ";", "if", "(", "Cycles", "<", "Threshold", ")", "{", "assert", "(", "MBB", "->", "size", "(", ")", ">", "0", "&&", "\"Basic block should contain at least a RET but is empty\"", ")", ";", "MachineBasicBlock", "::", "iterator", "ReturnLoc", "=", "--", "MBB", "->", "end", "(", ")", ";", "while", "(", "ReturnLoc", "->", "isDebugValue", "(", ")", ")", "--", "ReturnLoc", ";", "assert", "(", "ReturnLoc", "->", "isReturn", "(", ")", "&&", "!", "ReturnLoc", "->", "isCall", "(", ")", "&&", "\"Basic block does not end with RET\"", ")", ";", "addPadding", "(", "MBB", ",", "ReturnLoc", ",", "Threshold", "-", "Cycles", ")", ";", "NumBBsPadded", "++", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "X86", "X86", "0", "0", "\"Basic block should contain at least a RET but is empty\"", "\"Basic block does not end with RET\"" ]

[]

[ "<s>", "static", "bool", "rs6000_reg_live_or_pic_offset_p", "(", "int", "reg", ")", "{", "if", "(", "reg", "==", "RS6000_PIC_OFFSET_TABLE_REGNUM", "&&", "!", "TARGET_SINGLE_PIC_BASE", ")", "{", "if", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", "&&", "(", "crtl", "->", "calls_eh_return", "||", "df_regs_ever_live_p", "(", "reg", ")", "||", "!", "constant_pool_empty_p", "(", ")", ")", ")", "return", "true", ";", "if", "(", "(", "DEFAULT_ABI", "==", "ABI_V4", "||", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", "&&", "flag_pic", ")", "return", "true", ";", "}", "return", "(", "(", "crtl", "->", "calls_eh_return", "||", "df_regs_ever_live_p", "(", "reg", ")", ")", "&&", "!", "call_used_regs", "[", "reg", "]", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "the", "gp", "REG", "is", "really", "used", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "SDNode", "*", "M68kDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "auto", "&", "DL", "=", "MF", "->", "getDataLayout", "(", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", "->", "getPointerTy", "(", "DL", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "static", "void", "microblaze_function_prologue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "const", "char", "*", "fnname", ";", "long", "fsiz", "=", "current_frame_info", ".", "total_size", ";", "fnname", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", ",", "0", ")", ";", "if", "(", "!", "flag_inhibit_size_directive", ")", "{", "fputs", "(", "\"\\t.ent\\t\"", ",", "file", ")", ";", "if", "(", "interrupt_handler", "&&", "strcmp", "(", "INTERRUPT_HANDLER_NAME", ",", "fnname", ")", ")", "fputs", "(", "\"_interrupt_handler\"", ",", "file", ")", ";", "else", "if", "(", "break_handler", "&&", "strcmp", "(", "BREAK_HANDLER_NAME", ",", "fnname", ")", ")", "fputs", "(", "\"_break_handler\"", ",", "file", ")", ";", "else", "if", "(", "fast_interrupt", "&&", "strcmp", "(", "FAST_INTERRUPT_NAME", ",", "fnname", ")", ")", "fputs", "(", "\"_fast_interrupt\"", ",", "file", ")", ";", "else", "assemble_name", "(", "file", ",", "fnname", ")", ";", "fputs", "(", "\"\\n\"", ",", "file", ")", ";", "if", "(", "!", "microblaze_is_interrupt_variant", "(", ")", ")", "ASM_OUTPUT_TYPE_DIRECTIVE", "(", "file", ",", "fnname", ",", "\"function\"", ")", ";", "}", "assemble_name", "(", "file", ",", "fnname", ")", ";", "fputs", "(", "\":\\n\"", ",", "file", ")", ";", "if", "(", "interrupt_handler", "&&", "strcmp", "(", "INTERRUPT_HANDLER_NAME", ",", "fnname", ")", ")", "fputs", "(", "\"_interrupt_handler:\\n\"", ",", "file", ")", ";", "if", "(", "break_handler", "&&", "strcmp", "(", "BREAK_HANDLER_NAME", ",", "fnname", ")", ")", "fputs", "(", "\"_break_handler:\\n\"", ",", "file", ")", ";", "if", "(", "!", "flag_inhibit_size_directive", ")", "{", "fprintf", "(", "file", ",", "\"\\t.frame\\t%s,%ld,%s\\t\\t# vars= %ld, regs= %d, args= %d\\n\"", ",", "(", "reg_names", "[", "(", "frame_pointer_needed", ")", "?", "HARD_FRAME_POINTER_REGNUM", ":", "STACK_POINTER_REGNUM", "]", ")", ",", "fsiz", ",", "reg_names", "[", "MB_ABI_SUB_RETURN_ADDR_REGNUM", "+", "GP_REG_FIRST", "]", ",", "current_frame_info", ".", "var_size", ",", "current_frame_info", ".", "num_gp", ",", "crtl", "->", "outgoing_args_size", ")", ";", "fprintf", "(", "file", ",", "\"\\t.mask\\t0x%08lx\\n\"", ",", "current_frame_info", ".", "mask", ")", ";", "}", "}", "</s>" ]

[ "Set", "up", "the", "stack", "and", "frame", "(", "if", "desired", ")", "for", "the", "function", "." ]

[ "microblaze", "0", "0", "\"\\t.ent\\t\"", "\"_interrupt_handler\"", "\"_break_handler\"", "\"_fast_interrupt\"", "\"\\n\"", "\"function\"", "\":\\n\"", "\"_interrupt_handler:\\n\"", "\"_break_handler:\\n\"", "\"\\t.frame\\t%s,%ld,%s\\t\\t# vars= %ld, regs= %d, args= %d\\n\"", "\"\\t.mask\\t0x%08lx\\n\"" ]

[]

[ "<s>", "unsigned", "RISCVTargetLowering", "::", "getJumpTableEncoding", "(", ")", "const", "{", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "!", "isPositionIndependent", "(", ")", "&&", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", ")", "{", "return", "MachineJumpTableInfo", "::", "EK_Custom32", ";", "}", "return", "TargetLowering", "::", "getJumpTableEncoding", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "OperandMatchResultTy", "CSKYAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "const", "AsmToken", "&", "Tok", "=", "getParser", "(", ")", ".", "getTok", "(", ")", ";", "StartLoc", "=", "Tok", ".", "getLoc", "(", ")", ";", "EndLoc", "=", "Tok", ".", "getEndLoc", "(", ")", ";", "StringRef", "Name", "=", "getLexer", "(", ")", ".", "getTok", "(", ")", ".", "getIdentifier", "(", ")", ";", "if", "(", "matchRegisterNameHelper", "(", "getSTI", "(", ")", ",", "(", "MCRegister", "&", ")", "RegNo", ",", "Name", ")", ")", "return", "MatchOperand_NoMatch", ";", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "MatchOperand_Success", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "CSKY", "CSKY" ]

[]

[ "<s>", "static", "void", "free_array_of_ptrs", "(", "void", "*", "*", "ptr", ",", "unsigned", "n", ")", "{", "unsigned", "i", ";", "if", "(", "!", "ptr", ")", "return", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "if", "(", "!", "ptr", "[", "i", "]", ")", "break", ";", "free", "(", "ptr", "[", "i", "]", ")", ";", "}", "free", "(", "ptr", ")", ";", "return", ";", "}", "</s>" ]

[ "Auxiliary", "function", "that", "frees", "elements", "of", "PTR", "and", "PTR", "itself", ".", "N", "is", "number", "of", "elements", "to", "be", "freed", ".", "If", "PTR", "is", "NULL", ",", "nothing", "is", "freed", ".", "If", "an", "element", "is", "NULL", ",", "subsequent", "elements", "are", "not", "freed", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "static", "void", "*", "mingw32_gt_pch_get_address", "(", "size_t", "size", ",", "int", ")", "{", "void", "*", "res", ";", "res", "=", "VirtualAlloc", "(", "NULL", ",", "size", ",", "MEM_RESERVE", "|", "MEM_TOP_DOWN", ",", "PAGE_NOACCESS", ")", ";", "if", "(", "!", "res", ")", "w32_error", "(", "__FUNCTION__", ",", "__FILE__", ",", "__LINE__", ",", "\"VirtualAlloc\"", ")", ";", "else", "VirtualFree", "(", "res", ",", "0", ",", "MEM_RELEASE", ")", ";", "return", "res", ";", "}", "</s>" ]

[ "Identify", "an", "address", "that", "'s", "likely", "to", "be", "free", "in", "a", "subsequent", "invocation", "of", "the", "compiler", ".", "The", "area", "should", "be", "able", "to", "hold", "SIZE", "bytes", ".", "FD", "is", "an", "open", "file", "descriptor", "if", "the", "host", "would", "like", "to", "probe", "with", "mmap", "." ]

[ "i386", "\"VirtualAlloc\"", "0" ]

[]

[ "<s>", "TargetTransformInfo", "R600TargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "const", "{", "return", "TargetTransformInfo", "(", "R600TTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "AMDGPU", "R600", "R600" ]

[]

[ "<s>", "bool", "Thumb2SizeReduce", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "PredicateFtor", "&&", "!", "PredicateFtor", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "STI", "->", "isThumb1Only", "(", ")", "||", "STI", "->", "prefers32BitThumb", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", "->", "getInstrInfo", "(", ")", ")", ";", "OptimizeSize", "=", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ";", "MinimizeSize", "=", "STI", "->", "hasMinSize", "(", ")", ";", "BlockInfo", ".", "clear", "(", ")", ";", "BlockInfo", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "RPOT", "(", "&", "MF", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "::", "rpo_iterator", "I", "=", "RPOT", ".", "begin", "(", ")", ",", "E", "=", "RPOT", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Modified", "|=", "ReduceMBB", "(", "*", "*", "I", ")", ";", "return", "Modified", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "mmix_print_operand_address", "(", "FILE", "*", "stream", ",", "rtx", "x", ")", "{", "if", "(", "REG_P", "(", "x", ")", ")", "{", "fprintf", "(", "stream", ",", "\"%s,0\"", ",", "reg_names", "[", "MMIX_OUTPUT_REGNO", "(", "REGNO", "(", "x", ")", ")", "]", ")", ";", "return", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "x1", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "x2", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "REG_P", "(", "x1", ")", ")", "{", "fprintf", "(", "stream", ",", "\"%s,\"", ",", "reg_names", "[", "MMIX_OUTPUT_REGNO", "(", "REGNO", "(", "x1", ")", ")", "]", ")", ";", "if", "(", "REG_P", "(", "x2", ")", ")", "{", "fprintf", "(", "stream", ",", "\"%s\"", ",", "reg_names", "[", "MMIX_OUTPUT_REGNO", "(", "REGNO", "(", "x2", ")", ")", "]", ")", ";", "return", ";", "}", "else", "if", "(", "GET_CODE", "(", "x2", ")", "==", "CONST_INT", "&&", "CONST_OK_FOR_LETTER_P", "(", "INTVAL", "(", "x2", ")", ",", "'I'", ")", ")", "{", "output_addr_const", "(", "stream", ",", "x2", ")", ";", "return", ";", "}", "}", "}", "if", "(", "TARGET_BASE_ADDRESSES", "&&", "mmix_legitimate_constant_p", "(", "x", ")", ")", "{", "output_addr_const", "(", "stream", ",", "x", ")", ";", "return", ";", "}", "fatal_insn", "(", "\"MMIX Internal: This is not a recognized address\"", ",", "x", ")", ";", "}", "</s>" ]

[ "PRINT_OPERAND_ADDRESS", "." ]

[ "mmix", "\"%s,0\"", "0", "1", "\"%s,\"", "\"%s\"", "\"MMIX Internal: This is not a recognized address\"" ]

[]

[ "<s>", "static", "rtx", "iq2000_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "int", "reg", "=", "GP_RETURN", ";", "machine_mode", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "int", "unsignedp", "=", "TYPE_UNSIGNED", "(", "valtype", ")", ";", "const_tree", "func", "=", "fn_decl_or_type", ";", "if", "(", "fn_decl_or_type", "&&", "!", "DECL_P", "(", "fn_decl_or_type", ")", ")", "fn_decl_or_type", "=", "NULL", ";", "mode", "=", "promote_function_mode", "(", "valtype", ",", "mode", ",", "&", "unsignedp", ",", "func", ",", "1", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "reg", ")", ";", "}", "</s>" ]

[ "Return", "register", "to", "use", "for", "a", "function", "return", "value", "with", "VALTYPE", "for", "function", "FUNC", "." ]

[ "iq2000", "1" ]

[]

[ "<s>", "bool", "enablePostRAScheduler", "(", ")", "const", "override", "{", "return", "UsePostRAScheduler", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "Cpu0SEFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "EntryBlock", "=", "&", "MF", "->", "front", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "Cpu0", "::", "LR", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", ".", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "EntryBlock", "->", "addLiveIn", "(", "Reg", ")", ";", "bool", "IsKill", "=", "!", "IsRAAndRetAddrIsTaken", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "*", "EntryBlock", ",", "MI", ",", "Reg", ",", "IsKill", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "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", "(", ")", "." ]

[ "Cpu0", "Cpu0", "0", "Cpu0::LR" ]

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "HexagonTargetLowering", "::", "getPreferredVectorAction", "(", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "1", ")", "return", "TargetLoweringBase", "::", "TypeScalarizeVector", ";", "MVT", "ElemTy", "=", "VT", ".", "getSimpleVT", "(", ")", ".", "getVectorElementType", "(", ")", ";", "if", "(", "ElemTy", "==", "MVT", "::", "i1", ")", "return", "TargetLoweringBase", "::", "TypeWidenVector", ";", "if", "(", "Subtarget", ".", "useHVXOps", "(", ")", ")", "{", "ArrayRef", "<", "MVT", ">", "Tys", "=", "Subtarget", ".", "getHVXElementTypes", "(", ")", ";", "if", "(", "llvm", "::", "find", "(", "Tys", ",", "ElemTy", ")", "!=", "Tys", ".", "end", "(", ")", ")", "{", "unsigned", "HwWidth", "=", "8", "*", "Subtarget", ".", "getVectorLength", "(", ")", ";", "unsigned", "VecWidth", "=", "VT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "VecWidth", ">=", "HwWidth", "/", "2", "&&", "VecWidth", "<", "HwWidth", ")", "return", "TargetLoweringBase", "::", "TypeWidenVector", ";", "}", "}", "return", "TargetLoweringBase", "::", "TypeSplitVector", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "Hexagon", "Hexagon", "1", "MVT::i1", "8", "2" ]

[]

[ "<s>", "WasmEHFuncInfo", "*", "getWasmEHFuncInfo", "(", ")", "const", "{", "return", "WasmEHInfo", ";", "}", "</s>" ]

[ "getWasmEHFuncInfo", "-", "Return", "information", "about", "how", "the", "current", "function", "uses", "Wasm", "exception", "handling", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "int", "compute_frame_size", "(", "int", "size", ",", "long", "*", "p_reg_saved", ")", "{", "return", "(", "size", "+", "compute_register_save_size", "(", "p_reg_saved", ")", "+", "crtl", "->", "outgoing_args_size", ")", ";", "}", "</s>" ]

[ "Typical", "stack", "layout", "should", "looks", "like", "this", "after", "the", "function", "'s", "prologue", ":", "|", "|", "--", "^", "|", "|", "\\", "|", "|", "|", "arguments", "saved", "|", "Increasing", "|", "|", "on", "the", "stack", "|", "addresses", "PARENT", "arg", "pointer", "-", ">", "|", "|", "/", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "|", "|", "-", "space", "for", "argument", "split", "between", "regs", "&", "stack", "--", "CHILD", "|", "|", "\\", "<", "--", "(", "return", "address", "here", ")", "|", "|", "other", "call", "|", "|", "saved", "registers", "|", "|", "/", "--", "frame", "pointer", "-", ">", "|", "|", "\\", "___", "|", "|", "local", "|", "|", "|", "variables", "|f", "|", "|", "/", "|r", "--", "|a", "|", "|", "\\", "|m", "|", "|", "outgoing", "|e", "|", "|", "arguments", "|", "|", "Decreasing", "(", "hard", ")", "frame", "pointer", "|", "|", "/", "|", "|", "addresses", "and", "stack", "pointer", "-", ">", "|", "|", "/", "_|_", "|", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "V" ]

[ "v850" ]

[]

[ "<s>", "static", "void", "riscv_restore_reg", "(", "rtx", "reg", ",", "rtx", "mem", ")", "{", "rtx", "insn", "=", "riscv_emit_move", "(", "reg", ",", "mem", ")", ";", "rtx", "dwarf", "=", "NULL_RTX", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "if", "(", "epilogue_cfa_sp_offset", "&&", "REGNO", "(", "reg", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "{", "rtx", "cfa_adjust_rtx", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "epilogue_cfa_sp_offset", ")", ")", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_DEF_CFA", ",", "cfa_adjust_rtx", ",", "dwarf", ")", ";", "}", "REG_NOTES", "(", "insn", ")", "=", "dwarf", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Restore", "register", "REG", "from", "MEM", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "static", "tree", "char_to_type", "(", "char", "c", ")", "{", "static", "tree", "volatile_ptr_type_node", "=", "NULL", ";", "static", "tree", "volatile_const_ptr_type_node", "=", "NULL", ";", "if", "(", "volatile_ptr_type_node", "==", "NULL", ")", "{", "volatile_ptr_type_node", "=", "build_pointer_type", "(", "build_qualified_type", "(", "void_type_node", ",", "TYPE_QUAL_VOLATILE", ")", ")", ";", "volatile_const_ptr_type_node", "=", "build_pointer_type", "(", "build_qualified_type", "(", "void_type_node", ",", "TYPE_QUAL_CONST", "|", "TYPE_QUAL_VOLATILE", ")", ")", ";", "}", "switch", "(", "c", ")", "{", "case", "'v'", ":", "return", "void_type_node", ";", "case", "'l'", ":", "return", "long_unsigned_type_node", ";", "case", "'p'", ":", "return", "volatile_ptr_type_node", ";", "case", "'k'", ":", "return", "volatile_const_ptr_type_node", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Convert", "a", "character", "in", "a", "builtin", "type", "string", "to", "a", "tree", "type", "." ]

[ "tilepro" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "AARCH64_TYPE_PROMO_NAME", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "bool", "umips_build_save_restore", "(", "mips_save_restore_fn", "fn", ",", "unsigned", "*", "mask", ",", "HOST_WIDE_INT", "*", "offset", ")", "{", "int", "nregs", ";", "unsigned", "int", "i", ",", "j", ";", "rtx", "pattern", ",", "set", ",", "reg", ",", "mem", ";", "HOST_WIDE_INT", "this_offset", ";", "rtx", "this_base", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "umips_swm_mask", ")", ";", "i", "++", ")", "if", "(", "(", "*", "mask", "&", "0xffff0000", ")", "==", "umips_swm_mask", "[", "i", "]", ")", "break", ";", "if", "(", "i", "==", "ARRAY_SIZE", "(", "umips_swm_mask", ")", ")", "return", "false", ";", "nregs", "=", "(", "umips_swm_encoding", "[", "i", "]", "&", "0xf", ")", "+", "(", "umips_swm_encoding", "[", "i", "]", ">>", "4", ")", ";", "this_offset", "=", "*", "offset", "-", "UNITS_PER_WORD", "*", "(", "nregs", "-", "1", ")", ";", "if", "(", "!", "UMIPS_12BIT_OFFSET_P", "(", "this_offset", ")", ")", "return", "false", ";", "pattern", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nregs", ")", ")", ";", "this_base", "=", "stack_pointer_rtx", ";", "for", "(", "j", "=", "0", ";", "j", "<", "(", "umips_swm_encoding", "[", "i", "]", "&", "0xf", ")", ";", "j", "++", ")", "{", "HOST_WIDE_INT", "offset", "=", "this_offset", "+", "j", "*", "UNITS_PER_WORD", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "this_base", ",", "offset", ")", ")", ";", "unsigned", "int", "regno", "=", "(", "j", "!=", "8", ")", "?", "16", "+", "j", ":", "30", ";", "*", "mask", "&=", "~", "(", "1", "<<", "regno", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "if", "(", "fn", "==", "mips_save_reg", ")", "set", "=", "mips_frame_set", "(", "mem", ",", "reg", ")", ";", "else", "{", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ";", "mips_add_cfa_restore", "(", "reg", ")", ";", "}", "XVECEXP", "(", "pattern", ",", "0", ",", "j", ")", "=", "set", ";", "}", "if", "(", "umips_swm_encoding", "[", "i", "]", ">>", "4", ")", "{", "HOST_WIDE_INT", "offset", "=", "this_offset", "+", "j", "*", "UNITS_PER_WORD", ";", "*", "mask", "&=", "~", "(", "1", "<<", "31", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "this_base", ",", "offset", ")", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "31", ")", ";", "if", "(", "fn", "==", "mips_save_reg", ")", "set", "=", "mips_frame_set", "(", "mem", ",", "reg", ")", ";", "else", "{", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ";", "mips_add_cfa_restore", "(", "reg", ")", ";", "}", "XVECEXP", "(", "pattern", ",", "0", ",", "j", ")", "=", "set", ";", "}", "pattern", "=", "emit_insn", "(", "pattern", ")", ";", "if", "(", "fn", "==", "mips_save_reg", ")", "RTX_FRAME_RELATED_P", "(", "pattern", ")", "=", "1", ";", "*", "offset", "-=", "UNITS_PER_WORD", "*", "nregs", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "use", "a", "microMIPS", "LWM", "or", "SWM", "instruction", "to", "save", "or", "restore", "as", "many", "GPRs", "in", "*", "MASK", "as", "possible", ".", "*", "OFFSET", "is", "the", "offset", "from", "the", "stack", "pointer", "of", "the", "topmost", "save", "slot", ".", "Remove", "from", "*", "MASK", "all", "registers", "that", "were", "handled", "using", "LWM", "and", "SWM", ".", "Update", "*", "OFFSET", "so", "that", "it", "points", "to", "the", "first", "unused", "save", "slot", "." ]

[ "mips", "0", "0xffff0000", "0xf", "4", "1", "0", "0xf", "8", "16", "30", "1", "0", "4", "1", "31", "31", "0", "1" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "return", "createR600MachineScheduler", "(", "C", ")", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

[ "AMDGPU", "R600" ]

[]

[ "<s>", "unsigned", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Opd1Info", "=", "TTI", "::", "OK_AnyValue", ",", "TTI", "::", "OperandValueKind", "Opd2Info", "=", "TTI", "::", "OK_AnyValue", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", "=", "TTI", "::", "OP_None", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", "=", "TTI", "::", "OP_None", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", "=", "ArrayRef", "<", "const", "Value", "*", ">", "(", ")", ")", "{", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "switch", "(", "ISD", ")", "{", "default", ":", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "UREM", ":", "return", "64", "*", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "}", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "Lanai", "ISD::MUL", "ISD::SDIV", "ISD::UDIV", "ISD::UREM", "64" ]

[]

[ "<s>", "void", "PTXInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MII", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "false", "&&", "\"storeRegToStackSlot should not be called for PTX\"", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "PTX", "PTX", "\"storeRegToStackSlot should not be called for PTX\"" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "MipsInstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "MipsII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "Flags", "[", "]", "=", "{", "{", "MO_GOT", ",", "\"mips-got\"", "}", ",", "{", "MO_GOT_CALL", ",", "\"mips-got-call\"", "}", ",", "{", "MO_GPREL", ",", "\"mips-gprel\"", "}", ",", "{", "MO_ABS_HI", ",", "\"mips-abs-hi\"", "}", ",", "{", "MO_ABS_LO", ",", "\"mips-abs-lo\"", "}", ",", "{", "MO_TLSGD", ",", "\"mips-tlsgd\"", "}", ",", "{", "MO_TLSLDM", ",", "\"mips-tlsldm\"", "}", ",", "{", "MO_DTPREL_HI", ",", "\"mips-dtprel-hi\"", "}", ",", "{", "MO_DTPREL_LO", ",", "\"mips-dtprel-lo\"", "}", ",", "{", "MO_GOTTPREL", ",", "\"mips-gottprel\"", "}", ",", "{", "MO_TPREL_HI", ",", "\"mips-tprel-hi\"", "}", ",", "{", "MO_TPREL_LO", ",", "\"mips-tprel-lo\"", "}", ",", "{", "MO_GPOFF_HI", ",", "\"mips-gpoff-hi\"", "}", ",", "{", "MO_GPOFF_LO", ",", "\"mips-gpoff-lo\"", "}", ",", "{", "MO_GOT_DISP", ",", "\"mips-got-disp\"", "}", ",", "{", "MO_GOT_PAGE", ",", "\"mips-got-page\"", "}", ",", "{", "MO_GOT_OFST", ",", "\"mips-got-ofst\"", "}", ",", "{", "MO_HIGHER", ",", "\"mips-higher\"", "}", ",", "{", "MO_HIGHEST", ",", "\"mips-highest\"", "}", ",", "{", "MO_GOT_HI16", ",", "\"mips-got-hi16\"", "}", ",", "{", "MO_GOT_LO16", ",", "\"mips-got-lo16\"", "}", ",", "{", "MO_CALL_HI16", ",", "\"mips-call-hi16\"", "}", ",", "{", "MO_CALL_LO16", ",", "\"mips-call-lo16\"", "}", ",", "{", "MO_JALR", ",", "\"mips-jalr\"", "}", "}", ";", "return", "makeArrayRef", "(", "Flags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "direct", "target", "flag", "values", "and", "their", "names", "." ]

[ "Mips", "Mips", "Mips", "\"mips-got\"", "\"mips-got-call\"", "\"mips-gprel\"", "\"mips-abs-hi\"", "\"mips-abs-lo\"", "\"mips-tlsgd\"", "\"mips-tlsldm\"", "\"mips-dtprel-hi\"", "\"mips-dtprel-lo\"", "\"mips-gottprel\"", "\"mips-tprel-hi\"", "\"mips-tprel-lo\"", "\"mips-gpoff-hi\"", "\"mips-gpoff-lo\"", "\"mips-got-disp\"", "\"mips-got-page\"", "\"mips-got-ofst\"", "\"mips-higher\"", "\"mips-highest\"", "\"mips-got-hi16\"", "\"mips-got-lo16\"", "\"mips-call-hi16\"", "\"mips-call-lo16\"", "\"mips-jalr\"" ]

[]

[ "<s>", "Instruction", "*", "ARMTargetLowering", "::", "emitLeadingFence", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Instruction", "*", "Inst", ",", "AtomicOrdering", "Ord", ")", "const", "{", "switch", "(", "Ord", ")", "{", "case", "AtomicOrdering", "::", "NotAtomic", ":", "case", "AtomicOrdering", "::", "Unordered", ":", "llvm_unreachable", "(", "\"Invalid fence: unordered/non-atomic\"", ")", ";", "case", "AtomicOrdering", "::", "Monotonic", ":", "case", "AtomicOrdering", "::", "Acquire", ":", "return", "nullptr", ";", "case", "AtomicOrdering", "::", "SequentiallyConsistent", ":", "if", "(", "!", "Inst", "->", "hasAtomicStore", "(", ")", ")", "return", "nullptr", ";", "case", "AtomicOrdering", "::", "Release", ":", "case", "AtomicOrdering", "::", "AcquireRelease", ":", "if", "(", "Subtarget", "->", "preferISHSTBarriers", "(", ")", ")", "return", "makeDMB", "(", "Builder", ",", "ARM_MB", "::", "ISHST", ")", ";", "else", "return", "makeDMB", "(", "Builder", ",", "ARM_MB", "::", "ISH", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown fence ordering in emitLeadingFence\"", ")", ";", "}", "</s>" ]

[ "Custom", "Lower", "{", "." ]

[ "ARM", "ARM", "\"Invalid fence: unordered/non-atomic\"", "ARM_MB::ISHST", "ARM_MB::ISH", "\"Unknown fence ordering in emitLeadingFence\"" ]

[]

[ "<s>", "void", "AVRPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "new", "TestMFP", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "AVR", "AVR" ]

[]

[ "<s>", "const", "ARM64RegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "ARM64", "ARM64" ]

[]

[ "<s>", "static", "bool", "is_prefetch", "(", "rtx", "insn", ")", "{", "return", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PREFETCH", ";", "}", "</s>" ]

[ "Return", "true", "if", "insn", "is", "a", "prefetch", "instruction", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "ECLairAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "SMLoc", "ErrorLoc", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction use requires an option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "ErrorLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "ECLairOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "case", "Match_InvalidSImm8", ":", "ErrorLoc", "=", "(", "(", "ECLairOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "return", "Error", "(", "ErrorLoc", ",", "\"immediate must be an integer in the range [-127, 127]\"", ")", ";", "case", "Match_InvalidSImm16", ":", "ErrorLoc", "=", "(", "(", "ECLairOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "return", "Error", "(", "ErrorLoc", ",", "\"immediate must be an integer in the range [-65535, 65535]\"", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown match type detected!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "ECLair", "ECLair", "\"instruction use requires an option to be enabled\"", "\"unrecognized instruction mnemonic\"", "0U", "\"too few operands for instruction\"", "ECLair", "\"invalid operand for instruction\"", "ECLair", "\"immediate must be an integer in the range [-127, 127]\"", "ECLair", "\"immediate must be an integer in the range [-65535, 65535]\"", "\"Unknown match type detected!\"" ]

[]

[ "<s>", "unsigned", "constant_generates_xxspltiw", "(", "vec_const_128bit_type", "*", "vsx_const", ")", "{", "if", "(", "!", "TARGET_SPLAT_WORD_CONSTANT", "||", "!", "TARGET_PREFIXED", "||", "!", "TARGET_VSX", ")", "return", "0", ";", "if", "(", "!", "vsx_const", "->", "all_words_same", ")", "return", "0", ";", "if", "(", "vsx_const", "->", "all_bytes_same", ")", "return", "0", ";", "if", "(", "vsx_const", "->", "all_half_words_same", ")", "{", "short", "sign_h_word", "=", "vsx_const", "->", "half_words", "[", "0", "]", ";", "if", "(", "EASY_VECTOR_15", "(", "sign_h_word", ")", ")", "return", "0", ";", "}", "int", "sign_word", "=", "vsx_const", "->", "words", "[", "0", "]", ";", "if", "(", "EASY_VECTOR_15", "(", "sign_word", ")", ")", "return", "0", ";", "return", "vsx_const", "->", "words", "[", "0", "]", ";", "}", "</s>" ]

[ "Determine", "if", "a", "vector", "constant", "can", "be", "loaded", "with", "XXSPLTIW", ".", "Return", "zero", "if", "the", "XXSPLTIW", "instruction", "can", "not", "be", "used", ".", "Otherwise", "return", "the", "immediate", "value", "to", "be", "used", "with", "the", "XXSPLTIW", "instruction", "." ]

[ "rs6000", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "emitFileDirective", "(", "StringRef", "Filename", ")", "override", "{", "}", "</s>" ]

[ "Emit", "``", ".file", "assembler", "diretive", "with", "additioal", "info", "." ]

[ "Patmos" ]

[]

[ "<s>", "TOYSubtarget", "&", "TOYSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "bool", "Is64Bit", "=", "false", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "Is64Bit", "?", "\"generic-rv64\"", ":", "\"generic-rv32\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "TOY", "TOY", "TOY", "\"generic-rv64\"", "\"generic-rv32\"" ]

[]

[ "<s>", "static", "bool", "vectorize_vec_perm_const_1", "(", "const", "struct", "expand_vec_perm_d", "&", "d", ")", "{", "if", "(", "expand_perm_with_merge", "(", "d", ")", ")", "return", "true", ";", "if", "(", "expand_perm_with_vpdi", "(", "d", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Try", "to", "find", "the", "best", "sequence", "for", "the", "vector", "permute", "operation", "described", "by", "D.", "Return", "true", "if", "the", "operation", "could", "be", "expanded", "." ]

[ "s390" ]

[]

[ "<s>", "static", "void", "bpf_file_end", "(", "void", ")", "{", "if", "(", "TARGET_BPF_CORE", ")", "btf_ext_output", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FILE_END", "." ]

[ "bpf" ]

[]