Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "first_reg_to_save", "(", ")", "{", "int", "first_reg", ";", "for", "(", "first_reg", "=", "6", ";", "first_reg", "<=", "15", ";", "first_reg", "++", ")", "if", "(", "regs_ever_live", "[", "first_reg", "]", ")", "break", ";", "if", "(", "first_reg", ">", "14", "&&", "romp_using_r14", "(", ")", ")", "first_reg", "=", "14", ";", "return", "first_reg", ";", "}", "</s>" ]

[ "Return", "the", "first", "register", "that", "is", "required", "to", "be", "saved", ".", "16", "if", "none", "." ]

[ "romp", "6", "15", "14", "14" ]

[]

[ "<s>", "static", "int", "check_constant_argument", "(", "enum", "insn_code", "icode", ",", "int", "opnum", ",", "rtx", "opval", ")", "{", "if", "(", "GET_CODE", "(", "opval", ")", "!=", "CONST_INT", ")", "{", "error", "(", "\"%qs expects a constant argument\"", ",", "insn_data", "[", "icode", "]", ".", "name", ")", ";", "return", "false", ";", "}", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "predicate", ")", "(", "opval", ",", "VOIDmode", ")", ")", "{", "error", "(", "\"constant argument out of range for %qs\"", ",", "insn_data", "[", "icode", "]", ".", "name", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "OPVAL", "can", "be", "used", "for", "operand", "OPNUM", "of", "instruction", "ICODE", ".", "The", "instruction", "should", "require", "a", "constant", "operand", "of", "some", "sort", ".", "The", "function", "prints", "an", "error", "if", "OPVAL", "is", "not", "valid", "." ]

[ "sparc", "\"%qs expects a constant argument\"", "\"constant argument out of range for %qs\"" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "Count", "=", "CSI", ".", "size", "(", ")", ";", "DebugLoc", "DL", ";", "assert", "(", "(", "Count", "&", "1", ")", "==", "0", "&&", "\"Odd number of callee-saved regs to spill!\"", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "2", ")", "{", "unsigned", "Reg1", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "unsigned", "Reg2", "=", "CSI", "[", "i", "+", "1", "]", ".", "getReg", "(", ")", ";", "assert", "(", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", "+", "1", "==", "CSI", "[", "i", "+", "1", "]", ".", "getFrameIdx", "(", ")", "&&", "\"Out of order callee saved regs!\"", ")", ";", "unsigned", "LdrOpc", ";", "assert", "(", "(", "Count", "&", "1", ")", "==", "0", "&&", "\"Odd number of callee-saved regs to spill!\"", ")", ";", "assert", "(", "(", "i", "&", "1", ")", "==", "0", "&&", "\"Odd index for callee-saved reg spill!\"", ")", ";", "if", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "Reg1", ")", ")", "{", "assert", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "Reg2", ")", "&&", "\"Expected GPR64 callee-saved register pair!\"", ")", ";", "if", "(", "i", "==", "Count", "-", "2", ")", "LdrOpc", "=", "AArch64", "::", "LDPXpost", ";", "else", "LdrOpc", "=", "AArch64", "::", "LDPXi", ";", "}", "else", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "Reg1", ")", ")", "{", "assert", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "Reg2", ")", "&&", "\"Expected FPR64 callee-saved register pair!\"", ")", ";", "if", "(", "i", "==", "Count", "-", "2", ")", "LdrOpc", "=", "AArch64", "::", "LDPDpost", ";", "else", "LdrOpc", "=", "AArch64", "::", "LDPDi", ";", "}", "else", "llvm_unreachable", "(", "\"Unexpected callee saved register!\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR restore: (\"", "<<", "TRI", "->", "getName", "(", "Reg1", ")", "<<", "\", \"", "<<", "TRI", "->", "getName", "(", "Reg2", ")", "<<", "\") -> fi#(\"", "<<", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", "<<", "\", \"", "<<", "CSI", "[", "i", "+", "1", "]", ".", "getFrameIdx", "(", ")", "<<", "\")\\n\"", ")", ";", "const", "int", "Offset", "=", "(", "i", "==", "Count", "-", "2", ")", "?", "Count", ":", "Count", "-", "i", "-", "2", ";", "assert", "(", "(", "Offset", ">=", "-", "64", "&&", "Offset", "<=", "63", ")", "&&", "\"Offset out of bounds for LDP immediate\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "LdrOpc", ")", ")", ";", "if", "(", "LdrOpc", "==", "AArch64", "::", "LDPXpost", "||", "LdrOpc", "==", "AArch64", "::", "LDPDpost", ")", "MIB", ".", "addReg", "(", "AArch64", "::", "SP", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "Reg2", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "Reg1", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "Offset", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "AArch64", "AArch64", "1", "0", "\"Odd number of callee-saved regs to spill!\"", "0", "2", "1", "1", "1", "\"Out of order callee saved regs!\"", "1", "0", "\"Odd number of callee-saved regs to spill!\"", "1", "0", "\"Odd index for callee-saved reg spill!\"", "AArch64::GPR64RegClass", "AArch64::GPR64RegClass", "\"Expected GPR64 callee-saved register pair!\"", "2", "AArch64::LDPXpost", "AArch64::LDPXi", "AArch64::FPR64RegClass", "AArch64::FPR64RegClass", "\"Expected FPR64 callee-saved register pair!\"", "2", "AArch64::LDPDpost", "AArch64::LDPDi", "\"Unexpected callee saved register!\"", "\"CSR restore: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "2", "2", "64", "63", "\"Offset out of bounds for LDP immediate\"", "AArch64::LDPXpost", "AArch64::LDPDpost", "AArch64::SP", "AArch64::SP" ]

[]

[ "<s>", "bool", "Thumb2InstrInfo", "::", "isLegalToSplitMBBAt", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ")", "const", "{", "unsigned", "PredReg", "=", "0", ";", "return", "llvm", "::", "getITInstrPredicate", "(", "MBBI", ",", "PredReg", ")", "==", "ARMCC", "::", "AL", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "legal", "to", "split", "the", "given", "basic", "block", "at", "the", "specified", "instruction", "(", "i.e", "." ]

[ "ARM", "0", "ARMCC::AL" ]

[]

