Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "arm_block_set_vect", "(", "rtx", "dstbase", ",", "unsigned", "HOST_WIDE_INT", "length", ",", "unsigned", "HOST_WIDE_INT", "value", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "(", "(", "align", "&", "3", ")", "!=", "0", "||", "(", "length", "&", "3", ")", "!=", "0", ")", "&&", "(", "!", "unaligned_access", "||", "BYTES_BIG_ENDIAN", ")", ")", "return", "false", ";", "if", "(", "(", "align", "&", "3", ")", "==", "0", ")", "return", "arm_block_set_aligned_vect", "(", "dstbase", ",", "length", ",", "value", ",", "align", ")", ";", "else", "return", "arm_block_set_unaligned_vect", "(", "dstbase", ",", "length", ",", "value", ",", "align", ")", ";", "}", "</s>" ]

[ "Set", "a", "block", "of", "memory", "using", "vectorization", "instructions", "for", "both", "aligned", "and", "unaligned", "cases", ".", "We", "fill", "the", "first", "LENGTH", "bytes", "of", "the", "memory", "area", "starting", "from", "DSTBASE", "with", "byte", "constant", "VALUE", ".", "ALIGN", "is", "the", "alignment", "requirement", "of", "memory", "." ]

[ "arm", "3", "0", "3", "0", "3", "0" ]

[]

[ "<s>", "rtx", "legitimize_pic_address", "(", "rtx", "orig", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "reg", ")", "{", "if", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", ")", "{", "rtx", "pic_ref", ",", "address", ";", "rtx", "insn", ";", "if", "(", "reg", "==", "0", ")", "{", "gcc_assert", "(", "!", "reload_in_progress", "&&", "!", "reload_completed", ")", ";", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "}", "if", "(", "flag_pic", "==", "2", ")", "{", "rtx", "temp_reg", "=", "(", "(", "reload_in_progress", "||", "reload_completed", ")", "?", "reg", ":", "gen_reg_rtx", "(", "Pmode", ")", ")", ";", "if", "(", "TARGET_ARCH64", ")", "{", "emit_insn", "(", "gen_movdi_high_pic", "(", "temp_reg", ",", "orig", ")", ")", ";", "emit_insn", "(", "gen_movdi_lo_sum_pic", "(", "temp_reg", ",", "temp_reg", ",", "orig", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_movsi_high_pic", "(", "temp_reg", ",", "orig", ")", ")", ";", "emit_insn", "(", "gen_movsi_lo_sum_pic", "(", "temp_reg", ",", "temp_reg", ",", "orig", ")", ")", ";", "}", "address", "=", "temp_reg", ";", "}", "else", "address", "=", "orig", ";", "pic_ref", "=", "gen_const_mem", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "address", ")", ")", ";", "current_function_uses_pic_offset_table", "=", "1", ";", "insn", "=", "emit_move_insn", "(", "reg", ",", "pic_ref", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_EQUAL", ",", "orig", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "return", "reg", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST", ")", "{", "rtx", "base", ",", "offset", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "orig", ",", "0", ")", ")", "==", "PLUS", "&&", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "0", ")", "==", "pic_offset_table_rtx", ")", "return", "orig", ";", "if", "(", "reg", "==", "0", ")", "{", "gcc_assert", "(", "!", "reload_in_progress", "&&", "!", "reload_completed", ")", ";", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "orig", ",", "0", ")", ")", "==", "PLUS", ")", ";", "base", "=", "legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "0", ")", ",", "Pmode", ",", "reg", ")", ";", "offset", "=", "legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "1", ")", ",", "Pmode", ",", "base", "==", "reg", "?", "0", ":", "reg", ")", ";", "if", "(", "GET_CODE", "(", "offset", ")", "==", "CONST_INT", ")", "{", "if", "(", "SMALL_INT", "(", "offset", ")", ")", "return", "plus_constant", "(", "base", ",", "INTVAL", "(", "offset", ")", ")", ";", "else", "if", "(", "!", "reload_in_progress", "&&", "!", "reload_completed", ")", "offset", "=", "force_reg", "(", "Pmode", ",", "offset", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", ")", "current_function_uses_pic_offset_table", "=", "1", ";", "return", "orig", ";", "}", "</s>" ]

[ "Legitimize", "PIC", "addresses", ".", "If", "the", "address", "is", "already", "position-independent", ",", "we", "return", "ORIG", ".", "Newly", "generated", "position-independent", "addresses", "go", "into", "a", "reg", ".", "This", "is", "REG", "if", "nonzero", ",", "otherwise", "we", "allocate", "register", "(", "s", ")", "as", "necessary", "." ]

[ "sparc", "0", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "bool", "RISCVRegisterInfo", "::", "isConstantPhysReg", "(", "MCRegister", "PhysReg", ")", "const", "{", "return", "PhysReg", "==", "RISCV", "::", "X0", ";", "}", "</s>" ]

[ "Returns", "true", "if", "PhysReg", "is", "unallocatable", "and", "constant", "throughout", "the", "function", "." ]

[ "RI5CY", "RISCV", "RISCV::X0" ]

[]

[ "<s>", "int", "m32c_legitimize_reload_address", "(", "rtx", "*", "x", ",", "machine_mode", "mode", ",", "int", "opnum", ",", "int", "type", ",", "int", "ind_levels", "ATTRIBUTE_UNUSED", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nm32c_legitimize_reload_address for mode %s\\n\"", ",", "mode_name", "[", "mode", "]", ")", ";", "debug_rtx", "(", "*", "x", ")", ";", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "*", "x", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "*", "x", ",", "0", ")", ")", "==", "FB_REGNO", "&&", "GET_CODE", "(", "XEXP", "(", "*", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "XEXP", "(", "*", "x", ",", "1", ")", ")", "<", "-", "128", "||", "INTVAL", "(", "XEXP", "(", "*", "x", ",", "1", ")", ")", ">", "(", "128", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", "{", "rtx", "sum", ";", "int", "offset", "=", "INTVAL", "(", "XEXP", "(", "*", "x", ",", "1", ")", ")", ";", "int", "adjustment", "=", "-", "BIG_FB_ADJ", ";", "sum", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "*", "x", ",", "0", ")", ",", "GEN_INT", "(", "adjustment", ")", ")", ";", "*", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "sum", ",", "GEN_INT", "(", "offset", "-", "adjustment", ")", ")", ";", "if", "(", "type", "==", "RELOAD_OTHER", ")", "type", "=", "RELOAD_FOR_OTHER_ADDRESS", ";", "push_reload", "(", "sum", ",", "NULL_RTX", ",", "&", "XEXP", "(", "*", "x", ",", "0", ")", ",", "NULL", ",", "A_REGS", ",", "Pmode", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "return", "1", ";", "}", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "*", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "*", "x", ",", "0", ")", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "XEXP", "(", "*", "x", ",", "0", ")", ",", "0", ")", ")", "==", "FB_REGNO", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "*", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "XEXP", "(", "*", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "if", "(", "type", "==", "RELOAD_OTHER", ")", "type", "=", "RELOAD_FOR_OTHER_ADDRESS", ";", "push_reload", "(", "XEXP", "(", "*", "x", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "*", "x", ",", "0", ")", ",", "NULL", ",", "A_REGS", ",", "Pmode", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "return", "1", ";", "}", "if", "(", "TARGET_A24", "&&", "GET_MODE", "(", "*", "x", ")", "==", "PSImode", ")", "{", "push_reload", "(", "*", "x", ",", "NULL_RTX", ",", "x", ",", "NULL", ",", "A_REGS", ",", "PSImode", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Implements", "LEGITIMIZE_RELOAD_ADDRESS", ".", "See", "comment", "above", "." ]

[ "m32c", "\"\\nm32c_legitimize_reload_address for mode %s\\n\"", "0", "0", "1", "1", "128", "1", "128", "1", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "1", "1", "0", "0", "0", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "SIWholeQuadMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Instructions", ".", "clear", "(", ")", ";", "Blocks", ".", "clear", "(", ")", ";", "LiveMaskQueries", ".", "clear", "(", ")", ";", "LowerToCopyInstrs", ".", "clear", "(", ")", ";", "LowerToMovInstrs", ".", "clear", "(", ")", ";", "CallingConv", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "char", "GlobalFlags", "=", "analyzeFunction", "(", "MF", ")", ";", "unsigned", "LiveMaskReg", "=", "0", ";", "unsigned", "Exec", "=", "ST", "->", "isWave32", "(", ")", "?", "AMDGPU", "::", "EXEC_LO", ":", "AMDGPU", "::", "EXEC", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWQM", ")", ")", "{", "lowerLiveMaskQueries", "(", "Exec", ")", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWWM", ")", "&&", "LowerToCopyInstrs", ".", "empty", "(", ")", "&&", "LowerToMovInstrs", ".", "empty", "(", ")", ")", "return", "!", "LiveMaskQueries", ".", "empty", "(", ")", ";", "}", "else", "{", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "EntryMI", "=", "Entry", ".", "getFirstNonPHI", "(", ")", ";", "if", "(", "GlobalFlags", "&", "StateExact", "||", "!", "LiveMaskQueries", ".", "empty", "(", ")", ")", "{", "LiveMaskReg", "=", "MRI", "->", "createVirtualRegister", "(", "TRI", "->", "getBoolRC", "(", ")", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "LiveMaskReg", ")", ".", "addReg", "(", "Exec", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "MI", ")", ";", "}", "lowerLiveMaskQueries", "(", "LiveMaskReg", ")", ";", "if", "(", "GlobalFlags", "==", "StateWQM", ")", "{", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ST", "->", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_WQM_B32", ":", "AMDGPU", "::", "S_WQM_B64", ")", ",", "Exec", ")", ".", "addReg", "(", "Exec", ")", ";", "lowerCopyInstrs", "(", ")", ";", "return", "true", ";", "}", "}", "LLVM_DEBUG", "(", "printInfo", "(", ")", ")", ";", "lowerCopyInstrs", "(", ")", ";", "for", "(", "auto", "BII", ":", "Blocks", ")", "processBlock", "(", "*", "BII", ".", "first", ",", "LiveMaskReg", ",", "BII", ".", "first", "==", "&", "*", "MF", ".", "begin", "(", ")", ")", ";", "LIS", "->", "removeRegUnit", "(", "*", "MCRegUnitIterator", "(", "AMDGPU", "::", "SCC", ",", "TRI", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "AMDGPU::EXEC_LO", "AMDGPU::EXEC", "AMDGPU::COPY", "AMDGPU::S_WQM_B32", "AMDGPU::S_WQM_B64", "AMDGPU::SCC" ]

[]

[ "<s>", "static", "bool", "or1k_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", ")", "{", "if", "(", "!", "flag_pic", ")", "return", "true", ";", "if", "(", "decl", "==", "NULL", ")", "return", "true", ";", "return", "targetm", ".", "binds_local_p", "(", "decl", ")", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_FUNCTION_OK_FOR_SIBCALL", ".", "Returns", "true", "if", "the", "function", "declared", "by", "DECL", "is", "ok", "for", "calling", "as", "a", "nested", "function", "." ]

[ "or1k" ]

[]

[ "<s>", "enum", "aarch64_symbol_type", "aarch64_classify_symbolic_expression", "(", "rtx", "x", ")", "{", "rtx", "offset", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "return", "aarch64_classify_symbol", "(", "x", ",", "INTVAL", "(", "offset", ")", ")", ";", "}", "</s>" ]

[ "Classify", "the", "base", "of", "symbolic", "expression", "X", ",", "given", "that", "X", "appears", "in", "context", "CONTEXT", "." ]

[ "aarch64" ]

[]

[ "<s>", "rtx", "get_unaligned_address", "(", "rtx", "ref", ",", "int", "extra_offset", ")", "{", "rtx", "base", ";", "HOST_WIDE_INT", "offset", "=", "0", ";", "gcc_assert", "(", "GET_CODE", "(", "ref", ")", "==", "MEM", ")", ";", "if", "(", "reload_in_progress", "&&", "!", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "XEXP", "(", "ref", ",", "0", ")", ")", ")", "{", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "0", ")", ")", ";", "gcc_assert", "(", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "base", ")", ")", ";", "}", "else", "base", "=", "XEXP", "(", "ref", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "offset", "+=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "return", "plus_constant", "(", "base", ",", "offset", "+", "extra_offset", ")", ";", "}", "</s>" ]

[ "Similar", ",", "but", "just", "get", "the", "address", ".", "Handle", "the", "two", "reload", "cases", ".", "Add", "EXTRA_OFFSET", "to", "the", "address", "we", "return", "." ]

[ "alpha", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "aarch64_sve_cnt_immediate_p", "(", "rtx", "x", ")", "{", "poly_int64", "value", ";", "return", "poly_int_rtx_p", "(", "x", ",", "&", "value", ")", "&&", "aarch64_sve_cnt_immediate_p", "(", "value", ")", ";", "}", "</s>" ]

[ "Likewise", "for", "rtx", "X", "." ]

[ "aarch64" ]

[]

[ "<s>", "inline", "bool", "function_base", "::", "has_merge_operand_p", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "We", "choose", "to", "return", "true", "by", "default", "since", "most", "of", "the", "intrinsics", "use", "has", "merge", "operand", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "cris_init_expanders", "(", ")", "{", "}", "</s>" ]

[ "The", "INIT_EXPANDERS", "worker", "sets", "the", "per-function-data", "initializer", "and", "mark", "functions", "." ]

[ "cris" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "3", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "Sparc", "0", "4", "3", "8", "0xff" ]

[]

[ "<s>", "bool", "pbsada_insn_ra_rb_dep_reg_p", "(", "rtx", "pbsada_insn", ",", "rtx", "def_reg", ")", "{", "rtx", "unspec_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "pbsada_insn", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "unspec_rtx", ")", "==", "UNSPEC", ")", ";", "rtx", "pbsada_ra", "=", "XVECEXP", "(", "unspec_rtx", ",", "0", ",", "0", ")", ";", "rtx", "pbsada_rb", "=", "XVECEXP", "(", "unspec_rtx", ",", "0", ",", "1", ")", ";", "if", "(", "rtx_equal_p", "(", "def_reg", ",", "pbsada_ra", ")", "||", "rtx_equal_p", "(", "def_reg", ",", "pbsada_rb", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Determine", "if", "the", "latency", "is", "occured", "when", "the", "consumer", "PBSADA_INSN", "uses", "the", "value", "of", "DEF_REG", "in", "its", "Ra", "or", "Rb", "fields", "." ]

[ "nds32", "0", "0", "0", "1" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "int", "m32c_leaf_function_p", "(", "void", ")", "{", "int", "rv", ";", "push_topmost_sequence", "(", ")", ";", "rv", "=", "leaf_function_p", "(", ")", ";", "pop_topmost_sequence", "(", ")", ";", "return", "rv", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "the", "current", "function", "is", "a", "leaf", ",", "and", "thus", "we", "can", "determine", "which", "registers", "an", "interrupt", "function", "really", "needs", "to", "save", ".", "The", "logic", "below", "is", "mostly", "about", "finding", "the", "insn", "sequence", "that", "'s", "the", "function", ",", "versus", "any", "sequence", "that", "might", "be", "open", "for", "the", "current", "insn", "." ]

[ "m32c" ]

[]

[ "<s>", "void", "HexagonInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "*", "MI", ")", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "*", "MI", ")", "<=", "HEXAGON_PACKET_SIZE", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "*", "MI", ")", ">", "0", ")", ";", "HasExtender", "=", "false", ";", "for", "(", "auto", "const", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "*", "MI", ")", ")", "{", "MCInst", "const", "&", "MCI", "=", "*", "I", ".", "getInst", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isDuplex", "(", "MII", ",", "MCI", ")", ")", "{", "printInstruction", "(", "MCI", ".", "getOperand", "(", "1", ")", ".", "getInst", "(", ")", ",", "OS", ")", ";", "OS", "<<", "'\\v'", ";", "HasExtender", "=", "false", ";", "printInstruction", "(", "MCI", ".", "getOperand", "(", "0", ")", ".", "getInst", "(", ")", ",", "OS", ")", ";", "}", "else", "printInstruction", "(", "&", "MCI", ",", "OS", ")", ";", "setExtender", "(", "MCI", ")", ";", "OS", "<<", "\"\\n\"", ";", "}", "auto", "Separator", "=", "\"\"", ";", "if", "(", "HexagonMCInstrInfo", "::", "isInnerLoop", "(", "*", "MI", ")", ")", "{", "OS", "<<", "Separator", ";", "Separator", "=", "\" \"", ";", "MCInst", "ME", ";", "ME", ".", "setOpcode", "(", "Hexagon", "::", "ENDLOOP0", ")", ";", "printInstruction", "(", "&", "ME", ",", "OS", ")", ";", "}", "if", "(", "HexagonMCInstrInfo", "::", "isOuterLoop", "(", "*", "MI", ")", ")", "{", "OS", "<<", "Separator", ";", "Separator", "=", "\" \"", ";", "MCInst", "ME", ";", "ME", ".", "setOpcode", "(", "Hexagon", "::", "ENDLOOP1", ")", ";", "printInstruction", "(", "&", "ME", ",", "OS", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "0", "Hexagon", "Hexagon", "1", "0", "\"\\n\"", "\"\"", "Hexagon", "\" \"", "Hexagon::ENDLOOP0", "Hexagon", "\" \"", "Hexagon::ENDLOOP1" ]

