Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "AlphaFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAHg", ")", ",", "Alpha", "::", "R29", ")", ".", "addGlobalAddress", "(", "MF", ".", "getFunction", "(", ")", ")", ".", "addReg", "(", "Alpha", "::", "R27", ")", ".", "addImm", "(", "++", "curgpdist", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAg", ")", ",", "Alpha", "::", "R29", ")", ".", "addGlobalAddress", "(", "MF", ".", "getFunction", "(", ")", ")", ".", "addReg", "(", "Alpha", "::", "R29", ")", ".", "addImm", "(", "curgpdist", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "ALTENT", ")", ")", ".", "addGlobalAddress", "(", "MF", ".", "getFunction", "(", ")", ")", ";", "long", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "FP", ")", "NumBytes", "+=", "8", ";", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "NumBytes", "=", "(", "NumBytes", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "MFI", "->", "setStackSize", "(", "NumBytes", ")", ";", "NumBytes", "=", "-", "NumBytes", ";", "if", "(", "NumBytes", ">=", "Alpha", "::", "IMM_LOW", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "NumBytes", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "if", "(", "getUpper16", "(", "NumBytes", ")", ">=", "Alpha", "::", "IMM_LOW", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getUpper16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getLower16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "{", "report_fatal_error", "(", "\"Too big a stack frame at \"", "+", "Twine", "(", "NumBytes", ")", ")", ";", "}", "if", "(", "FP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "STQ", ")", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "BISr", ")", ",", "Alpha", "::", "R15", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::LDAHg", "Alpha::R29", "Alpha::R27", "Alpha::LDAg", "Alpha::R29", "Alpha::R29", "Alpha::ALTENT", "8", "0", "1", "Alpha::IMM_LOW", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "Alpha::IMM_LOW", "Alpha::LDAH", "Alpha::R30", "Alpha::R30", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "\"Too big a stack frame at \"", "Alpha::STQ", "Alpha::R15", "0", "Alpha::R30", "Alpha::BISr", "Alpha::R15", "Alpha::R30", "Alpha::R30" ]

[]

[ "<s>", "bool", "canCauseFpMLxStall", "(", "unsigned", "Opcode", ")", "const", "{", "return", "MLxHazardOpcodes", ".", "count", "(", "Opcode", ")", ";", "}", "</s>" ]

[ "canCauseFpMLxStall", "-", "Return", "true", "if", "an", "instruction", "of", "the", "specified", "opcode", "will", "cause", "stalls", "when", "scheduled", "after", "(", "within", "4-cycle", "window", ")", "a", "fp", "MLA", "/", "MLS", "instruction", "." ]

[ "ARM" ]

[]

[ "<s>", "const", "char", "*", "arm_strip_name_encoding", "(", "const", "char", "*", "name", ")", "{", "int", "skip", ";", "while", "(", "(", "skip", "=", "arm_get_strip_length", "(", "*", "name", ")", ")", ")", "name", "+=", "skip", ";", "return", "name", ";", "}", "</s>" ]

[ "Return", "a", "pointer", "to", "a", "function", "'s", "name", "with", "any", "and", "all", "prefix", "encodings", "stripped", "from", "it", "." ]

[ "arm" ]

[]

[ "<s>", "void", "ATTRIBUTE_UNUSED", "ix86_debug_options", "(", "void", ")", "{", "char", "*", "opts", "=", "ix86_target_string", "(", "ix86_isa_flags", ",", "target_flags", ",", "ix86_arch_string", ",", "ix86_tune_string", ",", "ix86_fpmath", ",", "true", ")", ";", "if", "(", "opts", ")", "{", "fprintf", "(", "stderr", ",", "\"%s\\n\\n\"", ",", "opts", ")", ";", "free", "(", "opts", ")", ";", "}", "else", "fputs", "(", "\"<no options>\\n\\n\"", ",", "stderr", ")", ";", "return", ";", "}", "</s>" ]

[ "Function", "that", "is", "callable", "from", "the", "debugger", "to", "print", "the", "current", "options", "." ]

[ "i386", "\"%s\\n\\n\"", "\"<no options>\\n\\n\"" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "unsigned", "char", "PPCSubtarget", "::", "classifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "return", "PPCII", "::", "MO_PIC_FLAG", "|", "PPCII", "::", "MO_NLP_FLAG", ";", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "*", "GV", "->", "getParent", "(", ")", ",", "GV", ")", ")", "return", "PPCII", "::", "MO_PIC_FLAG", ";", "return", "PPCII", "::", "MO_PIC_FLAG", "|", "PPCII", "::", "MO_NLP_FLAG", ";", "}", "</s>" ]