[ "<s>", "static", "void", "tilegx_gen_bundles", "(", "void", ")", "{", "basic_block", "bb", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next", ",", "*", "prev", ";", "rtx_insn", "*", "end", "=", "NEXT_INSN", "(", "BB_END", "(", "bb", ")", ")", ";", "prev", "=", "NULL", ";", "for", "(", "insn", "=", "next_insn_to_bundle", "(", "BB_HEAD", "(", "bb", ")", ",", "end", ")", ";", "insn", ";", "insn", "=", "next", ")", "{", "next", "=", "next_insn_to_bundle", "(", "NEXT_INSN", "(", "insn", ")", ",", "end", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ASM_INPUT", ")", "{", "if", "(", "next", "==", "NULL_RTX", "||", "GET_MODE", "(", "next", ")", "==", "TImode", "||", "CALL_P", "(", "insn", ")", ")", "{", "PUT_MODE", "(", "insn", ",", "QImode", ")", ";", "}", "else", "{", "PUT_MODE", "(", "insn", ",", "SImode", ")", ";", "}", "}", "if", "(", "get_attr_type", "(", "insn", ")", "==", "TYPE_NOTHING", ")", "{", "if", "(", "GET_MODE", "(", "insn", ")", "==", "QImode", "&&", "prev", "!=", "NULL", "&&", "GET_MODE", "(", "prev", ")", "==", "SImode", ")", "{", "PUT_MODE", "(", "prev", ",", "QImode", ")", ";", "}", "delete_insn", "(", "insn", ")", ";", "}", "else", "prev", "=", "insn", ";", "}", "}", "}", "</s>" ]

[ "Go", "through", "all", "insns", ",", "and", "use", "the", "information", "generated", "during", "scheduling", "to", "generate", "SEQUENCEs", "to", "represent", "bundles", "of", "instructions", "issued", "simultaneously", "." ]

[ "tilegx" ]

[]

[ "<s>", "static", "const", "char", "*", "i386_find_on_wrapper_list", "(", "const", "char", "*", "target", ")", "{", "static", "char", "first_time", "=", "1", ";", "static", "hash_table", "<", "wrapped_symbol_hasher", ">", "*", "wrappers", ";", "if", "(", "first_time", ")", "{", "static", "char", "wrapper_list_buffer", "[", "]", "=", "CXX_WRAP_SPEC_LIST", ";", "char", "*", "bufptr", ";", "wrappers", "=", "new", "hash_table", "<", "wrapped_symbol_hasher", ">", "(", "8", ")", ";", "for", "(", "bufptr", "=", "wrapper_list_buffer", ";", "*", "bufptr", ";", "++", "bufptr", ")", "{", "char", "*", "found", "=", "NULL", ";", "if", "(", "ISSPACE", "(", "*", "bufptr", ")", ")", "continue", ";", "if", "(", "*", "bufptr", "==", "'_'", ")", "found", "=", "bufptr", ";", "while", "(", "*", "bufptr", "&&", "!", "ISSPACE", "(", "*", "bufptr", ")", ")", "++", "bufptr", ";", "if", "(", "*", "bufptr", ")", "*", "bufptr", "=", "0", ";", "if", "(", "found", ")", "*", "wrappers", "->", "find_slot", "(", "found", ",", "INSERT", ")", "=", "found", ";", "}", "first_time", "=", "0", ";", "}", "return", "wrappers", "->", "find", "(", "target", ")", ";", "}", "</s>" ]

[ "Search", "for", "a", "function", "named", "TARGET", "in", "the", "list", "of", "library", "wrappers", "we", "are", "using", ",", "returning", "a", "pointer", "to", "it", "if", "found", "or", "NULL", "if", "not", ".", "This", "function", "might", "be", "called", "on", "quite", "a", "few", "symbols", ",", "and", "we", "only", "have", "the", "list", "of", "names", "of", "wrapped", "functions", "available", "to", "us", "as", "a", "spec", "string", ",", "so", "first", "time", "round", "we", "lazily", "initialise", "a", "hash", "table", "to", "make", "things", "quicker", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "*", "MipsSETargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "MipsTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "BPOSGE32_PSEUDO", ":", "return", "emitBPOSGE32", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "SNZ_B_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_B", ")", ";", "case", "Mips", "::", "SNZ_H_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_H", ")", ";", "case", "Mips", "::", "SNZ_W_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_W", ")", ";", "case", "Mips", "::", "SNZ_D_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_D", ")", ";", "case", "Mips", "::", "SNZ_V_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BNZ_V", ")", ";", "case", "Mips", "::", "SZ_B_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_B", ")", ";", "case", "Mips", "::", "SZ_H_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_H", ")", ";", "case", "Mips", "::", "SZ_W_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_W", ")", ";", "case", "Mips", "::", "SZ_D_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_D", ")", ";", "case", "Mips", "::", "SZ_V_PSEUDO", ":", "return", "emitMSACBranchPseudo", "(", "MI", ",", "BB", ",", "Mips", "::", "BZ_V", ")", ";", "case", "Mips", "::", "COPY_FW_PSEUDO", ":", "return", "emitCOPY_FW", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "COPY_FD_PSEUDO", ":", "return", "emitCOPY_FD", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "INSERT_FW_PSEUDO", ":", "return", "emitINSERT_FW", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "INSERT_FD_PSEUDO", ":", "return", "emitINSERT_FD", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "INSERT_B_VIDX_PSEUDO", ":", "case", "Mips", "::", "INSERT_B_VIDX64_PSEUDO", ":", "return", "emitINSERT_DF_VIDX", "(", "MI", ",", "BB", ",", "1", ",", "false", ")", ";", "case", "Mips", "::", "INSERT_H_VIDX_PSEUDO", ":", "case", "Mips", "::", "INSERT_H_VIDX64_PSEUDO", ":", "return", "emitINSERT_DF_VIDX", "(", "MI", ",", "BB", ",", "2", ",", "false", ")", ";", "case", "Mips", "::", "INSERT_W_VIDX_PSEUDO", ":", "case", "Mips", "::", "INSERT_W_VIDX64_PSEUDO", ":", "return", "emitINSERT_DF_VIDX", "(", "MI", ",", "BB", ",", "4", ",", "false", ")", ";", "case", "Mips", "::", "INSERT_D_VIDX_PSEUDO", ":", "case", "Mips", "::", "INSERT_D_VIDX64_PSEUDO", ":", "return", "emitINSERT_DF_VIDX", "(", "MI", ",", "BB", ",", "8", ",", "false", ")", ";", "case", "Mips", "::", "INSERT_FW_VIDX_PSEUDO", ":", "case", "Mips", "::", "INSERT_FW_VIDX64_PSEUDO", ":", "return", "emitINSERT_DF_VIDX", "(", "MI", ",", "BB", ",", "4", ",", "true", ")", ";", "case", "Mips", "::", "INSERT_FD_VIDX_PSEUDO", ":", "case", "Mips", "::", "INSERT_FD_VIDX64_PSEUDO", ":", "return", "emitINSERT_DF_VIDX", "(", "MI", ",", "BB", ",", "8", ",", "true", ")", ";", "case", "Mips", "::", "FILL_FW_PSEUDO", ":", "return", "emitFILL_FW", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "FILL_FD_PSEUDO", ":", "return", "emitFILL_FD", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "FEXP2_W_1_PSEUDO", ":", "return", "emitFEXP2_W_1", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "FEXP2_D_1_PSEUDO", ":", "return", "emitFEXP2_D_1", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips::BPOSGE32_PSEUDO", "Mips::SNZ_B_PSEUDO", "Mips::BNZ_B", "Mips::SNZ_H_PSEUDO", "Mips::BNZ_H", "Mips::SNZ_W_PSEUDO", "Mips::BNZ_W", "Mips::SNZ_D_PSEUDO", "Mips::BNZ_D", "Mips::SNZ_V_PSEUDO", "Mips::BNZ_V", "Mips::SZ_B_PSEUDO", "Mips::BZ_B", "Mips::SZ_H_PSEUDO", "Mips::BZ_H", "Mips::SZ_W_PSEUDO", "Mips::BZ_W", "Mips::SZ_D_PSEUDO", "Mips::BZ_D", "Mips::SZ_V_PSEUDO", "Mips::BZ_V", "Mips::COPY_FW_PSEUDO", "Mips::COPY_FD_PSEUDO", "Mips::INSERT_FW_PSEUDO", "Mips::INSERT_FD_PSEUDO", "Mips::INSERT_B_VIDX_PSEUDO", "Mips::INSERT_B_VIDX64_PSEUDO", "1", "Mips::INSERT_H_VIDX_PSEUDO", "Mips::INSERT_H_VIDX64_PSEUDO", "2", "Mips::INSERT_W_VIDX_PSEUDO", "Mips::INSERT_W_VIDX64_PSEUDO", "4", "Mips::INSERT_D_VIDX_PSEUDO", "Mips::INSERT_D_VIDX64_PSEUDO", "8", "Mips::INSERT_FW_VIDX_PSEUDO", "Mips::INSERT_FW_VIDX64_PSEUDO", "4", "Mips::INSERT_FD_VIDX_PSEUDO", "Mips::INSERT_FD_VIDX64_PSEUDO", "8", "Mips::FILL_FW_PSEUDO", "Mips::FILL_FD_PSEUDO", "Mips::FEXP2_W_1_PSEUDO", "Mips::FEXP2_D_1_PSEUDO" ]

[]

[ "<s>", "static", "void", "m68k_set_frame_related", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "body", ";", "int", "i", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "PARALLEL", ")", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "body", ",", "0", ")", ";", "i", "++", ")", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "body", ",", "0", ",", "i", ")", ")", "=", "1", ";", "}", "</s>" ]

[ "Make", "INSN", "a", "frame-related", "instruction", "." ]

[ "m68k", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SPARC Delay Slot Filler\"", ";", "}", "</s>" ]

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

[ "Sparc", "\"SPARC Delay Slot Filler\"" ]

[]

[ "<s>", "unsigned", "CSKYInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "if", "(", "!", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", "&&", "!", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "return", "0", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "1", ";", "--", "I", ";", "if", "(", "!", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "return", "1", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "CSKY", "CSKY", "0", "0", "0", "1", "1", "2" ]

[]

[ "<s>", "static", "bool", "ix86_check_avx_upper_register", "(", "const_rtx", "exp", ")", "{", "return", "(", "SSE_REG_P", "(", "exp", ")", "&&", "!", "EXT_REX_SSE_REG_P", "(", "exp", ")", "&&", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "exp", ")", ")", ">", "128", ")", ";", "}", "</s>" ]

[ "Check", "if", "a", "256bit", "or", "512", "bit", "AVX", "register", "is", "referenced", "inside", "of", "EXP", "." ]

[ "i386", "128" ]

[]

[ "<s>", "void", "X86MacroFusion", "::", "apply", "(", "ScheduleDAGInstrs", "*", "DAGInstrs", ")", "{", "ScheduleDAGMI", "*", "DAG", "=", "static_cast", "<", "ScheduleDAGMI", "*", ">", "(", "DAGInstrs", ")", ";", "const", "X86Subtarget", "&", "ST", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "SUnit", "&", "ExitSU", "=", "DAG", "->", "ExitSU", ";", "MachineInstr", "*", "Branch", "=", "ExitSU", ".", "getInstr", "(", ")", ";", "if", "(", "!", "Branch", "||", "!", "shouldScheduleAdjacent", "(", "ST", ",", "nullptr", ",", "Branch", ")", ")", "return", ";", "for", "(", "SDep", "&", "PredDep", ":", "ExitSU", ".", "Preds", ")", "{", "if", "(", "PredDep", ".", "isWeak", "(", ")", ")", "continue", ";", "SUnit", "&", "SU", "=", "*", "PredDep", ".", "getSUnit", "(", ")", ";", "MachineInstr", "&", "Pred", "=", "*", "SU", ".", "getInstr", "(", ")", ";", "if", "(", "!", "shouldScheduleAdjacent", "(", "ST", ",", "&", "Pred", ",", "Branch", ")", ")", "continue", ";", "bool", "Success", "=", "DAG", "->", "addEdge", "(", "&", "ExitSU", ",", "SDep", "(", "&", "SU", ",", "SDep", "::", "Cluster", ")", ")", ";", "(", "void", ")", "Success", ";", "assert", "(", "Success", "&&", "\"No DAG nodes should be reachable from ExitSU\"", ")", ";", "for", "(", "SDep", "&", "PredDep", ":", "ExitSU", ".", "Preds", ")", "if", "(", "PredDep", ".", "getSUnit", "(", ")", "==", "&", "SU", ")", "PredDep", ".", "setLatency", "(", "0", ")", ";", "for", "(", "SDep", "&", "SuccDep", ":", "SU", ".", "Succs", ")", "if", "(", "SuccDep", ".", "getSUnit", "(", ")", "==", "&", "ExitSU", ")", "SuccDep", ".", "setLatency", "(", "0", ")", ";", "++", "NumFused", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "DAG", "->", "MF", ".", "getName", "(", ")", "<<", "\"(): Macro fuse \"", ";", "SU", ".", "print", "(", "dbgs", "(", ")", ",", "DAG", ")", ";", "dbgs", "(", ")", "<<", "\" - ExitSU\"", "<<", "\" / \"", "<<", "DAG", "->", "TII", "->", "getName", "(", "Pred", ".", "getOpcode", "(", ")", ")", "<<", "\" - \"", "<<", "DAG", "->", "TII", "->", "getName", "(", "Branch", "->", "getOpcode", "(", ")", ")", "<<", "'\\n'", ";", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Apply", "the", "profile", "inference", "algorithm", "for", "a", "given", "function", "." ]

[ "X86", "X86", "X86", "X86", "\"No DAG nodes should be reachable from ExitSU\"", "0", "0", "\"(): Macro fuse \"", "\" - ExitSU\"", "\" / \"", "\" - \"" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createARMWinCOFFObjectWriter", "(", "OS", ",", "false", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "unsigned", "int", "mips_build_shift", "(", "struct", "mips_integer_op", "*", "codes", ",", "HOST_WIDE_INT", "value", ")", "{", "unsigned", "int", "i", ",", "shift", ";", "shift", "=", "0", ";", "while", "(", "(", "value", "&", "1", ")", "==", "0", ")", "value", "/=", "2", ",", "shift", "++", ";", "i", "=", "mips_build_integer", "(", "codes", ",", "value", ")", ";", "codes", "[", "i", "]", ".", "code", "=", "ASHIFT", ";", "codes", "[", "i", "]", ".", "value", "=", "shift", ";", "return", "i", "+", "1", ";", "}", "</s>" ]

[ "Subroutine", "of", "mips_build_integer", "(", "with", "the", "same", "interface", ")", ".", "Assume", "that", "the", "final", "action", "in", "the", "sequence", "should", "be", "a", "left", "shift", "." ]

[ "mips", "0", "1", "0", "2", "1" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "128" ]

[]

[ "<s>", "static", "bool", "expand_perm_with_vster", "(", "const", "struct", "expand_vec_perm_d", "&", "d", ")", "{", "if", "(", "TARGET_VXE2", "&&", "d", ".", "op0", "==", "d", ".", "op1", "&&", "is_reverse_perm_mask", "(", "d", ")", "&&", "(", "d", ".", "vmode", "==", "V2DImode", "||", "d", ".", "vmode", "==", "V2DFmode", "||", "d", ".", "vmode", "==", "V4SImode", "||", "d", ".", "vmode", "==", "V4SFmode", "||", "d", ".", "vmode", "==", "V8HImode", ")", ")", "{", "if", "(", "d", ".", "testing_p", ")", "return", "true", ";", "if", "(", "d", ".", "vmode", "==", "V2DImode", ")", "emit_insn", "(", "gen_eltswapv2di", "(", "d", ".", "target", ",", "d", ".", "op0", ")", ")", ";", "else", "if", "(", "d", ".", "vmode", "==", "V2DFmode", ")", "emit_insn", "(", "gen_eltswapv2df", "(", "d", ".", "target", ",", "d", ".", "op0", ")", ")", ";", "else", "if", "(", "d", ".", "vmode", "==", "V4SImode", ")", "emit_insn", "(", "gen_eltswapv4si", "(", "d", ".", "target", ",", "d", ".", "op0", ")", ")", ";", "else", "if", "(", "d", ".", "vmode", "==", "V4SFmode", ")", "emit_insn", "(", "gen_eltswapv4sf", "(", "d", ".", "target", ",", "d", ".", "op0", ")", ")", ";", "else", "if", "(", "d", ".", "vmode", "==", "V8HImode", ")", "emit_insn", "(", "gen_eltswapv8hi", "(", "d", ".", "target", ",", "d", ".", "op0", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "we", "just", "reverse", "the", "elements", ",", "emit", "an", "eltswap", "if", "we", "have", "vler/vster", "." ]

[ "s390" ]

[]

[ "<s>", "void", "LoongArchInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "Address", ",", "STI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "Address", ",", "STI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "LoongArch", "LoongArch" ]

[]

[ "<s>", "bool", "function_resolver", "::", "check_num_arguments", "(", "unsigned", "int", "expected", ")", "{", "if", "(", "m_arglist", ".", "length", "(", ")", "<", "expected", ")", "error_at", "(", "location", ",", "\"too few arguments to function %qE\"", ",", "fndecl", ")", ";", "else", "if", "(", "m_arglist", ".", "length", "(", ")", ">", "expected", ")", "error_at", "(", "location", ",", "\"too many arguments to function %qE\"", ",", "fndecl", ")", ";", "return", "m_arglist", ".", "length", "(", ")", "==", "expected", ";", "}", "</s>" ]

[ "Require", "the", "function", "to", "have", "exactly", "EXPECTED", "arguments", ".", "Return", "true", "if", "it", "does", ",", "otherwise", "report", "an", "appropriate", "error", "." ]

[ "aarch64", "\"too few arguments to function %qE\"", "\"too many arguments to function %qE\"" ]

[]

[ "<s>", "MCSection", "*", "GBZ80TargetObjectFile", "::", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ",", "unsigned", "&", "Align", ")", "const", "{", "assert", "(", "Kind", ".", "isReadOnly", "(", ")", "&&", "\"Writeable constant?\"", ")", ";", "return", "getSection", "(", "Kind", ",", "StringRef", "(", ")", ",", "ST_ROM0", ",", "0", ",", "~", "0U", ",", "Align", ",", "nullptr", ")", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "GBZ80", "GB", "\"Writeable constant?\"", "0", "0U" ]

[]

[ "<s>", "bool", "isFPImm", "(", ")", "const", "{", "return", "Kind", "==", "k_FPImmediate", ";", "}", "</s>" ]

[ "isFPImm", "-", "Tests", "if", "this", "is", "a", "MO_FPImmediate", "operand", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "WebAssemblyTargetELFStreamer", "::", "emitLocal", "(", "ArrayRef", "<", "MVT", ">", "Types", ")", "{", "Streamer", ".", "EmitULEB128IntValue", "(", "Types", ".", "size", "(", ")", ")", ";", "for", "(", "MVT", "Type", ":", "Types", ")", "Streamer", ".", "EmitIntValue", "(", "int64_t", "(", "WebAssembly", "::", "toValType", "(", "Type", ")", ")", ",", "1", ")", ";", "}", "</s>" ]

[ ".local" ]

[ "WebAssembly", "WebAssembly", "WebAssembly::toValType", "1" ]

[]

[ "<s>", "bool", "n7_consumed_by_ii_dep_p", "(", "rtx_insn", "*", "consumer", ",", "rtx", "def_reg", ")", "{", "rtx", "use_rtx", ";", "switch", "(", "get_attr_type", "(", "consumer", ")", ")", "{", "case", "TYPE_ALU", ":", "if", "(", "movd44_even_dep_p", "(", "consumer", ",", "def_reg", ")", ")", "return", "true", ";", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MUL", ":", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MAC", ":", "use_rtx", "=", "extract_mac_non_acc_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_DIV", ":", "if", "(", "INSN_CODE", "(", "consumer", ")", "==", "CODE_FOR_divmodsi4", "||", "INSN_CODE", "(", "consumer", ")", "==", "CODE_FOR_udivmodsi4", ")", "use_rtx", "=", "SET_SRC", "(", "parallel_element", "(", "consumer", ",", "0", ")", ")", ";", "else", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_LOAD", ":", "if", "(", "post_update_insn_p", "(", "consumer", ")", ")", "use_rtx", "=", "extract_base_reg", "(", "consumer", ")", ";", "else", "use_rtx", "=", "extract_mem_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_STORE", ":", "if", "(", "post_update_insn_p", "(", "consumer", ")", ")", "use_rtx", "=", "extract_base_reg", "(", "consumer", ")", ";", "else", "use_rtx", "=", "extract_mem_rtx", "(", "consumer", ")", ";", "if", "(", "reg_overlap_p", "(", "def_reg", ",", "use_rtx", ")", ")", "return", "true", ";", "if", "(", "!", "post_update_insn_p", "(", "consumer", ")", "&&", "!", "immed_offset_p", "(", "extract_mem_rtx", "(", "consumer", ")", ")", ")", "return", "false", ";", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_LOAD_MULTIPLE", ":", "use_rtx", "=", "extract_base_reg", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_STORE_MULTIPLE", ":", "use_rtx", "=", "extract_base_reg", "(", "consumer", ")", ";", "if", "(", "reg_overlap_p", "(", "def_reg", ",", "use_rtx", ")", ")", "return", "true", ";", "use_rtx", "=", "extract_nth_access_rtx", "(", "consumer", ",", "0", ")", ";", "break", ";", "case", "TYPE_BRANCH", ":", "use_rtx", "=", "PATTERN", "(", "consumer", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "reg_overlap_p", "(", "def_reg", ",", "use_rtx", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Check", "the", "dependency", "between", "the", "producer", "defining", "DEF_REG", "and", "CONSUMER", "requiring", "input", "operand", "at", "II", "." ]

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

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "const", "MipsSEInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsSEInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "MipsRegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "MipsRegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SP", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ";", "unsigned", "FP", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "FP_64", ":", "Mips", "::", "FP", ";", "unsigned", "ZERO", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "ZERO_64", ":", "Mips", "::", "ZERO", ";", "unsigned", "ADDu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDu", ":", "Mips", "::", "ADDu", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDu", ")", ",", "SP", ")", ".", "addReg", "(", "FP", ")", ".", "addReg", "(", "ZERO", ")", ";", "}", "if", "(", "MipsFI", "->", "callsEhReturn", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "STI", ".", "isABI_N64", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "for", "(", "int", "J", "=", "0", ";", "J", "<", "4", ";", "++", "J", ")", "{", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "ehDataReg", "(", "J", ")", ",", "MipsFI", "->", "getEhDataRegFI", "(", "J", ")", ",", "RC", ",", "&", "RegInfo", ")", ";", "}", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::SP_64", "Mips::SP", "Mips::FP_64", "Mips::FP", "Mips::ZERO_64", "Mips::ZERO", "Mips::DADDu", "Mips::ADDu", "0", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "0", "0", "4", "Mips" ]

[]

[ "<s>", "void", "X86FlagsCopyLoweringPass", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "X86TargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "bool", "ShouldPrint", "=", "false", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "(", "Subtarget", ".", "hasSSE2", "(", ")", "||", "Subtarget", ".", "hasAVX", "(", ")", ")", ")", "{", "PM", ".", "add", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "Subtarget", ".", "hasAVX", "(", ")", "&&", "UseVZeroUpper", ")", "{", "PM", ".", "add", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "return", "ShouldPrint", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::VR128RegClass", "X86" ]

[]

[ "<s>", "static", "hashval_t", "hash", "(", "const", "char", "*", "str", ")", "{", "return", "htab_hash_string", "(", "str", ")", ";", "}", "</s>" ]

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

[ "m32c" ]

[]

[ "<s>", "static", "void", "print_shift_count_operand", "(", "FILE", "*", "file", ",", "rtx", "op", ")", "{", "if", "(", "!", "s390_valid_shift_count", "(", "op", ",", "0", ")", ")", "gcc_unreachable", "(", ")", ";", "while", "(", "op", "&&", "GET_CODE", "(", "op", ")", "==", "SUBREG", ")", "op", "=", "SUBREG_REG", "(", "op", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "AND", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "print_addrstyle_operand", "(", "file", ",", "op", ")", ";", "}", "</s>" ]

[ "Output", "operand", "OP", "to", "stdio", "stream", "FILE", ".", "OP", "is", "an", "address", "(", "register", "+", "offset", ")", "which", "is", "not", "used", "to", "address", "data", ";", "instead", "the", "rightmost", "bits", "are", "interpreted", "as", "the", "value", "." ]

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

[]

[ "<s>", "static", "bool", "aarch64_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "size", ";", "machine_mode", "ag_mode", ";", "int", "count", ";", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "TREE_CODE", "(", "type", ")", "!=", "COMPLEX_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "VECTOR_TYPE", ")", "return", "false", ";", "if", "(", "aarch64_vfp_is_call_or_return_candidate", "(", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "&", "ag_mode", ",", "&", "count", ",", "NULL", ")", ")", "return", "false", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "<", "0", "||", "size", ">", "2", "*", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_RETURN_IN_MEMORY", ".", "If", "the", "type", "T", "of", "the", "result", "of", "a", "function", "is", "such", "that", "void", "func", "(", "T", "arg", ")", "would", "require", "that", "arg", "be", "passed", "as", "a", "value", "in", "a", "register", "(", "or", "set", "of", "registers", ")", "according", "to", "the", "parameter", "passing", "rules", ",", "then", "the", "result", "is", "returned", "in", "the", "same", "registers", "as", "would", "be", "used", "for", "such", "an", "argument", "." ]

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

[]

[ "<s>", "void", "aarch64_d_register_target_info", "(", "void", ")", "{", "const", "struct", "d_target_info_spec", "handlers", "[", "]", "=", "{", "{", "\"floatAbi\"", ",", "aarch64_d_handle_target_float_abi", "}", ",", "{", "NULL", ",", "NULL", "}", ",", "}", ";", "d_add_target_info_handlers", "(", "handlers", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_D_REGISTER_CPU_TARGET_INFO", "." ]

[ "aarch64", "\"floatAbi\"" ]

[]

[ "<s>", "static", "void", "rs6000_eliminate_indexed_memrefs", "(", "rtx", "operands", "[", "2", "]", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", "&&", "!", "REG_P", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", "&&", "!", "legitimate_constant_pool_address_p", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ",", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "false", ")", ")", "operands", "[", "0", "]", "=", "replace_equiv_address", "(", "operands", "[", "0", "]", ",", "copy_addr_to_reg", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", ")", ";", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", "&&", "!", "REG_P", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", "&&", "!", "legitimate_constant_pool_address_p", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ",", "GET_MODE", "(", "operands", "[", "1", "]", ")", ",", "false", ")", ")", "operands", "[", "1", "]", "=", "replace_equiv_address", "(", "operands", "[", "1", "]", ",", "copy_addr_to_reg", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", ")", ";", "}", "</s>" ]

[ "Helper", "for", "the", "following", ".", "Get", "rid", "of", "[", "r+r", "]", "memory", "refs", "in", "cases", "where", "it", "wo", "n't", "work", "(", "TImode", ",", "TFmode", ")", "." ]

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

[]

[ "<s>", "bool", "WebAssembly", "::", "mayThrow", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "THROW", ":", "case", "WebAssembly", "::", "THROW_S", ":", "case", "WebAssembly", "::", "RETHROW", ":", "case", "WebAssembly", "::", "RETHROW_S", ":", "return", "true", ";", "}", "if", "(", "isCallIndirect", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "isCall", "(", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "getCalleeOpNo", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", ";", "assert", "(", "MO", ".", "isGlobal", "(", ")", ")", ";", "const", "auto", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "if", "(", "!", "F", ")", "return", "true", ";", "if", "(", "F", "->", "doesNotThrow", "(", ")", ")", "return", "false", ";", "if", "(", "F", "->", "getName", "(", ")", "==", "CxaBeginCatchFn", "||", "F", "->", "getName", "(", ")", "==", "PersonalityWrapperFn", "||", "F", "->", "getName", "(", ")", "==", "ClangCallTerminateFn", "||", "F", "->", "getName", "(", ")", "==", "StdTerminateFn", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "may", "throw", "an", "exception", "." ]

[ "WebAssembly", "WebAssembly::mayThrow", "WebAssembly::THROW", "WebAssembly::THROW_S", "WebAssembly::RETHROW", "WebAssembly::RETHROW_S" ]

[]

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

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

[ "TriCore" ]

[]

[ "<s>", "static", "rtx", "visium_function_value", "(", "const_tree", "ret_type", ",", "const_tree", "fn_decl_or_type", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "return", "visium_function_value_1", "(", "TYPE_MODE", "(", "ret_type", ")", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTX", "representing", "the", "place", "where", "a", "function", "returns", "or", "receives", "a", "value", "of", "data", "type", "RET_TYPE", "." ]

[ "visium" ]

[]

[ "<s>", "bool", "ix86_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "mode1", "==", "mode2", ")", "return", "true", ";", "if", "(", "ix86_tieable_integer_mode_p", "(", "mode1", ")", "&&", "ix86_tieable_integer_mode_p", "(", "mode2", ")", ")", "return", "true", ";", "if", "(", "mode2", "==", "XFmode", ")", "return", "mode1", "==", "SFmode", "||", "mode1", "==", "DFmode", ";", "if", "(", "mode2", "==", "DFmode", ")", "return", "mode1", "==", "SFmode", ";", "if", "(", "GET_MODE_SIZE", "(", "mode2", ")", "==", "32", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode2", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode1", ")", "==", "32", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode1", ")", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode2", ")", "==", "16", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode2", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode1", ")", "==", "16", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode1", ")", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode2", ")", "==", "8", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_MMX_REG", ",", "mode2", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode1", ")", "==", "8", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_MMX_REG", ",", "mode1", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE1", "is", "accessible", "in", "a", "register", "that", "can", "hold", "MODE2", "without", "copying", ".", "That", "is", ",", "all", "register", "classes", "that", "can", "hold", "MODE2", "can", "also", "hold", "MODE1", "." ]

[ "i386", "32", "32", "16", "16", "8", "8" ]

[]

[ "<s>", "static", "bool", "loongarch_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", "||", "to", "==", "STACK_POINTER_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_ELIMINATE", ".", "Make", "sure", "that", "we", "'re", "not", "trying", "to", "eliminate", "to", "the", "wrong", "hard", "frame", "pointer", "." ]

[ "loongarch" ]

[]

[ "<s>", "bool", "AArch64CollectLOH", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineDominatorTree", "*", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MapRegToId", "RegToId", ";", "MapIdToReg", "IdToReg", ";", "AArch64FunctionInfo", "*", "AArch64FI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "assert", "(", "AArch64FI", "&&", "\"No MachineFunctionInfo for this function!\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Looking for LOH in \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "collectInvolvedReg", "(", "MF", ",", "RegToId", ",", "IdToReg", ",", "TRI", ")", ";", "if", "(", "RegToId", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineInstr", "*", "DummyOp", "=", "nullptr", ";", "if", "(", "BasicBlockScopeOnly", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DummyOp", "=", "MF", ".", "CreateMachineInstr", "(", "TII", "->", "get", "(", "AArch64", "::", "COPY", ")", ",", "DebugLoc", "(", ")", ")", ";", "}", "unsigned", "NbReg", "=", "RegToId", ".", "size", "(", ")", ";", "bool", "Modified", "=", "false", ";", "InstrToInstrs", "*", "ColorOpToReachedUses", "=", "new", "InstrToInstrs", "[", "NbReg", "]", ";", "reachingDef", "(", "MF", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "true", ",", "DummyOp", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"ADRP reaching defs\\n\"", ")", ";", "DEBUG", "(", "printReachingDef", "(", "ColorOpToReachedUses", ",", "NbReg", ",", "TRI", ",", "IdToReg", ")", ")", ";", "InstrToInstrs", "ADRPToReachingDefs", ";", "reachedUsesToDefs", "(", "ADRPToReachingDefs", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "true", ")", ";", "computeADRP", "(", "ADRPToReachingDefs", ",", "*", "AArch64FI", ",", "MDT", ")", ";", "delete", "[", "]", "ColorOpToReachedUses", ";", "ColorOpToReachedUses", "=", "new", "InstrToInstrs", "[", "NbReg", "]", ";", "reachingDef", "(", "MF", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "false", ",", "DummyOp", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"All reaching defs\\n\"", ")", ";", "DEBUG", "(", "printReachingDef", "(", "ColorOpToReachedUses", ",", "NbReg", ",", "TRI", ",", "IdToReg", ")", ")", ";", "InstrToInstrs", "UsesToReachingDefs", ";", "reachedUsesToDefs", "(", "UsesToReachingDefs", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "false", ")", ";", "computeOthers", "(", "UsesToReachingDefs", ",", "ColorOpToReachedUses", ",", "*", "AArch64FI", ",", "RegToId", ",", "MDT", ")", ";", "delete", "[", "]", "ColorOpToReachedUses", ";", "if", "(", "BasicBlockScopeOnly", ")", "MF", ".", "DeleteMachineInstr", "(", "DummyOp", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "\"No MachineFunctionInfo for this function!\"", "\"Looking for LOH in \"", "AArch64::COPY", "\"ADRP reaching defs\\n\"", "AArch64", "\"All reaching defs\\n\"", "AArch64" ]

[]

[ "<s>", "ARMProcFamilyEnum", "getProcFamily", "(", ")", "const", "{", "return", "ARMProcFamily", ";", "}", "</s>" ]

[ "Returns", "RISC-V", "processor", "family", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "machine_mode", "promote_return", "(", "machine_mode", "mode", ")", "{", "return", "promote_arg", "(", "mode", ",", "true", ")", ";", "}", "</s>" ]

[ "A", "non-memory", "return", "type", "of", "MODE", "is", "being", "returned", ".", "Determine", "the", "mode", "it", "should", "be", "promoted", "to", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "shouldFormOverflowOp", "(", "unsigned", "Opcode", ",", "EVT", "VT", ",", "bool", "MathUsed", ")", "const", "override", "{", "return", "TargetLowering", "::", "shouldFormOverflowOp", "(", "Opcode", ",", "VT", ",", "true", ")", ";", "}", "</s>" ]

[ "Overflow", "nodes", "should", "get", "combined/lowered", "to", "optimal", "instructions", "(", "they", "should", "allow", "eliminating", "explicit", "compares", "by", "getting", "flags", "from", "math", "ops", ")", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "int", "s390_sched_score", "(", "rtx_insn", "*", "insn", ")", "{", "unsigned", "int", "mask", "=", "s390_get_sched_attrmask", "(", "insn", ")", ";", "int", "score", "=", "0", ";", "switch", "(", "s390_sched_state", ")", "{", "case", "0", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "!=", "0", "||", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "!=", "0", ")", "score", "+=", "5", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "!=", "0", ")", "score", "+=", "10", ";", "case", "1", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "==", "0", ")", "score", "+=", "10", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_ENDGROUP", ")", "==", "0", ")", "score", "+=", "5", ";", "break", ";", "case", "2", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "==", "0", ")", "score", "+=", "10", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_ENDGROUP", ")", "!=", "0", ")", "score", "+=", "10", ";", "break", ";", "case", "S390_SCHED_STATE_NORMAL", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "==", "0", "&&", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "==", "0", ")", "score", "+=", "5", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "!=", "0", ")", "score", "+=", "10", ";", "break", ";", "case", "S390_SCHED_STATE_CRACKED", ":", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "!=", "0", "||", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "!=", "0", ")", "score", "+=", "5", ";", "break", ";", "}", "if", "(", "s390_tune", ">=", "PROCESSOR_2964_Z13", ")", "{", "int", "units", ",", "i", ";", "unsigned", "unit_mask", ",", "m", "=", "1", ";", "unit_mask", "=", "s390_get_unit_mask", "(", "insn", ",", "&", "units", ")", ";", "gcc_assert", "(", "units", "<=", "MAX_SCHED_UNITS", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "i", "++", ",", "m", "<<=", "1", ")", "if", "(", "m", "&", "unit_mask", ")", "score", "+=", "(", "last_scheduled_unit_distance", "[", "i", "]", "*", "MAX_SCHED_MIX_SCORE", "/", "MAX_SCHED_MIX_DISTANCE", ")", ";", "}", "return", "score", ";", "}", "</s>" ]

[ "Return", "the", "scheduling", "score", "for", "INSN", ".", "The", "higher", "the", "score", "the", "better", ".", "The", "score", "is", "calculated", "from", "the", "OOO", "scheduling", "attributes", "of", "INSN", "and", "the", "scheduling", "state", "s390_sched_state", "." ]

[ "s390", "0", "0", "0", "0", "5", "0", "10", "1", "0", "0", "0", "10", "0", "5", "2", "0", "0", "0", "10", "0", "10", "0", "0", "5", "0", "10", "0", "0", "5", "1", "0", "1" ]

[]

[ "<s>", "static", "reg_class_t", "mips_canonicalize_move_class", "(", "reg_class_t", "rclass", ")", "{", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "ACC_REGS", ")", ")", "rclass", "=", "ACC_REGS", ";", "if", "(", "TARGET_MIPS16", "&&", "reg_class_subset_p", "(", "rclass", ",", "M16_REGS", ")", ")", "rclass", "=", "M16_REGS", ";", "else", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "GENERAL_REGS", ")", ")", "rclass", "=", "GENERAL_REGS", ";", "return", "rclass", ";", "}", "</s>" ]

[ "RCLASS", "is", "a", "class", "involved", "in", "a", "REGISTER_MOVE_COST", "calculation", ".", "Return", "a", "``", "canonical", "''", "class", "to", "represent", "it", "in", "later", "calculations", "." ]

[ "mips" ]

[]

[ "<s>", "static", "void", "build_one", "(", "function_builder", "&", "b", ",", "const", "function_group_info", "&", "group", ",", "unsigned", "int", "pred_idx", ",", "unsigned", "int", "vec_type_idx", ")", "{", "auto_vec", "<", "tree", ",", "21", ">", "argument_types", ";", "function_instance", "function_instance", "(", "group", ".", "base_name", ",", "*", "group", ".", "base", ",", "*", "group", ".", "shape", ",", "group", ".", "ops_infos", ".", "types", "[", "vec_type_idx", "]", ",", "group", ".", "preds", "[", "pred_idx", "]", ",", "&", "group", ".", "ops_infos", ")", ";", "tree", "return_type", "=", "group", ".", "ops_infos", ".", "ret", ".", "get_tree_type", "(", "group", ".", "ops_infos", ".", "types", "[", "vec_type_idx", "]", ".", "index", ")", ";", "b", ".", "allocate_argument_types", "(", "function_instance", ",", "argument_types", ")", ";", "b", ".", "apply_predication", "(", "function_instance", ",", "return_type", ",", "argument_types", ")", ";", "b", ".", "add_unique_function", "(", "function_instance", ",", "(", "*", "group", ".", "shape", ")", ",", "return_type", ",", "argument_types", ")", ";", "}", "</s>" ]

[ "Add", "one", "function", "instance", "for", "GROUP", ",", "using", "operand", "suffix", "at", "index", "OI", ",", "mode", "suffix", "at", "index", "PAIR", "&", "&", "bi", "and", "predication", "suffix", "at", "index", "pred_idx", "." ]

[ "riscv", "21" ]

[]

[ "<s>", "void", "AArch64TargetStreamer", "::", "emitInst", "(", "uint32_t", "Inst", ")", "{", "char", "Buffer", "[", "4", "]", ";", "for", "(", "char", "&", "C", ":", "Buffer", ")", "{", "C", "=", "uint8_t", "(", "Inst", ")", ";", "Inst", ">>=", "8", ";", "}", "getStreamer", "(", ")", ".", "emitBytes", "(", "StringRef", "(", "Buffer", ",", "4", ")", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".inst", "directive", "." ]

[ "AArch64", "AArch64", "4", "8", "4" ]

[]

[ "<s>", "auto", "AlignVectors", "::", "move", "(", "const", "MoveGroup", "&", "Move", ")", "const", "->", "bool", "{", "assert", "(", "!", "Move", ".", "Main", ".", "empty", "(", ")", "&&", "\"Move group should have non-empty Main\"", ")", ";", "Instruction", "*", "Where", "=", "Move", ".", "Main", ".", "front", "(", ")", ";", "if", "(", "Move", ".", "IsLoad", ")", "{", "for", "(", "Instruction", "*", "D", ":", "Move", ".", "Deps", ")", "D", "->", "moveBefore", "(", "Where", ")", ";", "ArrayRef", "<", "Instruction", "*", ">", "Main", "(", "Move", ".", "Main", ")", ";", "for", "(", "Instruction", "*", "M", ":", "Main", ".", "drop_front", "(", "1", ")", ")", "{", "M", "->", "moveAfter", "(", "Where", ")", ";", "Where", "=", "M", ";", "}", "}", "else", "{", "assert", "(", "Move", ".", "Deps", ".", "empty", "(", ")", ")", ";", "ArrayRef", "<", "Instruction", "*", ">", "Main", "(", "Move", ".", "Main", ")", ";", "for", "(", "Instruction", "*", "M", ":", "Main", ".", "drop_front", "(", "1", ")", ")", "{", "M", "->", "moveBefore", "(", "Where", ")", ";", "Where", "=", "M", ";", "}", "}", "return", "Move", ".", "Main", ".", "size", "(", ")", "+", "Move", ".", "Deps", ".", "size", "(", ")", ">", "1", ";", "}", "</s>" ]

[ "Move", "in", "the", "provide", "values", "in", "ValuesToLink", "from", "Src", "." ]

[ "Hexagon", "\"Move group should have non-empty Main\"", "1", "1", "1" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isUInt", "<", "32", ">", "(", "Imm", ")", "||", "isUInt", "<", "32", ">", "(", "-", "Imm", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "add", "immediate", ",", "that", "is", "the", "target", "has", "add", "instructions", "which", "can", "add", "a", "register", "and", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

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

[]

[ "<s>", "void", "AArch64AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "OutStreamer", ",", "MI", ")", ")", "return", ";", "if", "(", "AArch64FI", "->", "getLOHRelated", "(", ")", ".", "count", "(", "MI", ")", ")", "{", "MCSymbol", "*", "LOHLabel", "=", "GetTempSymbol", "(", "\"loh\"", ",", "LOHLabelCounter", "++", ")", ";", "LOHInstToLabel", "[", "MI", "]", "=", "LOHLabel", ";", "OutStreamer", ".", "EmitLabel", "(", "LOHLabel", ")", ";", "}", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "DBG_VALUE", ":", "{", "if", "(", "isVerbose", "(", ")", "&&", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "{", "SmallString", "<", "128", ">", "TmpStr", ";", "raw_svector_ostream", "OS", "(", "TmpStr", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "OS", ".", "str", "(", ")", ")", ")", ";", "}", "return", ";", "}", "case", "AArch64", "::", "TCRETURNri", ":", "{", "MCInst", "TmpInst", ";", "TmpInst", ".", "setOpcode", "(", "AArch64", "::", "BR", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst", ")", ";", "return", ";", "}", "case", "AArch64", "::", "TCRETURNdi", ":", "{", "MCOperand", "Dest", ";", "MCInstLowering", ".", "lowerOperand", "(", "MI", "->", "getOperand", "(", "0", ")", ",", "Dest", ")", ";", "MCInst", "TmpInst", ";", "TmpInst", ".", "setOpcode", "(", "AArch64", "::", "B", ")", ";", "TmpInst", ".", "addOperand", "(", "Dest", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst", ")", ";", "return", ";", "}", "case", "AArch64", "::", "TLSDESC_BLR", ":", "{", "MCOperand", "Callee", ",", "Sym", ";", "MCInstLowering", ".", "lowerOperand", "(", "MI", "->", "getOperand", "(", "0", ")", ",", "Callee", ")", ";", "MCInstLowering", ".", "lowerOperand", "(", "MI", "->", "getOperand", "(", "1", ")", ",", "Sym", ")", ";", "MCInst", "TLSDescCall", ";", "TLSDescCall", ".", "setOpcode", "(", "AArch64", "::", "TLSDESCCALL", ")", ";", "TLSDescCall", ".", "addOperand", "(", "Sym", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TLSDescCall", ")", ";", "MCInst", "BLR", ";", "BLR", ".", "setOpcode", "(", "AArch64", "::", "BLR", ")", ";", "BLR", ".", "addOperand", "(", "Callee", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "BLR", ")", ";", "return", ";", "}", "case", "TargetOpcode", "::", "STACKMAP", ":", "return", "LowerSTACKMAP", "(", "OutStreamer", ",", "SM", ",", "*", "MI", ")", ";", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "return", "LowerPATCHPOINT", "(", "OutStreamer", ",", "SM", ",", "*", "MI", ")", ";", "}", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"loh\"", "AArch64::DBG_VALUE", "128", "AArch64::TCRETURNri", "AArch64::BR", "0", "AArch64::TCRETURNdi", "0", "AArch64::B", "AArch64::TLSDESC_BLR", "0", "1", "AArch64::TLSDESCCALL", "AArch64::BLR" ]

[]

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

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

[ "h8300", "4", "8" ]

[]

[ "<s>", "void", "cris_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "putc", "(", "'['", ",", "file", ")", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "cris_output_addr_const", "(", "file", ",", "x", ")", ";", "else", "if", "(", "BASE_OR_AUTOINCR_P", "(", "x", ")", ")", "cris_print_base", "(", "x", ",", "file", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "x1", ",", "x2", ";", "x1", "=", "XEXP", "(", "x", ",", "0", ")", ";", "x2", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "BASE_P", "(", "x1", ")", ")", "{", "cris_print_base", "(", "x1", ",", "file", ")", ";", "cris_print_index", "(", "x2", ",", "file", ")", ";", "}", "else", "if", "(", "BASE_P", "(", "x2", ")", ")", "{", "cris_print_base", "(", "x2", ",", "file", ")", ";", "cris_print_index", "(", "x1", ",", "file", ")", ";", "}", "else", "LOSE_AND_RETURN", "(", "\"unrecognized address\"", ",", "x", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "{", "putc", "(", "'['", ",", "file", ")", ";", "cris_print_base", "(", "XEXP", "(", "x", ",", "0", ")", ",", "file", ")", ";", "putc", "(", "']'", ",", "file", ")", ";", "}", "else", "LOSE_AND_RETURN", "(", "\"unrecognized address\"", ",", "x", ")", ";", "putc", "(", "']'", ",", "file", ")", ";", "}", "</s>" ]

[ "The", "PRINT_OPERAND_ADDRESS", "worker", "." ]

[ "cris", "0", "1", "\"unrecognized address\"", "0", "\"unrecognized address\"" ]

[]

[ "<s>", "static", "void", "report_out_of_range", "(", "location_t", "location", ",", "tree", "fndecl", ",", "unsigned", "int", "argno", ",", "HOST_WIDE_INT", "actual", ",", "HOST_WIDE_INT", "min", ",", "HOST_WIDE_INT", "max", ")", "{", "error_at", "(", "location", ",", "\"passing %wd to argument %d of %qE, which expects\"", "\" a value in the range [%wd, %wd]\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ",", "min", ",", "max", ")", ";", "}", "</s>" ]

[ "Report", "that", "LOCATION", "has", "a", "call", "to", "FNDECL", "in", "which", "argument", "ARGNO", "has", "the", "value", "ACTUAL", ",", "whereas", "the", "function", "requires", "a", "value", "in", "the", "range", "[", "MIN", ",", "MAX", "]", ".", "ARGNO", "counts", "from", "zero", "." ]

[ "aarch64", "\"passing %wd to argument %d of %qE, which expects\"", "\" a value in the range [%wd, %wd]\"", "1" ]

[]

[ "<s>", "int", "first_fp_reg_to_save", "(", "void", ")", "{", "int", "first_reg", ";", "for", "(", "first_reg", "=", "14", "+", "32", ";", "first_reg", "<=", "63", ";", "first_reg", "++", ")", "if", "(", "save_reg_p", "(", "first_reg", ")", ")", "break", ";", "return", "first_reg", ";", "}", "</s>" ]

[ "Similar", ",", "for", "FP", "regs", "." ]

[ "rs6000", "14", "32", "63" ]

[]

[ "<s>", "static", "unsigned", "rs6000_hash_constant", "(", "rtx", "k", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "k", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "k", ")", ";", "unsigned", "result", "=", "(", "code", "<<", "3", ")", "^", "mode", ";", "const", "char", "*", "format", ";", "int", "flen", ",", "fidx", ";", "format", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "flen", "=", "strlen", "(", "format", ")", ";", "fidx", "=", "0", ";", "switch", "(", "code", ")", "{", "case", "LABEL_REF", ":", "return", "result", "*", "1231", "+", "(", "unsigned", ")", "INSN_UID", "(", "XEXP", "(", "k", ",", "0", ")", ")", ";", "case", "CONST_WIDE_INT", ":", "{", "int", "i", ";", "flen", "=", "CONST_WIDE_INT_NUNITS", "(", "k", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "flen", ";", "i", "++", ")", "result", "=", "result", "*", "613", "+", "CONST_WIDE_INT_ELT", "(", "k", ",", "i", ")", ";", "return", "result", ";", "}", "case", "CONST_DOUBLE", ":", "return", "real_hash", "(", "CONST_DOUBLE_REAL_VALUE", "(", "k", ")", ")", "*", "result", ";", "case", "CODE_LABEL", ":", "fidx", "=", "3", ";", "break", ";", "default", ":", "break", ";", "}", "for", "(", ";", "fidx", "<", "flen", ";", "fidx", "++", ")", "switch", "(", "format", "[", "fidx", "]", ")", "{", "case", "'s'", ":", "{", "unsigned", "i", ",", "len", ";", "const", "char", "*", "str", "=", "XSTR", "(", "k", ",", "fidx", ")", ";", "len", "=", "strlen", "(", "str", ")", ";", "result", "=", "result", "*", "613", "+", "len", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "result", "=", "result", "*", "613", "+", "(", "unsigned", ")", "str", "[", "i", "]", ";", "break", ";", "}", "case", "'u'", ":", "case", "'e'", ":", "result", "=", "result", "*", "1231", "+", "rs6000_hash_constant", "(", "XEXP", "(", "k", ",", "fidx", ")", ")", ";", "break", ";", "case", "'i'", ":", "case", "'n'", ":", "result", "=", "result", "*", "613", "+", "(", "unsigned", ")", "XINT", "(", "k", ",", "fidx", ")", ";", "break", ";", "case", "'w'", ":", "if", "(", "sizeof", "(", "unsigned", ")", ">=", "sizeof", "(", "HOST_WIDE_INT", ")", ")", "result", "=", "result", "*", "613", "+", "(", "unsigned", ")", "XWINT", "(", "k", ",", "fidx", ")", ";", "else", "{", "size_t", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "HOST_WIDE_INT", ")", "/", "sizeof", "(", "unsigned", ")", ";", "i", "++", ")", "result", "=", "result", "*", "613", "+", "(", "unsigned", ")", "(", "XWINT", "(", "k", ",", "fidx", ")", ">>", "CHAR_BIT", "*", "i", ")", ";", "}", "break", ";", "case", "'0'", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Hash", "functions", "for", "the", "hash", "table", "." ]

[ "rs6000", "3", "0", "1231", "0", "0", "613", "3", "613", "0", "613", "1231", "613", "613", "0", "613" ]

[]

[ "<s>", "bool", "PPCCTRLoops", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "TM", "=", "&", "TPC", "->", "getTM", "<", "PPCTargetMachine", ">", "(", ")", ";", "STI", "=", "TM", "->", "getSubtargetImpl", "(", "F", ")", ";", "TLI", "=", "STI", "->", "getTargetLowering", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ".", "getSE", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "DL", "=", "&", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "auto", "*", "TLIP", "=", "getAnalysisIfAvailable", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "LibInfo", "=", "TLIP", "?", "&", "TLIP", "->", "getTLI", "(", ")", ":", "nullptr", ";", "PreserveLCSSA", "=", "mustPreserveAnalysisID", "(", "LCSSAID", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "LoopInfo", "::", "iterator", "I", "=", "LI", "->", "begin", "(", ")", ",", "E", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Loop", "*", "L", "=", "*", "I", ";", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "MadeChange", "|=", "convertToCTRLoop", "(", "L", ")", ";", "}", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

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

[]

[ "<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "override", "{", "return", "&", "getSubtargetImpl", "(", ")", "->", "getInstrItineraryData", "(", ")", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "RISCVTTIImpl", "::", "isLoweredToCall", "(", "const", "Function", "*", "F", ")", "{", "if", "(", "F", "->", "getName", "(", ")", ".", "startswith", "(", "\"llvm.riscv.cv\"", ")", ")", "return", "false", ";", "return", "BaseT", "::", "isLoweredToCall", "(", "F", ")", ";", "}", "</s>" ]

[ "Test", "whether", "calls", "to", "a", "function", "lower", "to", "actual", "program", "function", "calls", "." ]

[ "RISCV", "RISCV", "\"llvm.riscv.cv\"" ]

[]

[ "<s>", "static", "void", "tilegx_conditional_register_usage", "(", "void", ")", "{", "global_regs", "[", "TILEGX_NETORDER_REGNUM", "]", "=", "1", ";", "if", "(", "TILEGX_PIC_TEXT_LABEL_REGNUM", "!=", "INVALID_REGNUM", ")", "{", "fixed_regs", "[", "TILEGX_PIC_TEXT_LABEL_REGNUM", "]", "=", "1", ";", "call_used_regs", "[", "TILEGX_PIC_TEXT_LABEL_REGNUM", "]", "=", "1", ";", "}", "if", "(", "PIC_OFFSET_TABLE_REGNUM", "!=", "INVALID_REGNUM", ")", "{", "fixed_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "call_used_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Implemnet", "TARGET_CONDITIONAL_REGISTER_USAGE", "." ]

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

[]

[ "<s>", "bool", "ix86_rip_relative_addr_p", "(", "struct", "ix86_address", "*", "parts", ")", "{", "rtx", "base", ",", "index", ",", "disp", ";", "base", "=", "parts", "->", "base", ";", "index", "=", "parts", "->", "index", ";", "disp", "=", "parts", "->", "disp", ";", "if", "(", "disp", "&&", "!", "base", "&&", "!", "index", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "rtx", "symbol", "=", "disp", ";", "if", "(", "GET_CODE", "(", "disp", ")", "==", "CONST", ")", "symbol", "=", "XEXP", "(", "disp", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "symbol", ",", "1", ")", ")", ")", "symbol", "=", "XEXP", "(", "symbol", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "symbol", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "symbol", ")", "==", "0", ")", "||", "(", "GET_CODE", "(", "symbol", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "symbol", ",", "1", ")", "==", "UNSPEC_GOTPCREL", "||", "XINT", "(", "symbol", ",", "1", ")", "==", "UNSPEC_PCREL", "||", "XINT", "(", "symbol", ",", "1", ")", "==", "UNSPEC_GOTNTPOFF", ")", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "x86", "address", "PARTS", "is", "a", "pc-relative", "address", "." ]

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

[]

[ "<s>", "void", "SystemZFrameInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "const", "TargetFrameInfo", "&", "TFI", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SystemZInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "SystemZMachineFunctionInfo", "*", "SystemZMFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "StackSize", "-=", "SystemZMFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "StackSize", "-", "TFI", ".", "getOffsetOfLocalArea", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "MOV64mr", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "MOV64mrm", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "StackSize", "||", "MFI", "->", "hasCalls", "(", ")", ")", "{", "assert", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "SystemZ", "::", "R15D", ")", "&&", "\"Invalid stack frame calculation!\"", ")", ";", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "-", "(", "int64_t", ")", "NumBytes", ",", "TII", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "SystemZ", "::", "MOV64rr", ")", ",", "SystemZ", "::", "R11D", ")", ".", "addReg", "(", "SystemZ", "::", "R15D", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "llvm", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "SystemZ", "::", "R11D", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::MOV64mr", "SystemZ::MOV64mrm", "SystemZ::R15D", "\"Invalid stack frame calculation!\"", "SystemZ::MOV64rr", "SystemZ::R11D", "SystemZ::R15D", "SystemZ::R11D" ]

[]

[ "<s>", "static", "bool", "rs6000_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "tree", "fntype", ";", "if", "(", "CALL_EXPR_STATIC_CHAIN", "(", "exp", ")", ")", "return", "false", ";", "if", "(", "decl", ")", "fntype", "=", "TREE_TYPE", "(", "decl", ")", ";", "else", "fntype", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp", ")", ")", ")", ";", "if", "(", "TARGET_ALTIVEC_ABI", "&&", "TARGET_ALTIVEC_VRSAVE", "&&", "!", "(", "decl", "&&", "decl", "==", "current_function_decl", ")", ")", "{", "function_args_iterator", "args_iter", ";", "tree", "type", ";", "int", "nvreg", "=", "0", ";", "FOREACH_FUNCTION_ARGS", "(", "fntype", ",", "type", ",", "args_iter", ")", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "nvreg", "++", ";", "FOREACH_FUNCTION_ARGS", "(", "TREE_TYPE", "(", "current_function_decl", ")", ",", "type", ",", "args_iter", ")", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "nvreg", "--", ";", "if", "(", "nvreg", ">", "0", ")", "return", "false", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "||", "(", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "&&", "decl", "&&", "!", "DECL_EXTERNAL", "(", "decl", ")", "&&", "!", "DECL_WEAK", "(", "decl", ")", "&&", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", "||", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "(", "!", "TARGET_SECURE_PLT", "||", "!", "flag_pic", "||", "(", "decl", "&&", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", ")", ")", ")", "{", "tree", "attr_list", "=", "TYPE_ATTRIBUTES", "(", "fntype", ")", ";", "if", "(", "!", "lookup_attribute", "(", "\"longcall\"", ",", "attr_list", ")", "||", "lookup_attribute", "(", "\"shortcall\"", ",", "attr_list", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Say", "whether", "a", "function", "is", "a", "candidate", "for", "sibcall", "handling", "or", "not", ".", "We", "do", "not", "allow", "indirect", "calls", "to", "be", "optimized", "into", "sibling", "calls", ".", "Also", ",", "we", "ca", "n't", "do", "it", "if", "there", "are", "any", "vector", "parameters", ";", "there", "'s", "nowhere", "to", "put", "the", "VRsave", "code", "so", "it", "works", ";", "note", "that", "functions", "with", "vector", "parameters", "are", "required", "to", "have", "a", "prototype", ",", "so", "the", "argument", "type", "info", "must", "be", "available", "here", ".", "(", "The", "tail", "recursion", "case", "can", "work", "with", "vector", "parameters", ",", "but", "there", "'s", "no", "way", "to", "distinguish", "here", ".", ")" ]

[ "rs6000", "0", "0", "\"longcall\"", "\"shortcall\"" ]

[]

[ "<s>", "tree", "resolve", "(", "function_resolver", "&", "r", ")", "const", "OVERRIDE", "{", "unsigned", "int", "i", ",", "nargs", ";", "type_suffix_index", "type", ";", "if", "(", "!", "r", ".", "check_gp_argument", "(", "1", ",", "i", ",", "nargs", ")", "||", "(", "type", "=", "r", ".", "infer_vector_type", "(", "i", ")", ")", "==", "NUM_TYPE_SUFFIXES", ")", "return", "error_mark_node", ";", "if", "(", "type", "==", "TYPE_SUFFIX_b", ")", "return", "r", ".", "resolve_to", "(", "r", ".", "mode_suffix_id", ",", "type", ")", ";", "if", "(", "type_suffixes", "[", "type", "]", ".", "integer_p", "&&", "type_suffixes", "[", "type", "]", ".", "element_bits", "<", "64", ")", "{", "type_suffix_index", "wide_suffix", "=", "find_type_suffix", "(", "type_suffixes", "[", "type", "]", ".", "tclass", ",", "type_suffixes", "[", "type", "]", ".", "element_bits", "*", "2", ")", ";", "if", "(", "tree", "res", "=", "r", ".", "lookup_form", "(", "r", ".", "mode_suffix_id", ",", "wide_suffix", ")", ")", "return", "res", ";", "}", "return", "r", ".", "report_no_such_form", "(", "type", ")", ";", "}", "</s>" ]

[ "If", "the", "call", "is", "erroneous", ",", "report", "an", "appropriate", "error", "and", "return", "error_mark_node", ".", "Otherwise", ",", "if", "the", "function", "is", "overloaded", ",", "return", "the", "decl", "of", "the", "non-overloaded", "function", ".", "Return", "NULL_TREE", "otherwise", ",", "indicating", "that", "the", "call", "should", "be", "processed", "in", "the", "normal", "way", "." ]

[ "aarch64", "1", "64", "2" ]

[]

[ "<s>", "bool", "X86TTI", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataTy", ",", "int", "Consecutive", ")", "const", "{", "int", "DataWidth", "=", "DataTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "(", "DataWidth", "<", "32", ")", "||", "(", "Consecutive", "==", "0", ")", ")", "return", "false", ";", "if", "(", "ST", "->", "hasAVX512", "(", ")", "||", "ST", "->", "hasAVX2", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "load", "." ]

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

[]

[ "<s>", "bool", "AArch64AsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "size_t", "CondCodePos", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Mnemonic", "=", "Name", ".", "substr", "(", "0", ",", "CondCodePos", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "Mnemonic", ",", "NameLoc", ")", ")", ";", "if", "(", "CondCodePos", "!=", "StringRef", "::", "npos", ")", "{", "SMLoc", "S", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "CondCodePos", "+", "1", ")", ";", "StringRef", "CondStr", "=", "Name", ".", "substr", "(", "CondCodePos", "+", "1", ",", "StringRef", "::", "npos", ")", ";", "A64CC", "::", "CondCodes", "Code", ";", "Code", "=", "A64StringToCondCode", "(", "CondStr", ")", ";", "if", "(", "Code", "==", "A64CC", "::", "Invalid", ")", "{", "Error", "(", "S", ",", "\"invalid condition code\"", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "true", ";", "}", "SMLoc", "DotL", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "CondCodePos", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "\".\"", ",", "DotL", ")", ")", ";", "SMLoc", "E", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "CondCodePos", "+", "3", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateCondCode", "(", "Code", ",", "S", ",", "E", ")", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "ParseOperand", "(", "Operands", ",", "Mnemonic", ")", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "true", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ",", "Mnemonic", ")", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "true", ";", "}", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "RBrac", ")", ")", "{", "SMLoc", "Loc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "\"]\"", ",", "Loc", ")", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "}", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Exclaim", ")", ")", "{", "SMLoc", "Loc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "\"!\"", ",", "Loc", ")", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"expected comma before next operand\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "AArch64", "AArch64", "0", "AArch64", "1", "1", "A64CC::CondCodes", "A64CC::Invalid", "\"invalid condition code\"", "AArch64", "\".\"", "3", "AArch64", "AArch64", "\"]\"", "AArch64", "\"!\"", "\"expected comma before next operand\"" ]

[]

[ "<s>", "bool", "SystemZFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", "||", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", "->", "getManipulatesSP", "(", ")", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

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

[]

[ "<s>", "bool", "hasFPU", "(", ")", "const", "{", "return", "HasFPU", ";", "}", "</s>" ]

[ "Floating", "point", "support", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "rtx", "frv_int_to_acc", "(", "enum", "insn_code", "icode", ",", "int", "opnum", ",", "rtx", "opval", ")", "{", "rtx", "reg", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "ACC_MASK", ";", "i", "++", ")", "if", "(", "(", "i", "&", "ACC_MASK", ")", "==", "i", ")", "global_regs", "[", "i", "+", "ACC_FIRST", "]", "=", "global_regs", "[", "i", "+", "ACCG_FIRST", "]", "=", "1", ";", "if", "(", "GET_CODE", "(", "opval", ")", "!=", "CONST_INT", ")", "{", "error", "(", "\"accumulator is not a constant integer\"", ")", ";", "return", "NULL_RTX", ";", "}", "if", "(", "(", "INTVAL", "(", "opval", ")", "&", "~", "ACC_MASK", ")", "!=", "0", ")", "{", "error", "(", "\"accumulator number is out of bounds\"", ")", ";", "return", "NULL_RTX", ";", "}", "reg", "=", "gen_rtx_REG", "(", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "mode", ",", "ACC_FIRST", "+", "INTVAL", "(", "opval", ")", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "predicate", ")", "(", "reg", ",", "VOIDmode", ")", ")", "SET_REGNO", "(", "reg", ",", "ACCG_FIRST", "+", "INTVAL", "(", "opval", ")", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "predicate", ")", "(", "reg", ",", "VOIDmode", ")", ")", "{", "error", "(", "\"inappropriate accumulator for %qs\"", ",", "insn_data", "[", "icode", "]", ".", "name", ")", ";", "return", "NULL_RTX", ";", "}", "return", "reg", ";", "}", "</s>" ]

[ "Convert", "an", "integer", "constant", "to", "an", "accumulator", "register", ".", "ICODE", "is", "the", "code", "of", "the", "target", "instruction", ",", "OPNUM", "is", "the", "number", "of", "the", "accumulator", "operand", "and", "OPVAL", "is", "the", "constant", "integer", ".", "Try", "both", "ACC", "and", "ACCG", "registers", ";", "only", "report", "an", "error", "if", "neither", "fit", "the", "instruction", "." ]

[ "frv", "0", "1", "\"accumulator is not a constant integer\"", "0", "\"accumulator number is out of bounds\"", "\"inappropriate accumulator for %qs\"" ]

[]

[ "<s>", "HOST_WIDE_INT", "s390_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "HOST_WIDE_INT", "offset", ";", "int", "index", ";", "if", "(", "!", "s390_can_eliminate", "(", "from", ",", "to", ")", ")", "return", "0", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "offset", "=", "(", "get_frame_size", "(", ")", "+", "STACK_POINTER_OFFSET", "+", "current_function_outgoing_args_size", ")", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "s390_init_frame_layout", "(", ")", ";", "offset", "=", "cfun_frame_layout", ".", "frame_size", "+", "STACK_POINTER_OFFSET", ";", "break", ";", "case", "RETURN_ADDRESS_POINTER_REGNUM", ":", "s390_init_frame_layout", "(", ")", ";", "index", "=", "RETURN_REGNUM", "-", "cfun_frame_layout", ".", "first_save_gpr_slot", ";", "gcc_assert", "(", "index", ">=", "0", ")", ";", "offset", "=", "cfun_frame_layout", ".", "frame_size", "+", "cfun_frame_layout", ".", "gprs_offset", ";", "offset", "+=", "index", "*", "UNITS_PER_WORD", ";", "break", ";", "case", "BASE_REGNUM", ":", "offset", "=", "0", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "offset", ";", "}", "</s>" ]

[ "Return", "offset", "between", "register", "FROM", "and", "TO", "initially", "after", "prolog", "." ]

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

[]

[ "<s>", "void", "X86TargetLowering", "::", "insertSSPDeclarations", "(", "Module", "&", "M", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isOSMSVCRT", "(", ")", ")", "{", "M", ".", "getOrInsertGlobal", "(", "\"__security_cookie\"", ",", "Type", "::", "getInt8PtrTy", "(", "M", ".", "getContext", "(", ")", ")", ")", ";", "auto", "*", "SecurityCheckCookie", "=", "cast", "<", "Function", ">", "(", "M", ".", "getOrInsertFunction", "(", "\"__security_check_cookie\"", ",", "Type", "::", "getVoidTy", "(", "M", ".", "getContext", "(", ")", ")", ",", "Type", "::", "getInt8PtrTy", "(", "M", ".", "getContext", "(", ")", ")", ",", "nullptr", ")", ")", ";", "SecurityCheckCookie", "->", "setCallingConv", "(", "CallingConv", "::", "X86_FastCall", ")", ";", "SecurityCheckCookie", "->", "addAttribute", "(", "1", ",", "Attribute", "::", "AttrKind", "::", "InReg", ")", ";", "return", ";", "}", "if", "(", "Subtarget", ".", "isTargetGlibc", "(", ")", ")", "return", ";", "TargetLowering", "::", "insertSSPDeclarations", "(", "M", ")", ";", "}", "</s>" ]

[ "Inserts", "necessary", "declarations", "for", "SSP", "(", "stack", "protection", ")", "purpose", "." ]

[ "X86", "X86", "\"__security_cookie\"", "\"__security_check_cookie\"", "X86", "1" ]

[]

[ "<s>", "static", "machine_mode", "rs6000_promote_function_mode", "(", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", "ATTRIBUTE_UNUSED", ",", "const_tree", ",", "int", ")", "{", "PROMOTE_MODE", "(", "mode", ",", "*", "punsignedp", ",", "type", ")", ";", "return", "mode", ";", "}", "</s>" ]

[ "On", "rs6000", ",", "function", "arguments", "are", "promoted", ",", "as", "are", "function", "return", "values", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "ft32_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "named_size", "=", "GET_MODE_SIZE", "(", "SImode", ")", "*", "(", "*", "cum", "-", "FT32_R0", ")", "+", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", ";", "if", "(", "named_size", "<", "24", ")", "*", "pretend_size", "=", "24", "-", "named_size", ";", "else", "*", "pretend_size", "=", "0", ";", "}", "</s>" ]

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

[ "ft32", "24", "24", "0" ]

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "!", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "LR", ":", "PPC", "::", "LR8", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::LR", "PPC::LR8" ]

[]

[ "<s>", "bool", "AMDGPUCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "B", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "B", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setIfReturnsVoid", "(", "!", "Val", ")", ";", "assert", "(", "!", "Val", "==", "VRegs", ".", "empty", "(", ")", "&&", "\"Return value without a vreg\"", ")", ";", "CallingConv", "::", "ID", "CC", "=", "B", ".", "getMF", "(", ")", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "const", "bool", "IsShader", "=", "AMDGPU", "::", "isShader", "(", "CC", ")", ";", "const", "bool", "IsWaveEnd", "=", "(", "IsShader", "&&", "MFI", "->", "returnsVoid", "(", ")", ")", "||", "AMDGPU", "::", "isKernel", "(", "CC", ")", ";", "if", "(", "IsWaveEnd", ")", "{", "B", ".", "buildInstr", "(", "AMDGPU", "::", "S_ENDPGM", ")", ".", "addImm", "(", "0", ")", ";", "return", "true", ";", "}", "auto", "const", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "unsigned", "ReturnOpc", "=", "IsShader", "?", "AMDGPU", "::", "SI_RETURN_TO_EPILOG", ":", "AMDGPU", "::", "S_SETPC_B64_return", ";", "auto", "Ret", "=", "B", ".", "buildInstrNoInsert", "(", "ReturnOpc", ")", ";", "Register", "ReturnAddrVReg", ";", "if", "(", "ReturnOpc", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "{", "ReturnAddrVReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "CCR_SGPR_64RegClass", ")", ";", "Ret", ".", "addUse", "(", "ReturnAddrVReg", ")", ";", "}", "if", "(", "!", "lowerReturnVal", "(", "B", ",", "Val", ",", "VRegs", ",", "Ret", ")", ")", "return", "false", ";", "if", "(", "ReturnOpc", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "Register", "LiveInReturn", "=", "MF", ".", "addLiveIn", "(", "TRI", "->", "getReturnAddressReg", "(", "MF", ")", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ";", "B", ".", "buildCopy", "(", "ReturnAddrVReg", ",", "LiveInReturn", ")", ";", "}", "B", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "\"Return value without a vreg\"", "AMDGPU::isShader", "AMDGPU::isKernel", "AMDGPU::S_ENDPGM", "0", "AMDGPU::SI_RETURN_TO_EPILOG", "AMDGPU::S_SETPC_B64_return", "AMDGPU::S_SETPC_B64_return", "AMDGPU::CCR_SGPR_64RegClass", "AMDGPU::S_SETPC_B64_return", "SI", "AMDGPU::SGPR_64RegClass" ]

[]

[ "<s>", "static", "rtx", "alpha_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "basereg", ";", "int", "num_args", ";", "if", "(", "arg", ".", "aggregate_type_p", "(", ")", ")", "basereg", "=", "16", ";", "else", "{", "gcc_checking_assert", "(", "!", "COMPLEX_MODE_P", "(", "arg", ".", "mode", ")", ")", ";", "if", "(", "TARGET_FPREGS", "&&", "GET_MODE_CLASS", "(", "arg", ".", "mode", ")", "==", "MODE_FLOAT", ")", "basereg", "=", "32", "+", "16", ";", "else", "basereg", "=", "16", ";", "}", "{", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "return", "alpha_arg_info_reg_val", "(", "*", "cum", ")", ";", "num_args", "=", "cum", "->", "num_args", ";", "if", "(", "num_args", ">=", "6", "||", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", ")", "return", "NULL_RTX", ";", "}", "{", "if", "(", "*", "cum", ">=", "6", ")", "return", "NULL_RTX", ";", "num_args", "=", "*", "cum", ";", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "basereg", "=", "16", ";", "else", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", ")", "return", "NULL_RTX", ";", "}", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "num_args", "+", "basereg", ")", ";", "}", "</s>" ]

[ "Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "Alpha", "the", "first", "6", "words", "of", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", "." ]

[ "alpha", "16", "32", "16", "16", "6", "6", "16" ]

[]

[ "<s>", "static", "int", "rs6000_hard_regno_nregs_internal", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "reg_size", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "(", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "mode", "!=", "TDmode", "&&", "mode", "!=", "TFmode", ")", "?", "UNITS_PER_VSX_WORD", ":", "UNITS_PER_FP_WORD", ")", ";", "else", "if", "(", "SPE_SIMD_REGNO_P", "(", "regno", ")", "&&", "TARGET_SPE", "&&", "SPE_VECTOR_MODE", "(", "mode", ")", ")", "reg_size", "=", "UNITS_PER_SPE_WORD", ";", "else", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "UNITS_PER_ALTIVEC_WORD", ";", "else", "if", "(", "TARGET_E500_DOUBLE", "&&", "FLOAT_MODE_P", "(", "mode", ")", "&&", "mode", "!=", "SCmode", "&&", "!", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", "&&", "SPE_SIMD_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "UNITS_PER_FP_WORD", ";", "else", "reg_size", "=", "UNITS_PER_WORD", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "reg_size", "-", "1", ")", "/", "reg_size", ";", "}", "</s>" ]

[ "Return", "number", "of", "consecutive", "hard", "regs", "needed", "starting", "at", "reg", "REGNO", "to", "hold", "something", "of", "mode", "MODE", ".", "This", "is", "ordinarily", "the", "length", "in", "words", "of", "a", "value", "of", "mode", "MODE", "but", "can", "be", "less", "for", "certain", "modes", "in", "special", "long", "registers", ".", "POWER", "and", "PowerPC", "GPRs", "hold", "32", "bits", "worth", ";", "PowerPC64", "GPRs", "and", "FPRs", "point", "register", "holds", "64", "bits", "worth", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "const", "MOSRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "RegInfo", ";", "}", "</s>" ]

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

[ "MOS", "MOS" ]

[]

[ "<s>", "static", "rtx", "sparc_function_arg_1", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ",", "bool", "incoming_p", ")", "{", "const", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "regbase", "=", "(", "incoming_p", "?", "SPARC_INCOMING_INT_ARG_FIRST", ":", "SPARC_OUTGOING_INT_ARG_FIRST", ")", ";", "int", "slotno", ",", "regno", ",", "padding", ";", "enum", "mode_class", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "slotno", "=", "function_arg_slotno", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "incoming_p", ",", "&", "regno", ",", "&", "padding", ")", ";", "if", "(", "slotno", "==", "-", "1", ")", "return", "0", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "(", "TARGET_ARCH32", "&&", "size", "<=", "8", ")", "||", "(", "TARGET_ARCH64", "&&", "size", "<=", "16", ")", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "return", "function_arg_vector_value", "(", "size", ",", "SPARC_FP_ARG_FIRST", "+", "2", "*", "slotno", ")", ";", "mclass", "=", "MODE_FLOAT", ";", "}", "if", "(", "TARGET_ARCH32", ")", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "return", "function_arg_record_value", "(", "type", ",", "mode", ",", "slotno", ",", "named", ",", "regbase", ")", ";", "}", "else", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "return", "function_arg_union_value", "(", "size", ",", "mode", ",", "slotno", ",", "regno", ")", ";", "}", "else", "if", "(", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "SPARC_FP_REG_P", "(", "regno", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "if", "(", "cum", "->", "prototype_p", "||", "cum", "->", "libcall_p", ")", "{", "if", "(", "(", "regno", "-", "SPARC_FP_ARG_FIRST", ")", ">=", "SPARC_INT_ARG_MAX", "*", "2", ")", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ")", ")", ";", "else", "return", "reg", ";", "}", "else", "{", "rtx", "v0", ",", "v1", ";", "if", "(", "(", "regno", "-", "SPARC_FP_ARG_FIRST", ")", "<", "SPARC_INT_ARG_MAX", "*", "2", ")", "{", "int", "intreg", ";", "if", "(", "incoming_p", ")", "return", "reg", ";", "intreg", "=", "(", "SPARC_OUTGOING_INT_ARG_FIRST", "+", "(", "regno", "-", "SPARC_FP_ARG_FIRST", ")", "/", "2", ")", ";", "v0", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ";", "v1", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "intreg", ")", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "v0", ",", "v1", ")", ")", ";", "}", "else", "{", "v0", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "v1", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "v0", ",", "v1", ")", ")", ";", "}", "}", "}", "else", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "mode", "=", "mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "NAMED", "is", "true", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "INCOMING_P", "is", "false", "for", "TARGET_FUNCTION_ARG", ",", "true", "for", "TARGET_FUNCTION_INCOMING_ARG", "." ]

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

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "*", "MF", ".", "getFunction", "(", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "AArch64", "::", "RET_ReallyLR", ")", ";", "assert", "(", "(", "(", "Val", "&&", "VReg", ")", "||", "(", "!", "Val", "&&", "!", "VReg", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "bool", "Success", "=", "true", ";", "if", "(", "VReg", ")", "{", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForReturn", "(", "F", ".", "getCallingConv", "(", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "ArgInfo", "OrigArg", "{", "VReg", ",", "Val", "->", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "AttributeSet", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "unsigned", ">", "Regs", ",", "ArrayRef", "<", "uint64_t", ">", "Offsets", ")", "{", "MIRBuilder", ".", "buildExtract", "(", "Regs", ",", "Offsets", ",", "VReg", ")", ";", "}", ")", ";", "OutgoingArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "AssignFn", ",", "AssignFn", ")", ";", "Success", "=", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "Success", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "AArch64", "AArch64", "AArch64::RET_ReallyLR", "\"Return value without a vreg\"", "AArch64", "AArch64", "8" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "HexagonInstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "HexagonII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "Flags", "[", "]", "=", "{", "{", "HMOTF_ConstExtended", ",", "\"hexagon-ext\"", "}", "}", ";", "return", "makeArrayRef", "(", "Flags", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"hexagon-ext\"" ]

[]

[ "<s>", "static", "rtx", "aarch64_simd_dup_constant", "(", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vals", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "x", ";", "if", "(", "!", "const_vec_duplicate_p", "(", "vals", ",", "&", "x", ")", ")", "return", "NULL_RTX", ";", "x", "=", "copy_to_mode_reg", "(", "inner_mode", ",", "x", ")", ";", "return", "gen_vec_duplicate", "(", "mode", ",", "x", ")", ";", "}", "</s>" ]

[ "If", "VALS", "is", "a", "vector", "constant", "that", "can", "be", "loaded", "into", "a", "register", "using", "DUP", ",", "generate", "instructions", "to", "do", "so", "and", "return", "an", "RTX", "to", "assign", "to", "the", "register", ".", "Otherwise", "return", "NULL_RTX", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "NVPTXInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "{", "printInstruction", "(", "MI", ",", "Address", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "static", "bool", "riscv_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "enum", "riscv_symbol_type", "type", ";", "rtx", "base", ",", "offset", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "ALL", ")", "if", "(", "GET_CODE", "(", "*", "iter", ")", "==", "CONST_POLY_INT", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", ")", "return", "true", ";", "split_const", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "riscv_symbolic_constant_p", "(", "base", ",", "&", "type", ")", ")", "{", "if", "(", "SMALL_OPERAND", "(", "INTVAL", "(", "offset", ")", ")", "&&", "riscv_symbol_insns", "(", "type", ")", ">", "0", ")", "return", "true", ";", "if", "(", "flag_pic", ")", "return", "true", ";", "}", "if", "(", "tls_referenced_p", "(", "x", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "riscv", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "getName", "(", ")", "{", "return", "DEBUG_TYPE", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "{", "return", "Kind", "==", "Token", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "static", "enum", "tls_model", "tls_symbolic_operand_type", "(", "rtx", "symbol", ")", "{", "enum", "tls_model", "model", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "!=", "SYMBOL_REF", ")", "return", "0", ";", "model", "=", "SYMBOL_REF_TLS_MODEL", "(", "symbol", ")", ";", "if", "(", "model", "==", "TLS_MODEL_LOCAL_EXEC", "&&", "alpha_tls_size", "==", "64", ")", "model", "=", "TLS_MODEL_INITIAL_EXEC", ";", "return", "model", ";", "}", "</s>" ]

[ "Return", "the", "TLS", "model", "to", "use", "for", "SYMBOL", "." ]

[ "alpha", "0", "64" ]

[]

[ "<s>", "MachinePointerInfo", "MipsFunctionInfo", "::", "callPtrInfo", "(", "StringRef", "Name", ")", "{", "const", "MipsCallEntry", "*", "&", "E", "=", "ExternalCallEntries", "[", "Name", "]", ";", "if", "(", "!", "E", ")", "E", "=", "new", "MipsCallEntry", "(", "Name", ")", ";", "return", "MachinePointerInfo", "(", "E", ")", ";", "}", "</s>" ]

[ "Create", "a", "MachinePointerInfo", "that", "has", "a", "GlobalValuePseudoSourceValue", "object", "representing", "a", "GOT", "entry", "for", "a", "global", "function", "." ]

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

[]

[ "<s>", "DiagnosticInfoUnsupported", "(", "const", "Function", "&", "Fn", ",", "const", "Twine", "&", "Desc", ",", "DiagnosticSeverity", "Severity", "=", "DS_Error", ")", ":", "DiagnosticInfo", "(", "getKindID", "(", ")", ",", "Severity", ")", ",", "Description", "(", "Desc", ")", ",", "Fn", "(", "Fn", ")", "{", "}", "</s>" ]

[ "Fn", "is", "the", "function", "where", "the", "diagnostic", "is", "being", "emitted", "." ]

[ "R600" ]

[]

[ "<s>", "static", "rtx", "ia64_gen_spec_load", "(", "rtx", "insn", ",", "ds_t", "ts", ",", "int", "mode_no", ")", "{", "rtx", "pat", ",", "new_pat", ";", "gen_func_t", "gen_load", ";", "gen_load", "=", "get_spec_load_gen_function", "(", "ts", ",", "mode_no", ")", ";", "new_pat", "=", "gen_load", "(", "copy_rtx", "(", "recog_data", ".", "operand", "[", "0", "]", ")", ",", "copy_rtx", "(", "recog_data", ".", "operand", "[", "1", "]", ")", ")", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "COND_EXEC", ")", "new_pat", "=", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "copy_rtx", "(", "COND_EXEC_TEST", "(", "pat", ")", ")", ",", "new_pat", ")", ";", "return", "new_pat", ";", "}", "</s>" ]

[ "If", "GEN_P", "is", "true", ",", "calculate", "the", "index", "of", "needed", "speculation", "check", "and", "return", "speculative", "pattern", "for", "INSN", "with", "speculative", "mode", "TS", ",", "machine", "mode", "MODE_NO", "and", "with", "ZERO_EXTEND", "(", "if", "EXTEND_P", "is", "true", ")", ".", "If", "GEN_P", "is", "false", ",", "just", "calculate", "the", "index", "of", "needed", "speculation", "check", "." ]

[ "ia64", "0", "1" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "skipModule", "(", "M", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "PromotionCacheTy", "PromotionCache", ";", "for", "(", "auto", "&", "MF", ":", "M", ")", "{", "Changed", "|=", "runOnFunction", "(", "MF", ",", "PromotionCache", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "AArch64" ]

[]

[ "<s>", "DiagnosticInfoUnsupported", "(", "SDLoc", "DLoc", ",", "const", "Function", "&", "Fn", ",", "const", "Twine", "&", "Desc", ",", "SDValue", "Value", ")", ":", "DiagnosticInfo", "(", "getKindID", "(", ")", ",", "DS_Error", ")", ",", "DLoc", "(", "DLoc", ".", "getDebugLoc", "(", ")", ")", ",", "Description", "(", "Desc", ")", ",", "Fn", "(", "Fn", ")", ",", "Value", "(", "Value", ")", "{", "}", "</s>" ]

[ "Fn", "is", "the", "function", "where", "the", "diagnostic", "is", "being", "emitted", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "void", "KudeyarInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Kudeyar", "::", "MOV_MR32", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "Kudeyar::MOV_MR32", "0" ]

[]

[ "<s>", "const", "X86Subtarget", "&", "X86MCInstLower", "::", "getSubtarget", "(", ")", "const", "{", "return", "AsmPrinter", ".", "getSubtarget", "(", ")", ";", "}", "</s>" ]

[ "getSubtarget", "-", "Return", "the", "subtarget", "for", "which", "this", "machine", "code", "is", "being", "compiled", "." ]

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

[]

[ "<s>", "bool", "arm_vector_mode_supported_p", "(", "enum", "machine_mode", "mode", ")", "{", "if", "(", "(", "mode", "==", "V2SImode", ")", "||", "(", "mode", "==", "V4HImode", ")", "||", "(", "mode", "==", "V8QImode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "arm" ]

[]

[ "<s>", "PPCSubtarget", "::", "PPCSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "PPCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "IsPPC64", "(", "is64Bit", ")", ",", "TargetTriple", "(", "TT", ")", "{", "initializeEnvironment", "(", ")", ";", "resetSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

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

[]

[ "<s>", "const", "ARMGNULDBackend", "&", "getTarget", "(", ")", "const", "{", "return", "m_Target", ";", "}", "</s>" ]

[ "getTarget", "-", "Return", "the", "target", "machine", "this", "machine", "code", "is", "compiled", "with" ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressRegReg", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Index", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "EncodingAlignment", ")", "const", "{", "int16_t", "imm", "=", "0", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "if", "(", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "imm", ")", "&&", "(", "!", "EncodingAlignment", "||", "!", "(", "imm", "%", "EncodingAlignment", ")", ")", ")", "return", "false", ";", "if", "(", "N", ".", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "PPCISD", "::", "Lo", ")", "return", "false", ";", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "else", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", "{", "if", "(", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "imm", ")", "&&", "(", "!", "EncodingAlignment", "||", "!", "(", "imm", "%", "EncodingAlignment", ")", ")", ")", "return", "false", ";", "KnownBits", "LHSKnown", "=", "DAG", ".", "computeKnownBits", "(", "N", ".", "getOperand", "(", "0", ")", ")", ";", "if", "(", "LHSKnown", ".", "Zero", ".", "getBoolValue", "(", ")", ")", "{", "KnownBits", "RHSKnown", "=", "DAG", ".", "computeKnownBits", "(", "N", ".", "getOperand", "(", "1", ")", ")", ";", "if", "(", "~", "(", "LHSKnown", ".", "Zero", "|", "RHSKnown", ".", "Zero", ")", "==", "0", ")", "{", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "SelectAddressRegReg", "-", "Given", "the", "specified", "addressed", ",", "check", "to", "see", "if", "it", "can", "be", "more", "efficiently", "represented", "as", "[", "r+imm", "]", "." ]

[ "PowerPC", "PPC", "0", "ISD::ADD", "1", "1", "PPCISD::Lo", "0", "1", "ISD::OR", "1", "0", "1", "0", "0", "1" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "isCallerPreservedPhysReg", "(", "MCRegister", "PhysReg", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "assert", "(", "Register", "::", "isPhysicalRegister", "(", "PhysReg", ")", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "is64BitELFABI", "(", ")", "&&", "!", "Subtarget", ".", "isAIXABI", "(", ")", ")", "return", "false", ";", "if", "(", "PhysReg", "==", "Subtarget", ".", "getTOCPointerRegister", "(", ")", ")", "return", "(", "getReservedRegs", "(", "MF", ")", ".", "test", "(", "PhysReg", ")", ")", ";", "if", "(", "StackPtrConst", "&&", "PhysReg", "==", "Subtarget", ".", "getStackPointerRegister", "(", ")", "&&", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", ".", "hasOpaqueSPAdjustment", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Physical", "registers", "that", "may", "be", "modified", "within", "a", "function", "but", "are", "guaranteed", "to", "be", "restored", "before", "any", "uses", "." ]

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

[]

[ "<s>", "void", "AnalyzeCallOperands", "(", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "CCAssignFn", "Fn", ",", "std", "::", "vector", "<", "TargetLowering", "::", "ArgListEntry", ">", "&", "FuncArgs", ",", "const", "char", "*", "Func", ")", "{", "PreAnalyzeCallOperands", "(", "Outs", ",", "FuncArgs", ",", "Func", ")", ";", "CCState", "::", "AnalyzeCallOperands", "(", "Outs", ",", "Fn", ")", ";", "OriginalArgWasF128", ".", "clear", "(", ")", ";", "OriginalArgWasFloat", ".", "clear", "(", ")", ";", "OriginalArgWasFloatVector", ".", "clear", "(", ")", ";", "CallOperandIsFixed", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "AnalyzeCallOperands", "-", "Same", "as", "above", "except", "it", "takes", "vectors", "of", "types", "and", "argument", "flags", "." ]

[ "Mips", "ISD::OutputArg" ]

[]

[ "<s>", "static", "void", "expand_strncmp_align_check", "(", "rtx", "strncmp_label", ",", "rtx", "src_addr", ",", "HOST_WIDE_INT", "bytes", ")", "{", "rtx", "lab_ref", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "strncmp_label", ")", ";", "rtx", "src_pgoff", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "src_addr", ")", ")", ";", "do_and3", "(", "src_pgoff", ",", "src_addr", ",", "GEN_INT", "(", "0xfff", ")", ")", ";", "rtx", "cond", "=", "gen_reg_rtx", "(", "CCmode", ")", ";", "emit_move_insn", "(", "cond", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "src_pgoff", ",", "GEN_INT", "(", "4096", "-", "bytes", ")", ")", ")", ";", "rtx", "cmp_rtx", "=", "gen_rtx_GE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "rtx", "ifelse", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cmp_rtx", ",", "lab_ref", ",", "pc_rtx", ")", ";", "rtx_insn", "*", "j", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "ifelse", ")", ")", ";", "add_reg_br_prob_note", "(", "j", ",", "profile_probability", "::", "unlikely", "(", ")", ")", ";", "JUMP_LABEL", "(", "j", ")", "=", "strncmp_label", ";", "LABEL_NUSES", "(", "strncmp_label", ")", "+=", "1", ";", "}", "</s>" ]

[ "Generate", "page", "crossing", "check", "and", "branch", "code", "to", "set", "up", "for", "strncmp", "when", "we", "do", "n't", "have", "DI", "alignment", ".", "STRNCMP_LABEL", "is", "the", "label", "to", "branch", "if", "there", "is", "a", "page", "crossing", ".", "SRC_ADDR", "is", "the", "string", "address", "to", "be", "examined", ".", "BYTES", "is", "the", "max", "number", "of", "bytes", "to", "compare", "." ]

[ "rs6000", "0xfff", "4096", "1" ]

[]

[ "<s>", "StringRef", "HexagonInstPrinter", "::", "getOpcodeName", "(", "unsigned", "Opcode", ")", "const", "{", "return", "MII", ".", "getName", "(", "Opcode", ")", ";", "}", "</s>" ]

[ "Return", "a", "string", "representation", "for", "an", "opcode", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "compute_frame_size", "(", "HOST_WIDE_INT", "size", ")", "{", "int", "regno", ";", "HOST_WIDE_INT", "total_size", ";", "HOST_WIDE_INT", "var_size", ";", "HOST_WIDE_INT", "args_size", ";", "int", "link_debug_size", ";", "HOST_WIDE_INT", "gp_reg_size", ";", "long", "mask", ";", "interrupt_handler", "=", "microblaze_interrupt_function_p", "(", "current_function_decl", ")", ";", "break_handler", "=", "microblaze_break_function_p", "(", "current_function_decl", ")", ";", "fast_interrupt", "=", "microblaze_fast_interrupt_function_p", "(", "current_function_decl", ")", ";", "save_volatiles", "=", "microblaze_save_volatiles", "(", "current_function_decl", ")", ";", "if", "(", "break_handler", ")", "interrupt_handler", "=", "break_handler", ";", "gp_reg_size", "=", "0", ";", "mask", "=", "0", ";", "var_size", "=", "size", ";", "args_size", "=", "crtl", "->", "outgoing_args_size", ";", "if", "(", "(", "args_size", "==", "0", ")", "&&", "cfun", "->", "calls_alloca", ")", "args_size", "=", "NUM_OF_ARGS", "*", "UNITS_PER_WORD", ";", "total_size", "=", "var_size", "+", "args_size", ";", "if", "(", "flag_pic", "==", "2", "&&", "!", "TARGET_PIC_DATA_TEXT_REL", ")", "df_set_regs_ever_live", "(", "MB_ABI_PIC_ADDR_REGNUM", ",", "true", ")", ";", "for", "(", "regno", "=", "GP_REG_FIRST", ";", "regno", "<=", "GP_REG_LAST", ";", "regno", "++", ")", "{", "if", "(", "microblaze_must_save_register", "(", "regno", ")", ")", "{", "if", "(", "regno", "!=", "MB_ABI_SUB_RETURN_ADDR_REGNUM", ")", "gp_reg_size", "+=", "GET_MODE_SIZE", "(", "SImode", ")", ";", "mask", "|=", "(", "1L", "<<", "(", "regno", "-", "GP_REG_FIRST", ")", ")", ";", "}", "}", "total_size", "+=", "gp_reg_size", ";", "if", "(", "microblaze_is_interrupt_variant", "(", ")", ")", "total_size", "+=", "4", ";", "if", "(", "total_size", "==", "0", "&&", "crtl", "->", "is_leaf", ")", "link_debug_size", "=", "0", ";", "else", "link_debug_size", "=", "UNITS_PER_WORD", ";", "total_size", "+=", "link_debug_size", ";", "current_frame_info", ".", "total_size", "=", "total_size", ";", "current_frame_info", ".", "var_size", "=", "var_size", ";", "current_frame_info", ".", "args_size", "=", "args_size", ";", "current_frame_info", ".", "gp_reg_size", "=", "gp_reg_size", ";", "current_frame_info", ".", "mask", "=", "mask", ";", "current_frame_info", ".", "initialized", "=", "reload_completed", ";", "current_frame_info", ".", "num_gp", "=", "gp_reg_size", "/", "UNITS_PER_WORD", ";", "current_frame_info", ".", "link_debug_size", "=", "link_debug_size", ";", "if", "(", "mask", ")", "current_frame_info", ".", "gp_offset", "=", "(", "total_size", "-", "gp_reg_size", ")", ";", "else", "current_frame_info", ".", "gp_offset", "=", "0", ";", "return", "total_size", ";", "}", "</s>" ]

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

[ "microblaze", "0", "0", "0", "2", "1L", "4", "0", "0", "0" ]

[]

[ "<s>", "bool", "LanaiAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "if", "(", "(", "Count", "%", "4", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "4", ")", "OS", ".", "write", "(", "\"\\x15\\0\\0\\0\"", ",", "4", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "4", "0", "0", "4", "\"\\x15\\0\\0\\0\"", "4" ]

[]

[ "<s>", "bool", "WebAssemblyCFGStackify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "const", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "auto", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "SortBlocks", "(", "MF", ",", "MLI", ",", "MDT", ")", ";", "PlaceMarkers", "(", "MF", ",", "MLI", ",", "TII", ",", "MDT", ",", "MFI", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]