[]

[ "<s>", "void", "output_ascii", "(", "FILE", "*", "file", ",", "const", "char", "*", "p", ",", "int", "size", ")", "{", "int", "i", ";", "int", "chars_output", ";", "unsigned", "char", "partial_output", "[", "16", "]", ";", "fputs", "(", "\"\\t.STRING \\\"\"", ",", "file", ")", ";", "chars_output", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "size", ";", "i", "+=", "4", ")", "{", "int", "co", "=", "0", ";", "int", "io", "=", "0", ";", "for", "(", "io", "=", "0", ",", "co", "=", "0", ";", "io", "<", "MIN", "(", "4", ",", "size", "-", "i", ")", ";", "io", "++", ")", "{", "register", "unsigned", "int", "c", "=", "(", "unsigned", "char", ")", "p", "[", "i", "+", "io", "]", ";", "if", "(", "c", "==", "'\\\"'", "||", "c", "==", "'\\\\'", ")", "partial_output", "[", "co", "++", "]", "=", "'\\\\'", ";", "if", "(", "c", ">=", "' '", "&&", "c", "<", "0177", ")", "partial_output", "[", "co", "++", "]", "=", "c", ";", "else", "{", "unsigned", "int", "hexd", ";", "partial_output", "[", "co", "++", "]", "=", "'\\\\'", ";", "partial_output", "[", "co", "++", "]", "=", "'x'", ";", "hexd", "=", "c", "/", "16", "-", "0", "+", "'0'", ";", "if", "(", "hexd", ">", "'9'", ")", "hexd", "-=", "'9'", "-", "'a'", "+", "1", ";", "partial_output", "[", "co", "++", "]", "=", "hexd", ";", "hexd", "=", "c", "%", "16", "-", "0", "+", "'0'", ";", "if", "(", "hexd", ">", "'9'", ")", "hexd", "-=", "'9'", "-", "'a'", "+", "1", ";", "partial_output", "[", "co", "++", "]", "=", "hexd", ";", "}", "}", "if", "(", "chars_output", "+", "co", ">", "243", ")", "{", "fputs", "(", "\"\\\"\\n\\t.STRING \\\"\"", ",", "file", ")", ";", "chars_output", "=", "0", ";", "}", "fwrite", "(", "partial_output", ",", "1", ",", "(", "size_t", ")", "co", ",", "file", ")", ";", "chars_output", "+=", "co", ";", "co", "=", "0", ";", "}", "fputs", "(", "\"\\\"\\n\"", ",", "file", ")", ";", "}", "</s>" ]

[ "Output", "an", "assembler", "pseudo-op", "to", "write", "an", "ASCII", "string", "of", "N", "characters", "starting", "at", "P", "to", "FILE", ".", "On", "the", "RS/6000", ",", "we", "have", "to", "do", "this", "using", "the", ".byte", "operation", "and", "write", "out", "special", "characters", "outside", "the", "quoted", "string", ".", "Also", ",", "the", "assembler", "is", "broken", ";", "very", "long", "strings", "are", "truncated", ",", "so", "we", "must", "artificially", "break", "them", "up", "early", "." ]

[ "pa", "16", "\"\\t.STRING \\\"\"", "0", "0", "4", "0", "0", "0", "0", "4", "0177", "16", "0", "1", "16", "0", "1", "243", "\"\\\"\\n\\t.STRING \\\"\"", "0", "1", "0", "\"\\\"\\n\"" ]

[]

[ "<s>", "static", "bool", "str_prefix_p", "(", "const", "char", "*", "str", ",", "const", "char", "*", "prefix", ")", "{", "return", "0", "==", "strncmp", "(", "str", ",", "prefix", ",", "strlen", "(", "prefix", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "iff", "STR", "starts", "with", "PREFIX", "." ]

[ "avr", "0" ]

[]