[ "Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "PowerPC", "PPC", "PPCII::MO_PIC_FLAG", "PPCII::MO_NLP_FLAG", "PPCII::MO_PIC_FLAG", "PPCII::MO_PIC_FLAG", "PPCII::MO_NLP_FLAG" ]

[]

[ "<s>", "void", "AArch64ConditionOptimizer", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LiveIntervals", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "bool", "xtensa_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "return", "xtensa_tls_referenced_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CANNOT_FORCE_CONST_MEM", "." ]

[ "xtensa" ]

[]

[ "<s>", "void", "ix86_split_fp_branch", "(", "enum", "rtx_code", "code", ",", "rtx", "op1", ",", "rtx", "op2", ",", "rtx", "target1", ",", "rtx", "target2", ",", "rtx", "tmp", ")", "{", "rtx", "condition", ";", "rtx_insn", "*", "i", ";", "if", "(", "target2", "!=", "pc_rtx", ")", "{", "std", "::", "swap", "(", "target1", ",", "target2", ")", ";", "code", "=", "reverse_condition_maybe_unordered", "(", "code", ")", ";", "}", "condition", "=", "ix86_expand_fp_compare", "(", "code", ",", "op1", ",", "op2", ",", "tmp", ")", ";", "i", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "condition", ",", "target1", ",", "target2", ")", ")", ")", ";", "if", "(", "split_branch_probability", ">=", "0", ")", "add_int_reg_note", "(", "i", ",", "REG_BR_PROB", ",", "split_branch_probability", ")", ";", "}", "</s>" ]

[ "Split", "branch", "based", "on", "floating", "point", "condition", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "addPass", "(", "createSIInsertWaitsPass", "(", ")", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "createSILowerControlFlowPass", "(", ")", ")", ";", "addPass", "(", "createSIDebuggerInsertNopsPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "static", "rtx", "pru_function_value", "(", "const_tree", "ret_type", ",", "const_tree", "fn", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "ret_type", ")", ",", "FIRST_RETVAL_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE", "." ]

[ "pru" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", ",", "MachineMemOperand", "::", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "bool", "AllowsUnaligned", "=", "Subtarget", "->", "allowsUnalignedMem", "(", ")", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "{", "if", "(", "AllowsUnaligned", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "Subtarget", "->", "hasV7Ops", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v2f64", ":", "{", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", "&&", "(", "AllowsUnaligned", "||", "Subtarget", "->", "isLittle", "(", ")", ")", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::f64", "MVT::v2f64" ]

[]

[ "<s>", "MachineMemOperand", "::", "Flags", "SystemZTargetLowering", "::", "getTargetMMOFlags", "(", "const", "Instruction", "&", "I", ")", "const", "{", "if", "(", "auto", "*", "SI", "=", "dyn_cast", "<", "StoreInst", ">", "(", "&", "I", ")", ")", "if", "(", "SI", "->", "isAtomic", "(", ")", ")", "return", "MachineMemOperand", "::", "MOVolatile", ";", "if", "(", "auto", "*", "LI", "=", "dyn_cast", "<", "LoadInst", ">", "(", "&", "I", ")", ")", "if", "(", "LI", "->", "isAtomic", "(", ")", ")", "return", "MachineMemOperand", "::", "MOVolatile", ";", "if", "(", "auto", "*", "AI", "=", "dyn_cast", "<", "AtomicRMWInst", ">", "(", "&", "I", ")", ")", "if", "(", "AI", "->", "isAtomic", "(", ")", ")", "return", "MachineMemOperand", "::", "MOVolatile", ";", "if", "(", "auto", "*", "AI", "=", "dyn_cast", "<", "AtomicCmpXchgInst", ">", "(", "&", "I", ")", ")", "if", "(", "AI", "->", "isAtomic", "(", ")", ")", "return", "MachineMemOperand", "::", "MOVolatile", ";", "return", "MachineMemOperand", "::", "MONone", ";", "}", "</s>" ]

[ "This", "callback", "is", "used", "to", "inspect", "load/store", "instructions", "and", "add", "target-specific", "MachineMemOperand", "flags", "to", "them", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "int", "avr_naked_function_p", "(", "tree", "func", ")", "{", "tree", "a", ";", "gcc_assert", "(", "TREE_CODE", "(", "func", ")", "==", "FUNCTION_DECL", ")", ";", "a", "=", "lookup_attribute", "(", "\"naked\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "return", "a", "!=", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "FUNC", "is", "a", "naked", "function", "." ]

[ "avr", "\"naked\"" ]

[]

[ "<s>", "bool", "HexagonOptAddrMode", "::", "isValidOffset", "(", "MachineInstr", "*", "MI", ",", "int", "Offset", ")", "{", "unsigned", "AlignMask", "=", "0", ";", "switch", "(", "HII", "->", "getMemAccessSize", "(", "*", "MI", ")", ")", "{", "case", "HexagonII", "::", "MemAccessSize", "::", "DoubleWordAccess", ":", "AlignMask", "=", "0x7", ";", "break", ";", "case", "HexagonII", "::", "MemAccessSize", "::", "WordAccess", ":", "AlignMask", "=", "0x3", ";", "break", ";", "case", "HexagonII", "::", "MemAccessSize", "::", "HalfWordAccess", ":", "AlignMask", "=", "0x1", ";", "break", ";", "case", "HexagonII", "::", "MemAccessSize", "::", "ByteAccess", ":", "AlignMask", "=", "0x0", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "(", "AlignMask", "&", "Offset", ")", "!=", "0", ")", "return", "false", ";", "return", "HII", "->", "isValidOffset", "(", "MI", "->", "getOpcode", "(", ")", ",", "Offset", ",", "HRI", ",", "false", ")", ";", "}", "</s>" ]

[ "Test", "the", "validity", "of", "offset", "." ]

[ "Hexagon", "Hexagon", "0", "HexagonII::MemAccessSize", "0x7", "HexagonII::MemAccessSize", "0x3", "HexagonII::MemAccessSize", "0x1", "HexagonII::MemAccessSize", "0x0", "0" ]

[]

[ "<s>", "static", "bool", "hwloop_optimize", "(", "hwloop_info", "loop", ")", "{", "int", "i", ";", "edge", "entry_edge", ";", "basic_block", "entry_bb", ";", "rtx", "iter_reg", ";", "rtx_insn", "*", "insn", ",", "*", "seq", ",", "*", "entry_after", ";", "if", "(", "loop", "->", "depth", ">", "1", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; loop %d is not innermost\\n\"", ",", "loop", "->", "loop_no", ")", ";", "return", "false", ";", "}", "if", "(", "!", "loop", "->", "incoming_dest", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; loop %d has more than one entry\\n\"", ",", "loop", "->", "loop_no", ")", ";", "return", "false", ";", "}", "if", "(", "loop", "->", "incoming_dest", "!=", "loop", "->", "head", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; loop %d is not entered from head\\n\"", ",", "loop", "->", "loop_no", ")", ";", "return", "false", ";", "}", "if", "(", "loop", "->", "has_call", "||", "loop", "->", "has_asm", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; loop %d has invalid insn\\n\"", ",", "loop", "->", "loop_no", ")", ";", "return", "false", ";", "}", "if", "(", "loop", "->", "iter_reg_used", "||", "loop", "->", "iter_reg_used_outside", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; loop %d uses iterator\\n\"", ",", "loop", "->", "loop_no", ")", ";", "return", "false", ";", "}", "insn", "=", "loop", "->", "start_label", ";", "while", "(", "insn", "&&", "insn", "!=", "loop", "->", "loop_end", ")", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "!", "insn", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; loop %d start_label not before loop_end\\n\"", ",", "loop", "->", "loop_no", ")", ";", "return", "false", ";", "}", "iter_reg", "=", "loop", "->", "iter_reg", ";", "gcc_assert", "(", "REG_P", "(", "iter_reg", ")", ")", ";", "entry_edge", "=", "NULL", ";", "FOR_EACH_VEC_SAFE_ELT", "(", "loop", "->", "incoming", ",", "i", ",", "entry_edge", ")", "if", "(", "entry_edge", "->", "flags", "&", "EDGE_FALLTHRU", ")", "break", ";", "if", "(", "entry_edge", "==", "NULL", ")", "return", "false", ";", "entry_bb", "=", "entry_edge", "->", "src", ";", "start_sequence", "(", ")", ";", "insn", "=", "emit_insn", "(", "gen_zero_cost_loop_start", "(", "loop", "->", "iter_reg", ",", "loop", "->", "start_label", ",", "loop", "->", "iter_reg", ")", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "if", "(", "!", "single_succ_p", "(", "entry_bb", ")", "||", "vec_safe_length", "(", "loop", "->", "incoming", ")", ">", "1", ")", "{", "basic_block", "new_bb", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "emit_insn_before", "(", "seq", ",", "BB_HEAD", "(", "loop", "->", "head", ")", ")", ";", "seq", "=", "emit_label_before", "(", "gen_label_rtx", "(", ")", ",", "seq", ")", ";", "new_bb", "=", "create_basic_block", "(", "seq", ",", "insn", ",", "entry_bb", ")", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "loop", "->", "incoming", ")", "{", "if", "(", "!", "(", "e", "->", "flags", "&", "EDGE_FALLTHRU", ")", ")", "redirect_edge_and_branch_force", "(", "e", ",", "new_bb", ")", ";", "else", "redirect_edge_succ", "(", "e", ",", "new_bb", ")", ";", "}", "make_edge", "(", "new_bb", ",", "loop", "->", "head", ",", "0", ")", ";", "}", "else", "{", "entry_after", "=", "BB_END", "(", "entry_bb", ")", ";", "while", "(", "DEBUG_INSN_P", "(", "entry_after", ")", "||", "(", "NOTE_P", "(", "entry_after", ")", "&&", "NOTE_KIND", "(", "entry_after", ")", "!=", "NOTE_INSN_BASIC_BLOCK", ")", ")", "entry_after", "=", "PREV_INSN", "(", "entry_after", ")", ";", "emit_insn_after", "(", "seq", ",", "entry_after", ")", ";", "}", "end_sequence", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "callback", "for", "the", "hw-doloop", "pass", ".", "Called", "to", "optimize", "LOOP", "in", "a", "machine-specific", "fashion", ";", "returns", "true", "if", "successful", "and", "false", "if", "the", "hwloop_fail", "function", "should", "be", "called", "." ]

[ "xtensa", "1", "\";; loop %d is not innermost\\n\"", "\";; loop %d has more than one entry\\n\"", "\";; loop %d is not entered from head\\n\"", "\";; loop %d has invalid insn\\n\"", "\";; loop %d uses iterator\\n\"", "\";; loop %d start_label not before loop_end\\n\"", "1", "0" ]

[]

[ "<s>", "void", "MipsGOT", "::", "reserve", "(", "size_t", "pNum", ")", "{", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "pNum", ";", "++", "i", ")", "createEntry", "(", "0", ",", "m_SectionData", ")", ";", "}", "</s>" ]

[ "Grow", "the", "map", "so", "that", "it", "has", "at", "least", "Size", "buckets", ".", "Does", "not", "shrink", "." ]

[ "Mips", "Mips", "0", "0" ]

[]

[ "<s>", "const", "uint16_t", "*", "HexagonRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegsV2", "[", "]", "=", "{", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsV3", "[", "]", "=", "{", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "switch", "(", "Subtarget", ".", "getHexagonArchVersion", "(", ")", ")", "{", "case", "HexagonSubtarget", "::", "V1", ":", "break", ";", "case", "HexagonSubtarget", "::", "V2", ":", "return", "CalleeSavedRegsV2", ";", "case", "HexagonSubtarget", "::", "V3", ":", "case", "HexagonSubtarget", "::", "V4", ":", "return", "CalleeSavedRegsV3", ";", "}", "llvm_unreachable", "(", "\"Callee saved registers requested for unknown architecture \"", "\"version\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Callee saved registers requested for unknown architecture \"", "\"version\"" ]

[]

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

[ "Check", "whether", "the", "target", "can", "fold", "a", "load", "that", "feeds", "a", "subreg", "operand", "(", "or", "a", "subreg", "operand", "that", "feeds", "a", "store", ")", "." ]

[ "Z80" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"LoongArch Assembly Printer\"", ";", "}", "</s>" ]

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

[ "LoongArch", "\"LoongArch Assembly Printer\"" ]

[]

[ "<s>", "const", "char", "*", "output_probe_stack_range", "(", "rtx", "reg1", ",", "rtx", "reg2", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ",", "end_lab", "[", "32", "]", ";", "rtx", "xops", "[", "2", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "end_lab", ",", "\"LPSRE\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "reg1", ";", "xops", "[", "1", "]", "=", "reg2", ";", "if", "(", "TARGET_64BIT", ")", "output_asm_insn", "(", "\"cmpd 0,%0,%1\"", ",", "xops", ")", ";", "else", "output_asm_insn", "(", "\"cmpw 0,%0,%1\"", ",", "xops", ")", ";", "fputs", "(", "\"\\tbeq 0,\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "end_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "-", "PROBE_INTERVAL", ")", ";", "output_asm_insn", "(", "\"addi %0,%0,%1\"", ",", "xops", ")", ";", "xops", "[", "1", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "output_asm_insn", "(", "\"stw %1,0(%0)\"", ",", "xops", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tb \"", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "end_lab", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Wrapper", "around", "the", "output_probe_stack_range", "routines", "." ]

[ "rs6000", "0", "32", "32", "2", "\"LPSRL\"", "\"LPSRE\"", "0", "1", "\"cmpd 0,%0,%1\"", "\"cmpw 0,%0,%1\"", "\"\\tbeq 0,\"", "1", "\"addi %0,%0,%1\"", "1", "0", "\"stw %1,0(%0)\"", "\"\\tb \"", "\"\"" ]

[]

[ "<s>", "StackOffset", "AArch64FrameLowering", "::", "getFrameIndexReferencePreferSP", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ",", "bool", "IgnoreSPUpdates", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "IgnoreSPUpdates", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Offset from the SP for \"", "<<", "FI", "<<", "\" is \"", "<<", "MFI", ".", "getObjectOffset", "(", "FI", ")", "<<", "\"\\n\"", ")", ";", "FrameReg", "=", "AArch64", "::", "SP", ";", "return", "StackOffset", "::", "getFixed", "(", "MFI", ".", "getObjectOffset", "(", "FI", ")", ")", ";", "}", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "getStackSizeSVE", "(", ")", "||", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", "->", "hasStackRealignment", "(", "MF", ")", ")", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "FrameReg", "=", "AArch64", "::", "SP", ";", "return", "getStackOffset", "(", "MF", ",", "MFI", ".", "getObjectOffset", "(", "FI", ")", ")", ";", "}", "</s>" ]

[ "Same", "as", "getFrameIndexReference", ",", "except", "that", "the", "stack", "pointer", "(", "as", "opposed", "to", "the", "frame", "pointer", ")", "will", "be", "the", "preferred", "value", "for", "FrameReg", "." ]

[ "AArch64", "AArch64", "\"Offset from the SP for \"", "\" is \"", "\"\\n\"", "AArch64::SP", "AArch64", "AArch64::SP" ]

[]

[ "<s>", "unsigned", "getFlatAddressSpace", "(", ")", "const", "{", "if", "(", "IsGraphicsShader", ")", "return", "-", "1", ";", "return", "ST", "->", "hasFlatAddressSpace", "(", ")", "?", "ST", "->", "getAMDGPUAS", "(", ")", ".", "FLAT_ADDRESS", ":", "ST", "->", "getAMDGPUAS", "(", ")", ".", "UNKNOWN_ADDRESS_SPACE", ";", "}", "</s>" ]

[ "Returns", "the", "address", "space", "ID", "for", "a", "target", "'s", "'flat", "'", "address", "space", "." ]

[ "AMDGPU", "1", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "MachineBasicBlock", "*", "GBZ80TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "llvm_unreachable", "(", "\"Custom inserters are disabled.\"", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "GBZ80", "GB", "\"Custom inserters are disabled.\"" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "getTargetStreamer", "(", ")", "&&", "!", "getTargetStreamer", "(", ")", "->", "getTargetID", "(", ")", ")", "initializeTargetID", "(", "M", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "AMDHSA", "&&", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "AMDPAL", ")", "return", ";", "if", "(", "isHsaAbiVersion3AndAbove", "(", "getGlobalSTI", "(", ")", ")", ")", "getTargetStreamer", "(", ")", "->", "EmitDirectiveAMDGCNTarget", "(", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "HSAMetadataStream", "->", "begin", "(", "M", ",", "*", "getTargetStreamer", "(", ")", "->", "getTargetID", "(", ")", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDPAL", ")", "getTargetStreamer", "(", ")", "->", "getPALMetadata", "(", ")", "->", "readFromIR", "(", "M", ")", ";", "if", "(", "isHsaAbiVersion3AndAbove", "(", "getGlobalSTI", "(", ")", ")", ")", "return", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "getTargetStreamer", "(", ")", "->", "EmitDirectiveHSACodeObjectVersion", "(", "2", ",", "1", ")", ";", "IsaVersion", "Version", "=", "getIsaVersion", "(", "getGlobalSTI", "(", ")", "->", "getCPU", "(", ")", ")", ";", "getTargetStreamer", "(", ")", "->", "EmitDirectiveHSACodeObjectISAV2", "(", "Version", ".", "Major", ",", "Version", ".", "Minor", ",", "Version", ".", "Stepping", ",", "\"AMD\"", ",", "\"AMDGPU\"", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "." ]

[ "AMDGPU", "AMDGPU", "2", "1", "\"AMD\"", "\"AMDGPU\"" ]

[]

[ "<s>", "InstructionCost", "AArch64TTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "DataTy", ",", "const", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "Align", "Alignment", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "const", "Instruction", "*", "I", ")", "{", "if", "(", "useNeonVector", "(", "DataTy", ")", ")", "return", "BaseT", "::", "getGatherScatterOpCost", "(", "Opcode", ",", "DataTy", ",", "Ptr", ",", "VariableMask", ",", "Alignment", ",", "CostKind", ",", "I", ")", ";", "auto", "*", "VT", "=", "cast", "<", "VectorType", ">", "(", "DataTy", ")", ";", "auto", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "DataTy", ")", ";", "if", "(", "!", "LT", ".", "first", ".", "isValid", "(", ")", ")", "return", "InstructionCost", "::", "getInvalid", "(", ")", ";", "if", "(", "cast", "<", "VectorType", ">", "(", "DataTy", ")", "->", "getElementCount", "(", ")", "==", "ElementCount", "::", "getScalable", "(", "1", ")", ")", "return", "InstructionCost", "::", "getInvalid", "(", ")", ";", "ElementCount", "LegalVF", "=", "LT", ".", "second", ".", "getVectorElementCount", "(", ")", ";", "InstructionCost", "MemOpCost", "=", "getMemoryOpCost", "(", "Opcode", ",", "VT", "->", "getElementType", "(", ")", ",", "Alignment", ",", "0", ",", "CostKind", ",", "I", ")", ";", "return", "LT", ".", "first", "*", "MemOpCost", "*", "getMaxNumElements", "(", "LegalVF", ",", "I", "->", "getFunction", "(", ")", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

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

[]

[ "<s>", "void", "AMDGPUCFGStructurizer", "::", "removeSuccessor", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "while", "(", "MBB", "->", "succ_size", "(", ")", ")", "MBB", "->", "removeSuccessor", "(", "*", "MBB", "->", "succ_begin", "(", ")", ")", ";", "}", "</s>" ]

[ "Remove", "specified", "successor", "from", "the", "successors", "list", "of", "this", "MachineBasicBlock", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "HexagonBitSimplify", "::", "isZero", "(", "const", "BitTracker", "::", "RegisterCell", "&", "RC", ",", "uint16_t", "B", ",", "uint16_t", "W", ")", "{", "assert", "(", "B", "<", "RC", ".", "width", "(", ")", "&&", "B", "+", "W", "<=", "RC", ".", "width", "(", ")", ")", ";", "for", "(", "uint16_t", "i", "=", "B", ";", "i", "<", "B", "+", "W", ";", "++", "i", ")", "if", "(", "!", "RC", "[", "i", "]", ".", "is", "(", "0", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "expression", "is", "a", "constant", "zero", "." ]

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

[]

[ "<s>", "bool", "X86AsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", ")", "{", "return", "Fixup", ".", "getKind", "(", ")", "==", "FK_NONE", ";", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "AArch64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"Invalid MachineFunction pointer.\"", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CFGuard_Check", ")", "return", "CSR_Win_AArch64_CFGuard_Check_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetWindows", "(", ")", ")", "return", "CSR_Win_AArch64_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_VectorCall", ")", "return", "CSR_AArch64_AAVPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_SVE_VectorCall", ")", "return", "CSR_AArch64_SVE_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_AArch64_CXX_TLS_Darwin_PE_SaveList", ":", "CSR_AArch64_CXX_TLS_Darwin_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_AArch64_AAPCS_SwiftError_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "PreserveMost", ")", "return", "CSR_AArch64_RT_MostRegs_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetDarwin", "(", ")", ")", "return", "CSR_Darwin_AArch64_AAPCS_SaveList", ";", "return", "CSR_AArch64_AAPCS_SaveList", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Invalid MachineFunction pointer.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "static", "tree", "ix86_vectorize_builtin_scatter", "(", "const_tree", "vectype", ",", "const_tree", "index_type", ",", "int", "scale", ")", "{", "bool", "si", ";", "enum", "ix86_builtins", "code", ";", "if", "(", "!", "TARGET_AVX512F", ")", "return", "NULL_TREE", ";", "if", "(", "(", "TREE_CODE", "(", "index_type", ")", "!=", "INTEGER_TYPE", "&&", "!", "POINTER_TYPE_P", "(", "index_type", ")", ")", "||", "(", "TYPE_MODE", "(", "index_type", ")", "!=", "SImode", "&&", "TYPE_MODE", "(", "index_type", ")", "!=", "DImode", ")", ")", "return", "NULL_TREE", ";", "if", "(", "TYPE_PRECISION", "(", "index_type", ")", ">", "POINTER_SIZE", ")", "return", "NULL_TREE", ";", "if", "(", "TYPE_PRECISION", "(", "index_type", ")", "<", "POINTER_SIZE", "&&", "TYPE_UNSIGNED", "(", "index_type", ")", ")", "return", "NULL_TREE", ";", "if", "(", "scale", "<=", "0", "||", "scale", ">", "8", "||", "(", "scale", "&", "(", "scale", "-", "1", ")", ")", "!=", "0", ")", "return", "NULL_TREE", ";", "si", "=", "TYPE_MODE", "(", "index_type", ")", "==", "SImode", ";", "switch", "(", "TYPE_MODE", "(", "vectype", ")", ")", "{", "case", "E_V8DFmode", ":", "code", "=", "si", "?", "IX86_BUILTIN_SCATTERALTSIV8DF", ":", "IX86_BUILTIN_SCATTERDIV8DF", ";", "break", ";", "case", "E_V8DImode", ":", "code", "=", "si", "?", "IX86_BUILTIN_SCATTERALTSIV8DI", ":", "IX86_BUILTIN_SCATTERDIV8DI", ";", "break", ";", "case", "E_V16SFmode", ":", "code", "=", "si", "?", "IX86_BUILTIN_SCATTERSIV16SF", ":", "IX86_BUILTIN_SCATTERALTDIV16SF", ";", "break", ";", "case", "E_V16SImode", ":", "code", "=", "si", "?", "IX86_BUILTIN_SCATTERSIV16SI", ":", "IX86_BUILTIN_SCATTERALTDIV16SI", ";", "break", ";", "case", "E_V4DFmode", ":", "if", "(", "TARGET_AVX512VL", ")", "code", "=", "si", "?", "IX86_BUILTIN_SCATTERALTSIV4DF", ":", "IX86_BUILTIN_SCATTERDIV4DF", ";", "else", "return", "NULL_TREE", ";", "break", ";", "case", "E_V4DImode", ":", "if", "(", "TARGET_AVX512VL", ")", "code", "=", "si", "?", "IX86_BUILTIN_SCATTERALTSIV4DI", ":", "IX86_BUILTIN_SCATTERDIV4DI", ";", "else", "return", "NULL_TREE", ";", "break", ";", "case", "E_V8SFmode", ":", "if", "(", "TARGET_AVX512VL", ")", "code", "=", "si", "?", "IX86_BUILTIN_SCATTERSIV8SF", ":", "IX86_BUILTIN_SCATTERALTDIV8SF", ";", "else", "return", "NULL_TREE", ";", "break", ";", "case", "E_V8SImode", ":", "if", "(", "TARGET_AVX512VL", ")", "code", "=", "si", "?", "IX86_BUILTIN_SCATTERSIV8SI", ":", "IX86_BUILTIN_SCATTERALTDIV8SI", ";", "else", "return", "NULL_TREE", ";", "break", ";", "case", "E_V2DFmode", ":", "if", "(", "TARGET_AVX512VL", ")", "code", "=", "si", "?", "IX86_BUILTIN_SCATTERALTSIV2DF", ":", "IX86_BUILTIN_SCATTERDIV2DF", ";", "else", "return", "NULL_TREE", ";", "break", ";", "case", "E_V2DImode", ":", "if", "(", "TARGET_AVX512VL", ")", "code", "=", "si", "?", "IX86_BUILTIN_SCATTERALTSIV2DI", ":", "IX86_BUILTIN_SCATTERDIV2DI", ";", "else", "return", "NULL_TREE", ";", "break", ";", "case", "E_V4SFmode", ":", "if", "(", "TARGET_AVX512VL", ")", "code", "=", "si", "?", "IX86_BUILTIN_SCATTERSIV4SF", ":", "IX86_BUILTIN_SCATTERALTDIV4SF", ";", "else", "return", "NULL_TREE", ";", "break", ";", "case", "E_V4SImode", ":", "if", "(", "TARGET_AVX512VL", ")", "code", "=", "si", "?", "IX86_BUILTIN_SCATTERSIV4SI", ":", "IX86_BUILTIN_SCATTERALTDIV4SI", ";", "else", "return", "NULL_TREE", ";", "break", ";", "default", ":", "return", "NULL_TREE", ";", "}", "return", "get_ix86_builtin", "(", "code", ")", ";", "}", "</s>" ]

[ "Returns", "a", "decl", "of", "a", "function", "that", "implements", "scatter", "store", "with", "register", "type", "VECTYPE", "and", "index", "type", "INDEX_TYPE", "and", "SCALE", ".", "Return", "NULL_TREE", "if", "it", "is", "not", "available", "." ]

[ "i386", "0", "8", "1", "0" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "Thumb1FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "Thumb1InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Thumb1InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "ThumbRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "ThumbRegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "DebugLoc", "dl", "=", "Old", ".", "getDebugLoc", "(", ")", ";", "unsigned", "Amount", "=", "Old", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "unsigned", "Opc", "=", "Old", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKDOWN", ")", "{", "emitSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "RegInfo", ",", "-", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "emitSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "RegInfo", ",", "Amount", ")", ";", "}", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "ARM", "0", "0", "1", "ARM::ADJCALLSTACKDOWN", "ARM::tADJCALLSTACKDOWN", "ARM::ADJCALLSTACKUP", "ARM::tADJCALLSTACKUP" ]

[]

[ "<s>", "static", "rtx", "get_thread_pointer", "(", "machine_mode", "tp_mode", ",", "bool", "to_reg", ")", "{", "rtx", "tp", "=", "gen_rtx_UNSPEC", "(", "ptr_mode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ",", "UNSPEC_TP", ")", ";", "if", "(", "GET_MODE", "(", "tp", ")", "!=", "tp_mode", ")", "{", "gcc_assert", "(", "GET_MODE", "(", "tp", ")", "==", "SImode", ")", ";", "gcc_assert", "(", "tp_mode", "==", "DImode", ")", ";", "tp", "=", "gen_rtx_ZERO_EXTEND", "(", "tp_mode", ",", "tp", ")", ";", "}", "if", "(", "to_reg", ")", "tp", "=", "copy_to_mode_reg", "(", "tp_mode", ",", "tp", ")", ";", "return", "tp", ";", "}", "</s>" ]

[ "Load", "the", "thread", "pointer", ".", "If", "TO_REG", "is", "true", ",", "force", "it", "into", "a", "register", "." ]

[ "i386", "1" ]

[]

[ "<s>", "void", "SparcTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "dl", "(", "N", ")", ";", "RTLIB", "::", "Libcall", "libCall", "=", "RTLIB", "::", "UNKNOWN_LIBCALL", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Do not know how to custom type legalize this operation!\"", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "!=", "MVT", "::", "f128", "||", "N", "->", "getValueType", "(", "0", ")", "!=", "MVT", "::", "i64", ")", "return", ";", "libCall", "=", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_TO_SINT", ")", "?", "RTLIB", "::", "FPTOSINT_F128_I64", ":", "RTLIB", "::", "FPTOUINT_F128_I64", ")", ";", "Results", ".", "push_back", "(", "LowerF128Op", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "getLibcallName", "(", "libCall", ")", ",", "1", ")", ")", ";", "return", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "{", "assert", "(", "Subtarget", "->", "hasLeonCycleCounter", "(", ")", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getCopyFromReg", "(", "N", "->", "getOperand", "(", "0", ")", ",", "dl", ",", "SP", "::", "ASR23", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getCopyFromReg", "(", "Lo", ",", "dl", ",", "SP", "::", "G0", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Lo", ",", "Hi", "}", ";", "SDValue", "Pair", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "dl", ",", "MVT", "::", "i64", ",", "Ops", ")", ";", "Results", ".", "push_back", "(", "Pair", ")", ";", "Results", ".", "push_back", "(", "N", "->", "getOperand", "(", "0", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "if", "(", "N", "->", "getValueType", "(", "0", ")", "!=", "MVT", "::", "f128", "||", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i64", ")", "return", ";", "libCall", "=", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SINT_TO_FP", ")", "?", "RTLIB", "::", "SINTTOFP_I64_F128", ":", "RTLIB", "::", "UINTTOFP_I64_F128", ")", ";", "Results", ".", "push_back", "(", "LowerF128Op", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "getLibcallName", "(", "libCall", ")", ",", "1", ")", ")", ";", "return", ";", "case", "ISD", "::", "LOAD", ":", "{", "LoadSDNode", "*", "Ld", "=", "cast", "<", "LoadSDNode", ">", "(", "N", ")", ";", "if", "(", "Ld", "->", "getValueType", "(", "0", ")", "!=", "MVT", "::", "i64", "||", "Ld", "->", "getMemoryVT", "(", ")", "!=", "MVT", "::", "i64", ")", "return", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "LoadRes", "=", "DAG", ".", "getExtLoad", "(", "Ld", "->", "getExtensionType", "(", ")", ",", "dl", ",", "MVT", "::", "v2i32", ",", "Ld", "->", "getChain", "(", ")", ",", "Ld", "->", "getBasePtr", "(", ")", ",", "Ld", "->", "getPointerInfo", "(", ")", ",", "MVT", "::", "v2i32", ",", "Ld", "->", "getOriginalAlign", "(", ")", ",", "Ld", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ",", "Ld", "->", "getAAInfo", "(", ")", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "i64", ",", "LoadRes", ")", ";", "Results", ".", "push_back", "(", "Res", ")", ";", "Results", ".", "push_back", "(", "LoadRes", ".", "getValue", "(", "1", ")", ")", ";", "return", ";", "}", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"Do not know how to custom type legalize this operation!\"", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "0", "MVT::f128", "0", "MVT::i64", "ISD::FP_TO_SINT", "0", "1", "ISD::READCYCLECOUNTER", "0", "SP::ASR23", "MVT::i32", "SP::G0", "MVT::i32", "ISD::BUILD_PAIR", "MVT::i64", "0", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "0", "MVT::f128", "0", "MVT::i64", "ISD::SINT_TO_FP", "0", "1", "ISD::LOAD", "0", "MVT::i64", "MVT::i64", "MVT::v2i32", "MVT::v2i32", "ISD::BITCAST", "MVT::i64", "1" ]

[]

[ "<s>", "bool", "Thumb1InstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "ARM", "::", "tPUSH", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "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", "(", ")", "." ]

[ "ARM", "ARM::tPUSH", "0", "1" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "{", "if", "(", "isSpecialLLVMGlobalArrayToSkip", "(", "GV", ")", "||", "isSpecialLLVMGlobalArrayForStaticInit", "(", "GV", ")", ")", "return", ";", "assert", "(", "!", "GV", "->", "getName", "(", ")", ".", "startswith", "(", "\"llvm.\"", ")", "&&", "\"Unhandled intrinsic global variable.\"", ")", ";", "ValidateGV", "(", "GV", ")", ";", "MCSymbolXCOFF", "*", "GVSym", "=", "cast", "<", "MCSymbolXCOFF", ">", "(", "getSymbol", "(", "GV", ")", ")", ";", "if", "(", "GV", "->", "isDeclarationForLinker", "(", ")", ")", "{", "emitLinkage", "(", "GV", ",", "GVSym", ")", ";", "return", ";", "}", "SectionKind", "GVKind", "=", "getObjFileLowering", "(", ")", ".", "getKindForGlobal", "(", "GV", ",", "TM", ")", ";", "if", "(", "!", "GVKind", ".", "isGlobalWriteableData", "(", ")", "&&", "!", "GVKind", ".", "isReadOnly", "(", ")", ")", "report_fatal_error", "(", "\"Encountered a global variable kind that is \"", "\"not supported yet.\"", ")", ";", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GV", ",", "GVKind", ",", "TM", ")", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Csect", ")", ";", "const", "DataLayout", "&", "DL", "=", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "if", "(", "GVKind", ".", "isCommon", "(", ")", "||", "GVKind", ".", "isBSSLocal", "(", ")", ")", "{", "Align", "Alignment", "=", "GV", "->", "getAlign", "(", ")", ".", "getValueOr", "(", "DL", ".", "getPreferredAlign", "(", "GV", ")", ")", ";", "uint64_t", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ")", ";", "GVSym", "->", "setStorageClass", "(", "TargetLoweringObjectFileXCOFF", "::", "getStorageClassForGlobal", "(", "GV", ")", ")", ";", "if", "(", "GVKind", ".", "isBSSLocal", "(", ")", ")", "OutStreamer", "->", "emitXCOFFLocalCommonSymbol", "(", "OutContext", ".", "getOrCreateSymbol", "(", "GVSym", "->", "getSymbolTableName", "(", ")", ")", ",", "Size", ",", "GVSym", ",", "Alignment", ".", "value", "(", ")", ")", ";", "else", "OutStreamer", "->", "emitCommonSymbol", "(", "GVSym", ",", "Size", ",", "Alignment", ".", "value", "(", ")", ")", ";", "return", ";", "}", "MCSymbol", "*", "EmittedInitSym", "=", "GVSym", ";", "emitLinkage", "(", "GV", ",", "EmittedInitSym", ")", ";", "emitAlignment", "(", "getGVAlignment", "(", "GV", ",", "DL", ")", ",", "GV", ")", ";", "if", "(", "!", "TM", ".", "getDataSections", "(", ")", "||", "GV", "->", "hasSection", "(", ")", ")", "{", "OutStreamer", "->", "emitLabel", "(", "EmittedInitSym", ")", ";", "}", "llvm", "::", "for_each", "(", "GOAliasMap", "[", "GV", "]", ",", "[", "this", "]", "(", "const", "GlobalAlias", "*", "Alias", ")", "{", "OutStreamer", "->", "emitLabel", "(", "getSymbol", "(", "Alias", ")", ")", ";", "}", ")", ";", "emitGlobalConstant", "(", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ",", "GV", "->", "getInitializer", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "specified", "global", "variable", "to", "the", ".s", "file", "." ]

[ "PowerPC", "PPC", "\"llvm.\"", "\"Unhandled intrinsic global variable.\"", "\"Encountered a global variable kind that is \"", "\"not supported yet.\"" ]

[]

[ "<s>", "DecodeStatus", "RISCVDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "if", "(", "(", "Bytes", "[", "0", "]", "&", "0x3", ")", "==", "0x3", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "support", "::", "endian", "::", "read32le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV32 table :\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "4", ";", "}", "else", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "support", "::", "endian", "::", "read16le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "Feature64Bit", "]", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV32Only_16 table (16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableRISCV32Only_16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "}", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtZbproposedc", "]", "&&", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtC", "]", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RVBC32 table (BitManip 16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableRVBC16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV_C table (16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "2", ";", "}", "return", "Result", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "RISCV", "RISCV", "0", "0x3", "0x3", "4", "0", "support::endian", "\"Trying RISCV32 table :\\n\"", "4", "2", "0", "support::endian", "RISCV::Feature64Bit", "\"Trying RISCV32Only_16 table (16-bit Instruction):\\n\"", "RISCV", "2", "RISCV::FeatureStdExtZbproposedc", "RISCV::FeatureStdExtC", "\"Trying RVBC32 table (BitManip 16-bit Instruction):\\n\"", "2", "\"Trying RISCV_C table (16-bit Instruction):\\n\"", "2" ]

[]

[ "<s>", "tree", "aarch64_general_builtin_rsqrt", "(", "unsigned", "int", "fn", ")", "{", "if", "(", "fn", "==", "AARCH64_SIMD_BUILTIN_UNOP_sqrtv2df", ")", "return", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_RSQRT_V2DF", "]", ";", "if", "(", "fn", "==", "AARCH64_SIMD_BUILTIN_UNOP_sqrtv2sf", ")", "return", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_RSQRT_V2SF", "]", ";", "if", "(", "fn", "==", "AARCH64_SIMD_BUILTIN_UNOP_sqrtv4sf", ")", "return", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_RSQRT_V4SF", "]", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "builtin", "for", "reciprocal", "square", "root", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "s390_register_info", "(", ")", "{", "int", "i", ";", "char", "clobbered_regs", "[", "32", "]", ";", "gcc_assert", "(", "!", "epilogue_completed", ")", ";", "if", "(", "reload_completed", ")", "s390_regs_ever_clobbered", "(", "clobbered_regs", ")", ";", "else", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "clobbered_regs", "[", "i", "]", "=", "df_regs_ever_live_p", "(", "i", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "clobbered_regs", "[", "i", "]", "=", "clobbered_regs", "[", "i", "]", "&&", "!", "global_regs", "[", "i", "]", ";", "cfun_frame_layout", ".", "fpr_bitmap", "=", "0", ";", "cfun_frame_layout", ".", "high_fprs", "=", "0", ";", "for", "(", "i", "=", "FPR0_REGNUM", ";", "i", "<=", "FPR15_REGNUM", ";", "i", "++", ")", "if", "(", "clobbered_regs", "[", "i", "]", "&&", "!", "call_really_used_regs", "[", "i", "]", ")", "{", "cfun_set_fpr_save", "(", "i", ")", ";", "if", "(", "i", ">=", "FPR8_REGNUM", ")", "cfun_frame_layout", ".", "high_fprs", "++", ";", "}", "clobbered_regs", "[", "12", "]", "|=", "(", "(", "flag_pic", "&&", "df_regs_ever_live_p", "(", "PIC_OFFSET_TABLE_REGNUM", ")", ")", "||", "(", "flag_split_stack", "&&", "cfun", "->", "stdarg", "&&", "(", "crtl", "->", "is_leaf", "||", "TARGET_TPF_PROFILING", "||", "has_hard_reg_initial_val", "(", "Pmode", ",", "RETURN_REGNUM", ")", ")", ")", ")", ";", "clobbered_regs", "[", "BASE_REGNUM", "]", "|=", "(", "cfun", "->", "machine", "->", "base_reg", "&&", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", "==", "BASE_REGNUM", ")", ";", "clobbered_regs", "[", "HARD_FRAME_POINTER_REGNUM", "]", "|=", "!", "!", "frame_pointer_needed", ";", "clobbered_regs", "[", "RETURN_REGNUM", "]", "|=", "(", "!", "crtl", "->", "is_leaf", "||", "TARGET_TPF_PROFILING", "||", "cfun_frame_layout", ".", "save_return_addr_p", "||", "crtl", "->", "calls_eh_return", ")", ";", "clobbered_regs", "[", "STACK_POINTER_REGNUM", "]", "|=", "(", "!", "crtl", "->", "is_leaf", "||", "TARGET_TPF_PROFILING", "||", "cfun_save_high_fprs_p", "||", "get_frame_size", "(", ")", ">", "0", "||", "(", "reload_completed", "&&", "cfun_frame_layout", ".", "frame_size", ">", "0", ")", "||", "cfun", "->", "calls_alloca", ")", ";", "memset", "(", "cfun_frame_layout", ".", "gpr_save_slots", ",", "SAVE_SLOT_NONE", ",", "16", ")", ";", "for", "(", "i", "=", "6", ";", "i", "<", "16", ";", "i", "++", ")", "if", "(", "clobbered_regs", "[", "i", "]", ")", "cfun_gpr_save_slot", "(", "i", ")", "=", "SAVE_SLOT_STACK", ";", "s390_register_info_stdarg_fpr", "(", ")", ";", "s390_register_info_gprtofpr", "(", ")", ";", "s390_register_info_set_ranges", "(", ")", ";", "s390_register_info_stdarg_gpr", "(", ")", ";", "}", "</s>" ]

[ "Fill", "cfun-", ">", "machine", "with", "info", "about", "register", "usage", "of", "current", "function", ".", "Return", "in", "CLOBBERED_REGS", "which", "GPRs", "are", "currently", "considered", "set", "." ]

[ "s390", "32", "0", "32", "0", "32", "0", "0", "12", "0", "0", "16", "6", "16" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "(", "Kind", "==", "k_Register", "||", "Kind", "==", "k_Memri", ")", "&&", "\"Invalid access!\"", ")", ";", "return", "RegImm", ".", "Reg", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "AVR", "\"Invalid access!\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldReduceLoadWidth", "(", "SDNode", "*", "Load", ",", "ISD", "::", "LoadExtType", "ExtTy", ",", "EVT", "NewVT", ")", "const", "{", "assert", "(", "cast", "<", "LoadSDNode", ">", "(", "Load", ")", "->", "isSimple", "(", ")", "&&", "\"illegal to narrow\"", ")", ";", "SDValue", "BasePtr", "=", "cast", "<", "LoadSDNode", ">", "(", "Load", ")", "->", "getBasePtr", "(", ")", ";", "if", "(", "BasePtr", ".", "getOpcode", "(", ")", "==", "X86ISD", "::", "WrapperRIP", ")", "if", "(", "const", "auto", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "BasePtr", ".", "getOperand", "(", "0", ")", ")", ")", "return", "GA", "->", "getTargetFlags", "(", ")", "!=", "X86II", "::", "MO_GOTTPOFF", ";", "EVT", "VT", "=", "Load", "->", "getValueType", "(", "0", ")", ";", "if", "(", "(", "VT", ".", "is256BitVector", "(", ")", "||", "VT", ".", "is512BitVector", "(", ")", ")", "&&", "!", "Load", "->", "hasOneUse", "(", ")", ")", "{", "for", "(", "auto", "UI", "=", "Load", "->", "use_begin", "(", ")", ",", "UE", "=", "Load", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", ".", "getUse", "(", ")", ".", "getResNo", "(", ")", "!=", "0", ")", "continue", ";", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_SUBVECTOR", "||", "!", "UI", "->", "hasOneUse", "(", ")", "||", "UI", "->", "use_begin", "(", ")", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "STORE", ")", "return", "true", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "believe", "it", "is", "correct", "and", "profitable", "to", "reduce", "the", "load", "node", "to", "a", "smaller", "type", "." ]

[ "X86", "X86", "ISD::LoadExtType", "\"illegal to narrow\"", "X86ISD::WrapperRIP", "0", "X86II::MO_GOTTPOFF", "0", "0", "ISD::EXTRACT_SUBVECTOR", "ISD::STORE" ]

[]

[ "<s>", "void", "StackPU2AsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "StackPU2MCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "I", ";", "MCInstLowering", ".", "lowerInstruction", "(", "*", "MI", ",", "I", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "I", ")", ";", "}", "</s>" ]

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

[ "StackPU2", "StackPU2", "StackPU2" ]

[]

[ "<s>", "unsigned", "VEInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "STSri", "||", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "STLri", "||", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "STUri", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "VE", "VE", "VE::STSri", "VE::STLri", "VE::STUri", "0", "1", "1", "0", "0", "2", "0" ]

[]

[ "<s>", "static", "bool", "riscv_valid_lo_sum_p", "(", "enum", "riscv_symbol_type", "sym_type", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "riscv_symbol_insns", "(", "sym_type", ")", "==", "0", ")", "return", "false", ";", "if", "(", "!", "riscv_split_symbol_type", "(", "sym_type", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "GET_MODE_ALIGNMENT", "(", "mode", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "LO_SUM", "can", "address", "a", "value", "of", "mode", "MODE", "when", "the", "LO_SUM", "symbol", "has", "type", "SYM_TYPE", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "RISCVFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "unsigned", "SPReg", "=", "RISCV", "::", "X2", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "alignSPAdjust", "(", "Amount", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "RISCV", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "adjustReg", "(", "MBB", ",", "MI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "Amount", ",", "MachineInstr", "::", "NoFlags", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "RISCV", "RISCV", "RISCV::X2", "0", "0", "RISCV::ADJCALLSTACKDOWN" ]

[]

[ "<s>", "rtx", "riscv_return_addr", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "const0_rtx", ";", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "RETURN_ADDR_RTX", ".", "We", "do", "not", "support", "moving", "back", "to", "a", "previous", "frame", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "static", "int", "stackSlotSize", "(", ")", "{", "return", "2", ";", "}", "</s>" ]

[ "Stack", "slot", "size", "(", "4", "bytes", ")" ]

[ "Teak", "2" ]

[]

[ "<s>", "bool", "ARCFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Restore callee saved registers: \"", "<<", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "unsigned", "Last", "=", "determineLastCalleeSave", "(", "CSI", ")", ";", "if", "(", "UseSaveRestoreFunclet", "&&", "Last", ">", "ARC", "::", "R14", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</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", "(", ")", "." ]

[ "ARC", "ARC", "\"Restore callee saved registers: \"", "\"\\n\"", "ARC::R14" ]

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "SystemZMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "IsVarArg", "=", "MF", ".", "getFunction", "(", ")", "->", "isVarArg", "(", ")", ";", "if", "(", "IsVarArg", ")", "for", "(", "unsigned", "I", "=", "MFI", "->", "getVarArgsFirstGPR", "(", ")", ";", "I", "<", "SystemZ", "::", "NumArgGPRs", ";", "++", "I", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "ArgGPRs", "[", "I", "]", ")", ";", "if", "(", "!", "MF", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ")", "{", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R6D", ")", ";", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R7D", ")", ";", "}", "if", "(", "HasFP", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R11D", ")", ";", "if", "(", "MFFrame", ".", "hasCalls", "(", ")", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R14D", ")", ";", "const", "MCPhysReg", "*", "CSRegs", "=", "TRI", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "CSRegs", "[", "I", "]", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSRegs", "[", "I", "]", ";", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "Reg", ")", "&&", "SavedRegs", ".", "test", "(", "Reg", ")", ")", "{", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R15D", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::NumArgGPRs", "SystemZ::ArgGPRs", "SystemZ::R6D", "SystemZ::R7D", "SystemZ::R11D", "SystemZ::R14D", "0", "SystemZ::GR64BitRegClass", "SystemZ::R15D" ]

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "lowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "VE", "VE", "\"Should not custom lower this!\"", "ISD::BlockAddress", "ISD::DYNAMIC_STACKALLOC", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::VASTART", "ISD::VAARG" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "TM", "->", "isPagerando", "(", ")", ")", "{", "addPass", "(", "createAArch64PagerandoOptimizerPass", "(", ")", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableDeadRegisterElimination", ")", "addPass", "(", "createAArch64DeadRegisterDefinitions", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAdvSIMDScalar", ")", "{", "addPass", "(", "createAArch64AdvSIMDScalar", "(", ")", ")", ";", "addPass", "(", "&", "PeepholeOptimizerID", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "MSP430FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "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", "(", ")", "." ]

[ "MSP430", "MSP430", "MSP430", "MSP430", "2", "0", "1", "MSP430::PUSH16r" ]

[]

[ "<s>", "Align", "PPCTargetLowering", "::", "getPrefLoopAlignment", "(", "MachineLoop", "*", "ML", ")", "const", "{", "switch", "(", "Subtarget", ".", "getCPUDirective", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "DIR_970", ":", "case", "PPC", "::", "DIR_PWR4", ":", "case", "PPC", "::", "DIR_PWR5", ":", "case", "PPC", "::", "DIR_PWR5X", ":", "case", "PPC", "::", "DIR_PWR6", ":", "case", "PPC", "::", "DIR_PWR6X", ":", "case", "PPC", "::", "DIR_PWR7", ":", "case", "PPC", "::", "DIR_PWR8", ":", "case", "PPC", "::", "DIR_PWR9", ":", "case", "PPC", "::", "DIR_PWR10", ":", "case", "PPC", "::", "DIR_PWR_FUTURE", ":", "{", "if", "(", "!", "ML", ")", "break", ";", "if", "(", "!", "DisableInnermostLoopAlign32", ")", "{", "if", "(", "ML", "->", "getLoopDepth", "(", ")", ">", "1", "&&", "ML", "->", "getSubLoops", "(", ")", ".", "empty", "(", ")", ")", "return", "Align", "(", "32", ")", ";", "}", "const", "PPCInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "uint64_t", "LoopSize", "=", "0", ";", "for", "(", "auto", "I", "=", "ML", "->", "block_begin", "(", ")", ",", "IE", "=", "ML", "->", "block_end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "J", "=", "(", "*", "I", ")", "->", "begin", "(", ")", ",", "JE", "=", "(", "*", "I", ")", "->", "end", "(", ")", ";", "J", "!=", "JE", ";", "++", "J", ")", "{", "LoopSize", "+=", "TII", "->", "getInstSizeInBytes", "(", "*", "J", ")", ";", "if", "(", "LoopSize", ">", "32", ")", "break", ";", "}", "if", "(", "LoopSize", ">", "16", "&&", "LoopSize", "<=", "32", ")", "return", "Align", "(", "32", ")", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getPrefLoopAlignment", "(", "ML", ")", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "loop", "alignment", "." ]

[ "PowerPC", "PPC", "PPC::DIR_970", "PPC::DIR_PWR4", "PPC::DIR_PWR5", "PPC::DIR_PWR5X", "PPC::DIR_PWR6", "PPC::DIR_PWR6X", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC::DIR_PWR9", "PPC::DIR_PWR10", "PPC::DIR_PWR_FUTURE", "1", "32", "PPC", "0", "32", "16", "32", "32" ]

[]

[ "<s>", "static", "inline", "bool", "offset_9bit_signed_scaled_p", "(", "machine_mode", "mode", ",", "poly_int64", "offset", ")", "{", "HOST_WIDE_INT", "multiple", ";", "return", "(", "constant_multiple_p", "(", "offset", ",", "GET_MODE_SIZE", "(", "mode", ")", ",", "&", "multiple", ")", "&&", "IN_RANGE", "(", "multiple", ",", "-", "256", ",", "255", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OFFSET", "is", "a", "signed", "9-bit", "value", "multiplied", "by", "the", "size", "of", "MODE", "." ]

[ "aarch64", "256", "255" ]

[]

[ "<s>", "static", "void", "avr_insert_attributes", "(", "tree", "node", ",", "tree", "*", "attributes", ")", "{", "avr_pgm_check_var_decl", "(", "node", ")", ";", "if", "(", "TREE_CODE", "(", "node", ")", "==", "VAR_DECL", "&&", "(", "TREE_STATIC", "(", "node", ")", "||", "DECL_EXTERNAL", "(", "node", ")", ")", "&&", "avr_progmem_p", "(", "node", ",", "*", "attributes", ")", ")", "{", "addr_space_t", "as", ";", "tree", "node0", "=", "node", ";", "do", "node0", "=", "TREE_TYPE", "(", "node0", ")", ";", "while", "(", "TREE_CODE", "(", "node0", ")", "==", "ARRAY_TYPE", ")", ";", "if", "(", "error_mark_node", "==", "node0", ")", "return", ";", "as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "node", ")", ")", ";", "if", "(", "avr_addrspace", "[", "as", "]", ".", "segment", ">=", "avr_n_flash", ")", "{", "error", "(", "\"variable %q+D located in address space %qs beyond flash \"", "\"of %d KiB\"", ",", "node", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "avr_n_flash", ")", ";", "}", "else", "if", "(", "!", "AVR_HAVE_LPM", "&&", "avr_addrspace", "[", "as", "]", ".", "pointer_size", ">", "2", ")", "{", "error", "(", "\"variable %q+D located in address space %qs\"", "\" which is not supported for architecture %qs\"", ",", "node", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "avr_arch", "->", "name", ")", ";", "}", "if", "(", "!", "TYPE_READONLY", "(", "node0", ")", "&&", "!", "TREE_READONLY", "(", "node", ")", ")", "{", "const", "char", "*", "reason", "=", "\"__attribute__((progmem))\"", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "reason", "=", "avr_addrspace", "[", "as", "]", ".", "name", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"\\n%?: %t\\n%t\\n\"", ",", "node", ",", "node0", ")", ";", "error", "(", "\"variable %q+D must be const in order to be put into\"", "\" read-only section by means of %qs\"", ",", "node", ",", "reason", ")", ";", "}", "}", "}", "</s>" ]

[ "Add", "the", "section", "attribute", "if", "the", "variable", "is", "in", "progmem", "." ]

[ "avr", "\"variable %q+D located in address space %qs beyond flash \"", "\"of %d KiB\"", "2", "\"variable %q+D located in address space %qs\"", "\" which is not supported for architecture %qs\"", "\"__attribute__((progmem))\"", "\"\\n%?: %t\\n%t\\n\"", "\"variable %q+D must be const in order to be put into\"", "\" read-only section by means of %qs\"" ]

[]

[ "<s>", "void", "MipsSERegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "const", "MipsSEInstrInfo", "*", "II", "=", "static_cast", "<", "const", "MipsSEInstrInfo", "*", ">", "(", "&", "TII", ")", ";", "unsigned", "SP", "=", "Subtarget", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ";", "II", "->", "adjustStackPtr", "(", "SP", ",", "Amount", ",", "MBB", ",", "I", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "Mips", "Mips", "0", "Mips::ADJCALLSTACKDOWN", "Mips", "Mips", "Mips::SP_64", "Mips::SP" ]

[]

[ "<s>", "static", "tree", "ix86_build_builtin_va_list_abi", "(", "enum", "calling_abi", "abi", ")", "{", "tree", "f_gpr", ",", "f_fpr", ",", "f_ovf", ",", "f_sav", ",", "record", ",", "type_decl", ";", "if", "(", "!", "TARGET_64BIT", "||", "abi", "==", "MS_ABI", ")", "return", "build_pointer_type", "(", "char_type_node", ")", ";", "record", "=", "lang_hooks", ".", "types", ".", "make_type", "(", "RECORD_TYPE", ")", ";", "type_decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list_tag\"", ")", ",", "record", ")", ";", "f_gpr", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"gp_offset\"", ")", ",", "unsigned_type_node", ")", ";", "f_fpr", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"fp_offset\"", ")", ",", "unsigned_type_node", ")", ";", "f_ovf", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"overflow_arg_area\"", ")", ",", "ptr_type_node", ")", ";", "f_sav", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"reg_save_area\"", ")", ",", "ptr_type_node", ")", ";", "va_list_gpr_counter_field", "=", "f_gpr", ";", "va_list_fpr_counter_field", "=", "f_fpr", ";", "DECL_FIELD_CONTEXT", "(", "f_gpr", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_fpr", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_ovf", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_sav", ")", "=", "record", ";", "TYPE_STUB_DECL", "(", "record", ")", "=", "type_decl", ";", "TYPE_NAME", "(", "record", ")", "=", "type_decl", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_gpr", ";", "DECL_CHAIN", "(", "f_gpr", ")", "=", "f_fpr", ";", "DECL_CHAIN", "(", "f_fpr", ")", "=", "f_ovf", ";", "DECL_CHAIN", "(", "f_ovf", ")", "=", "f_sav", ";", "layout_type", "(", "record", ")", ";", "return", "build_array_type", "(", "record", ",", "build_index_type", "(", "size_zero_node", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "calling", "convention", "specific", "va_list", "date", "type", ".", "The", "argument", "ABI", "can", "be", "DEFAULT_ABI", ",", "MS_ABI", ",", "or", "SYSV_ABI", "." ]

[ "i386", "\"__va_list_tag\"", "\"gp_offset\"", "\"fp_offset\"", "\"overflow_arg_area\"", "\"reg_save_area\"" ]

[]

[ "<s>", "TargetPassConfig", "*", "GCNTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "GCNPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "TargetIRAnalysis", "HexagonTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "HexagonTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

[ "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "virtual", "const", "NVPTXInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "DebugLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "32", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVector", "<", "SDValue", ",", "32", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "32", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "if", "(", "isTailCall", ")", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "DAG", ")", ";", "if", "(", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "LowerCall_32SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "return", "LowerCall_Darwin_Or_64SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "PowerPC", "PPC", "ISD::OutputArg", "32", "32", "ISD::InputArg", "32", "PPC", "PPC", "PPC" ]

[]

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

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

[ "XCore", "XCore", "XCore::R10", "XCore::SP" ]

[]

[ "<s>", "bool", "ARMBaseTargetMachine", "::", "addPreRegAlloc", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "if", "(", "Subtarget", ".", "hasNEON", "(", ")", ")", "PM", ".", "add", "(", "createNEONPreAllocPass", "(", ")", ")", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "!", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "PM", ".", "add", "(", "createARMLoadStoreOptimizationPass", "(", "true", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "ARM", "ARM", "ARM" ]

[]

[ "<s>", "int", "romp_makes_calls", "(", ")", "{", "rtx", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "next_insn", "(", "insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", ")", "return", "1", ";", "else", "if", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "!=", "USE", "&&", "GET_CODE", "(", "body", ")", "!=", "CLOBBER", "&&", "GET_CODE", "(", "body", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "body", ")", "!=", "ADDR_DIFF_VEC", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_FP", ")", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "this", "function", "makes", "calls", "or", "has", "fp", "operations", "(", "which", "are", "really", "calls", ")", "." ]

[ "romp", "1", "1", "0" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DstReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "RISCV", "::", "GPRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "RISCV", "::", "ADDI", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "unsigned", "Opc", ";", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "RISCV", "::", "FSGNJ_S", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "RISCV", "::", "FSGNJ_D", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::ADDI", "0", "RISCV::FPR32RegClass", "RISCV::FSGNJ_S", "RISCV::FPR64RegClass", "RISCV::FSGNJ_D", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "VirtRegMap", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LiveRegMatrix", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "SlotIndexes", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "M68kOperand", "::", "isImm", "(", ")", "const", "{", "return", "Kind", "==", "KindTy", "::", "Imm", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "M68k", "M68k" ]

[]

[ "<s>", "bool", "MSP430FrameLowering", "::", "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", "(", "MSP430", "::", "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", "(", ")", "." ]

[ "MSP430", "MSP430", "0", "MSP430::POP16r" ]

[]

[ "<s>", "static", "void", "riscv_expand_conditional_move_onesided", "(", "rtx", "dest", ",", "rtx", "cons", ",", "rtx", "alt", ",", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ")", ";", "gcc_assert", "(", "reg_or_0_operand", "(", "cons", ",", "mode", ")", ")", ";", "gcc_assert", "(", "reg_or_0_operand", "(", "alt", ",", "mode", ")", ")", ";", "riscv_emit_int_compare", "(", "&", "code", ",", "&", "op0", ",", "&", "op1", ",", "true", ")", ";", "rtx", "cond", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "op0", ",", "op1", ")", ";", "rtx", "tmp1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "tmp2", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp1", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "cond", ",", "cons", ",", "const0_rtx", ")", ")", ")", ";", "cond", "=", "gen_rtx_fmt_ee", "(", "(", "code", "==", "EQ", ")", "?", "NE", ":", "EQ", ",", "mode", ",", "op0", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp2", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "cond", ",", "alt", ",", "const0_rtx", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IOR", "(", "mode", ",", "tmp1", ",", "tmp2", ")", ")", ")", ";", "}", "</s>" ]

[ "Helper", "to", "emit", "two", "one-sided", "conditional", "moves", "for", "the", "movecc", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "rtx", "altivec_expand_vec_ext_builtin", "(", "tree", "exp", ",", "rtx", "target", ")", "{", "machine_mode", "tmode", ",", "mode0", ";", "tree", "arg0", ",", "arg1", ";", "int", "elt", ";", "rtx", "op0", ";", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "elt", "=", "get_element_number", "(", "TREE_TYPE", "(", "arg0", ")", ",", "arg1", ")", ";", "tmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", ";", "mode0", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", ";", "op0", "=", "force_reg", "(", "mode0", ",", "op0", ")", ";", "if", "(", "optimize", "||", "!", "target", "||", "!", "register_operand", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "rs6000_expand_vector_extract", "(", "target", ",", "op0", ",", "elt", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "vec_ext", "builtin", "." ]

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

[]

[ "<s>", "int", "HexagonMCInstrInfo", "::", "getMaxValue", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCInst", "const", "&", "MCI", ")", "{", "assert", "(", "HexagonMCInstrInfo", "::", "isExtendable", "(", "MCII", ",", "MCI", ")", "||", "HexagonMCInstrInfo", "::", "isExtended", "(", "MCII", ",", "MCI", ")", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isExtentSigned", "(", "MCII", ",", "MCI", ")", ")", "return", "(", "1", "<<", "(", "HexagonMCInstrInfo", "::", "getExtentBits", "(", "MCII", ",", "MCI", ")", "-", "1", ")", ")", "-", "1", ";", "return", "(", "1", "<<", "HexagonMCInstrInfo", "::", "getExtentBits", "(", "MCII", ",", "MCI", ")", ")", "-", "1", ";", "}", "</s>" ]

[ "Return", "the", "maximal", "unsigned", "value", "possible", "given", "these", "KnownBits", "." ]

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

[]

[ "<s>", "static", "bool", "const_load_sequence_p", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx", "insn", ")", "{", "unsigned", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "if", "(", "!", "insn_entry", "[", "uid", "]", ".", "is_swap", "||", "insn_entry", "[", "uid", "]", ".", "is_load", ")", "return", "false", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "df_ref", "use", ";", "FOR_EACH_INSN_INFO_USE", "(", "use", ",", "insn_info", ")", "{", "struct", "df_link", "*", "def_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "if", "(", "!", "def_link", "||", "def_link", "->", "next", ")", "return", "false", ";", "rtx", "def_insn", "=", "DF_REF_INSN", "(", "def_link", "->", "ref", ")", ";", "unsigned", "uid2", "=", "INSN_UID", "(", "def_insn", ")", ";", "if", "(", "!", "insn_entry", "[", "uid2", "]", ".", "is_load", "||", "!", "insn_entry", "[", "uid2", "]", ".", "is_swap", ")", "return", "false", ";", "rtx", "body", "=", "PATTERN", "(", "def_insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "!=", "SET", "||", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "!=", "VEC_SELECT", "||", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", "!=", "MEM", ")", "return", "false", ";", "rtx", "mem", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "rtx", "base_reg", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "df_ref", "base_use", ";", "insn_info", "=", "DF_INSN_INFO_GET", "(", "def_insn", ")", ";", "FOR_EACH_INSN_INFO_USE", "(", "base_use", ",", "insn_info", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "DF_REF_REG", "(", "base_use", ")", ",", "base_reg", ")", ")", "continue", ";", "struct", "df_link", "*", "base_def_link", "=", "DF_REF_CHAIN", "(", "base_use", ")", ";", "if", "(", "!", "base_def_link", "||", "base_def_link", "->", "next", ")", "return", "false", ";", "rtx", "tocrel_insn", "=", "DF_REF_INSN", "(", "base_def_link", "->", "ref", ")", ";", "rtx", "tocrel_body", "=", "PATTERN", "(", "tocrel_insn", ")", ";", "rtx", "base", ",", "offset", ";", "if", "(", "GET_CODE", "(", "tocrel_body", ")", "!=", "SET", ")", "return", "false", ";", "rtx", "tocrel_expr", "=", "SET_SRC", "(", "tocrel_body", ")", ";", "if", "(", "GET_CODE", "(", "tocrel_expr", ")", "==", "MEM", ")", "tocrel_expr", "=", "XEXP", "(", "tocrel_expr", ",", "0", ")", ";", "if", "(", "!", "toc_relative_expr_p", "(", "tocrel_expr", ",", "false", ")", ")", "return", "false", ";", "split_const", "(", "XVECEXP", "(", "tocrel_base", ",", "0", ",", "0", ")", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "!=", "SYMBOL_REF", "||", "!", "CONSTANT_POOL_ADDRESS_P", "(", "base", ")", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "insn", "is", "a", "swap", "fed", "by", "a", "load", "from", "the", "constant", "pool", "." ]

[ "powerpcspe", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "EVT", "WebAssemblyTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "C", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "return", "TargetLowering", "::", "getSetCCResultType", "(", "DL", ",", "C", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "int", "initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "regs_saved", ";", "int", "regs_saved_rounding", "=", "0", ";", "int", "total_saved_regs_space", ";", "int", "total_auto_space", ";", "int", "save_flags", "=", "target_flags", ";", "int", "copy_flags", ";", "HARD_REG_SET", "live_regs_mask", ";", "shmedia_space_reserved_for_target_registers", "=", "false", ";", "regs_saved", "=", "calc_live_regs", "(", "&", "live_regs_mask", ")", ";", "regs_saved", "+=", "SHMEDIA_REGS_STACK_ADJUST", "(", ")", ";", "if", "(", "shmedia_reserve_space_for_target_registers_p", "(", "regs_saved", ",", "&", "live_regs_mask", ")", ")", "{", "shmedia_space_reserved_for_target_registers", "=", "true", ";", "regs_saved", "+=", "shmedia_target_regs_stack_adjust", "(", "&", "live_regs_mask", ")", ";", "}", "if", "(", "TARGET_SH5", "&&", "regs_saved", "%", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ")", "regs_saved_rounding", "=", "(", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", "-", "regs_saved", "%", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ")", ";", "total_auto_space", "=", "rounded_frame_size", "(", "regs_saved", ")", "-", "regs_saved_rounding", ";", "copy_flags", "=", "target_flags", ";", "target_flags", "=", "save_flags", ";", "total_saved_regs_space", "=", "regs_saved", "+", "regs_saved_rounding", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "total_saved_regs_space", "+", "total_auto_space", "+", "current_function_args_info", ".", "byref_regs", "*", "8", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "total_saved_regs_space", "+", "total_auto_space", "+", "current_function_args_info", ".", "byref_regs", "*", "8", ";", "if", "(", "from", "==", "HARD_FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "0", ";", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "rounded_frame_size", "(", "0", ")", ";", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "rounded_frame_size", "(", "0", ")", ";", "gcc_assert", "(", "from", "==", "RETURN_ADDRESS_POINTER_REGNUM", "&&", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", "||", "to", "==", "STACK_POINTER_REGNUM", ")", ")", ";", "if", "(", "TARGET_SH5", ")", "{", "int", "n", "=", "total_saved_regs_space", ";", "int", "pr_reg", "=", "TARGET_SHMEDIA", "?", "PR_MEDIA_REG", ":", "PR_REG", ";", "save_schedule", "schedule", ";", "save_entry", "*", "entry", ";", "n", "+=", "total_auto_space", ";", "if", "(", "!", "TEST_HARD_REG_BIT", "(", "live_regs_mask", ",", "pr_reg", ")", ")", "return", "n", ";", "target_flags", "=", "copy_flags", ";", "sh5_schedule_saves", "(", "&", "live_regs_mask", ",", "&", "schedule", ",", "n", ")", ";", "for", "(", "entry", "=", "&", "schedule", ".", "entries", "[", "1", "]", ";", "entry", "->", "mode", "!=", "VOIDmode", ";", "entry", "++", ")", "if", "(", "entry", "->", "reg", "==", "pr_reg", ")", "{", "target_flags", "=", "save_flags", ";", "return", "entry", "->", "offset", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "else", "return", "total_auto_space", ";", "}", "</s>" ]

[ "Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "sh", "0", "8", "8", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "RISCVTargetStreamer", "::", "reset", "(", ")", "{", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "RISCV", "RISCV" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "Move32R16", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "S0", ")", ";", "TII", ".", "restoreFrame", "(", "Mips", "::", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips::Move32R16", "Mips::SP", "Mips::S0", "Mips::SP" ]

[]

[ "<s>", "static", "rtx", "set_frame_related_p", "(", "void", ")", "{", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "rtx_insn", "*", "insn", ";", "end_sequence", "(", ")", ";", "if", "(", "!", "seq", ")", "return", "NULL_RTX", ";", "if", "(", "INSN_P", "(", "seq", ")", ")", "{", "insn", "=", "seq", ";", "while", "(", "insn", "!=", "NULL_RTX", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "}", "seq", "=", "emit_insn", "(", "seq", ")", ";", "}", "else", "{", "seq", "=", "emit_insn", "(", "seq", ")", ";", "RTX_FRAME_RELATED_P", "(", "seq", ")", "=", "1", ";", "}", "return", "seq", ";", "}", "</s>" ]

[ "Helper", "function", "to", "set", "RTX_FRAME_RELATED_P", "on", "instructions", ",", "including", "sequences", "." ]

[ "tilegx", "1", "1" ]

[]

[ "<s>", "static", "inline", "void", "xtensa_reorg_loops", "(", "void", ")", "{", "}", "</s>" ]

[ "Run", "from", "machine_dependent_reorg", ",", "this", "pass", "looks", "for", "doloop_end", "insns", "and", "tries", "to", "rewrite", "the", "RTL", "of", "these", "loops", "so", "that", "proper", "Xtensa", "hardware", "loops", "are", "generated", "." ]

[ "xtensa" ]

[]

[ "<s>", "opt_machine_mode", "aarch64_sve_data_mode", "(", "scalar_mode", "inner_mode", ",", "poly_uint64", "nunits", ")", "{", "enum", "mode_class", "mclass", "=", "(", "is_a", "<", "scalar_float_mode", ">", "(", "inner_mode", ")", "?", "MODE_VECTOR_FLOAT", ":", "MODE_VECTOR_INT", ")", ";", "machine_mode", "mode", ";", "FOR_EACH_MODE_IN_CLASS", "(", "mode", ",", "mclass", ")", "if", "(", "inner_mode", "==", "GET_MODE_INNER", "(", "mode", ")", "&&", "known_eq", "(", "nunits", ",", "GET_MODE_NUNITS", "(", "mode", ")", ")", "&&", "aarch64_sve_data_mode_p", "(", "mode", ")", ")", "return", "mode", ";", "return", "opt_machine_mode", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "SVE", "vector", "mode", "that", "has", "NUNITS", "elements", "of", "mode", "INNER_MODE", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "mmix_asm_output_mi_thunk", "(", "FILE", "*", "stream", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", "ATTRIBUTE_UNUSED", ",", "tree", "func", ")", "{", "const", "char", "*", "regname", "=", "reg_names", "[", "MMIX_FIRST_INCOMING_ARG_REGNUM", "]", ";", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk_fndecl", ")", ")", ";", "assemble_start_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "if", "(", "delta", ">=", "0", "&&", "delta", "<", "65536", ")", "fprintf", "(", "stream", ",", "\"\\tINCL %s,%d\\n\"", ",", "regname", ",", "(", "int", ")", "delta", ")", ";", "else", "if", "(", "delta", "<", "0", "&&", "delta", ">=", "-", "255", ")", "fprintf", "(", "stream", ",", "\"\\tSUBU %s,%s,%d\\n\"", ",", "regname", ",", "regname", ",", "(", "int", ")", "-", "delta", ")", ";", "else", "{", "mmix_output_register_setting", "(", "stream", ",", "255", ",", "delta", ",", "1", ")", ";", "fprintf", "(", "stream", ",", "\"\\tADDU %s,%s,$255\\n\"", ",", "regname", ",", "regname", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\tJMP \"", ")", ";", "assemble_name", "(", "stream", ",", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "func", ")", ",", "0", ")", ",", "0", ")", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "assemble_end_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "}", "</s>" ]

[ "ASM_OUTPUT_MI_THUNK", "." ]

[ "mmix", "0", "65536", "\"\\tINCL %s,%d\\n\"", "0", "255", "\"\\tSUBU %s,%s,%d\\n\"", "255", "1", "\"\\tADDU %s,%s,$255\\n\"", "\"\\tJMP \"", "0", "0", "\"\\n\"" ]

[]

[ "<s>", "void", "MOSNoRecurse", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "CallGraphWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "CallGraphWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "MOS", "MOS" ]

[]

[ "<s>", "void", "XCoreRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "if", "(", "FP", ")", "{", "unsigned", "FramePtr", "=", "XCore", "::", "R10", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "SETSP_1r", ")", ")", ".", "addReg", "(", "FramePtr", ")", ";", "}", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "assert", "(", "FrameSize", "%", "4", "==", "0", "&&", "\"Misaligned frame size\"", ")", ";", "FrameSize", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "FrameSize", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "FrameSize", ")", ")", "{", "cerr", "<<", "\"emitEpilogue Frame size too big: \"", "<<", "FrameSize", "<<", "\"\\n\"", ";", "abort", "(", ")", ";", "}", "if", "(", "FrameSize", ")", "{", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "if", "(", "FP", ")", "{", "int", "FPSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getFPSpillSlot", "(", ")", ")", ";", "FPSpillOffset", "+=", "FrameSize", "*", "4", ";", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "XCore", "::", "R10", ",", "FPSpillOffset", ",", "dl", ")", ";", "}", "bool", "restoreLR", "=", "XFI", "->", "getUsesLR", "(", ")", ";", "if", "(", "restoreLR", "&&", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", "!=", "0", ")", "{", "int", "LRSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", ";", "LRSpillOffset", "+=", "FrameSize", "*", "4", ";", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "XCore", "::", "LR", ",", "LRSpillOffset", ",", "dl", ")", ";", "restoreLR", "=", "false", ";", "}", "if", "(", "restoreLR", ")", "{", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "RETSP_u6", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "RETSP_lu6", ")", ";", "int", "Opcode", "=", "(", "isU6", ")", "?", "XCore", "::", "RETSP_u6", ":", "XCore", "::", "RETSP_lu6", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "FrameSize", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "else", "{", "int", "Opcode", "=", "(", "isU6", ")", "?", "XCore", "::", "LDAWSP_ru6_RRegs", ":", "XCore", "::", "LDAWSP_lru6_RRegs", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "XCore", "XCore", "XCore::R10", "XCore::SETSP_1r", "4", "0", "\"Misaligned frame size\"", "4", "\"emitEpilogue Frame size too big: \"", "\"\\n\"", "XCore", "XCore", "4", "XCore::R10", "0", "4", "XCore::LR", "XCore::RETSP_u6", "XCore::RETSP_lu6", "XCore::RETSP_u6", "XCore::RETSP_lu6", "XCore::LDAWSP_ru6_RRegs", "XCore::LDAWSP_lru6_RRegs", "XCore::SP" ]

[]

[ "<s>", "unsigned", "AMDGPUAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "Op", ",", "unsigned", "Kind", ")", "{", "AMDGPUOperand", "&", "Operand", "=", "(", "AMDGPUOperand", "&", ")", "Op", ";", "switch", "(", "Kind", ")", "{", "case", "MCK_addr64", ":", "return", "Operand", ".", "isAddr64", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_gds", ":", "return", "Operand", ".", "isGDS", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_lds", ":", "return", "Operand", ".", "isLDS", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_glc", ":", "return", "Operand", ".", "isGLC", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_idxen", ":", "return", "Operand", ".", "isIdxen", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_offen", ":", "return", "Operand", ".", "isOffen", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SSrcB32", ":", "return", "Operand", ".", "isSSrcB32", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SSrcF32", ":", "return", "Operand", ".", "isSSrcF32", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SoppBrTarget", ":", "return", "Operand", ".", "isSoppBrTarget", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_VReg32OrOff", ":", "return", "Operand", ".", "isVReg32OrOff", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_InterpSlot", ":", "return", "Operand", ".", "isInterpSlot", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_Attr", ":", "return", "Operand", ".", "isInterpAttr", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_AttrChan", ":", "return", "Operand", ".", "isAttrChan", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SReg_64", ":", "case", "MCK_SReg_64_XEXEC", ":", "return", "Operand", ".", "isNull", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "default", ":", "return", "Match_InvalidOperand", ";", "}", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

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

[]

[ "<s>", "bool", "X86MCInstrAnalysis", "::", "clearsSuperRegisters", "(", "const", "MCRegisterInfo", "&", "MRI", ",", "const", "MCInst", "&", "Inst", ",", "APInt", "&", "Mask", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "NumDefs", "=", "Desc", ".", "getNumDefs", "(", ")", ";", "unsigned", "NumImplicitDefs", "=", "Desc", ".", "getNumImplicitDefs", "(", ")", ";", "assert", "(", "Mask", ".", "getBitWidth", "(", ")", "==", "NumDefs", "+", "NumImplicitDefs", "&&", "\"Unexpected number of bits in the mask!\"", ")", ";", "bool", "HasVEX", "=", "(", "Desc", ".", "TSFlags", "&", "X86II", "::", "EncodingMask", ")", "==", "X86II", "::", "VEX", ";", "bool", "HasEVEX", "=", "(", "Desc", ".", "TSFlags", "&", "X86II", "::", "EncodingMask", ")", "==", "X86II", "::", "EVEX", ";", "bool", "HasXOP", "=", "(", "Desc", ".", "TSFlags", "&", "X86II", "::", "EncodingMask", ")", "==", "X86II", "::", "XOP", ";", "const", "MCRegisterClass", "&", "GR32RC", "=", "MRI", ".", "getRegClass", "(", "X86", "::", "GR32RegClassID", ")", ";", "const", "MCRegisterClass", "&", "VR128XRC", "=", "MRI", ".", "getRegClass", "(", "X86", "::", "VR128XRegClassID", ")", ";", "const", "MCRegisterClass", "&", "VR256XRC", "=", "MRI", ".", "getRegClass", "(", "X86", "::", "VR256XRegClassID", ")", ";", "auto", "ClearsSuperReg", "=", "[", "=", "]", "(", "unsigned", "RegID", ")", "{", "if", "(", "GR32RC", ".", "contains", "(", "RegID", ")", ")", "return", "true", ";", "if", "(", "!", "HasEVEX", "&&", "!", "HasVEX", "&&", "!", "HasXOP", ")", "return", "false", ";", "return", "VR128XRC", ".", "contains", "(", "RegID", ")", "||", "VR256XRC", ".", "contains", "(", "RegID", ")", ";", "}", ";", "Mask", ".", "clearAllBits", "(", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "NumDefs", ";", "I", "<", "E", ";", "++", "I", ")", "{", "const", "MCOperand", "&", "Op", "=", "Inst", ".", "getOperand", "(", "I", ")", ";", "if", "(", "ClearsSuperReg", "(", "Op", ".", "getReg", "(", ")", ")", ")", "Mask", ".", "setBit", "(", "I", ")", ";", "}", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "NumImplicitDefs", ";", "I", "<", "E", ";", "++", "I", ")", "{", "const", "MCPhysReg", "Reg", "=", "Desc", ".", "getImplicitDefs", "(", ")", "[", "I", "]", ";", "if", "(", "ClearsSuperReg", "(", "Reg", ")", ")", "Mask", ".", "setBit", "(", "NumDefs", "+", "I", ")", ";", "}", "return", "Mask", ".", "getBoolValue", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "at", "least", "one", "of", "the", "register", "writes", "performed", "by", "." ]

[ "X86", "X86", "\"Unexpected number of bits in the mask!\"", "X86II::EncodingMask", "X86II::VEX", "X86II::EncodingMask", "X86II::EVEX", "X86II::EncodingMask", "X86II::XOP", "X86::GR32RegClassID", "X86::VR128XRegClassID", "X86::VR256XRegClassID", "0", "0" ]

[]

[ "<s>", "bool", "requiresFrameIndexScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "void", "aarch64_print_hint_for_core_or_arch", "(", "const", "char", "*", "str", ",", "bool", "arch", ")", "{", "auto_vec", "<", "const", "char", "*", ">", "candidates", ";", "const", "struct", "processor", "*", "entry", "=", "arch", "?", "all_architectures", ":", "all_cores", ";", "for", "(", ";", "entry", "->", "name", "!=", "NULL", ";", "entry", "++", ")", "candidates", ".", "safe_push", "(", "entry", "->", "name", ")", ";", "char", "*", "s", ";", "const", "char", "*", "hint", "=", "candidates_list_and_hint", "(", "str", ",", "s", ",", "candidates", ")", ";", "if", "(", "hint", ")", "inform", "(", "input_location", ",", "\"valid arguments are: %s;\"", "\" did you mean %qs?\"", ",", "s", ",", "hint", ")", ";", "XDELETEVEC", "(", "s", ")", ";", "}", "</s>" ]

[ "Print", "a", "hint", "with", "a", "suggestion", "for", "a", "core", "or", "architecture", "name", "that", "most", "closely", "resembles", "what", "the", "user", "passed", "in", "STR", ".", "ARCH", "is", "true", "if", "the", "user", "is", "asking", "for", "an", "architecture", "name", ".", "ARCH", "is", "false", "if", "the", "user", "is", "asking", "for", "a", "core", "name", "." ]

[ "aarch64", "\"valid arguments are: %s;\"", "\" did you mean %qs?\"" ]

[]

[ "<s>", "GCNSubtarget", "&", "GCNSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "GPU", ",", "StringRef", "FS", ")", "{", "SmallString", "<", "256", ">", "FullFS", "(", "\"+promote-alloca,+load-store-opt,+enable-ds128,+sram-ecc,+xnack,\"", ")", ";", "if", "(", "isAmdHsaOS", "(", ")", ")", "FullFS", "+=", "\"+flat-for-global,+unaligned-access-mode,+trap-handler,\"", ";", "FullFS", "+=", "\"+enable-prt-strict-null,\"", ";", "if", "(", "FS", ".", "find_lower", "(", "\"+wavefrontsize\"", ")", "!=", "StringRef", "::", "npos", ")", "{", "if", "(", "FS", ".", "find_lower", "(", "\"wavefrontsize16\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize16,\"", ";", "if", "(", "FS", ".", "find_lower", "(", "\"wavefrontsize32\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize32,\"", ";", "if", "(", "FS", ".", "find_lower", "(", "\"wavefrontsize64\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize64,\"", ";", "}", "FullFS", "+=", "FS", ";", "ParseSubtargetFeatures", "(", "GPU", ",", "GPU", ",", "FullFS", ")", ";", "assert", "(", "!", "hasFP64", "(", ")", "||", "(", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", ")", ";", "if", "(", "!", "hasAddr64", "(", ")", "&&", "!", "FS", ".", "contains", "(", "\"flat-for-global\"", ")", ")", "{", "FlatForGlobal", "=", "true", ";", "}", "if", "(", "MaxPrivateElementSize", "==", "0", ")", "MaxPrivateElementSize", "=", "4", ";", "if", "(", "LDSBankCount", "==", "0", ")", "LDSBankCount", "=", "32", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "if", "(", "LocalMemorySize", "==", "0", ")", "LocalMemorySize", "=", "32768", ";", "if", "(", "!", "HasMovrel", "&&", "!", "HasVGPRIndexMode", ")", "HasMovrel", "=", "true", ";", "}", "if", "(", "WavefrontSizeLog2", "==", "0", ")", "WavefrontSizeLog2", "=", "5", ";", "HasFminFmaxLegacy", "=", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ";", "if", "(", "!", "FS", ".", "contains", "(", "\"+xnack\"", ")", "&&", "DoesNotSupportXNACK", "&&", "EnableXNACK", ")", "{", "ToggleFeature", "(", "AMDGPU", "::", "FeatureXNACK", ")", ";", "EnableXNACK", "=", "false", ";", "}", "if", "(", "DoesNotSupportSRAMECC", "&&", "EnableSRAMECC", ")", "{", "ToggleFeature", "(", "AMDGPU", "::", "FeatureSRAMECC", ")", ";", "EnableSRAMECC", "=", "false", ";", "}", "return", "*", "this", ";", "}", "</s>" ]

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

[ "AMDGPU", "256", "\"+promote-alloca,+load-store-opt,+enable-ds128,+sram-ecc,+xnack,\"", "\"+flat-for-global,+unaligned-access-mode,+trap-handler,\"", "\"+enable-prt-strict-null,\"", "\"+wavefrontsize\"", "\"wavefrontsize16\"", "\"-wavefrontsize16,\"", "\"wavefrontsize32\"", "\"-wavefrontsize32,\"", "\"wavefrontsize64\"", "\"-wavefrontsize64,\"", "AMDGPU", "\"flat-for-global\"", "0", "4", "0", "32", "0", "32768", "0", "5", "AMDGPU", "\"+xnack\"", "AMDGPU::FeatureXNACK", "AMDGPU::FeatureSRAMECC" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "areLoadsFromSameBasePtr", "(", "SDNode", "*", "Load1", ",", "SDNode", "*", "Load2", ",", "int64_t", "&", "Offset1", ",", "int64_t", "&", "Offset2", ")", "const", "{", "if", "(", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Load1", "->", "isMachineOpcode", "(", ")", "||", "!", "Load2", "->", "isMachineOpcode", "(", ")", ")", "return", "false", ";", "switch", "(", "Load1", "->", "getMachineOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "ARM", "::", "LDR", ":", "case", "ARM", "::", "LDRB", ":", "case", "ARM", "::", "LDRD", ":", "case", "ARM", "::", "LDRH", ":", "case", "ARM", "::", "LDRSB", ":", "case", "ARM", "::", "LDRSH", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "t2LDRi8", ":", "case", "ARM", "::", "t2LDRDi8", ":", "case", "ARM", "::", "t2LDRSHi8", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "t2LDRSHi12", ":", "break", ";", "}", "switch", "(", "Load2", "->", "getMachineOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "ARM", "::", "LDR", ":", "case", "ARM", "::", "LDRB", ":", "case", "ARM", "::", "LDRD", ":", "case", "ARM", "::", "LDRH", ":", "case", "ARM", "::", "LDRSB", ":", "case", "ARM", "::", "LDRSH", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "t2LDRi8", ":", "case", "ARM", "::", "t2LDRDi8", ":", "case", "ARM", "::", "t2LDRSHi8", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "t2LDRSHi12", ":", "break", ";", "}", "if", "(", "Load1", "->", "getOperand", "(", "0", ")", "!=", "Load2", "->", "getOperand", "(", "0", ")", "||", "Load1", "->", "getOperand", "(", "4", ")", "!=", "Load2", "->", "getOperand", "(", "4", ")", ")", "return", "false", ";", "if", "(", "Load1", "->", "getOperand", "(", "3", ")", "!=", "Load2", "->", "getOperand", "(", "3", ")", ")", "return", "false", ";", "if", "(", "isa", "<", "ConstantSDNode", ">", "(", "Load1", "->", "getOperand", "(", "1", ")", ")", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Load2", "->", "getOperand", "(", "1", ")", ")", ")", "{", "Offset1", "=", "cast", "<", "ConstantSDNode", ">", "(", "Load1", "->", "getOperand", "(", "1", ")", ")", "->", "getSExtValue", "(", ")", ";", "Offset2", "=", "cast", "<", "ConstantSDNode", ">", "(", "Load2", "->", "getOperand", "(", "1", ")", ")", "->", "getSExtValue", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "areLoadsFromSameBasePtr", "-", "This", "is", "used", "by", "the", "pre-regalloc", "scheduler", "to", "determine", "if", "two", "loads", "are", "loading", "from", "the", "same", "base", "address", "." ]

[ "ARM", "ARM", "ARM::LDR", "ARM::LDRB", "ARM::LDRD", "ARM::LDRH", "ARM::LDRSB", "ARM::LDRSH", "ARM::VLDRD", "ARM::VLDRS", "ARM::t2LDRi8", "ARM::t2LDRDi8", "ARM::t2LDRSHi8", "ARM::t2LDRi12", "ARM::t2LDRSHi12", "ARM::LDR", "ARM::LDRB", "ARM::LDRD", "ARM::LDRH", "ARM::LDRSB", "ARM::LDRSH", "ARM::VLDRD", "ARM::VLDRS", "ARM::t2LDRi8", "ARM::t2LDRDi8", "ARM::t2LDRSHi8", "ARM::t2LDRi12", "ARM::t2LDRSHi12", "0", "0", "4", "4", "3", "3", "1", "1", "1", "1" ]

[]

[ "<s>", "inline", "hashval_t", "mips_lo_sum_offset_hasher", "::", "hash", "(", "const", "mips_lo_sum_offset", "*", "entry", ")", "{", "return", "mips_hash_base", "(", "entry", "->", "base", ")", ";", "}", "</s>" ]

[ "Hash", "function", "for", "builtin", "functions", "with", "up", "to", "3", "arguments", "and", "a", "return", "type", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "WebAssemblyTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", ",", "MachineFunction", "&", ",", "bool", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", ")", "const", "{", "return", "Outs", ".", "size", "(", ")", "<=", "1", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "WebAssembly", "WebAssembly", "ISD::OutputArg", "1" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSUBCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMULCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ARMISD", "::", "VMOVRRD", ":", "return", "PerformVMOVRRDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ARMISD", "::", "VMOVDRR", ":", "return", "PerformVMOVDRRCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "PerformBUILD_VECTORCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformVECTOR_SHUFFLECombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ARMISD", "::", "VDUPLANE", ":", "return", "PerformVDUPLANECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "PerformIntrinsicCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "return", "PerformExtendCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "PerformSELECT_CCCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "ARM", "ARM", "ISD::ADD", "ISD::SUB", "ISD::MUL", "ISD::OR", "ISD::AND", "ARMISD::VMOVRRD", "ARMISD::VMOVDRR", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ARMISD::VDUPLANE", "ISD::INTRINSIC_WO_CHAIN", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "ISD::SELECT_CC" ]

[]

[ "<s>", "static", "bool", "mips_handle_option", "(", "size_t", "code", ",", "const", "char", "*", "arg", ",", "int", "value", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "code", ")", "{", "case", "OPT_mabi_", ":", "if", "(", "strcmp", "(", "arg", ",", "\"32\"", ")", "==", "0", ")", "mips_abi", "=", "ABI_32", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"o64\"", ")", "==", "0", ")", "mips_abi", "=", "ABI_O64", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"n32\"", ")", "==", "0", ")", "mips_abi", "=", "ABI_N32", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"64\"", ")", "==", "0", ")", "mips_abi", "=", "ABI_64", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"eabi\"", ")", "==", "0", ")", "mips_abi", "=", "ABI_EABI", ";", "else", "return", "false", ";", "return", "true", ";", "case", "OPT_march_", ":", "case", "OPT_mtune_", ":", "return", "mips_parse_cpu", "(", "arg", ")", "!=", "0", ";", "case", "OPT_mips", ":", "mips_isa_info", "=", "mips_parse_cpu", "(", "ACONCAT", "(", "(", "\"mips\"", ",", "arg", ",", "NULL", ")", ")", ")", ";", "return", "mips_isa_info", "!=", "0", ";", "case", "OPT_mno_flush_func", ":", "mips_cache_flush_func", "=", "NULL", ";", "return", "true", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_HANDLE_OPTION", "." ]

[ "mips", "\"32\"", "0", "\"o64\"", "0", "\"n32\"", "0", "\"64\"", "0", "\"eabi\"", "0", "0", "\"mips\"", "0" ]

[]

[ "<s>", "void", "HexagonHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", ")", "return", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "!", "MO", ".", "isImplicit", "(", ")", ")", "RegDefs", ".", "insert", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "TII", "->", "isZeroCost", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", ";", "if", "(", "!", "Resources", "->", "canReserveResources", "(", "*", "MI", ")", "||", "isNewStore", "(", "*", "MI", ")", ")", "{", "assert", "(", "TII", "->", "mayBeNewStore", "(", "*", "MI", ")", "&&", "\"Expecting .new store\"", ")", ";", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineInstr", "*", "NewMI", "=", "MF", "->", "CreateMachineInstr", "(", "TII", "->", "get", "(", "TII", "->", "getDotNewOp", "(", "*", "MI", ")", ")", ",", "MI", "->", "getDebugLoc", "(", ")", ")", ";", "if", "(", "Resources", "->", "canReserveResources", "(", "*", "NewMI", ")", ")", "Resources", "->", "reserveResources", "(", "*", "NewMI", ")", ";", "else", "Resources", "->", "reserveResources", "(", "*", "MI", ")", ";", "MF", "->", "deleteMachineInstr", "(", "NewMI", ")", ";", "}", "else", "Resources", "->", "reserveResources", "(", "*", "MI", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" Add instruction \"", "<<", "*", "MI", ")", ";", "if", "(", "TII", "->", "mayBeCurLoad", "(", "*", "MI", ")", ")", "for", "(", "auto", "&", "S", ":", "SU", "->", "Succs", ")", "if", "(", "S", ".", "isAssignedRegDep", "(", ")", "&&", "S", ".", "getLatency", "(", ")", "==", "0", "&&", "S", ".", "getSUnit", "(", ")", "->", "NumPredsLeft", "==", "1", ")", "{", "UsesDotCur", "=", "S", ".", "getSUnit", "(", ")", ";", "DotCurPNum", "=", "PacketNum", ";", "break", ";", "}", "if", "(", "SU", "==", "UsesDotCur", ")", "{", "UsesDotCur", "=", "nullptr", ";", "DotCurPNum", "=", "-", "1", ";", "}", "UsesLoad", "=", "MI", "->", "mayLoad", "(", ")", ";", "if", "(", "TII", "->", "isHVXVec", "(", "*", "MI", ")", "&&", "!", "MI", "->", "mayLoad", "(", ")", "&&", "!", "MI", "->", "mayStore", "(", ")", ")", "for", "(", "auto", "&", "S", ":", "SU", "->", "Succs", ")", "if", "(", "S", ".", "isAssignedRegDep", "(", ")", "&&", "S", ".", "getLatency", "(", ")", "==", "0", "&&", "TII", "->", "mayBeNewStore", "(", "*", "S", ".", "getSUnit", "(", ")", "->", "getInstr", "(", ")", ")", "&&", "Resources", "->", "canReserveResources", "(", "*", "S", ".", "getSUnit", "(", ")", "->", "getInstr", "(", ")", ")", ")", "{", "PrefVectorStoreNew", "=", "S", ".", "getSUnit", "(", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "Hexagon", "Hexagon", "\"Expecting .new store\"", "\" Add instruction \"", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "return", ";", "}", "if", "(", "!", "ST", ".", "isVGPRSpillingEnabled", "(", "*", "MF", "->", "getFunction", "(", ")", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "KILL", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::M0", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", "AMDGPU::KILL", "\"Only VGPR spilling expected\"", "0" ]

[]

[ "<s>", "bool", "ShouldShrinkFPConstant", "(", "EVT", "VT", ")", "const", "override", "{", "return", "VT", "!=", "MVT", "::", "f64", ";", "}", "</s>" ]

[ "If", "true", ",", "then", "instruction", "selection", "should", "seek", "to", "shrink", "the", "FP", "constant", "of", "the", "specified", "type", "to", "a", "smaller", "type", "in", "order", "to", "save", "space", "and", "/", "or", "reduce", "runtime", "." ]

[ "SystemZ", "MVT::f64" ]

[]

[ "<s>", "const", "SPIRVRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV" ]

[]

[ "<s>", "bool", "RISCVAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "ExtraCode", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "true", ";", "OS", "<<", "\"0(\"", "<<", "RISCVInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\")\"", ";", "return", "false", ";", "}", "return", "AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "RISCV", "RISCV", "\"0(\"", "RISCV", "\")\"" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "HandleByVal", "(", "CCState", "*", "State", ",", "unsigned", "&", "Size", ",", "unsigned", "Align", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFL", "=", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "assert", "(", "Size", "&&", "\"Byval argument's size shouldn't be 0.\"", ")", ";", "Align", "=", "std", "::", "min", "(", "Align", ",", "TFL", "->", "getStackAlignment", "(", ")", ")", ";", "unsigned", "FirstReg", "=", "0", ";", "unsigned", "NumRegs", "=", "0", ";", "if", "(", "State", "->", "getCallingConv", "(", ")", "!=", "CallingConv", "::", "Fast", ")", "{", "unsigned", "RegSizeInBytes", "=", "Subtarget", ".", "getGPRSizeInBytes", "(", ")", ";", "ArrayRef", "<", "MCPhysReg", ">", "IntArgRegs", "=", "ABI", ".", "GetByValArgRegs", "(", ")", ";", "const", "MCPhysReg", "*", "ShadowRegs", "=", "ABI", ".", "IsO32", "(", ")", "?", "IntArgRegs", ".", "data", "(", ")", ":", "Mips64DPRegs", ";", "assert", "(", "!", "(", "Align", "%", "RegSizeInBytes", ")", "&&", "\"Byval argument's alignment should be a multiple of\"", "\"RegSizeInBytes.\"", ")", ";", "FirstReg", "=", "State", "->", "getFirstUnallocated", "(", "IntArgRegs", ")", ";", "if", "(", "(", "Align", ">", "RegSizeInBytes", ")", "&&", "(", "FirstReg", "%", "2", ")", ")", "{", "State", "->", "AllocateReg", "(", "IntArgRegs", "[", "FirstReg", "]", ",", "ShadowRegs", "[", "FirstReg", "]", ")", ";", "++", "FirstReg", ";", "}", "Size", "=", "RoundUpToAlignment", "(", "Size", ",", "RegSizeInBytes", ")", ";", "for", "(", "unsigned", "I", "=", "FirstReg", ";", "Size", ">", "0", "&&", "(", "I", "<", "IntArgRegs", ".", "size", "(", ")", ")", ";", "Size", "-=", "RegSizeInBytes", ",", "++", "I", ",", "++", "NumRegs", ")", "State", "->", "AllocateReg", "(", "IntArgRegs", "[", "I", "]", ",", "ShadowRegs", "[", "I", "]", ")", ";", "}", "State", "->", "addInRegsParamInfo", "(", "FirstReg", ",", "FirstReg", "+", "NumRegs", ")", ";", "}", "</s>" ]

[ "Target-specific", "cleanup", "for", "formal", "ByVal", "parameters", "." ]

[ "Mips", "Mips", "\"Byval argument's size shouldn't be 0.\"", "0", "0", "Mips", "\"Byval argument's alignment should be a multiple of\"", "\"RegSizeInBytes.\"", "2", "0" ]

[]

[ "<s>", "void", "M88kPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "BranchRelaxation", ")", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "if", "(", "!", "DisableDelaySlotFiller", ")", "addPass", "(", "createM88kDelaySlotFiller", "(", ")", ")", ";", "}", "</s>" ]

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

[ "M88k", "M88k", "M88k" ]

[]