[ "<s>", "bool", "Thumb1RegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVtgpr2gpr", ")", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "bool", "done", "=", "false", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "II", "=", "I", ";", "!", "done", "&&", "II", "!=", "UseMI", ";", "++", "II", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "II", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "II", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isUndef", "(", ")", "||", "!", "MO", ".", "getReg", "(", ")", "||", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "continue", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "R12", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "}", "}", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVgpr2tgpr", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Kill", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "ARM", "ARM::tMOVtgpr2gpr", "ARM::R12", "0", "ARM::R12", "ARM::tMOVgpr2tgpr", "ARM::R12" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "assert", "(", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "empty", "(", ")", "&&", "\"WebAssembly should not have callee-saved registers\"", ")", ";", "assert", "(", "!", "hasFP", "(", "MF", ")", "&&", "\"Functions needing frame pointers not yet supported\"", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", "&&", "(", "!", "MFI", "->", "adjustsStack", "(", ")", "||", "MFI", "->", "getMaxCallFrameSize", "(", ")", "==", "0", ")", ")", "return", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "adjustStackPointer", "(", "StackSize", ",", "false", ",", "MF", ",", "MBB", ",", "TII", ",", "InsertPt", ",", "DL", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"WebAssembly should not have callee-saved registers\"", "\"Functions needing frame pointers not yet supported\"", "0", "WebAssembly" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "*", "MIa", ",", "MachineInstr", "*", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "unsigned", "Opc0", "=", "MIa", "->", "getOpcode", "(", ")", ";", "unsigned", "Opc1", "=", "MIb", "->", "getOpcode", "(", ")", ";", "assert", "(", "MIa", "&&", "(", "MIa", "->", "mayLoad", "(", ")", "||", "MIa", "->", "mayStore", "(", ")", ")", "&&", "\"MIa must load from or modify a memory location\"", ")", ";", "assert", "(", "MIb", "&&", "(", "MIb", "->", "mayLoad", "(", ")", "||", "MIb", "->", "mayStore", "(", ")", ")", "&&", "\"MIb must load from or modify a memory location\"", ")", ";", "if", "(", "MIa", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", "->", "hasUnmodeledSideEffects", "(", ")", ")", "return", "false", ";", "if", "(", "MIa", "->", "hasOrderedMemoryRef", "(", ")", "||", "MIb", "->", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "isDS", "(", "Opc0", ")", ")", "{", "if", "(", "isDS", "(", "Opc1", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "Opc1", ")", ";", "}", "if", "(", "isMUBUF", "(", "Opc0", ")", "||", "isMTBUF", "(", "Opc0", ")", ")", "{", "if", "(", "isMUBUF", "(", "Opc1", ")", "||", "isMTBUF", "(", "Opc1", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "Opc1", ")", "&&", "!", "isSMRD", "(", "Opc1", ")", ";", "}", "if", "(", "isSMRD", "(", "Opc0", ")", ")", "{", "if", "(", "isSMRD", "(", "Opc1", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "Opc1", ")", "&&", "!", "isMUBUF", "(", "Opc0", ")", "&&", "!", "isMTBUF", "(", "Opc0", ")", ";", "}", "if", "(", "isFLAT", "(", "Opc0", ")", ")", "{", "if", "(", "isFLAT", "(", "Opc1", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"MIa must load from or modify a memory location\"", "\"MIb must load from or modify a memory location\"" ]

[]

[ "<s>", "bool", "aarch64_madd_needs_nop", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_type", "attr_type", ";", "rtx_insn", "*", "prev", ";", "rtx", "body", ";", "if", "(", "!", "aarch64_fix_a53_err835769", ")", "return", "false", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "false", ";", "attr_type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "!", "is_madd_op", "(", "attr_type", ")", ")", "return", "false", ";", "prev", "=", "aarch64_prev_real_insn", "(", "insn", ")", ";", "extract_constrain_insn_cached", "(", "insn", ")", ";", "if", "(", "!", "prev", "||", "!", "has_memory_op", "(", "prev", ")", ")", "return", "false", ";", "body", "=", "single_set", "(", "prev", ")", ";", "if", "(", "GET_MODE", "(", "recog_data", ".", "operand", "[", "0", "]", ")", "==", "DImode", "&&", "(", "!", "body", "||", "!", "dep_between_memop_and_curr", "(", "body", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "When", "working", "around", "the", "Cortex-A53", "erratum", "835769", ",", "given", "rtx_insn", "INSN", ",", "return", "true", "if", "it", "is", "a", "64-bit", "multiply-accumulate", "instruction", "and", "has", "a", "preceding", "memory", "instruction", "such", "that", "a", "NOP", "should", "be", "inserted", "between", "them", "." ]

[ "aarch64", "0", "0" ]

[]

[ "<s>", "SDValue", "HSAILTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "HSAILMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "HSAILMachineFunctionInfo", ">", "(", ")", ";", "HSAILParamManager", "&", "PM", "=", "FuncInfo", "->", "getParamManager", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "FunctionType", "*", "funcType", "=", "F", "->", "getFunctionType", "(", ")", ";", "SmallVector", "<", "SDValue", ",", "6", ">", "RetOps", ";", "RetOps", ".", "push_back", "(", "Chain", ")", ";", "const", "DataLayout", "&", "DL", "=", "F", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "Type", "*", "type", "=", "funcType", "->", "getReturnType", "(", ")", ";", "if", "(", "!", "type", "->", "isVoidTy", "(", ")", ")", "{", "Mangler", "Mang", ";", "const", "char", "*", "SymName", "=", "PM", ".", "getParamName", "(", "PM", ".", "addReturnParam", "(", "type", ",", "PM", ".", "mangleArg", "(", "&", "Mang", ",", "F", "->", "getName", "(", ")", ",", "DL", ")", ")", ")", ";", "MVT", "ArgPtrVT", "=", "getPointerTy", "(", "DL", ",", "HSAILAS", "::", "ARG_ADDRESS", ")", ";", "SDValue", "RetVariable", "=", "DAG", ".", "getTargetExternalSymbol", "(", "SymName", ",", "ArgPtrVT", ")", ";", "AAMDNodes", "MD", ";", "unsigned", "ArgNo", "=", "0", ";", "LowerArgument", "(", "Chain", ",", "SDValue", "(", ")", ",", "false", ",", "nullptr", ",", "&", "Outs", ",", "dl", ",", "DAG", ",", "&", "RetOps", ",", "ArgNo", ",", "type", ",", "HSAILAS", "::", "ARG_ADDRESS", ",", "nullptr", ",", "RetVariable", ",", "&", "OutVals", ",", "false", ",", "MD", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "HSAILISD", "::", "RET", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "HSAIL", "HSAIL", "ISD::OutputArg", "HSAIL", "HSAIL", "HSAIL", "6", "HSAILAS::ARG_ADDRESS", "0", "HSAILAS::ARG_ADDRESS", "ISD::TokenFactor", "MVT::Other", "HSAILISD::RET", "MVT::Other" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "LC3" ]

[]

[ "<s>", "MachineBasicBlock", "::", "instr_iterator", "skip", "(", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "Index", ")", "{", "auto", "I", "=", "MBB", "->", "instr_begin", "(", ")", ";", "auto", "E", "=", "MBB", "->", "instr_end", "(", ")", ";", "unsigned", "Cur", "=", "0", ";", "while", "(", "I", "!=", "E", "&&", "Cur", "!=", "Index", ")", "++", "I", ",", "++", "Cur", ";", "return", "++", "I", ";", "}", "</s>" ]

[ "Advance", "the", "Cursor", "position", "by", "the", "given", "number", "of", "bytes", "." ]

[ "X86", "0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUInstrInfo", "::", "expandPostRAPseudo", "(", "MI", ")", ";", "case", "AMDGPU", "::", "SI_CONSTDATA_PTR", ":", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "RegLo", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "sub0", ")", ";", "unsigned", "RegHi", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "sub1", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_GETPC_B64", ")", ",", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADD_U32", ")", ",", "RegLo", ")", ".", "addReg", "(", "RegLo", ")", ".", "addTargetIndex", "(", "AMDGPU", "::", "TI_CONSTDATA_START", ")", ".", "addReg", "(", "AMDGPU", "::", "SCC", ",", "RegState", "::", "Define", "|", "RegState", "::", "Implicit", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADDC_U32", ")", ",", "RegHi", ")", ".", "addReg", "(", "RegHi", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "AMDGPU", "::", "SCC", ",", "RegState", "::", "Define", "|", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "AMDGPU", "::", "SCC", ",", "RegState", "::", "Implicit", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "R600", "SI", "SI", "0", "0" ]

[]

[ "<s>", "SDValue", "WDC65816TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "WDC65816", "WDC", "\"Should not custom lower this!\"", "ISD::GlobalAddress" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "case", "'r'", ":", "break", ";", "}", "}", "AMDGPUInstPrinter", "::", "printRegOperand", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", ",", "O", ",", "*", "TM", ".", "getSubtargetImpl", "(", "*", "MF", "->", "getFunction", "(", ")", ")", "->", "getRegisterInfo", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

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

[]

[ "<s>", "static", "rtx", "pru_add_to_sp", "(", "int", "addendum", ",", "const", "enum", "reg_note", "kind", ")", "{", "return", "pru_add3_frame_adjust", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "addendum", ",", "kind", ")", ";", "}", "</s>" ]

[ "Add", "a", "const_int", "to", "the", "stack", "pointer", "register", "." ]

[ "pru" ]

[]

[ "<s>", "void", "mt_set_memflags", "(", "rtx", "ref", ")", "{", "rtx", "insn", ";", "int", "in_struct_p", ",", "volatile_p", ";", "if", "(", "GET_CODE", "(", "ref", ")", "!=", "MEM", ")", "return", ";", "in_struct_p", "=", "MEM_IN_STRUCT_P", "(", "ref", ")", ";", "volatile_p", "=", "MEM_VOLATILE_P", "(", "ref", ")", ";", "if", "(", "!", "in_struct_p", "&&", "!", "volatile_p", ")", "return", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "mt_set_memflags_1", "(", "insn", ",", "in_struct_p", ",", "volatile_p", ")", ";", "}", "</s>" ]

[ "Look", "for", "any", "MEMs", "in", "the", "current", "sequence", "of", "insns", "and", "set", "the", "in-struct", ",", "unchanging", ",", "and", "volatile", "flags", "from", "the", "flags", "in", "REF", ".", "If", "REF", "is", "not", "a", "MEM", ",", "do", "n't", "do", "anything", "." ]

[ "mt" ]

[]

[ "<s>", "bool", "NVPTXTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "{", "if", "(", "AM", ".", "BaseOffs", "||", "AM", ".", "HasBaseReg", "||", "AM", ".", "Scale", ")", "return", "false", ";", "return", "true", ";", "}", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "AM", ".", "HasBaseReg", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "NVPTX", "NVPTX", "0", "1" ]

[]

[ "<s>", "bool", "FixupLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "MF", "=", "&", "Func", ";", "TM", "=", "&", "Func", ".", "getTarget", "(", ")", ";", "const", "X86Subtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "LEAusesAG", "(", ")", "&&", "!", "ST", ".", "slowLEA", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "X86InstrInfo", "*", ">", "(", "TM", "->", "getInstrInfo", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupLEAs\\n\"", ";", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "Func", ".", "begin", "(", ")", ",", "E", "=", "Func", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processBasicBlock", "(", "Func", ",", "I", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupLEAs\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"Start X86FixupLEAs\\n\"", "\"End X86FixupLEAs\\n\"" ]

[]

[ "<s>", "void", "SparcPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", "&", "getSparcTargetMachine", "(", ")", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "Sparc", "Sparc", "Sparc" ]

[]

[ "<s>", "int", "const_ok_for_arm", "(", "HOST_WIDE_INT", "i", ")", "{", "int", "lowbit", ";", "if", "(", "(", "i", "&", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "0xffffffff", ")", "!=", "0", "&&", "(", "(", "i", "&", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "0xffffffff", ")", "!=", "(", "(", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "0", ")", "&", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "0xffffffff", ")", ")", ")", "return", "FALSE", ";", "i", "&=", "(", "unsigned", "HOST_WIDE_INT", ")", "0xffffffff", ";", "if", "(", "(", "i", "&", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "0xff", ")", "==", "0", ")", "return", "TRUE", ";", "lowbit", "=", "(", "ffs", "(", "(", "int", ")", "i", ")", "-", "1", ")", "&", "~", "1", ";", "if", "(", "(", "i", "&", "~", "(", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "0xff", ")", "<<", "lowbit", ")", ")", "==", "0", ")", "return", "TRUE", ";", "else", "if", "(", "lowbit", "<=", "4", "&&", "(", "(", "i", "&", "~", "0xc000003f", ")", "==", "0", "||", "(", "i", "&", "~", "0xf000000f", ")", "==", "0", "||", "(", "i", "&", "~", "0xfc000003", ")", "==", "0", ")", ")", "return", "TRUE", ";", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "int", "I", "is", "a", "valid", "immediate", "ARM", "constant", "." ]

[ "arm", "0xffffffff", "0", "0xffffffff", "0", "0xffffffff", "0xffffffff", "0xff", "0", "1", "1", "0xff", "0", "4", "0xc000003f", "0", "0xf000000f", "0", "0xfc000003", "0" ]

[]

[ "<s>", "void", "nds32_asm_file_start_for_isr", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NDS32_N_ISR_VECTORS", ";", "i", "++", ")", "{", "nds32_isr_vectors", "[", "i", "]", ".", "category", "=", "NDS32_ISR_NONE", ";", "strcpy", "(", "nds32_isr_vectors", "[", "i", "]", ".", "func_name", ",", "\"\"", ")", ";", "nds32_isr_vectors", "[", "i", "]", ".", "save_reg", "=", "NDS32_PARTIAL_SAVE", ";", "nds32_isr_vectors", "[", "i", "]", ".", "nested_type", "=", "NDS32_NOT_NESTED", ";", "nds32_isr_vectors", "[", "i", "]", ".", "total_n_vectors", "=", "0", ";", "strcpy", "(", "nds32_isr_vectors", "[", "i", "]", ".", "nmi_name", ",", "\"\"", ")", ";", "strcpy", "(", "nds32_isr_vectors", "[", "i", "]", ".", "warm_name", ",", "\"\"", ")", ";", "}", "}", "</s>" ]

[ "A", "helper", "function", "to", "handle", "isr", "stuff", "at", "the", "beginning", "of", "asm", "file", "." ]

[ "nds32", "0", "\"\"", "0", "\"\"", "\"\"" ]

[]

[ "<s>", "void", "AArch64AsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "EmitHwasanMemaccessSymbols", "(", "M", ")", ";", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "MachineModuleInfoMachO", "&", "MMIMacho", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ";", "auto", "Stubs", "=", "MMIMacho", ".", "getAuthGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "OutContext", ".", "getMachOSection", "(", "\"__DATA\"", ",", "\"__auth_ptr\"", ",", "MachO", "::", "S_REGULAR", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ")", ";", "emitAlignment", "(", "Align", "(", "8", ")", ")", ";", "for", "(", "auto", "&", "Stub", ":", "Stubs", ")", "emitAuthenticatedPointer", "(", "*", "OutStreamer", ",", "Stub", ".", "first", ",", "Stub", ".", "second", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "OutStreamer", "->", "emitAssemblerFlag", "(", "MCAF_SubsectionsViaSymbols", ")", ";", "}", "emitStackMaps", "(", "SM", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"__DATA\"", "\"__auth_ptr\"", "8" ]

[]

[ "<s>", "void", "output_pcrel_opt_reloc", "(", "rtx", "label_num", ")", "{", "rtx", "operands", "[", "1", "]", "=", "{", "label_num", "}", ";", "output_asm_insn", "(", "\".reloc .Lpcrel%0-8,R_PPC64_PCREL_OPT,.-(.Lpcrel%0-8)\"", ",", "operands", ")", ";", "}", "</s>" ]

[ "Emit", "the", "relocation", "to", "tie", "the", "next", "instruction", "to", "a", "previous", "instruction", "that", "loads", "up", "an", "external", "address", ".", "This", "is", "used", "to", "do", "the", "PCREL_OPT", "optimization", ".", "Note", ",", "the", "label", "is", "generated", "after", "the", "PLD", "of", "the", "got", "pc-relative", "address", "to", "allow", "for", "the", "assembler", "to", "insert", "NOPs", "before", "the", "PLD", "instruction", ".", "The", "operand", "is", "a", "constant", "integer", "that", "is", "the", "label", "number", "." ]

[ "rs6000", "1", "\".reloc .Lpcrel%0-8,R_PPC64_PCREL_OPT,.-(.Lpcrel%0-8)\"" ]

[]

[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", ")", "const", "override", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "MSP430", "MVT::i8" ]

[]

[ "<s>", "static", "void", "nvptx_init_axis_predicate", "(", "FILE", "*", "file", ",", "int", "regno", ",", "const", "char", "*", "name", ")", "{", "fprintf", "(", "file", ",", "\"\\t{\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\t.reg.u32\\t%%%s;\\n\"", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tmov.u32\\t%%%s, %%tid.%s;\\n\"", ",", "name", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tsetp.ne.u32\\t%%r%d, %%%s, 0;\\n\"", ",", "regno", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t}\\n\"", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "initialize", "the", "REGNO", "predicate", "register", "to", "indicate", "whether", "we", "are", "not", "lane", "zero", "on", "the", "NAME", "axis", "." ]

[ "nvptx", "\"\\t{\\n\"", "\"\\t\\t.reg.u32\\t%%%s;\\n\"", "\"\\t\\tmov.u32\\t%%%s, %%tid.%s;\\n\"", "\"\\t\\tsetp.ne.u32\\t%%r%d, %%%s, 0;\\n\"", "\"\\t}\\n\"" ]

[]

[ "<s>", "void", "arm_emit_call_insn", "(", "rtx", "pat", ",", "rtx", "addr", ",", "bool", "sibcall", ")", "{", "rtx", "insn", ";", "insn", "=", "emit_call_insn", "(", "pat", ")", ";", "if", "(", "TARGET_VXWORKS_RTP", "&&", "flag_pic", "&&", "!", "sibcall", "&&", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", "&&", "(", "SYMBOL_REF_DECL", "(", "addr", ")", "?", "!", "targetm", ".", "binds_local_p", "(", "SYMBOL_REF_DECL", "(", "addr", ")", ")", ":", "!", "SYMBOL_REF_LOCAL_P", "(", "addr", ")", ")", ")", "{", "require_pic_register", "(", "NULL_RTX", ",", "false", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "cfun", "->", "machine", "->", "pic_reg", ")", ";", "}", "if", "(", "TARGET_AAPCS_BASED", ")", "{", "rtx", "*", "fusage", "=", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ";", "clobber_reg", "(", "fusage", ",", "gen_rtx_REG", "(", "word_mode", ",", "IP_REGNUM", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "call", "instruction", "with", "pattern", "PAT", ".", "ADDR", "is", "the", "address", "of", "the", "call", "target", "." ]

[ "arm" ]

[]

[ "<s>", "virtual", "SMLoc", "getStartLoc", "(", ")", "const", "LLVM_OVERRIDE", "{", "return", "StartLoc", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "SystemZ" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ARMTargetLowering", "::", "getRegClassFor", "(", "MVT", "VT", ",", "bool", "isDivergent", ")", "const", "{", "(", "void", ")", "isDivergent", ";", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", "||", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", ")", "{", "if", "(", "VT", "==", "MVT", "::", "v4i64", ")", "return", "&", "ARM", "::", "QQPRRegClass", ";", "if", "(", "VT", "==", "MVT", "::", "v8i64", ")", "return", "&", "ARM", "::", "QQQQPRRegClass", ";", "}", "return", "TargetLowering", "::", "getRegClassFor", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "class", "that", "should", "be", "used", "for", "the", "specified", "value", "type", "." ]

[ "ARM", "ARM", "MVT::v4i64", "ARM::QQPRRegClass", "MVT::v8i64", "ARM::QQQQPRRegClass" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getTypeForExtReturn", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ",", "ISD", "::", "NodeType", "ExtendKind", ")", "const", "{", "MVT", "ReturnMVT", "=", "MVT", "::", "i32", ";", "bool", "Darwin", "=", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isOSDarwin", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i1", "||", "(", "!", "Darwin", "&&", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", ")", ")", ")", "{", "ReturnMVT", "=", "MVT", "::", "i8", ";", "}", "EVT", "MinVT", "=", "getRegisterType", "(", "Context", ",", "ReturnMVT", ")", ";", "return", "VT", ".", "bitsLT", "(", "MinVT", ")", "?", "MinVT", ":", "VT", ";", "}", "</s>" ]

[ "Return", "the", "type", "that", "should", "be", "used", "to", "zero", "or", "sign", "extend", "a", "zeroext/signext", "integer", "return", "value", "." ]

[ "X86", "X86", "ISD::NodeType", "MVT::i32", "MVT::i1", "MVT::i8", "MVT::i16", "MVT::i8" ]

[]

[ "<s>", "void", "MipsTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "const", "MipsSubtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isABI_N64", "(", ")", "||", "Subtarget", ".", "isABI_N32", "(", ")", ")", "ReginfoSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".MIPS.options\"", ",", "ELF", "::", "SHT_MIPS_OPTIONS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MIPS_NOSTRIP", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "else", "ReginfoSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".reginfo\"", ",", "ELF", "::", "SHT_MIPS_REGINFO", ",", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "Mips", "Mips", "\".sdata\"", "\".sbss\"", "Mips", "Mips", "\".MIPS.options\"", "\".reginfo\"" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonNewValueJump", "(", ")", ")", ";", "addPass", "(", "createHexagonBranchRelaxation", "(", ")", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "addPass", "(", "createHexagonFixupHwLoops", "(", ")", ")", ";", "if", "(", "EnableGenMux", ")", "addPass", "(", "createHexagonGenMux", "(", ")", ")", ";", "}", "addPass", "(", "createHexagonPacketizer", "(", "NoOpt", ")", ",", "false", ")", ";", "if", "(", "EnableVectorPrint", ")", "addPass", "(", "createHexagonVectorPrint", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonCallFrameInformation", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "MCS51FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MCS51MachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "MCS51MachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", "&&", "!", "AFI", "->", "isInterruptOrSignalHandler", "(", ")", ")", "{", "return", ";", "}", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "assert", "(", "MBBI", "->", "getDesc", "(", ")", ".", "isReturn", "(", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", "-", "AFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "const", "MCS51Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "MCS51Subtarget", ">", "(", ")", ";", "const", "MCS51InstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "FrameSize", ")", "{", "restoreStatusRegister", "(", "MF", ",", "MBB", ")", ";", "return", ";", "}", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "int", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "MCS51", "::", "POPRd", "&&", "Opc", "!=", "MCS51", "::", "POPWRd", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "{", "break", ";", "}", "--", "MBBI", ";", "}", "unsigned", "Opcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "FrameSize", ")", ")", "{", "Opcode", "=", "MCS51", "::", "ADIWRdK", ";", "}", "else", "{", "Opcode", "=", "MCS51", "::", "SUBIWRdK", ";", "FrameSize", "=", "-", "FrameSize", ";", "}", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "MCS51", "::", "R29R28", ")", ".", "addReg", "(", "MCS51", "::", "R29R28", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "FrameSize", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MCS51", "::", "SPWRITE", ")", ",", "MCS51", "::", "SP", ")", ".", "addReg", "(", "MCS51", "::", "R29R28", ",", "RegState", "::", "Kill", ")", ";", "restoreStatusRegister", "(", "MF", ",", "MBB", ")", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51", "MCS51", "\"Can only insert epilog into returning blocks\"", "MCS51", "MCS51", "MCS51", "MCS51::POPRd", "MCS51::POPWRd", "6", "MCS51::ADIWRdK", "MCS51::SUBIWRdK", "MCS51::R29R28", "MCS51::R29R28", "3", "MCS51::SPWRITE", "MCS51::SP", "MCS51::R29R28" ]

[]

[ "<s>", "static", "bool", "ix86_unordered_fp_compare", "(", "enum", "rtx_code", "code", ")", "{", "if", "(", "!", "TARGET_IEEE_FP", ")", "return", "false", ";", "switch", "(", "code", ")", "{", "case", "LT", ":", "case", "LE", ":", "case", "GT", ":", "case", "GE", ":", "case", "LTGT", ":", "return", "false", ";", "case", "EQ", ":", "case", "NE", ":", "case", "UNORDERED", ":", "case", "ORDERED", ":", "case", "UNLT", ":", "case", "UNLE", ":", "case", "UNGT", ":", "case", "UNGE", ":", "case", "UNEQ", ":", "return", "true", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Figure", "out", "whether", "to", "use", "unordered", "fp", "comparisons", "." ]

[ "i386" ]

[]

[ "<s>", "void", "pa_output_addr_vec", "(", "rtx", "lab", ",", "rtx", "body", ")", "{", "int", "idx", ",", "vlen", "=", "XVECLEN", "(", "body", ",", "0", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "lab", ")", ")", ";", "if", "(", "TARGET_GAS", ")", "fputs", "(", "\"\\t.begin_brtab\\n\"", ",", "asm_out_file", ")", ";", "for", "(", "idx", "=", "0", ";", "idx", "<", "vlen", ";", "idx", "++", ")", "{", "ASM_OUTPUT_ADDR_VEC_ELT", "(", "asm_out_file", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "XVECEXP", "(", "body", ",", "0", ",", "idx", ")", ",", "0", ")", ")", ")", ";", "}", "if", "(", "TARGET_GAS", ")", "fputs", "(", "\"\\t.end_brtab\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Output", "address", "vector", "." ]

[ "pa", "0", "\"L\"", "\"\\t.begin_brtab\\n\"", "0", "0", "0", "\"\\t.end_brtab\\n\"" ]

[]

[ "<s>", "void", "X86RegisterBankInfo", "::", "applyMappingImpl", "(", "const", "OperandsMapper", "&", "OpdMapper", ")", "const", "{", "return", "applyDefaultMapping", "(", "OpdMapper", ")", ";", "}", "</s>" ]

[ "See", "RegisterBankInfo", ":", ":applyMapping", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "MipsRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "if", "(", "Subtarget", ".", "isSingleFloat", "(", ")", ")", "return", "CSR_SingleFloatOnly_SaveList", ";", "if", "(", "Subtarget", ".", "isABI_N64", "(", ")", ")", "return", "CSR_N64_SaveList", ";", "if", "(", "Subtarget", ".", "isABI_N32", "(", ")", ")", "return", "CSR_N32_SaveList", ";", "if", "(", "Subtarget", ".", "isFP64bit", "(", ")", ")", "return", "CSR_O32_FP64_SaveList", ";", "if", "(", "Subtarget", ".", "isFPXX", "(", ")", ")", "return", "CSR_O32_FPXX_SaveList", ";", "return", "CSR_O32_SaveList", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"<--------->\\n\"", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "uint64_t", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "int64_t", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", ")", ";", "eliminateFI", "(", "MI", ",", "FIOperandNum", ",", "FrameIndex", ",", "stackSize", ",", "spOffset", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "Mips", "Mips", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"" ]

[]

[ "<s>", "MCOperand", "PTXAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ")", "{", "MCOperand", "MCOp", ";", "const", "PTXMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "PTXMachineFunctionInfo", ">", "(", ")", ";", "const", "MCExpr", "*", "Expr", ";", "const", "char", "*", "RegSymbolName", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "RegSymbolName", "=", "MFI", "->", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ";", "Expr", "=", "MCSymbolRefExpr", "::", "Create", "(", "RegSymbolName", ",", "MCSymbolRefExpr", "::", "VK_None", ",", "OutContext", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "Expr", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "OutContext", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "Mang", "->", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "APFloat", "Val", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ";", "bool", "ignored", ";", "Val", ".", "convert", "(", "APFloat", "::", "IEEEdouble", ",", "APFloat", "::", "rmTowardZero", ",", "&", "ignored", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateFPImm", "(", "Val", ".", "convertToDouble", "(", ")", ")", ";", "break", ";", "}", "return", "MCOp", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "PTX", "PTX", "PTX", "PTX", "\"Unknown operand type\"" ]

[]

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

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

[ "LC2200", "LC2200", "LC2200" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createARMMachObjectWriter", "(", "OS", ",", "false", ",", "MachO", "::", "CPU_TYPE_ARM", ",", "Subtype", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

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

[]

[ "<s>", "void", "microblaze_asm_output_ident", "(", "const", "char", "*", "string", ")", "{", "const", "char", "*", "section_asm_op", ";", "int", "size", ";", "char", "*", "buf", ";", "if", "(", "symtab", "->", "state", "!=", "PARSING", ")", "return", ";", "size", "=", "strlen", "(", "string", ")", "+", "1", ";", "if", "(", "size", "<=", "microblaze_section_threshold", ")", "section_asm_op", "=", "SDATA2_SECTION_ASM_OP", ";", "else", "section_asm_op", "=", "READONLY_DATA_SECTION_ASM_OP", ";", "buf", "=", "ACONCAT", "(", "(", "section_asm_op", ",", "\"\\n\\t.ascii \\\"\"", ",", "string", ",", "\"\\\\0\\\"\\n\"", ",", "NULL", ")", ")", ";", "symtab", "->", "finalize_toplevel_asm", "(", "build_string", "(", "strlen", "(", "buf", ")", ",", "buf", ")", ")", ";", "}", "</s>" ]

[ "Queue", "an", ".ident", "string", "in", "the", "queue", "of", "top-level", "asm", "statements", ".", "If", "the", "string", "size", "is", "below", "the", "threshold", ",", "put", "it", "into", ".sdata2", ".", "If", "the", "front-end", "is", "done", ",", "we", "must", "be", "being", "called", "from", "toplev.cc", ".", "In", "that", "case", ",", "do", "nothing", "." ]

[ "microblaze", "1", "\"\\n\\t.ascii \\\"\"", "\"\\\\0\\\"\\n\"" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "override", "{", "static", "const", "uint32_t", "Nopcode", "=", "0x7f000000", ",", "ParseIn", "=", "0x00004000", ",", "ParseEnd", "=", "0x0000c000", ";", "while", "(", "Count", "%", "HEXAGON_INSTR_SIZE", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Alignment not a multiple of the instruction size:\"", "<<", "Count", "%", "HEXAGON_INSTR_SIZE", "<<", "\"/\"", "<<", "HEXAGON_INSTR_SIZE", "<<", "\"\\n\"", ")", ";", "--", "Count", ";", "OW", "->", "write8", "(", "0", ")", ";", "}", "while", "(", "Count", ")", "{", "Count", "-=", "HEXAGON_INSTR_SIZE", ";", "uint32_t", "ParseBits", "=", "(", "Count", "%", "(", "HEXAGON_PACKET_SIZE", "*", "HEXAGON_INSTR_SIZE", ")", ")", "?", "ParseIn", ":", "ParseEnd", ";", "OW", "->", "write32", "(", "Nopcode", "|", "ParseBits", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "Hexagon", "0x7f000000", "0x00004000", "0x0000c000", "\"Alignment not a multiple of the instruction size:\"", "\"/\"", "\"\\n\"", "0" ]

[]

[ "<s>", "void", "GCNMaxOccupancySchedStrategy", "::", "pickNodeFromQueue", "(", "SchedBoundary", "&", "Zone", ",", "const", "CandPolicy", "&", "ZonePolicy", ",", "const", "RegPressureTracker", "&", "RPTracker", ",", "SchedCandidate", "&", "Cand", ")", "{", "const", "SIRegisterInfo", "*", "SRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "TRI", ")", ";", "ArrayRef", "<", "unsigned", ">", "Pressure", "=", "RPTracker", ".", "getRegSetPressureAtPos", "(", ")", ";", "unsigned", "SGPRPressure", "=", "Pressure", "[", "SRI", "->", "getSGPRPressureSet", "(", ")", "]", ";", "unsigned", "VGPRPressure", "=", "Pressure", "[", "SRI", "->", "getVGPRPressureSet", "(", ")", "]", ";", "ReadyQueue", "&", "Q", "=", "Zone", ".", "Available", ";", "for", "(", "SUnit", "*", "SU", ":", "Q", ")", "{", "SchedCandidate", "TryCand", "(", "ZonePolicy", ")", ";", "initCandidate", "(", "TryCand", ",", "SU", ",", "Zone", ".", "isTop", "(", ")", ",", "RPTracker", ",", "SRI", ",", "SGPRPressure", ",", "VGPRPressure", ")", ";", "SchedBoundary", "*", "ZoneArg", "=", "Cand", ".", "AtTop", "==", "TryCand", ".", "AtTop", "?", "&", "Zone", ":", "nullptr", ";", "GenericScheduler", "::", "tryCandidate", "(", "Cand", ",", "TryCand", ",", "ZoneArg", ")", ";", "if", "(", "TryCand", ".", "Reason", "!=", "NoCand", ")", "{", "if", "(", "TryCand", ".", "ResDelta", "==", "SchedResourceDelta", "(", ")", ")", "TryCand", ".", "initResourceDelta", "(", "Zone", ".", "DAG", ",", "SchedModel", ")", ";", "Cand", ".", "setBest", "(", "TryCand", ")", ";", "}", "}", "}", "</s>" ]

[ "Pick", "the", "best", "candidate", "from", "the", "queue", "." ]

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "JVMSubtarget", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MFI", "=", "MF", ".", "getInfo", "<", "JVMFunctionInfo", ">", "(", ")", ";", "OutStreamer", "->", "SetFunctionInfo", "(", "MFI", "->", "getDescVector", "(", ")", ")", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "JVM", "JVM", "JVM" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "const", "auto", "&", "Desc", "=", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Inst", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "if", "(", "Desc", ".", "OpInfo", "[", "i", "]", ".", "OperandType", "==", "MCOI", "::", "OPERAND_PCREL", ")", "{", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "i", ")", ".", "getImm", "(", ")", "*", "4", ";", "Target", "=", "Addr", "+", "Imm", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "AArch64", "0", "4" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "isToken", "(", "const", "AsmToken", "::", "TokenKind", "Kind", ")", "const", "{", "return", "getTokenKind", "(", ")", "==", "Kind", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "ix86_match_ccmode", "(", "rtx", "insn", ",", "machine_mode", "req_mode", ")", "{", "rtx", "set", ";", "machine_mode", "set_mode", ";", "set", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "PARALLEL", ")", "set", "=", "XVECEXP", "(", "set", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "COMPARE", ")", ";", "set_mode", "=", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", ";", "switch", "(", "set_mode", ")", "{", "case", "CCNOmode", ":", "if", "(", "req_mode", "!=", "CCNOmode", "&&", "(", "req_mode", "!=", "CCmode", "||", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", "!=", "const0_rtx", ")", ")", "return", "false", ";", "break", ";", "case", "CCmode", ":", "if", "(", "req_mode", "==", "CCGCmode", ")", "return", "false", ";", "case", "CCGCmode", ":", "if", "(", "req_mode", "==", "CCGOCmode", "||", "req_mode", "==", "CCNOmode", ")", "return", "false", ";", "case", "CCGOCmode", ":", "if", "(", "req_mode", "==", "CCZmode", ")", "return", "false", ";", "case", "CCZmode", ":", "break", ";", "case", "CCAmode", ":", "case", "CCCmode", ":", "case", "CCOmode", ":", "case", "CCPmode", ":", "case", "CCSmode", ":", "if", "(", "set_mode", "!=", "req_mode", ")", "return", "false", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "set_mode", ";", "}", "</s>" ]

[ "Return", "TRUE", "or", "FALSE", "depending", "on", "whether", "the", "first", "SET", "in", "INSN", "has", "source", "and", "destination", "with", "matching", "CC", "modes", ",", "and", "that", "the", "CC", "mode", "is", "at", "least", "as", "constrained", "as", "REQ_MODE", "." ]

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

[]

[ "<s>", "MCSymbol", "*", "ARMAsmPrinter", "::", "GetCPISymbol", "(", "unsigned", "CPID", ")", "const", "{", "const", "DataLayout", "&", "DL", "=", "getDataLayout", "(", ")", ";", "return", "OutContext", ".", "getOrCreateSymbol", "(", "Twine", "(", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ")", "+", "\"CPI\"", "+", "Twine", "(", "getFunctionNumber", "(", ")", ")", "+", "\"_\"", "+", "Twine", "(", "CPID", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "symbol", "for", "the", "specified", "constant", "pool", "entry", "." ]

[ "ARM", "ARM", "\"CPI\"", "\"_\"" ]

[]

[ "<s>", "bool", "MINA32PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createMINA32ISelDag", "(", "getMINA32TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "MINA32", "MINA32", "MINA32", "MINA32" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "AND", ":", "return", "Loweri1ContextSwitch", "(", "Op", ",", "DAG", ",", "ISD", "::", "AND", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "unsigned", "IntrinsicID", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "switch", "(", "IntrinsicID", ")", "{", "case", "AMDGPUIntrinsic", "::", "SI_vs_load_buffer_index", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "VReg_32RegClass", ",", "AMDGPU", "::", "VGPR0", ",", "VT", ")", ";", "default", ":", "return", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "}", "break", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "R600", "SI", "ISD::BRCOND", "ISD::LOAD", "ISD::SELECT_CC", "ISD::AND", "ISD::AND", "ISD::INTRINSIC_WO_CHAIN", "0", "AMDGPUIntrinsic::SI_vs_load_buffer_index" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"M68k PIC Global Base Reg Initialization\"", ";", "}", "</s>" ]

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

[ "M68k", "\"M68k PIC Global Base Reg Initialization\"" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "reservedPrivateSegmentBufferReg", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "hasSGPRInitBug", "(", ")", ")", "{", "unsigned", "BaseIdx", "=", "AMDGPUSubtarget", "::", "FIXED_SGPR_COUNT_FOR_INIT_BUG", "-", "8", "-", "4", ";", "unsigned", "BaseReg", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "BaseIdx", ")", ")", ";", "return", "getMatchingSuperReg", "(", "BaseReg", ",", "AMDGPU", "::", "sub0", ",", "&", "AMDGPU", "::", "SReg_128RegClass", ")", ";", "}", "if", "(", "ST", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "return", "AMDGPU", "::", "SGPR92_SGPR93_SGPR94_SGPR95", ";", "}", "return", "AMDGPU", "::", "SGPR96_SGPR97_SGPR98_SGPR99", ";", "}", "</s>" ]

[ "Return", "the", "end", "register", "initially", "reserved", "for", "the", "scratch", "buffer", "in", "case", "spilling", "is", "needed", "." ]

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "AMDGPU", "8", "4", "AMDGPU::SGPR_32RegClass", "AMDGPU::sub0", "AMDGPU::SReg_128RegClass", "AMDGPU", "AMDGPU::SGPR92_SGPR93_SGPR94_SGPR95", "AMDGPU::SGPR96_SGPR97_SGPR98_SGPR99" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "const", "MachineMemOperand", "*", "Dummy", ";", "return", "MI", ".", "mayLoad", "(", ")", "&&", "hasLoadFromStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "}", "</s>" ]

[ "isLoadFromStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "cond", ",", "rtx", "label", ")", "{", "int", "very_unlikely", "=", "REG_BR_PROB_BASE", "/", "100", "-", "1", ";", "rtx", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cond", ",", "label", ",", "pc_rtx", ")", ";", "rtx_insn", "*", "insn", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "add_int_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "very_unlikely", ")", ";", "}", "</s>" ]

[ "Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "." ]

[ "rs6000", "100", "1" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addIRTranslator", "(", ")", "{", "addPass", "(", "new", "IRTranslator", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "an", "IR", "translator", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "with", "possibly", "generic", "opcodes", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "frv_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_size", ",", "int", "second_time", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"setup_vararg: words = %2d, mode = %4s, pretend_size = %d, second_time = %d\\n\"", ",", "*", "cum", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "*", "pretend_size", ",", "second_time", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_SETUP_INCOMING_VARARGS", "." ]

[ "frv", "\"setup_vararg: words = %2d, mode = %4s, pretend_size = %d, second_time = %d\\n\"" ]

[]

[ "<s>", "void", "ConvergingVLIWScheduler", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "DAG", "=", "static_cast", "<", "VLIWMachineScheduler", "*", ">", "(", "dag", ")", ";", "SchedModel", "=", "DAG", "->", "getSchedModel", "(", ")", ";", "Top", ".", "init", "(", "DAG", ",", "SchedModel", ")", ";", "Bot", ".", "init", "(", "DAG", ",", "SchedModel", ")", ";", "const", "InstrItineraryData", "*", "Itin", "=", "DAG", "->", "getSchedModel", "(", ")", "->", "getInstrItineraries", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "DAG", "->", "MF", ".", "getTarget", "(", ")", ";", "delete", "Top", ".", "HazardRec", ";", "delete", "Bot", ".", "HazardRec", ";", "Top", ".", "HazardRec", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "Bot", ".", "HazardRec", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "delete", "Top", ".", "ResourceModel", ";", "delete", "Bot", ".", "ResourceModel", ";", "Top", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "TM", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "Bot", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "TM", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "assert", "(", "(", "!", "llvm", "::", "ForceTopDown", "||", "!", "llvm", "::", "ForceBottomUp", ")", "&&", "\"-misched-topdown incompatible with -misched-bottomup\"", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "Hexagon", "\"-misched-topdown incompatible with -misched-bottomup\"" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "Mips", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_Mips_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Mips_REL32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Mips_26\"", ",", "0", ",", "26", ",", "0", "}", ",", "{", "\"fixup_Mips_HI16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_LO16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GPREL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_LITERAL\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_Global\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_Local\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_PC16\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_Mips_CALL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GPREL32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Mips_SHIFT5\"", ",", "6", ",", "5", ",", "0", "}", ",", "{", "\"fixup_Mips_SHIFT6\"", ",", "6", ",", "5", ",", "0", "}", ",", "{", "\"fixup_Mips_64\"", ",", "0", ",", "64", ",", "0", "}", ",", "{", "\"fixup_Mips_TLSGD\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOTTPREL\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_TPREL_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_TPREL_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_TLSLDM\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_DTPREL_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_DTPREL_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_Branch_PCRel\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_Mips_GPOFF_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GPOFF_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_PAGE\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_OFST\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_DISP\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_HIGHER\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_HIGHEST\"", ",", "0", ",", "16", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "Mips", "Mips::NumTargetFixupKinds", "\"fixup_Mips_16\"", "0", "16", "0", "\"fixup_Mips_32\"", "0", "32", "0", "\"fixup_Mips_REL32\"", "0", "32", "0", "\"fixup_Mips_26\"", "0", "26", "0", "\"fixup_Mips_HI16\"", "0", "16", "0", "\"fixup_Mips_LO16\"", "0", "16", "0", "\"fixup_Mips_GPREL16\"", "0", "16", "0", "\"fixup_Mips_LITERAL\"", "0", "16", "0", "\"fixup_Mips_GOT_Global\"", "0", "16", "0", "\"fixup_Mips_GOT_Local\"", "0", "16", "0", "\"fixup_Mips_PC16\"", "0", "16", "\"fixup_Mips_CALL16\"", "0", "16", "0", "\"fixup_Mips_GPREL32\"", "0", "32", "0", "\"fixup_Mips_SHIFT5\"", "6", "5", "0", "\"fixup_Mips_SHIFT6\"", "6", "5", "0", "\"fixup_Mips_64\"", "0", "64", "0", "\"fixup_Mips_TLSGD\"", "0", "16", "0", "\"fixup_Mips_GOTTPREL\"", "0", "16", "0", "\"fixup_Mips_TPREL_HI\"", "0", "16", "0", "\"fixup_Mips_TPREL_LO\"", "0", "16", "0", "\"fixup_Mips_TLSLDM\"", "0", "16", "0", "\"fixup_Mips_DTPREL_HI\"", "0", "16", "0", "\"fixup_Mips_DTPREL_LO\"", "0", "16", "0", "\"fixup_Mips_Branch_PCRel\"", "0", "16", "\"fixup_Mips_GPOFF_HI\"", "0", "16", "0", "\"fixup_Mips_GPOFF_LO\"", "0", "16", "0", "\"fixup_Mips_GOT_PAGE\"", "0", "16", "0", "\"fixup_Mips_GOT_OFST\"", "0", "16", "0", "\"fixup_Mips_GOT_DISP\"", "0", "16", "0", "\"fixup_Mips_HIGHER\"", "0", "16", "0", "\"fixup_Mips_HIGHEST\"", "0", "16", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "void", "GBZ80InstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "&", "Orig", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "&", "Orig", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "MachineInstr", "&", "NewMI", "=", "*", "std", "::", "prev", "(", "I", ")", ";", "NewMI", ".", "substituteRegister", "(", "Orig", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "DestReg", ",", "SubIdx", ",", "TRI", ")", ";", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "GBZ80", "GB", "0" ]

[]

[ "<s>", "void", "Nios2DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Nios2", "Nios2", "\"== \"", "\"\\n\"", "1" ]

[]

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

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

[ "MOS", "MOS" ]

[]

[ "<s>", "static", "struct", "constant_pool", "*", "s390_start_pool", "(", "struct", "constant_pool", "*", "*", "pool_list", ",", "rtx_insn", "*", "insn", ")", "{", "struct", "constant_pool", "*", "pool", ",", "*", "*", "prev", ";", "pool", "=", "s390_alloc_pool", "(", ")", ";", "pool", "->", "first_insn", "=", "insn", ";", "for", "(", "prev", "=", "pool_list", ";", "*", "prev", ";", "prev", "=", "&", "(", "*", "prev", ")", "->", "next", ")", ";", "*", "prev", "=", "pool", ";", "return", "pool", ";", "}", "</s>" ]

[ "Create", "new", "constant", "pool", "covering", "instructions", "starting", "at", "INSN", "and", "chain", "it", "to", "the", "end", "of", "POOL_LIST", "." ]

[ "s390" ]

[]

[ "<s>", "static", "tree", "arm_d_handle_target_float_abi", "(", "void", ")", "{", "const", "char", "*", "abi", ";", "switch", "(", "arm_float_abi", ")", "{", "case", "ARM_FLOAT_ABI_HARD", ":", "abi", "=", "\"hard\"", ";", "break", ";", "case", "ARM_FLOAT_ABI_SOFT", ":", "abi", "=", "\"soft\"", ";", "break", ";", "case", "ARM_FLOAT_ABI_SOFTFP", ":", "abi", "=", "\"softfp\"", ";", "break", ";", "default", ":", "abi", "=", "\"\"", ";", "break", ";", "}", "return", "build_string_literal", "(", "strlen", "(", "abi", ")", "+", "1", ",", "abi", ")", ";", "}", "</s>" ]

[ "Handle", "a", "call", "to", "`", "__traits", "(", "getTargetInfo", ",", "``", "floatAbi", "''", ")", "'", "." ]

[ "arm", "\"hard\"", "\"soft\"", "\"softfp\"", "\"\"", "1" ]

[]

[ "<s>", "void", "emitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "override", "{", "EmitMappingSymbol", "(", "\"$t\"", ")", ";", "MCELFStreamer", "::", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "CSKY", "\"$t\"" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "override", "{", "if", "(", "Count", "==", "0", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "FISC", "0" ]

[]

[ "<s>", "unsigned", "postKnownBits", "(", "unsigned", "LogAlign", "=", "0", ")", "const", "{", "return", "std", "::", "max", "(", "LogAlign", ",", "internalKnownBits", "(", ")", ")", ";", "}", "</s>" ]

[ "Compute", "the", "number", "of", "known", "low", "bits", "of", "postOffset", "." ]

[ "AArch64", "0" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRi12", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "DestReg", ",", "FI", ",", "RC", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegisterClass", "ARM::t2LDRi12", "0", "ARM" ]

[]

[ "<s>", "bool", "extract_base_offset_in_addr", "(", "rtx", "mem", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ")", "{", "rtx", "addr", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "REG_P", "(", "addr", ")", ")", "{", "*", "base", "=", "addr", ";", "*", "offset", "=", "const0_rtx", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "{", "*", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "*", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "return", "true", ";", "}", "*", "base", "=", "NULL_RTX", ";", "*", "offset", "=", "NULL_RTX", ";", "return", "false", ";", "}", "</s>" ]

[ "If", "MEM", "is", "in", "the", "form", "of", "``", "base+offset", "''", ",", "extract", "the", "two", "parts", "of", "address", "and", "set", "to", "BASE", "and", "OFFSET", ",", "otherwise", "return", "false", "after", "clearing", "BASE", "and", "OFFSET", "." ]

[ "aarch64", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "bool", "MipsCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "return", "false", ";", "}", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "}", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "ArgInfos", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "OrigArgIndices", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "AInfo", "(", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "AInfo", ",", "i", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "AInfo", ",", "i", ",", "ArgInfos", ",", "OrigArgIndices", ")", ";", "++", "i", ";", "}", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "Ins", ";", "subTargetRegTypeForCallingConv", "(", "MIRBuilder", ",", "ArgInfos", ",", "OrigArgIndices", ",", "[", "&", "]", "(", "ISD", "::", "ArgFlagsTy", "flags", ",", "EVT", "vt", ",", "EVT", "argvt", ",", "bool", "used", ",", "unsigned", "origIdx", ",", "unsigned", "partOffs", ")", "{", "Ins", ".", "emplace_back", "(", "flags", ",", "vt", ",", "argvt", ",", "used", ",", "origIdx", ",", "partOffs", ")", ";", "}", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "TLI", ".", "CCAssignFnForCall", "(", ")", ")", ";", "IncomingValueHandler", "Handler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ")", ";", "if", "(", "!", "Handler", ".", "handle", "(", "ArgLocs", ",", "ArgInfos", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "Mips", "Mips", "Mips", "Mips", "8", "8", "0", "ISD::InputArg", "8", "ISD::ArgFlagsTy", "16", "Mips" ]

[]

[ "<s>", "static", "bool", "rs6000_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "unsigned", "from_size", "=", "GET_MODE_SIZE", "(", "from", ")", ";", "unsigned", "to_size", "=", "GET_MODE_SIZE", "(", "to", ")", ";", "if", "(", "from_size", "!=", "to_size", ")", "{", "enum", "reg_class", "xclass", "=", "(", "TARGET_VSX", ")", "?", "VSX_REGS", ":", "FLOAT_REGS", ";", "if", "(", "reg_classes_intersect_p", "(", "xclass", ",", "rclass", ")", ")", "{", "unsigned", "to_nregs", "=", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "to", ")", ";", "unsigned", "from_nregs", "=", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "from", ")", ";", "bool", "to_float128_vector_p", "=", "FLOAT128_VECTOR_P", "(", "to", ")", ";", "bool", "from_float128_vector_p", "=", "FLOAT128_VECTOR_P", "(", "from", ")", ";", "if", "(", "to_float128_vector_p", "&&", "from_float128_vector_p", ")", "return", "true", ";", "else", "if", "(", "to_float128_vector_p", "||", "from_float128_vector_p", ")", "return", "false", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", "&&", "(", "to", "==", "TDmode", "||", "from", "==", "TDmode", ")", ")", "return", "false", ";", "if", "(", "from_size", "<", "8", "||", "to_size", "<", "8", ")", "return", "false", ";", "if", "(", "from_size", "==", "8", "&&", "(", "8", "*", "to_nregs", ")", "!=", "to_size", ")", "return", "false", ";", "if", "(", "to_size", "==", "8", "&&", "(", "8", "*", "from_nregs", ")", "!=", "from_size", ")", "return", "false", ";", "return", "true", ";", "}", "else", "return", "true", ";", "}", "if", "(", "TARGET_E500_DOUBLE", "&&", "(", "(", "(", "(", "to", ")", "==", "DFmode", ")", "+", "(", "(", "from", ")", "==", "DFmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "TFmode", ")", "+", "(", "(", "from", ")", "==", "TFmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "IFmode", ")", "+", "(", "(", "from", ")", "==", "IFmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "KFmode", ")", "+", "(", "(", "from", ")", "==", "KFmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "DDmode", ")", "+", "(", "(", "from", ")", "==", "DDmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "TDmode", ")", "+", "(", "(", "from", ")", "==", "TDmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "DImode", ")", "+", "(", "(", "from", ")", "==", "DImode", ")", ")", "==", "1", ")", ")", "return", "false", ";", "if", "(", "TARGET_VSX", "&&", "VSX_REG_CLASS_P", "(", "rclass", ")", ")", "{", "unsigned", "num_regs", "=", "(", "from_size", "+", "15", ")", "/", "16", ";", "if", "(", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "to", ")", ">", "num_regs", "||", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "from", ")", ">", "num_regs", ")", "return", "false", ";", "return", "(", "from_size", "==", "8", "||", "from_size", "==", "16", ")", ";", "}", "if", "(", "TARGET_ALTIVEC", "&&", "rclass", "==", "ALTIVEC_REGS", "&&", "(", "ALTIVEC_VECTOR_MODE", "(", "from", ")", "+", "ALTIVEC_VECTOR_MODE", "(", "to", ")", ")", "==", "1", ")", "return", "false", ";", "if", "(", "TARGET_SPE", "&&", "(", "SPE_VECTOR_MODE", "(", "from", ")", "+", "SPE_VECTOR_MODE", "(", "to", ")", ")", "==", "1", "&&", "reg_classes_intersect_p", "(", "GENERAL_REGS", ",", "rclass", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", "." ]

[ "powerpcspe", "8", "8", "8", "8", "8", "8", "1", "1", "1", "1", "1", "1", "1", "15", "16", "8", "16", "1", "1" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "CallGraph", ">", "(", ")", ";", "}", "</s>" ]

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

[ "PIC16" ]

[]

[ "<s>", "void", "AGCInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "SrcReg", "==", "DestReg", ")", "return", ";", "if", "(", "DestReg", "==", "AGC", "::", "R0", ")", "{", "assert", "(", "AGC", "::", "MM12RegClass", ".", "contains", "(", "SrcReg", ")", "&&", "\"Can only copy from memory\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AGC", "::", "CA", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "assert", "(", "AGC", "::", "MM10RegClass", ".", "contains", "(", "DestReg", ")", "&&", "\"Can only copy to erasable memory\"", ")", ";", "if", "(", "SrcReg", "!=", "AGC", "::", "R0", ")", "{", "assert", "(", "AGC", "::", "MM12RegClass", ".", "contains", "(", "SrcReg", ")", "&&", "\"Can only copy from memory\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AGC", "::", "CA", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "KillSrc", "=", "true", ";", "}", "assert", "(", "KillSrc", "&&", "\"Cannot copy accumulator without killing it\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AGC", "::", "TS", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "AGC", "AGC", "AGC::R0", "AGC::MM12RegClass", "\"Can only copy from memory\"", "AGC::CA", "AGC::MM10RegClass", "\"Can only copy to erasable memory\"", "AGC::R0", "AGC::MM12RegClass", "\"Can only copy from memory\"", "AGC::CA", "\"Cannot copy accumulator without killing it\"", "AGC::TS" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "RealignStack", "&&", "(", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "EnableBasePointer", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "rtx", "gen_ldst", "(", "bool", "load_p", ",", "int", "regno", ",", "rtx", "base_mem", ",", "int", "offset", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "rtx", "mem", "=", "adjust_address_nv", "(", "base_mem", ",", "SImode", ",", "offset", ")", ";", "return", "gen_rtx_SET", "(", "load_p", "?", "reg", ":", "mem", ",", "load_p", "?", "mem", ":", "reg", ")", ";", "}", "</s>" ]

[ "Helper", "for", "nios2_ldst_parallel", ",", "for", "generating", "a", "parallel", "vector", "SET", "element", "." ]

[ "nios2" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isProfitableToHoist", "(", "Instruction", "*", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "Instruction", "::", "FMul", ")", "return", "true", ";", "if", "(", "I", "->", "getNumUses", "(", ")", "!=", "1", ")", "return", "true", ";", "Instruction", "*", "User", "=", "I", "->", "user_back", "(", ")", ";", "if", "(", "User", "&&", "!", "(", "User", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "FSub", "||", "User", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "FAdd", ")", ")", "return", "true", ";", "const", "TargetOptions", "&", "Options", "=", "getTargetMachine", "(", ")", ".", "Options", ";", "const", "DataLayout", "&", "DL", "=", "I", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "EVT", "VT", "=", "getValueType", "(", "DL", ",", "User", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "if", "(", "isFMAFasterThanFMulAndFAdd", "(", "VT", ")", "&&", "isOperationLegalOrCustom", "(", "ISD", "::", "FMA", ",", "VT", ")", "&&", "(", "Options", ".", "AllowFPOpFusion", "==", "FPOpFusion", "::", "Fast", "||", "Options", ".", "UnsafeFPMath", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "hoist", "instruction", "in", "the", "then/else", "to", "before", "if", "." ]

[ "AArch64", "AArch64", "1", "0", "ISD::FMA" ]

[]

[ "<s>", "static", "bool", "rs6000_cannot_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "enum", "reg_class", "rclass", ")", "{", "unsigned", "from_size", "=", "GET_MODE_SIZE", "(", "from", ")", ";", "unsigned", "to_size", "=", "GET_MODE_SIZE", "(", "to", ")", ";", "if", "(", "from_size", "!=", "to_size", ")", "{", "enum", "reg_class", "xclass", "=", "(", "TARGET_VSX", ")", "?", "VSX_REGS", ":", "FLOAT_REGS", ";", "if", "(", "reg_classes_intersect_p", "(", "xclass", ",", "rclass", ")", ")", "{", "unsigned", "to_nregs", "=", "hard_regno_nregs", "[", "FIRST_FPR_REGNO", "]", "[", "to", "]", ";", "unsigned", "from_nregs", "=", "hard_regno_nregs", "[", "FIRST_FPR_REGNO", "]", "[", "from", "]", ";", "bool", "to_float128_vector_p", "=", "FLOAT128_VECTOR_P", "(", "to", ")", ";", "bool", "from_float128_vector_p", "=", "FLOAT128_VECTOR_P", "(", "from", ")", ";", "if", "(", "to_float128_vector_p", "&&", "from_float128_vector_p", ")", "return", "false", ";", "else", "if", "(", "to_float128_vector_p", "||", "from_float128_vector_p", ")", "return", "true", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", "&&", "(", "to", "==", "TDmode", "||", "from", "==", "TDmode", ")", ")", "return", "true", ";", "if", "(", "from_size", "<", "8", "||", "to_size", "<", "8", ")", "return", "true", ";", "if", "(", "from_size", "==", "8", "&&", "(", "8", "*", "to_nregs", ")", "!=", "to_size", ")", "return", "true", ";", "if", "(", "to_size", "==", "8", "&&", "(", "8", "*", "from_nregs", ")", "!=", "from_size", ")", "return", "true", ";", "return", "false", ";", "}", "else", "return", "false", ";", "}", "if", "(", "TARGET_E500_DOUBLE", "&&", "(", "(", "(", "(", "to", ")", "==", "DFmode", ")", "+", "(", "(", "from", ")", "==", "DFmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "TFmode", ")", "+", "(", "(", "from", ")", "==", "TFmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "IFmode", ")", "+", "(", "(", "from", ")", "==", "IFmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "KFmode", ")", "+", "(", "(", "from", ")", "==", "KFmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "DDmode", ")", "+", "(", "(", "from", ")", "==", "DDmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "TDmode", ")", "+", "(", "(", "from", ")", "==", "TDmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "DImode", ")", "+", "(", "(", "from", ")", "==", "DImode", ")", ")", "==", "1", ")", ")", "return", "true", ";", "if", "(", "TARGET_VSX", "&&", "VSX_REG_CLASS_P", "(", "rclass", ")", ")", "{", "unsigned", "num_regs", "=", "(", "from_size", "+", "15", ")", "/", "16", ";", "if", "(", "hard_regno_nregs", "[", "FIRST_FPR_REGNO", "]", "[", "to", "]", ">", "num_regs", "||", "hard_regno_nregs", "[", "FIRST_FPR_REGNO", "]", "[", "from", "]", ">", "num_regs", ")", "return", "true", ";", "return", "(", "from_size", "!=", "8", "&&", "from_size", "!=", "16", ")", ";", "}", "if", "(", "TARGET_ALTIVEC", "&&", "rclass", "==", "ALTIVEC_REGS", "&&", "(", "ALTIVEC_VECTOR_MODE", "(", "from", ")", "+", "ALTIVEC_VECTOR_MODE", "(", "to", ")", ")", "==", "1", ")", "return", "true", ";", "if", "(", "TARGET_SPE", "&&", "(", "SPE_VECTOR_MODE", "(", "from", ")", "+", "SPE_VECTOR_MODE", "(", "to", ")", ")", "==", "1", "&&", "reg_classes_intersect_p", "(", "GENERAL_REGS", ",", "rclass", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "for", "CLASS", "a", "mode", "change", "from", "FROM", "to", "TO", "is", "invalid", "." ]

[ "rs6000", "8", "8", "8", "8", "8", "8", "1", "1", "1", "1", "1", "1", "1", "15", "16", "8", "16", "1", "1" ]

[]

[ "<s>", "unsigned", "int", "mips_hard_regno_nregs", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "ST_REG_P", "(", "regno", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "3", ")", "/", "4", ";", "if", "(", "FP_REG_P", "(", "regno", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_FPREG", "-", "1", ")", "/", "UNITS_PER_FPREG", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_NREGS", "." ]

[ "mips", "3", "4", "1", "1" ]

[]

[ "<s>", "bool", "MOSRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "const", "auto", "&", "MRI", "=", "MI", "->", "getMF", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "NewRC", "==", "&", "MOS", "::", "Imag8RegClass", "||", "NewRC", "==", "&", "MOS", "::", "Imag16RegClass", ")", "{", "if", "(", "DstRC", "==", "&", "MOS", "::", "AImag8RegClass", "&&", "referencedByShiftRotate", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "MRI", ")", "&&", "!", "isRmwPattern", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "return", "false", ";", "if", "(", "SrcRC", "==", "&", "MOS", "::", "AImag8RegClass", "&&", "referencedByShiftRotate", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ")", "&&", "!", "isRmwPattern", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "return", "false", ";", "if", "(", "DstRC", "==", "&", "MOS", "::", "Anyi8RegClass", "&&", "referencedByIncDec", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "MRI", ")", "&&", "!", "isRmwPattern", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "return", "false", ";", "if", "(", "SrcRC", "==", "&", "MOS", "::", "Anyi8RegClass", "&&", "referencedByIncDec", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ")", "&&", "!", "isRmwPattern", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "return", "false", ";", "}", "if", "(", "NewRC", "==", "&", "MOS", "::", "GPRRegClass", ")", "{", "if", "(", "DstRC", "==", "&", "MOS", "::", "Anyi8RegClass", "&&", "referencedByIncDec", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "return", "false", ";", "if", "(", "SrcRC", "==", "&", "MOS", "::", "Anyi8RegClass", "&&", "referencedByIncDec", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Subtarget", "Hooks", "." ]

[ "MOS", "MOS", "MOS::Imag8RegClass", "MOS::Imag16RegClass", "MOS::AImag8RegClass", "0", "0", "MOS::AImag8RegClass", "1", "1", "MOS::Anyi8RegClass", "0", "0", "MOS::Anyi8RegClass", "1", "1", "MOS::GPRRegClass", "MOS::Anyi8RegClass", "0", "MOS::Anyi8RegClass", "1" ]

[]

[ "<s>", "void", "setupMF", "(", "MachineFunction", "&", "MF", ",", "GISelKnownBits", "*", "KB", ",", "CodeGenCoverage", "&", "CoverageInfo", ",", "ProfileSummaryInfo", "*", "PSI", ",", "BlockFrequencyInfo", "*", "BFI", ",", "AAResults", "*", "AA", ")", "override", "{", "InstructionSelector", "::", "setupMF", "(", "MF", ",", "KB", ",", "CoverageInfo", ",", "PSI", ",", "BFI", ",", "AA", ")", ";", "MIB", ".", "setMF", "(", "MF", ")", ";", "ProduceNonFlagSettingCondBr", "=", "!", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "SpeculativeLoadHardening", ")", ";", "MFReturnAddr", "=", "Register", "(", ")", ";", "processPHIs", "(", "MF", ")", ";", "}", "</s>" ]

[ "Setup", "per-MF", "executor", "state", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "rtx", "csky_dwarf_register_span", "(", "rtx", "rtl", ")", "{", "machine_mode", "mode", ";", "unsigned", "regno", ";", "rtx", "parts", "[", "16", "]", ";", "int", "nregs", ";", "int", "i", ";", "regno", "=", "REGNO", "(", "rtl", ")", ";", "if", "(", "!", "CSKY_VREG_P", "(", "regno", ")", ")", "return", "NULL_RTX", ";", "if", "(", "CSKY_VREG_HI_P", "(", "regno", ")", ")", "regno", "+=", "16", ";", "mode", "=", "GET_MODE", "(", "rtl", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "8", ")", "return", "NULL_RTX", ";", "if", "(", "TARGET_SINGLE_FPU", ")", "{", "nregs", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nregs", ";", "i", "+=", "2", ")", "if", "(", "TARGET_BIG_ENDIAN", ")", "{", "parts", "[", "i", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", "+", "1", ")", ";", "parts", "[", "i", "+", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", ")", ";", "}", "else", "{", "parts", "[", "i", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", ")", ";", "parts", "[", "i", "+", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", "+", "1", ")", ";", "}", "}", "else", "{", "nregs", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nregs", ";", "i", "+=", "2", ")", "if", "(", "TARGET_BIG_ENDIAN", ")", "{", "parts", "[", "i", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", "-", "16", ")", ";", "parts", "[", "i", "+", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", ")", ";", "}", "else", "{", "parts", "[", "i", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", ")", ";", "parts", "[", "i", "+", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", "-", "16", ")", ";", "}", "}", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "nregs", ",", "parts", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_DWARF_REGISTER_SPAN", ".", "Dwarf", "models", "VFP", "registers", "as", "64-bit", "or", "128-bit", "registers", "default", ".", "GCC", "models", "tham", "as", "32-bit", "registers", ",", "so", "we", "need", "to", "describe", "this", "to", "the", "DWARF", "generation", "code", ".", "Other", "registers", "can", "use", "the", "default", "." ]

[ "csky", "16", "16", "8", "4", "0", "2", "1", "1", "1", "1", "4", "0", "2", "16", "1", "1", "16" ]

[]

[ "<s>", "int", "avr_progmem_p", "(", "tree", "decl", ",", "tree", "attributes", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "0", ";", "if", "(", "avr_decl_memx_p", "(", "decl", ")", ")", "return", "2", ";", "if", "(", "avr_decl_flash_p", "(", "decl", ")", ")", "return", "1", ";", "if", "(", "NULL_TREE", "!=", "lookup_attribute", "(", "\"progmem\"", ",", "attributes", ")", ")", "return", "-", "1", ";", "a", "=", "decl", ";", "do", "a", "=", "TREE_TYPE", "(", "a", ")", ";", "while", "(", "TREE_CODE", "(", "a", ")", "==", "ARRAY_TYPE", ")", ";", "if", "(", "a", "==", "error_mark_node", ")", "return", "0", ";", "if", "(", "NULL_TREE", "!=", "lookup_attribute", "(", "\"progmem\"", ",", "TYPE_ATTRIBUTES", "(", "a", ")", ")", ")", "return", "-", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Look", "for", "attribute", "`", "progmem", "'", "in", "DECL", "if", "found", "return", "1", ",", "otherwise", "0", "." ]

[ "avr", "0", "2", "1", "\"progmem\"", "1", "0", "\"progmem\"", "1", "0" ]

[]

[ "<s>", "static", "bool", "atomic_insn_for_leon3_p", "(", "rtx_insn", "*", "insn", ")", "{", "switch", "(", "INSN_CODE", "(", "insn", ")", ")", "{", "case", "CODE_FOR_swapsi", ":", "case", "CODE_FOR_ldstub", ":", "case", "CODE_FOR_atomic_compare_and_swap_leon3_1", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "True", "if", "INSN", "is", "an", "atomic", "instruction", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "std", "::", "string", "getGraphName", "(", "const", "MCallSubGraph", "&", "G", ")", "{", "return", "\"CallGraph\"", ";", "}", "</s>" ]

[ "Generate", "a", "title", "for", "the", "graph", "in", "DOT", "format", "." ]

[ "Patmos", "\"CallGraph\"" ]

[]

[ "<s>", "static", "void", "push_regs", "(", "int", "mask", ")", "{", "int", "i", ";", "int", "exregs", "[", "FIRST_PSEUDO_REGISTER", "]", ";", "memset", "(", "exregs", ",", "0", ",", "sizeof", "(", "exregs", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "exregs", "[", "renumber", "[", "i", "]", "]", "=", "1", ";", "}", "}", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", "-", "1", ";", "i", "+=", "2", ")", "{", "if", "(", "exregs", "[", "i", "]", "&&", "exregs", "[", "i", "+", "1", "]", ")", "{", "push", "(", "rev_renumber", "[", "i", "]", ",", "SImode", ")", ";", "}", "else", "if", "(", "exregs", "[", "i", "]", ")", "{", "push", "(", "rev_renumber", "[", "i", "]", ",", "HImode", ")", ";", "}", "else", "if", "(", "exregs", "[", "i", "+", "1", "]", ")", "{", "push", "(", "rev_renumber", "[", "i", "+", "1", "]", ",", "HImode", ")", ";", "}", "}", "}", "</s>" ]

[ "Generate", "code", "to", "push", "the", "regs", "specified", "in", "the", "mask", ".", "remember", "that", "the", "mask", "is", "of", "the", "internal", "shape", "of", "the", "regs", ",", "not", "the", "external", "shape", "-", "so", "go", "through", "the", "renumber", "vector" ]

[ "z8k", "0", "0", "1", "1", "0", "1", "2", "1", "1", "1" ]

[]

[ "<s>", "static", "bool", "h8300_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", "||", "GET_MODE_SIZE", "(", "TYPE_MODE", "(", "type", ")", ")", ">", "8", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "." ]

[ "h8300", "8" ]

[]

[ "<s>", "const", "uint32_t", "*", "MMIXRegisterInfo", "::", "getNoPreservedMask", "(", ")", "const", "{", "return", "CSR_NoRegs_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "register", "mask", "that", "clobbers", "everything", "." ]

[ "MMIX", "MMIX" ]

[]