Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "EVT", "HexagonTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "auto", "Aligned", "=", "[", "]", "(", "unsigned", "GivenA", ",", "unsigned", "MinA", ")", "->", "bool", "{", "return", "(", "GivenA", "%", "MinA", ")", "==", "0", ";", "}", ";", "if", "(", "Size", ">=", "8", "&&", "Aligned", "(", "DstAlign", ",", "8", ")", "&&", "(", "IsMemset", "||", "Aligned", "(", "SrcAlign", ",", "8", ")", ")", ")", "return", "MVT", "::", "i64", ";", "if", "(", "Size", ">=", "4", "&&", "Aligned", "(", "DstAlign", ",", "4", ")", "&&", "(", "IsMemset", "||", "Aligned", "(", "SrcAlign", ",", "4", ")", ")", ")", "return", "MVT", "::", "i32", ";", "if", "(", "Size", ">=", "2", "&&", "Aligned", "(", "DstAlign", ",", "2", ")", "&&", "(", "IsMemset", "||", "Aligned", "(", "SrcAlign", ",", "2", ")", ")", ")", "return", "MVT", "::", "i16", ";", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "Hexagon", "Hexagon", "0", "8", "8", "8", "MVT::i64", "4", "4", "4", "MVT::i32", "2", "2", "2", "MVT::i16", "MVT::Other" ]

[]

[ "<s>", "bool", "GBZ80TargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", ";", "SDLoc", "DL", "(", "N", ")", ";", "if", "(", "const", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "if", "(", "LD", "->", "getExtensionType", "(", ")", "!=", "ISD", "::", "NON_EXTLOAD", ")", "return", "false", ";", "}", "else", "if", "(", "const", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "}", "else", "{", "return", "false", ";", "}", "if", "(", "VT", "!=", "MVT", "::", "i8", ")", "{", "return", "false", ";", "}", "if", "(", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", "&&", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "SUB", ")", "{", "return", "false", ";", "}", "if", "(", "const", "ConstantSDNode", "*", "RHS", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ")", "{", "int", "RHSC", "=", "RHS", "->", "getSExtValue", "(", ")", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", ")", "RHSC", "=", "-", "RHSC", ";", "if", "(", "RHSC", "==", "1", ")", "{", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "Offset", "=", "DAG", ".", "getConstant", "(", "RHSC", ",", "DL", ",", "MVT", "::", "i16", ")", ";", "AM", "=", "ISD", "::", "POST_INC", ";", "return", "true", ";", "}", "else", "if", "(", "RHSC", "==", "-", "1", ")", "{", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "Offset", "=", "DAG", ".", "getConstant", "(", "RHSC", ",", "DL", ",", "MVT", "::", "i16", ")", ";", "AM", "=", "ISD", "::", "POST_DEC", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "GBZ80", "GB", "ISD::MemIndexedMode", "ISD::NON_EXTLOAD", "MVT::i8", "ISD::ADD", "ISD::SUB", "1", "ISD::SUB", "1", "0", "MVT::i16", "ISD::POST_INC", "1", "0", "MVT::i16", "ISD::POST_DEC" ]

[]

[ "<s>", "static", "void", "cr16_compute_save_regs", "(", "void", ")", "{", "unsigned", "int", "regno", ";", "current_frame_info", ".", "last_reg_to_save", "=", "-", "1", ";", "current_frame_info", ".", "reg_size", "=", "0", ";", "if", "(", "FUNC_IS_NORETURN_P", "(", "current_function_decl", ")", "&&", "!", "MUST_SAVE_REGS_P", "(", ")", ")", "return", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "{", "if", "(", "fixed_regs", "[", "regno", "]", ")", "{", "current_frame_info", ".", "save_regs", "[", "regno", "]", "=", "0", ";", "continue", ";", "}", "if", "(", "cr16_interrupt_function_p", "(", ")", ")", "{", "if", "(", "!", "crtl", "->", "is_leaf", "&&", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "current_frame_info", ".", "save_regs", "[", "regno", "]", "=", "1", ";", "else", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", ")", "current_frame_info", ".", "save_regs", "[", "regno", "]", "=", "1", ";", "else", "current_frame_info", ".", "save_regs", "[", "regno", "]", "=", "0", ";", "}", "else", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", "||", "regno", "==", "RETURN_ADDRESS_REGNUM", ")", ")", "current_frame_info", ".", "save_regs", "[", "regno", "]", "=", "1", ";", "else", "current_frame_info", ".", "save_regs", "[", "regno", "]", "=", "0", ";", "}", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", ";", "++", "i", ")", "{", "regno", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "INVALID_REGNUM", "==", "regno", ")", "break", ";", "current_frame_info", ".", "save_regs", "[", "regno", "]", "=", "1", ";", "}", "}", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "current_frame_info", ".", "save_regs", "[", "regno", "]", "==", "1", ")", "{", "current_frame_info", ".", "last_reg_to_save", "=", "regno", ";", "if", "(", "regno", ">=", "CR16_FIRST_DWORD_REGISTER", ")", "current_frame_info", ".", "reg_size", "+=", "CR16_UNITS_PER_DWORD", ";", "else", "current_frame_info", ".", "reg_size", "+=", "UNITS_PER_WORD", ";", "}", "}", "</s>" ]

[ "Compute", "values", "for", "the", "array", "current_frame_info.save_regs", "and", "the", "variable", "current_frame_info.reg_size", ".", "The", "index", "of", "current_frame_info.save_regs", "is", "numbers", "of", "register", ",", "each", "will", "get", "1", "if", "we", "need", "to", "save", "it", "in", "the", "current", "function", ",", "0", "if", "not", ".", "current_frame_info.reg_size", "is", "the", "total", "sum", "of", "the", "registers", "being", "saved", "." ]

[ "cr16", "1", "0", "0", "0", "1", "1", "0", "1", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "MCExpr", "const", "&", "HexagonMCInstrInfo", "::", "getExpr", "(", "MCExpr", "const", "&", "Expr", ")", "{", "const", "auto", "&", "HExpr", "=", "cast", "<", "HexagonMCExpr", ">", "(", "Expr", ")", ";", "assert", "(", "HExpr", ".", "getExpr", "(", ")", ")", ";", "return", "*", "HExpr", ".", "getExpr", "(", ")", ";", "}", "</s>" ]

[ "Implementation", "of", "the", "SCEVPredicate", "interface", "." ]

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

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "getExtractSubregLikeInputs", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "DefIdx", ",", "RegSubRegPairAndIdx", "&", "InputReg", ")", "const", "{", "assert", "(", "DefIdx", "<", "MI", ".", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", "&&", "\"Invalid definition index\"", ")", ";", "assert", "(", "MI", ".", "isExtractSubregLike", "(", ")", "&&", "\"Invalid kind of instruction\"", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VMOVRRD", ":", "const", "MachineOperand", "&", "MOReg", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "MOReg", ".", "isUndef", "(", ")", ")", "return", "false", ";", "InputReg", ".", "Reg", "=", "MOReg", ".", "getReg", "(", ")", ";", "InputReg", ".", "SubReg", "=", "MOReg", ".", "getSubReg", "(", ")", ";", "InputReg", ".", "SubIdx", "=", "DefIdx", "==", "0", "?", "ARM", "::", "ssub_0", ":", "ARM", "::", "ssub_1", ";", "return", "true", ";", "}", "llvm_unreachable", "(", "\"Target dependent opcode missing\"", ")", ";", "}", "</s>" ]

[ "Target-dependent", "implementation", "of", "getExtractSubregInputs", "." ]

[ "ARM", "ARM", "\"Invalid definition index\"", "\"Invalid kind of instruction\"", "ARM::VMOVRRD", "2", "0", "ARM::ssub_0", "ARM::ssub_1", "\"Target dependent opcode missing\"" ]

[]

[ "<s>", "const", "char", "*", "Nios2TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "Nios2ISD", "::", "Hi", ":", "return", "\"Nios2ISD::Hi\"", ";", "case", "Nios2ISD", "::", "Lo", ":", "return", "\"Nios2ISD::Lo\"", ";", "case", "Nios2ISD", "::", "Ret", ":", "return", "\"Nios2ISD::Ret\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "Nios2", "Nios2", "Nios2ISD::Hi", "\"Nios2ISD::Hi\"", "Nios2ISD::Lo", "\"Nios2ISD::Lo\"", "Nios2ISD::Ret", "\"Nios2ISD::Ret\"" ]

[]

[ "<s>", "bool", "nds32_rtx_costs_impl", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "if", "(", "speed", ")", "goto", "performance_cost", ";", "else", "goto", "size_cost", ";", "performance_cost", ":", "switch", "(", "code", ")", "{", "case", "SET", ":", "return", "false", ";", "case", "USE", ":", "*", "total", "=", "0", ";", "break", ";", "case", "MULT", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "break", ";", "case", "DIV", ":", "case", "UDIV", ":", "case", "MOD", ":", "case", "UMOD", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "7", ")", ";", "break", ";", "default", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "break", ";", "}", "return", "true", ";", "size_cost", ":", "switch", "(", "code", ")", "{", "case", "SET", ":", "return", "false", ";", "case", "USE", ":", "*", "total", "=", "0", ";", "break", ";", "case", "CONST_INT", ":", "if", "(", "outer_code", "==", "SET", ")", "{", "if", "(", "satisfies_constraint_Is05", "(", "x", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", "-", "2", ";", "else", "if", "(", "satisfies_constraint_Is20", "(", "x", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "}", "else", "if", "(", "outer_code", "==", "PLUS", "||", "outer_code", "==", "MINUS", ")", "{", "if", "(", "satisfies_constraint_Iu05", "(", "x", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", "-", "2", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "else", "if", "(", "outer_code", "==", "ASHIFT", ")", "{", "if", "(", "satisfies_constraint_Iu03", "(", "x", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", "-", "2", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "else", "if", "(", "outer_code", "==", "ASHIFTRT", "||", "outer_code", "==", "LSHIFTRT", ")", "{", "if", "(", "satisfies_constraint_Iu05", "(", "x", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", "-", "2", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "else", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "break", ";", "case", "CONST_DOUBLE", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "break", ";", "default", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "target", "hook", "describes", "the", "relative", "costs", "of", "RTL", "expressions", ".", "Return", "'true", "'", "when", "all", "subexpressions", "of", "x", "have", "been", "processed", ".", "Return", "'false", "'", "to", "sum", "the", "costs", "of", "sub-rtx", ",", "plus", "cost", "of", "this", "operation", ".", "Refer", "to", "gcc/rtlanal.cc", "for", "more", "information", "." ]

[ "nds32", "0", "1", "7", "1", "0", "1", "2", "1", "2", "1", "2", "1", "1", "2", "1", "1", "2", "1", "1", "2", "1" ]

[]

[ "<s>", "void", "PPCAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "RLWINM", ")", "{", "unsigned", "char", "SH", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "unsigned", "char", "MB", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "unsigned", "char", "ME", "=", "MI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ";", "bool", "useSubstituteMnemonic", "=", "false", ";", "if", "(", "SH", "<=", "31", "&&", "MB", "==", "0", "&&", "ME", "==", "(", "31", "-", "SH", ")", ")", "{", "O", "<<", "\"\\tslwi \"", ";", "useSubstituteMnemonic", "=", "true", ";", "}", "if", "(", "SH", "<=", "31", "&&", "MB", "==", "(", "32", "-", "SH", ")", "&&", "ME", "==", "31", ")", "{", "O", "<<", "\"\\tsrwi \"", ";", "useSubstituteMnemonic", "=", "true", ";", "SH", "=", "32", "-", "SH", ";", "}", "if", "(", "useSubstituteMnemonic", ")", "{", "printOperand", "(", "MI", ",", "0", ")", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "1", ")", ";", "O", "<<", "\", \"", "<<", "(", "unsigned", "int", ")", "SH", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "return", ";", "}", "}", "if", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "OR", "||", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "OR8", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "{", "O", "<<", "\"\\tmr \"", ";", "printOperand", "(", "MI", ",", "0", ")", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "1", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "return", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "RLDICR", ")", "{", "unsigned", "char", "SH", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "unsigned", "char", "ME", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "63", "-", "SH", "==", "ME", ")", "{", "O", "<<", "\"\\tsldi \"", ";", "printOperand", "(", "MI", ",", "0", ")", ";", "O", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "1", ")", ";", "O", "<<", "\", \"", "<<", "(", "unsigned", "int", ")", "SH", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "return", ";", "}", "}", "printInstruction", "(", "MI", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::RLWINM", "2", "3", "4", "31", "0", "31", "\"\\tslwi \"", "31", "32", "31", "\"\\tsrwi \"", "32", "0", "\", \"", "1", "\", \"", "PPC::OR", "PPC::OR8", "1", "2", "\"\\tmr \"", "0", "\", \"", "1", "PPC::RLDICR", "2", "3", "63", "\"\\tsldi \"", "0", "\", \"", "1", "\", \"" ]

[]

[ "<s>", "virtual", "bool", "isFMAFasterThanFMulAndFAdd", "(", "EVT", "VT", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "int", "ix86_function_regparm", "(", "const_tree", "type", ",", "const_tree", "decl", ")", "{", "tree", "attr", ";", "int", "regparm", ";", "unsigned", "int", "ccvt", ";", "if", "(", "TARGET_64BIT", ")", "return", "(", "ix86_function_type_abi", "(", "type", ")", "==", "SYSV_ABI", "?", "X86_64_REGPARM_MAX", ":", "X86_64_MS_REGPARM_MAX", ")", ";", "ccvt", "=", "ix86_get_callcvt", "(", "type", ")", ";", "regparm", "=", "ix86_regparm", ";", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_REGPARM", ")", "!=", "0", ")", "{", "attr", "=", "lookup_attribute", "(", "\"regparm\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "if", "(", "attr", ")", "{", "regparm", "=", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "attr", ")", ")", ")", ";", "return", "regparm", ";", "}", "}", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_FASTCALL", ")", "!=", "0", ")", "return", "2", ";", "else", "if", "(", "(", "ccvt", "&", "IX86_CALLCVT_THISCALL", ")", "!=", "0", ")", "return", "1", ";", "if", "(", "decl", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "cgraph_node", "*", "target", "=", "cgraph_node", "::", "get", "(", "decl", ")", ";", "if", "(", "target", ")", "target", "=", "target", "->", "function_symbol", "(", ")", ";", "if", "(", "target", "&&", "opt_for_fn", "(", "target", "->", "decl", ",", "optimize", ")", "&&", "!", "(", "profile_flag", "&&", "!", "flag_fentry", ")", ")", "{", "if", "(", "target", "->", "local", "&&", "target", "->", "can_change_signature", ")", "{", "int", "local_regparm", ",", "globals", "=", "0", ",", "regno", ";", "for", "(", "local_regparm", "=", "0", ";", "local_regparm", "<", "REGPARM_MAX", ";", "local_regparm", "++", ")", "if", "(", "fixed_regs", "[", "local_regparm", "]", ")", "break", ";", "if", "(", "local_regparm", "==", "3", "&&", "DECL_STATIC_CHAIN", "(", "target", "->", "decl", ")", ")", "local_regparm", "=", "2", ";", "if", "(", "flag_split_stack", ")", "{", "if", "(", "local_regparm", "==", "3", ")", "local_regparm", "=", "2", ";", "else", "if", "(", "local_regparm", "==", "2", "&&", "DECL_STATIC_CHAIN", "(", "target", "->", "decl", ")", ")", "local_regparm", "=", "1", ";", "}", "for", "(", "regno", "=", "AX_REG", ";", "regno", "<=", "DI_REG", ";", "regno", "++", ")", "if", "(", "fixed_regs", "[", "regno", "]", ")", "globals", "++", ";", "local_regparm", "=", "globals", "<", "local_regparm", "?", "local_regparm", "-", "globals", ":", "0", ";", "if", "(", "local_regparm", ">", "regparm", ")", "regparm", "=", "local_regparm", ";", "}", "}", "}", "return", "regparm", ";", "}", "</s>" ]

[ "Return", "the", "regparm", "value", "for", "a", "function", "with", "the", "indicated", "TYPE", "and", "DECL", ".", "DECL", "may", "be", "NULL", "when", "calling", "function", "indirectly", "or", "considering", "a", "libcall", "." ]

[ "i386", "0", "\"regparm\"", "0", "2", "0", "1", "0", "0", "3", "2", "3", "2", "2", "1", "0" ]

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "DebugLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "if", "(", "Subtarget", "->", "isTargetNaCl", "(", ")", "||", "!", "Subtarget", "->", "isAAPCS_ABI", "(", ")", "||", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "return", "SDValue", "(", ")", ";", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "static_cast", "<", "const", "ARMTargetLowering", "*", ">", "(", "DAG", ".", "getTarget", "(", ")", ".", "getTargetLowering", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Type", "*", "IntPtrTy", "=", "TLI", ".", "getDataLayout", "(", ")", "->", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Entry", ".", "isSExt", "=", "false", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "else", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Entry", ".", "Ty", "=", "Type", "::", "getInt32Ty", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "isSExt", "=", "true", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "Chain", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "false", ",", "false", ",", "false", ",", "false", ",", "0", ",", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMSET", ")", ",", "false", ",", "false", ",", "false", ",", "DAG", ".", "getExternalSymbol", "(", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ",", "Args", ",", "DAG", ",", "dl", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]

[ "ARM", "ARM", "ARM", "ARM", "MVT::i32", "ISD::TRUNCATE", "MVT::i32", "ISD::ZERO_EXTEND", "MVT::i32", "0" ]

[]

[ "<s>", "bool", "RV16KTargetLowering", "::", "IsEligibleForTailCallOptimization", "(", "CCState", "&", "CCInfo", ",", "CallLoweringInfo", "&", "CLI", ",", "MachineFunction", "&", "MF", ",", "const", "SmallVector", "<", "CCValAssign", ",", "16", ">", "&", "ArgLocs", ")", "const", "{", "auto", "&", "Callee", "=", "CLI", ".", "Callee", ";", "auto", "CalleeCC", "=", "CLI", ".", "CallConv", ";", "auto", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "auto", "&", "Outs", "=", "CLI", ".", "Outs", ";", "auto", "&", "Caller", "=", "MF", ".", "getFunction", "(", ")", ";", "auto", "CallerCC", "=", "Caller", ".", "getCallingConv", "(", ")", ";", "if", "(", "Caller", ".", "getFnAttribute", "(", "\"disable-tail-calls\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "return", "false", ";", "if", "(", "IsVarArg", ")", "return", "false", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", "!=", "0", ")", "return", "false", ";", "auto", "IsCallerStructRet", "=", "Caller", ".", "hasStructRetAttr", "(", ")", ";", "auto", "IsCalleeStructRet", "=", "Outs", ".", "empty", "(", ")", "?", "false", ":", "Outs", "[", "0", "]", ".", "Flags", ".", "isSRet", "(", ")", ";", "if", "(", "IsCallerStructRet", "||", "IsCalleeStructRet", ")", "return", "false", ";", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "G", "->", "getGlobal", "(", ")", ";", "if", "(", "GV", "->", "hasExternalWeakLinkage", "(", ")", ")", "return", "false", ";", "}", "const", "RV16KRegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "CallerPreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallerCC", ")", ";", "if", "(", "CalleeCC", "!=", "CallerCC", ")", "{", "const", "uint32_t", "*", "CalleePreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CalleeCC", ")", ";", "if", "(", "!", "TRI", "->", "regmaskSubsetEqual", "(", "CallerPreserved", ",", "CalleePreserved", ")", ")", "return", "false", ";", "}", "for", "(", "auto", "&", "Arg", ":", "Outs", ")", "if", "(", "Arg", ".", "Flags", ".", "isByVal", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "IsEligibleForTailCallOptimization", "-", "Check", "whether", "the", "call", "is", "eligible", "for", "tail", "call", "optimization", "." ]

[ "RV16K", "RV16K", "16", "\"disable-tail-calls\"", "\"true\"", "0", "0", "RV16K" ]

[]

[ "<s>", "void", "X86AsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "{", "bool", "is16BitMode", "=", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode16Bit", "]", ";", "unsigned", "RelaxedOp", "=", "getRelaxedOpcode", "(", "Inst", ",", "is16BitMode", ")", ";", "if", "(", "RelaxedOp", "==", "Inst", ".", "getOpcode", "(", ")", ")", "{", "SmallString", "<", "256", ">", "Tmp", ";", "raw_svector_ostream", "OS", "(", "Tmp", ")", ";", "Inst", ".", "dump_pretty", "(", "OS", ")", ";", "OS", "<<", "\"\\n\"", ";", "report_fatal_error", "(", "\"unexpected instruction to relax: \"", "+", "OS", ".", "str", "(", ")", ")", ";", "}", "Res", "=", "Inst", ";", "Res", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "X86", "X86", "X86::Mode16Bit", "256", "\"\\n\"", "\"unexpected instruction to relax: \"" ]

[]

[ "<s>", "int", "getLength", "(", ")", "{", "return", "length", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "bytes", "of", "data", "in", "this", "stream", "." ]

[ "TPC" ]

[]

[ "<s>", "bool", "n9_2r1w_consumed_by_ex_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_PBSAD", ":", "case", "TYPE_MUL", ":", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_ALU_SHIFT", ":", "use_rtx", "=", "extract_shift_reg", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_PBSADA", ":", "return", "pbsada_insn_ra_rb_dep_reg_p", "(", "consumer", ",", "def_reg", ")", ";", "case", "TYPE_MAC", ":", "use_rtx", "=", "PATTERN", "(", "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_MMU", ":", "if", "(", "GET_CODE", "(", "PATTERN", "(", "consumer", ")", ")", "==", "SET", ")", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "else", "return", "true", ";", "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", "EX", "." ]

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

[]

[ "<s>", "void", "NVPTXInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "DestRC", "=", "MRI", ".", "getRegClass", "(", "DestReg", ")", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "MRI", ".", "getRegClass", "(", "SrcReg", ")", ";", "if", "(", "DestRC", "->", "getSize", "(", ")", "!=", "SrcRC", "->", "getSize", "(", ")", ")", "report_fatal_error", "(", "\"Copy one register into another with a different width\"", ")", ";", "unsigned", "Op", ";", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int1RegsRegClass", ")", "{", "Op", "=", "NVPTX", "::", "IMOV1rr", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int16RegsRegClass", ")", "{", "Op", "=", "NVPTX", "::", "IMOV16rr", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int32RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Int32RegsRegClass", "?", "NVPTX", "::", "IMOV32rr", ":", "NVPTX", "::", "BITCONVERT_32_F2I", ")", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int64RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Int64RegsRegClass", "?", "NVPTX", "::", "IMOV64rr", ":", "NVPTX", "::", "BITCONVERT_64_F2I", ")", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Float32RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Float32RegsRegClass", "?", "NVPTX", "::", "FMOV32rr", ":", "NVPTX", "::", "BITCONVERT_32_I2F", ")", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Float64RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Float64RegsRegClass", "?", "NVPTX", "::", "FMOV64rr", ":", "NVPTX", "::", "BITCONVERT_64_I2F", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Bad register copy\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Op", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "\"Copy one register into another with a different width\"", "NVPTX::Int1RegsRegClass", "NVPTX::IMOV1rr", "NVPTX::Int16RegsRegClass", "NVPTX::IMOV16rr", "NVPTX::Int32RegsRegClass", "NVPTX::Int32RegsRegClass", "NVPTX::IMOV32rr", "NVPTX::BITCONVERT_32_F2I", "NVPTX::Int64RegsRegClass", "NVPTX::Int64RegsRegClass", "NVPTX::IMOV64rr", "NVPTX::BITCONVERT_64_F2I", "NVPTX::Float32RegsRegClass", "NVPTX::Float32RegsRegClass", "NVPTX::FMOV32rr", "NVPTX::BITCONVERT_32_I2F", "NVPTX::Float64RegsRegClass", "NVPTX::Float64RegsRegClass", "NVPTX::FMOV64rr", "NVPTX::BITCONVERT_64_I2F", "\"Bad register copy\"" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass2", "(", ")", "{", "addPass", "(", "createX86RetpolineThunksPass", "(", ")", ")", ";", "const", "Triple", "&", "TT", "=", "TM", "->", "getTargetTriple", "(", ")", ";", "if", "(", "!", "TT", ".", "isOSDarwin", "(", ")", "&&", "!", "TT", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFIInstrInserter", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "may", "add", "passes", "immediately", "before", "machine", "code", "is", "emitted", "in", "this", "callback", "." ]

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

[]

[ "<s>", "rtx", "mips_pic_base_register", "(", "rtx", "temp", ")", "{", "if", "(", "!", "TARGET_MIPS16", ")", "return", "pic_offset_table_rtx", ";", "if", "(", "currently_expanding_to_rtl", ")", "return", "mips16_gp_pseudo_reg", "(", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "temp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "TARGET_USE_GOT", ")", "mips_emit_move", "(", "temp", ",", "pic_offset_table_rtx", ")", ";", "else", "emit_insn", "(", "gen_load_const_gp", "(", "temp", ")", ")", ";", "return", "temp", ";", "}", "</s>" ]

[ "Return", "a", "base", "register", "that", "holds", "pic_offset_table_rtx", ".", "TEMP", ",", "if", "nonnull", ",", "is", "a", "scratch", "Pmode", "base", "register", "." ]

[ "mips" ]

[]

[ "<s>", "DecodeStatus", "BPFDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "VStream", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "bool", "IsLittleEndian", "=", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", "->", "isLittleEndian", "(", ")", ";", "uint64_t", "Insn", ",", "Hi", ";", "DecodeStatus", "Result", ";", "Result", "=", "readInstruction64", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ",", "IsLittleEndian", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableBPF64", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "switch", "(", "Instr", ".", "getOpcode", "(", ")", ")", "{", "case", "BPF", "::", "LD_imm64", ":", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "16", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Size", "=", "16", ";", "if", "(", "IsLittleEndian", ")", "Hi", "=", "(", "Bytes", "[", "12", "]", "<<", "0", ")", "|", "(", "Bytes", "[", "13", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "14", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "15", "]", "<<", "24", ")", ";", "else", "Hi", "=", "(", "Bytes", "[", "12", "]", "<<", "24", ")", "|", "(", "Bytes", "[", "13", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "14", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "15", "]", "<<", "0", ")", ";", "auto", "&", "Op", "=", "Instr", ".", "getOperand", "(", "1", ")", ";", "Op", ".", "setImm", "(", "Make_64", "(", "Hi", ",", "Op", ".", "getImm", "(", ")", ")", ")", ";", "break", ";", "}", "case", "BPF", "::", "LD_ABS_B", ":", "case", "BPF", "::", "LD_ABS_H", ":", "case", "BPF", "::", "LD_ABS_W", ":", "case", "BPF", "::", "LD_IND_B", ":", "case", "BPF", "::", "LD_IND_H", ":", "case", "BPF", "::", "LD_IND_W", ":", "{", "auto", "Op", "=", "Instr", ".", "getOperand", "(", "0", ")", ";", "Instr", ".", "clear", "(", ")", ";", "Instr", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "BPF", "::", "R6", ")", ")", ";", "Instr", ".", "addOperand", "(", "Op", ")", ";", "break", ";", "}", "}", "return", "Result", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF", "BPF::LD_imm64", "16", "0", "16", "12", "0", "13", "8", "14", "16", "15", "24", "12", "24", "13", "16", "14", "8", "15", "0", "1", "BPF::LD_ABS_B", "BPF::LD_ABS_H", "BPF::LD_ABS_W", "BPF::LD_IND_B", "BPF::LD_IND_H", "BPF::LD_IND_W", "0", "BPF::R6" ]

[]

[ "<s>", "rtx", "rs6000_gen_le_vsx_permute", "(", "rtx", "source", ",", "machine_mode", "mode", ")", "{", "if", "(", "FLOAT128_VECTOR_P", "(", "mode", ")", "||", "mode", "==", "TImode", ")", "return", "gen_rtx_ROTATE", "(", "mode", ",", "source", ",", "GEN_INT", "(", "64", ")", ")", ";", "else", "{", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rs6000_const_vec", "(", "mode", ")", ")", ";", "return", "gen_rtx_VEC_SELECT", "(", "mode", ",", "source", ",", "par", ")", ";", "}", "}", "</s>" ]

[ "Generate", "a", "permute", "rtx", "that", "represents", "an", "lxvd2x", ",", "stxvd2x", ",", "or", "xxpermdi", "for", "a", "VSX", "load", "or", "store", "operation", "." ]

[ "rs6000", "64" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "getARMSubtarget", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "addPass", "(", "createInsertDivideCheckPass", "(", ")", ")", ";", "addPass", "(", "createAtomicExpandLoadLinkedPass", "(", "TM", ")", ")", ";", "const", "ARMSubtarget", "*", "Subtarget", "=", "&", "getARMSubtarget", "(", ")", ";", "if", "(", "Subtarget", "->", "hasAnyDataBarrier", "(", ")", "&&", "!", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "Align", "Alignment", ",", "MachineMemOperand", "::", "Flags", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "MVT", "SVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "Subtarget", ".", "isHVXVectorType", "(", "SVT", ",", "true", ")", ")", "return", "allowsHvxMisalignedMemoryAccesses", "(", "SVT", ",", "Flags", ",", "Fast", ")", ";", "if", "(", "Fast", ")", "*", "Fast", "=", "false", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SNESRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "SNES", "::", "MainRegsRegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "SNES", "SNES", "SNES::MainRegsRegClass" ]

[]

[ "<s>", "static", "void", "print_csky_value", "(", "FILE", "*", "f", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "f", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "x", ")", ")", ";", "return", ";", "case", "CONST_DOUBLE", ":", "fprintf", "(", "f", ",", "\"<0x%lx,0x%lx>\"", ",", "(", "long", ")", "XWINT", "(", "x", ",", "2", ")", ",", "(", "long", ")", "XWINT", "(", "x", ",", "3", ")", ")", ";", "return", ";", "case", "CONST_VECTOR", ":", "{", "int", "i", ";", "fprintf", "(", "f", ",", "\"<\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CONST_VECTOR_NUNITS", "(", "x", ")", ";", "i", "++", ")", "{", "fprintf", "(", "f", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ")", ")", ";", "if", "(", "i", "<", "(", "CONST_VECTOR_NUNITS", "(", "x", ")", "-", "1", ")", ")", "fputc", "(", "','", ",", "f", ")", ";", "}", "fprintf", "(", "f", ",", "\">\"", ")", ";", "}", "return", ";", "case", "CONST_STRING", ":", "fprintf", "(", "f", ",", "\"\\\"%s\\\"\"", ",", "XSTR", "(", "x", ",", "0", ")", ")", ";", "return", ";", "case", "SYMBOL_REF", ":", "fprintf", "(", "f", ",", "\"`%s'\"", ",", "XSTR", "(", "x", ",", "0", ")", ")", ";", "return", ";", "case", "LABEL_REF", ":", "fprintf", "(", "f", ",", "\"L%d\"", ",", "INSN_UID", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "return", ";", "case", "CONST", ":", "print_csky_value", "(", "f", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "return", ";", "case", "PLUS", ":", "print_csky_value", "(", "f", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "f", ",", "\"+\"", ")", ";", "print_csky_value", "(", "f", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "return", ";", "case", "PC", ":", "fprintf", "(", "f", ",", "\"pc\"", ")", ";", "return", ";", "default", ":", "fprintf", "(", "f", ",", "\"????\"", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "Print", "a", "symbolic", "form", "of", "the", "constant", "X", "to", "the", "dump", "file", "F.", "This", "is", "used", "for", "dump", "output", "for", "-mconstpool", "in", "the", "target-dependent", "reorg", "pass", "." ]

[ "csky", "\"<0x%lx,0x%lx>\"", "2", "3", "\"<\"", "0", "1", "\">\"", "\"\\\"%s\\\"\"", "0", "\"`%s'\"", "0", "\"L%d\"", "0", "0", "0", "\"+\"", "1", "\"pc\"", "\"????\"" ]

[]

[ "<s>", "unsigned", "getSubReg", "(", ")", "const", "{", "assert", "(", "isReg", "(", ")", "&&", "\"Wrong CountValue accessor\"", ")", ";", "return", "Contents", ".", "R", ".", "Sub", ";", "}", "</s>" ]

[ "Returns", "the", "physical", "register", "number", "of", "sub-register", "``", "Index", "''", "for", "physical", "register", "RegNo", "." ]

[ "RI5CY", "\"Wrong CountValue accessor\"" ]

[]

[ "<s>", "void", "AVRAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "if", "(", "Value", "==", "0", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "auto", "NumBits", "=", "Info", ".", "TargetSize", "+", "Info", ".", "TargetOffset", ";", "auto", "NumBytes", "=", "(", "NumBits", "/", "8", ")", "+", "(", "(", "NumBits", "%", "8", ")", "==", "0", "?", "0", ":", "1", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumBytes", ";", "++", "i", ")", "{", "uint8_t", "mask", "=", "(", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ")", ";", "Data", "[", "Offset", "+", "i", "]", "|=", "mask", ";", "}", "}", "</s>" ]

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

[ "AVR", "AVR", "0", "8", "8", "0", "0", "1", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "unsigned", "encode", "(", "unsigned", "Val", ")", "const", "{", "return", "(", "Val", "&", "Mask", ")", "<<", "Shift", ";", "}", "</s>" ]

[ "Utility", "function", "to", "encode", "a", "Dwarf", "pair", "of", "LineDelta", "and", "AddrDeltas", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "erase", "(", ")", "{", "while", "(", "!", "Items", ".", "empty", "(", ")", ")", "{", "TransformItem", "*", "TI", "=", "Items", ".", "pop_back_val", "(", ")", ";", "TI", "->", "erase", "(", ")", ";", "}", "}", "</s>" ]

[ "erase", "-", "Erases", "an", "element", "identified", "by", "Key", ",", "if", "it", "exists", "." ]

[ "TPC" ]

[]

[ "<s>", "unsigned", "Cpu0SEInstrInfo", "::", "loadImmediate", "(", "int64_t", "Imm", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "II", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "*", "NewImm", ")", "const", "{", "Cpu0AnalyzeImmediate", "AnalyzeImm", ";", "unsigned", "Size", "=", "32", ";", "unsigned", "LUi", "=", "Cpu0", "::", "LUi", ";", "unsigned", "ZEROReg", "=", "Cpu0", "::", "ZERO", ";", "unsigned", "ATReg", "=", "Cpu0", "::", "AT", ";", "bool", "LastInstrIsADDiu", "=", "NewImm", ";", "const", "Cpu0AnalyzeImmediate", "::", "InstSeq", "&", "Seq", "=", "AnalyzeImm", ".", "Analyze", "(", "Imm", ",", "Size", ",", "LastInstrIsADDiu", ")", ";", "Cpu0AnalyzeImmediate", "::", "InstSeq", "::", "const_iterator", "Inst", "=", "Seq", ".", "begin", "(", ")", ";", "assert", "(", "Seq", ".", "size", "(", ")", "&&", "(", "!", "LastInstrIsADDiu", "||", "(", "Seq", ".", "size", "(", ")", ">", "1", ")", ")", ")", ";", "if", "(", "Inst", "->", "Opc", "==", "LUi", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "LUi", ")", ",", "ATReg", ")", ".", "addImm", "(", "SignExtend64", "<", "16", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "Inst", "->", "Opc", ")", ",", "ATReg", ")", ".", "addReg", "(", "ZEROReg", ")", ".", "addImm", "(", "SignExtend64", "<", "16", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "for", "(", "++", "Inst", ";", "Inst", "!=", "Seq", ".", "end", "(", ")", "-", "LastInstrIsADDiu", ";", "++", "Inst", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "Inst", "->", "Opc", ")", ",", "ATReg", ")", ".", "addReg", "(", "ATReg", ")", ".", "addImm", "(", "SignExtend64", "<", "16", ">", "(", "Inst", "->", "ImmOpnd", ")", ")", ";", "if", "(", "LastInstrIsADDiu", ")", "*", "NewImm", "=", "Inst", "->", "ImmOpnd", ";", "return", "ATReg", ";", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "load", "an", "immediate", "." ]

[ "Cpu0", "Cpu0", "Cpu0", "32", "Cpu0::LUi", "Cpu0::ZERO", "Cpu0::AT", "Cpu0", "Cpu0", "InstSeq::const_iterator", "1", "16", "16", "16" ]

[]

[ "<s>", "bool", "AMDGPUPrintfRuntimeBindingImpl", "::", "run", "(", "Module", "&", "M", ")", "{", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "r600", ")", "return", "false", ";", "auto", "PrintfFunction", "=", "M", ".", "getFunction", "(", "\"printf\"", ")", ";", "if", "(", "!", "PrintfFunction", ")", "return", "false", ";", "for", "(", "auto", "&", "U", ":", "PrintfFunction", "->", "uses", "(", ")", ")", "{", "if", "(", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "U", ".", "getUser", "(", ")", ")", ")", "{", "if", "(", "CI", "->", "isCallee", "(", "&", "U", ")", ")", "Printfs", ".", "push_back", "(", "CI", ")", ";", "}", "}", "if", "(", "Printfs", ".", "empty", "(", ")", ")", "return", "false", ";", "TD", "=", "&", "M", ".", "getDataLayout", "(", ")", ";", "return", "lowerPrintfForGpu", "(", "M", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"printf\"" ]

[]

[ "<s>", "bool", "MipsTargetMachine", "::", "addPostRegAlloc", "(", "PassManagerBase", "&", "PM", ")", "{", "PM", ".", "add", "(", "createMipsExpandPseudoPass", "(", "*", "this", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

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

[]

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

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

[ "Alpha", "Alpha" ]

[]

[ "<s>", "static", "AMDGPUOperand", "::", "Ptr", "CreateReg", "(", "const", "AMDGPUAsmParser", "*", "AsmParser", ",", "unsigned", "RegNo", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "auto", "Op", "=", "std", "::", "make_unique", "<", "AMDGPUOperand", ">", "(", "Register", ",", "AsmParser", ")", ";", "Op", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Op", "->", "Reg", ".", "Mods", "=", "Modifiers", "(", ")", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

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

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "CreateLiveInRegister", "(", "SelectionDAG", "&", "DAG", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ",", "EVT", "VT", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "VirtualRegister", ";", "if", "(", "!", "MRI", ".", "isLiveIn", "(", "Reg", ")", ")", "{", "VirtualRegister", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "MRI", ".", "addLiveIn", "(", "Reg", ",", "VirtualRegister", ")", ";", "}", "else", "{", "VirtualRegister", "=", "MRI", ".", "getLiveInVirtReg", "(", "Reg", ")", ";", "}", "return", "DAG", ".", "getRegister", "(", "VirtualRegister", ",", "VT", ")", ";", "}", "</s>" ]

[ "Helper", "function", "that", "adds", "Reg", "to", "the", "LiveIn", "list", "of", "the", "DAG", "'s", "MachineFunction", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "M68kInstrInfo", "::", "decomposeMachineOperandsTargetFlags", "(", "unsigned", "TF", ")", "const", "{", "return", "std", "::", "make_pair", "(", "TF", ",", "0u", ")", ";", "}", "</s>" ]

[ "Decompose", "the", "machine", "operand", "'s", "target", "flags", "into", "two", "values", "-", "the", "direct", "target", "flag", "value", "and", "any", "of", "bit", "flags", "that", "are", "applied", "." ]

[ "M68k", "M68k", "0u" ]

[]

[ "<s>", "opt_machine_mode", "arm_mode_to_pred_mode", "(", "machine_mode", "mode", ")", "{", "switch", "(", "GET_MODE_NUNITS", "(", "mode", ")", ")", "{", "case", "16", ":", "return", "V16BImode", ";", "case", "8", ":", "return", "V8BImode", ";", "case", "4", ":", "return", "V4BImode", ";", "}", "return", "opt_machine_mode", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "mode", "for", "the", "MVE", "vector", "of", "predicates", "corresponding", "to", "MODE", "." ]

[ "arm", "16", "8", "4" ]

[]

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

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

[ "M88k", "M88k" ]

[]

[ "<s>", "void", "PPCScoreboardHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "ScoreboardHazardRecognizer", "::", "AdvanceCycle", "(", ")", ";", "}", "</s>" ]

[ "AdvanceCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "top-down", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "int", "sh_address_cost", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "GBR_REG", ")", "return", "2", ";", "if", "(", "REG_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "POST_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "if", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "GBR_REG", "&&", "gbr_displacement", "(", "XEXP", "(", "x", ",", "1", ")", ",", "mode", ")", ")", "return", "2", ";", "const", "HOST_WIDE_INT", "offset", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "offset", "==", "0", ")", "return", "1", ";", "if", "(", "offset", ">", "0", "&&", "offset", "<=", "sh_max_mov_insn_displacement", "(", "mode", ",", "false", ")", ")", "return", "(", "mode", "==", "HImode", "||", "mode", "==", "QImode", ")", "?", "2", ":", "1", ";", "if", "(", "TARGET_SH2A", "&&", "offset", ">", "0", "&&", "offset", "<=", "sh_max_mov_insn_displacement", "(", "mode", ",", "true", ")", ")", "return", "2", ";", "return", "3", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "!", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "3", ";", "return", "10", ";", "}", "</s>" ]

[ "Compute", "the", "cost", "of", "an", "address", ".", "For", "the", "SH", ",", "all", "valid", "addresses", "are", "the", "same", "cost", ".", "Use", "a", "slightly", "higher", "cost", "for", "reg", "+", "reg", "addressing", ",", "since", "it", "increases", "pressure", "on", "r0", "." ]

[ "sh", "2", "1", "0", "1", "0", "1", "2", "1", "0", "1", "0", "2", "1", "0", "2", "3", "1", "3", "10" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Set wave priority\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"Set wave priority\"" ]

[]

[ "<s>", "int", "SparcRegisterInfo", "::", "getDwarfRegNum", "(", "unsigned", "RegNum", ",", "bool", "isEH", ")", "const", "{", "return", "SparcGenRegisterInfo", "::", "getDwarfRegNumFull", "(", "RegNum", ",", "0", ")", ";", "}", "</s>" ]

[ "Map", "a", "target", "register", "to", "an", "equivalent", "dwarf", "register", "number", "." ]

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

[]

[ "<s>", "MCInst", "X86InstrInfo", "::", "getNop", "(", ")", "const", "{", "MCInst", "Nop", ";", "Nop", ".", "setOpcode", "(", "X86", "::", "NOOP", ")", ";", "return", "Nop", ";", "}", "</s>" ]

[ "Return", "the", "noop", "instruction", "to", "use", "for", "a", "noop", "." ]

[ "X86", "X86", "X86::NOOP" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon Constant Propagation\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Constant Propagation\"" ]

[]

[ "<s>", "void", "HexagonRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOp", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MB", ".", "getParent", "(", ")", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HII", "=", "*", "HST", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "HFI", "=", "*", "HST", ".", "getFrameLowering", "(", ")", ";", "unsigned", "BP", "=", "0", ";", "int", "FI", "=", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "getIndex", "(", ")", ";", "int", "Offset", "=", "HFI", ".", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "BP", ")", ";", "int", "RealOffset", "=", "Offset", "+", "MI", ".", "getOperand", "(", "FIOp", "+", "1", ")", ".", "getImm", "(", ")", ";", "bool", "IsKill", "=", "false", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "PS_fia", ":", "MI", ".", "setDesc", "(", "HII", ".", "get", "(", "Hexagon", "::", "A2_addi", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "ChangeToImmediate", "(", "RealOffset", ")", ";", "MI", ".", "RemoveOperand", "(", "FIOp", "+", "1", ")", ";", "return", ";", "case", "Hexagon", "::", "PS_fi", ":", "MI", ".", "setDesc", "(", "HII", ".", "get", "(", "Hexagon", "::", "A2_addi", ")", ")", ";", "break", ";", "}", "if", "(", "!", "HII", ".", "isValidOffset", "(", "Opc", ",", "RealOffset", ",", "this", ")", ")", "{", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "Register", "TmpR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MB", ",", "II", ",", "DL", ",", "HII", ".", "get", "(", "Hexagon", "::", "A2_addi", ")", ",", "TmpR", ")", ".", "addReg", "(", "BP", ")", ".", "addImm", "(", "RealOffset", ")", ";", "BP", "=", "TmpR", ";", "RealOffset", "=", "0", ";", "IsKill", "=", "true", ";", "}", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "ChangeToRegister", "(", "BP", ",", "false", ",", "false", ",", "IsKill", ")", ";", "MI", ".", "getOperand", "(", "FIOp", "+", "1", ")", ".", "ChangeToImmediate", "(", "RealOffset", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "\"Unexpected\"", "Hexagon", "0", "1", "Hexagon::PS_fia", "Hexagon::A2_addi", "1", "Hexagon::PS_fi", "Hexagon::A2_addi", "Hexagon::IntRegsRegClass", "Hexagon::A2_addi", "0", "1" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "TOY" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "SICacheControl", ">", "SICacheControl", "::", "create", "(", "const", "GCNSubtarget", "&", "ST", ")", "{", "GCNSubtarget", "::", "Generation", "Generation", "=", "ST", ".", "getGeneration", "(", ")", ";", "if", "(", "ST", ".", "hasGFX940Insts", "(", ")", ")", "return", "std", "::", "make_unique", "<", "SIGfx940CacheControl", ">", "(", "ST", ")", ";", "if", "(", "ST", ".", "hasGFX90AInsts", "(", ")", ")", "return", "std", "::", "make_unique", "<", "SIGfx90ACacheControl", ">", "(", "ST", ")", ";", "if", "(", "Generation", "<=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "return", "std", "::", "make_unique", "<", "SIGfx6CacheControl", ">", "(", "ST", ")", ";", "if", "(", "Generation", "<", "AMDGPUSubtarget", "::", "GFX10", ")", "return", "std", "::", "make_unique", "<", "SIGfx7CacheControl", ">", "(", "ST", ")", ";", "return", "std", "::", "make_unique", "<", "SIGfx10CacheControl", ">", "(", "ST", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

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

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "hasAndNot", "(", "SDValue", "Y", ")", "const", "{", "EVT", "VT", "=", "Y", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "false", ";", "return", "Subtarget", ".", "hasStdExtZbb", "(", ")", "&&", "!", "isa", "<", "ConstantSDNode", ">", "(", "Y", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "a", "bitwise", "and-not", "operation", ":", "X", "=", "~A", "&", "B", "This", "can", "be", "used", "to", "simplify", "select", "or", "other", "instructions", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"unimplemented operand\"", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::SELECT", "ISD::VASTART", "ISD::FRAMEADDR", "ISD::RETURNADDR" ]

[]

[ "<s>", "static", "bool", "ia64_libgcc_floating_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "case", "DFmode", ":", "return", "true", ";", "case", "XFmode", ":", "return", "false", ";", "return", "true", ";", "case", "TFmode", ":", "return", "false", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P", "." ]

[ "ia64" ]

[]

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

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

[ "NVPTX", "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "OptimizeLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "if", "(", "DisableX86LEAOpt", "||", "!", "MF", ".", "getFunction", "(", ")", "->", "optForSize", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "MemOpMap", "LEAs", ";", "InstrPos", ".", "clear", "(", ")", ";", "findLEAs", "(", "MBB", ",", "LEAs", ")", ";", "if", "(", "LEAs", ".", "empty", "(", ")", ")", "continue", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", ")", "Changed", "|=", "removeRedundantLEAs", "(", "LEAs", ")", ";", "Changed", "|=", "removeRedundantAddrCalc", "(", "LEAs", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "hppa_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "int", "factor", ";", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "if", "(", "INTVAL", "(", "x", ")", "==", "0", ")", "*", "total", "=", "0", ";", "else", "if", "(", "INT_14_BITS", "(", "x", ")", ")", "*", "total", "=", "1", ";", "else", "*", "total", "=", "2", ";", "return", "true", ";", "case", "HIGH", ":", "*", "total", "=", "2", ";", "return", "true", ";", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "*", "total", "=", "4", ";", "return", "true", ";", "case", "CONST_DOUBLE", ":", "if", "(", "(", "x", "==", "CONST0_RTX", "(", "DFmode", ")", "||", "x", "==", "CONST0_RTX", "(", "SFmode", ")", ")", "&&", "outer_code", "!=", "SET", ")", "*", "total", "=", "0", ";", "else", "*", "total", "=", "8", ";", "return", "true", ";", "case", "MULT", ":", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "return", "true", ";", "}", "factor", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "/", "4", ";", "if", "(", "factor", "==", "0", ")", "factor", "=", "1", ";", "if", "(", "TARGET_PA_11", "&&", "!", "TARGET_DISABLE_FPREGS", "&&", "!", "TARGET_SOFT_FLOAT", ")", "*", "total", "=", "factor", "*", "factor", "*", "COSTS_N_INSNS", "(", "8", ")", ";", "else", "*", "total", "=", "factor", "*", "factor", "*", "COSTS_N_INSNS", "(", "20", ")", ";", "return", "true", ";", "case", "DIV", ":", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "14", ")", ";", "return", "true", ";", "}", "case", "UDIV", ":", "case", "MOD", ":", "case", "UMOD", ":", "factor", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "/", "4", ";", "if", "(", "factor", "==", "0", ")", "factor", "=", "1", ";", "*", "total", "=", "factor", "*", "factor", "*", "COSTS_N_INSNS", "(", "60", ")", ";", "return", "true", ";", "case", "PLUS", ":", "case", "MINUS", ":", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "return", "true", ";", "}", "factor", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "factor", "==", "0", ")", "factor", "=", "1", ";", "*", "total", "=", "factor", "*", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Compute", "a", "(", "partial", ")", "cost", "for", "rtx", "X", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "." ]

[ "pa", "0", "0", "1", "2", "2", "4", "0", "8", "3", "4", "0", "1", "8", "20", "14", "4", "0", "1", "60", "3", "0", "1", "1", "1" ]

[]

[ "<s>", "void", "mcore_print_operand_address", "(", "FILE", "*", "stream", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "stream", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "base", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "index", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "!=", "REG", ")", "{", "rtx", "temp", "=", "base", ";", "base", "=", "index", ";", "index", "=", "temp", ";", "}", "switch", "(", "GET_CODE", "(", "index", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "stream", ",", "\"(%s,\"", "HOST_WIDE_INT_PRINT_DEC", "\")\"", ",", "reg_names", "[", "REGNO", "(", "base", ")", "]", ",", "INTVAL", "(", "index", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "break", ";", "default", ":", "output_addr_const", "(", "stream", ",", "x", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "operand", "address", "in", "x", "to", "the", "stream", "." ]

[ "mcore", "\"(%s)\"", "0", "1", "\"(%s,\"", "\")\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "ARMBaseRegisterInfo", "::", "getThisReturnPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "nullptr", ";", "return", "(", "STI", ".", "isTargetIOS", "(", ")", "&&", "!", "STI", ".", "isAAPCS_ABI", "(", ")", ")", "?", "CSR_iOS_ThisReturn_RegMask", ":", "CSR_AAPCS_ThisReturn_RegMask", ";", "}", "</s>" ]

[ "getThisReturnPreservedMask", "-", "Returns", "a", "call", "preserved", "mask", "specific", "to", "the", "case", "that", "'returned", "'", "is", "on", "an", "i32", "first", "argument", "if", "the", "calling", "convention", "is", "one", "that", "can", "(", "partially", ")", "model", "this", "attribute", "with", "a", "preserved", "mask", "(", "i.e", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Mips VR4300 mulmul bugfix\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips VR4300 mulmul bugfix\"" ]

[]

[ "<s>", "void", "HexagonTargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isHvxOperation", "(", "N", ")", ")", "{", "LowerHvxOperationWrapper", "(", "N", ",", "Results", ",", "DAG", ")", ";", "if", "(", "!", "Results", ".", "empty", "(", ")", ")", "return", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "STORE", ")", "return", "TargetLowering", "::", "LowerOperationWrapper", "(", "N", ",", "Results", ",", "DAG", ")", ";", "}", "</s>" ]

[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]

[ "Hexagon", "Hexagon", "ISD::STORE" ]

[]

[ "<s>", "void", "initializePass", "(", ")", "override", "{", "pushTTIStack", "(", "this", ")", ";", "}", "</s>" ]

[ "initializePass", "-", "This", "method", "may", "be", "overriden", "by", "immutable", "passes", "to", "allow", "them", "to", "perform", "various", "initialization", "actions", "they", "require", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "HexagonEarlyIfConversion", "::", "removeBlock", "(", "MachineBasicBlock", "*", "B", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Removing block \"", "<<", "PrintMB", "(", "B", ")", "<<", "\"\\n\"", ")", ";", "MachineDomTreeNode", "*", "N", "=", "MDT", "->", "getNode", "(", "B", ")", ";", "MachineDomTreeNode", "*", "IDN", "=", "N", "->", "getIDom", "(", ")", ";", "if", "(", "IDN", ")", "{", "MachineBasicBlock", "*", "IDB", "=", "IDN", "->", "getBlock", "(", ")", ";", "using", "GTN", "=", "GraphTraits", "<", "MachineDomTreeNode", "*", ">", ";", "using", "DTNodeVectType", "=", "SmallVector", "<", "MachineDomTreeNode", "*", ",", "4", ">", ";", "DTNodeVectType", "Cn", "(", "GTN", "::", "child_begin", "(", "N", ")", ",", "GTN", "::", "child_end", "(", "N", ")", ")", ";", "for", "(", "DTNodeVectType", "::", "iterator", "I", "=", "Cn", ".", "begin", "(", ")", ",", "E", "=", "Cn", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineBasicBlock", "*", "SB", "=", "(", "*", "I", ")", "->", "getBlock", "(", ")", ";", "MDT", "->", "changeImmediateDominator", "(", "SB", ",", "IDB", ")", ";", "}", "}", "while", "(", "B", "->", "succ_size", "(", ")", ">", "0", ")", "B", "->", "removeSuccessor", "(", "B", "->", "succ_begin", "(", ")", ")", ";", "for", "(", "auto", "I", "=", "B", "->", "pred_begin", "(", ")", ",", "E", "=", "B", "->", "pred_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "(", "*", "I", ")", "->", "removeSuccessor", "(", "B", ",", "true", ")", ";", "Deleted", ".", "insert", "(", "B", ")", ";", "MDT", "->", "eraseNode", "(", "B", ")", ";", "MFN", "->", "erase", "(", "B", "->", "getIterator", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "completely", "removes", "BB", "from", "all", "data", "structures", ",", "including", "all", "of", "the", "Loop", "objects", "it", "is", "nested", "in", "and", "our", "mapping", "from", "MachineBasicBlocks", "to", "loops", "." ]

[ "Hexagon", "Hexagon", "\"Removing block \"", "\"\\n\"", "4", "0" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ")", "const", "{", "assert", "(", "Pred", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid condition\"", ")", ";", "unsigned", "CCValid", "=", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "CCMask", "=", "Pred", "[", "1", "]", ".", "getImm", "(", ")", ";", "assert", "(", "CCMask", ">", "0", "&&", "CCMask", "<", "15", "&&", "\"Invalid predicate\"", ")", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "SystemZ", "::", "Trap", ")", "{", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CondTrap", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "Return", ")", "{", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CondReturn", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "CallJG", ")", "{", "MachineOperand", "FirstOp", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getRegMask", "(", ")", ";", "MI", ".", "RemoveOperand", "(", "1", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CallBRCL", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "add", "(", "FirstOp", ")", ".", "addRegMask", "(", "RegMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "if", "(", "Opcode", "==", "SystemZ", "::", "CallBR", ")", "{", "MachineOperand", "Target", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getRegMask", "(", ")", ";", "MI", ".", "RemoveOperand", "(", "1", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "SystemZ", "::", "CallBCR", ")", ")", ";", "MachineInstrBuilder", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "add", "(", "Target", ")", ".", "addRegMask", "(", "RegMask", ")", ".", "addReg", "(", "SystemZ", "::", "CC", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "SystemZ", "SystemZ", "2", "\"Invalid condition\"", "0", "1", "0", "15", "\"Invalid predicate\"", "SystemZ::Trap", "SystemZ::CondTrap", "SystemZ::CC", "SystemZ::Return", "SystemZ::CondReturn", "SystemZ::CC", "SystemZ::CallJG", "0", "1", "1", "0", "SystemZ::CallBRCL", "SystemZ::CC", "SystemZ::CallBR", "0", "1", "1", "0", "SystemZ::CallBCR", "SystemZ::CC" ]

[]

[ "<s>", "SDValue", "Nios2TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_Nios2EABI", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Nios2ISD", "::", "Ret", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2", "ISD::OutputArg", "16", "Nios2", "4", "1", "0", "\"Can only return in registers!\"", "ISD::BITCAST", "1", "Nios2ISD::Ret", "MVT::Other" ]

[]

[ "<s>", "int", "SIInstrInfo", "::", "pseudoToMCOpcode", "(", "int", "Opcode", ")", "const", "{", "SIEncodingFamily", "Gen", "=", "subtargetEncodingFamily", "(", "ST", ")", ";", "if", "(", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "renamedInGFX9", ")", "!=", "0", "&&", "ST", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "GFX9", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX9", ";", "if", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", "Gen", "=", "ST", ".", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "GFX9", "?", "SIEncodingFamily", "::", "SDWA9", ":", "SIEncodingFamily", "::", "SDWA", ";", "if", "(", "ST", ".", "hasUnpackedD16VMem", "(", ")", "&&", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "D16Buf", ")", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX80", ";", "int", "MCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "Gen", ")", ";", "if", "(", "MCOp", "==", "-", "1", ")", "return", "Opcode", ";", "if", "(", "MCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "return", "-", "1", ";", "return", "MCOp", ";", "}", "</s>" ]

[ "Return", "a", "target-specific", "opcode", "if", "Opcode", "is", "a", "pseudo", "instruction", "." ]

[ "AMDGPU", "SI", "SI", "SIInstrFlags::renamedInGFX9", "0", "AMDGPU", "SIEncodingFamily::GFX9", "SIInstrFlags::SDWA", "AMDGPU", "SIEncodingFamily::SDWA9", "SIEncodingFamily::SDWA", "SIInstrFlags::D16Buf", "SIEncodingFamily::GFX80", "AMDGPU::getMCOpcode", "1", "1", "1" ]

[]

[ "<s>", "bool", "HexagonSplitConst32AndConst64", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "HexagonTargetObjectFile", "&", "TLOF", "=", "*", "static_cast", "<", "const", "HexagonTargetObjectFile", "*", ">", "(", "Fn", ".", "getTarget", "(", ")", ".", "getObjFileLowering", "(", ")", ")", ";", "if", "(", "TLOF", ".", "isSmallDataEnabled", "(", ")", ")", "return", "true", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "B", ":", "Fn", ")", "{", "for", "(", "auto", "I", "=", "B", ".", "begin", "(", ")", ",", "E", "=", "B", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "++", "I", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "Hexagon", "::", "CONST32", ")", "{", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "uint64_t", "ImmValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "DestReg", ")", ".", "addImm", "(", "ImmValue", ")", ";", "B", ".", "erase", "(", "&", "MI", ")", ";", "}", "else", "if", "(", "Opc", "==", "Hexagon", "::", "CONST64", ")", "{", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "int64_t", "ImmValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "DestLo", "=", "TRI", "->", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "isub_lo", ")", ";", "unsigned", "DestHi", "=", "TRI", "->", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "isub_hi", ")", ";", "int32_t", "LowWord", "=", "(", "ImmValue", "&", "0xFFFFFFFF", ")", ";", "int32_t", "HighWord", "=", "(", "ImmValue", ">>", "32", ")", "&", "0xFFFFFFFF", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "DestLo", ")", ".", "addImm", "(", "LowWord", ")", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "DestHi", ")", ".", "addImm", "(", "HighWord", ")", ";", "B", ".", "erase", "(", "&", "MI", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon::CONST32", "0", "1", "Hexagon::A2_tfrsi", "Hexagon::CONST64", "0", "1", "Hexagon::isub_lo", "Hexagon::isub_hi", "0xFFFFFFFF", "32", "0xFFFFFFFF", "Hexagon::A2_tfrsi", "Hexagon::A2_tfrsi" ]

[]

[ "<s>", "MachineBasicBlock", "*", "MSP430TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "MSP430", "::", "Shl8", "||", "Opc", "==", "MSP430", "::", "Shl16", "||", "Opc", "==", "MSP430", "::", "Sra8", "||", "Opc", "==", "MSP430", "::", "Sra16", "||", "Opc", "==", "MSP430", "::", "Srl8", "||", "Opc", "==", "MSP430", "::", "Srl16", ")", "return", "EmitShiftInstr", "(", "MI", ",", "BB", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "Opc", "==", "MSP430", "::", "Select16", "||", "Opc", "==", "MSP430", "::", "Select8", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "BB", ";", "++", "I", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "copy1MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "I", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "I", ",", "copy1MBB", ")", ";", "copy1MBB", "->", "splice", "(", "copy1MBB", "->", "begin", "(", ")", ",", "BB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "copy1MBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "copy1MBB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "JCC", ")", ")", ".", "addMBB", "(", "copy1MBB", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "copy1MBB", ")", ";", "BB", "=", "copy1MBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::Shl8", "MSP430::Shl16", "MSP430::Sra8", "MSP430::Sra16", "MSP430::Srl8", "MSP430::Srl16", "MSP430::Select16", "MSP430::Select8", "\"Unexpected instr type to insert\"", "MSP430::JCC", "3", "MSP430::PHI", "0", "2", "1" ]

[]

[ "<s>", "bool", "WebAssemblyMemIntrinsicResults", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Memory Intrinsic Results **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "WebAssemblyTargetLowering", "&", "TLI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", ";", "const", "auto", "&", "LibInfo", "=", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", ")", ";", "LiveIntervals", "&", "LIS", "=", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "assert", "(", "MRI", ".", "tracksLiveness", "(", ")", "&&", "\"MemIntrinsicResults expects liveness tracking\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Basic Block: \"", "<<", "MBB", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "WebAssembly", "::", "CALL_I32", ":", "case", "WebAssembly", "::", "CALL_I64", ":", "Changed", "|=", "optimizeCall", "(", "MBB", ",", "MI", ",", "MRI", ",", "MDT", ",", "LIS", ",", "TLI", ",", "LibInfo", ")", ";", "break", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Memory Intrinsic Results **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "\"MemIntrinsicResults expects liveness tracking\"", "\"Basic Block: \"", "WebAssembly::CALL_I32", "WebAssembly::CALL_I64" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "F", ".", "getFnAttribute", "(", "\"mnop-mcount\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", "&&", "F", ".", "getFnAttribute", "(", "\"fentry-call\"", ")", ".", "getValueAsString", "(", ")", "!=", "\"true\"", ")", "report_fatal_error", "(", "\"mnop-mcount only supported with fentry-call\"", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "\"mnop-mcount\"", "\"true\"", "\"fentry-call\"", "\"true\"", "\"mnop-mcount only supported with fentry-call\"", "SystemZ" ]

[]

[ "<s>", "static", "int", "rs6000_emit_int_cmove", "(", "rtx", "dest", ",", "rtx", "op", ",", "rtx", "true_cond", ",", "rtx", "false_cond", ")", "{", "rtx", "condition_rtx", ",", "cr", ";", "if", "(", "GET_MODE", "(", "rs6000_compare_op0", ")", "!=", "SImode", ")", "return", "0", ";", "condition_rtx", "=", "rs6000_generate_compare", "(", "GET_CODE", "(", "op", ")", ")", ";", "cr", "=", "XEXP", "(", "condition_rtx", ",", "0", ")", ";", "if", "(", "GET_MODE", "(", "cr", ")", "==", "CCmode", ")", "emit_insn", "(", "gen_isel_signed", "(", "dest", ",", "condition_rtx", ",", "true_cond", ",", "false_cond", ",", "cr", ")", ")", ";", "else", "emit_insn", "(", "gen_isel_unsigned", "(", "dest", ",", "condition_rtx", ",", "true_cond", ",", "false_cond", ",", "cr", ")", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Same", "as", "above", ",", "but", "for", "ints", "(", "isel", ")", "." ]

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

[]

[ "<s>", "void", "A57PBQPConstraints", "::", "apply", "(", "PBQPRAGraph", "&", "G", ")", "{", "MachineFunction", "&", "MF", "=", "G", ".", "getMetadata", "(", ")", ".", "MF", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "(", "void", ")", "TRI", ";", "DEBUG", "(", "MF", ".", "dump", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "const_iterator", "mbbItr", "=", "MF", ".", "begin", "(", ")", ",", "mbbEnd", "=", "MF", ".", "end", "(", ")", ";", "mbbItr", "!=", "mbbEnd", ";", "++", "mbbItr", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "&", "*", "mbbItr", ";", "Chains", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "const_iterator", "miItr", "=", "MBB", "->", "begin", "(", ")", ",", "miEnd", "=", "MBB", "->", "end", "(", ")", ";", "miItr", "!=", "miEnd", ";", "++", "miItr", ")", "{", "const", "MachineInstr", "*", "MI", "=", "&", "*", "miItr", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AArch64", "::", "FMSUBSrrr", ":", "case", "AArch64", "::", "FMADDSrrr", ":", "case", "AArch64", "::", "FNMSUBSrrr", ":", "case", "AArch64", "::", "FNMADDSrrr", ":", "case", "AArch64", "::", "FMSUBDrrr", ":", "case", "AArch64", "::", "FMADDDrrr", ":", "case", "AArch64", "::", "FNMSUBDrrr", ":", "case", "AArch64", "::", "FNMADDDrrr", ":", "{", "unsigned", "Rd", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Ra", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "if", "(", "addIntraChainConstraint", "(", "G", ",", "Rd", ",", "Ra", ")", ")", "addInterChainConstraint", "(", "G", ",", "Rd", ",", "Ra", ")", ";", "break", ";", "}", "case", "AArch64", "::", "FMLAv2f32", ":", "case", "AArch64", "::", "FMLSv2f32", ":", "{", "unsigned", "Rd", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "addInterChainConstraint", "(", "G", ",", "Rd", ",", "Rd", ")", ";", "break", ";", "}", "default", ":", "for", "(", "auto", "r", ":", "Chains", ")", "{", "SmallVector", "<", "unsigned", ",", "8", ">", "toDel", ";", "if", "(", "MI", "->", "killsRegister", "(", "r", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Killing chain \"", "<<", "PrintReg", "(", "r", ",", "&", "TRI", ")", "<<", "\" at \"", ";", "MI", "->", "print", "(", "dbgs", "(", ")", ")", ";", ")", ";", "toDel", ".", "push_back", "(", "r", ")", ";", "}", "while", "(", "!", "toDel", ".", "empty", "(", ")", ")", "{", "Chains", ".", "remove", "(", "toDel", ".", "back", "(", ")", ")", ";", "toDel", ".", "pop_back", "(", ")", ";", "}", "}", "}", "}", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64::FMSUBSrrr", "AArch64::FMADDSrrr", "AArch64::FNMSUBSrrr", "AArch64::FNMADDSrrr", "AArch64::FMSUBDrrr", "AArch64::FMADDDrrr", "AArch64::FNMSUBDrrr", "AArch64::FNMADDDrrr", "0", "3", "AArch64::FMLAv2f32", "AArch64::FMLSv2f32", "0", "8", "\"Killing chain \"", "\" at \"" ]

[]

[ "<s>", "bool", "aarch64_bitmask_imm", "(", "HOST_WIDE_INT", "val_in", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "val", ",", "tmp", ",", "mask", ",", "first_one", ",", "next_one", ";", "int", "bits", ";", "val", "=", "aarch64_replicate_bitmask_imm", "(", "val_in", ",", "mode", ")", ";", "tmp", "=", "val", "+", "(", "val", "&", "-", "val", ")", ";", "if", "(", "tmp", "==", "(", "tmp", "&", "-", "tmp", ")", ")", "return", "(", "val", "+", "1", ")", ">", "1", ";", "if", "(", "mode", "==", "SImode", ")", "val", "=", "(", "val", "<<", "32", ")", "|", "(", "val", "&", "0xffffffff", ")", ";", "if", "(", "val", "&", "1", ")", "val", "=", "~", "val", ";", "first_one", "=", "val", "&", "-", "val", ";", "tmp", "=", "val", "&", "(", "val", "+", "first_one", ")", ";", "if", "(", "tmp", "==", "0", ")", "return", "true", ";", "next_one", "=", "tmp", "&", "-", "tmp", ";", "bits", "=", "clz_hwi", "(", "first_one", ")", "-", "clz_hwi", "(", "next_one", ")", ";", "mask", "=", "val", "^", "tmp", ";", "if", "(", "(", "mask", ">>", "bits", ")", "!=", "0", "||", "bits", "!=", "(", "bits", "&", "-", "bits", ")", ")", "return", "false", ";", "return", "val", "==", "mask", "*", "bitmask_imm_mul", "[", "__builtin_clz", "(", "bits", ")", "-", "26", "]", ";", "}", "</s>" ]

[ "Return", "true", "if", "val", "is", "a", "valid", "bitmask", "immediate", "." ]

[ "aarch64", "1", "1", "32", "0xffffffff", "1", "0", "0", "26" ]

[]

[ "<s>", "int", "first_reg_to_save", "(", "void", ")", "{", "int", "first_reg", ";", "for", "(", "first_reg", "=", "13", ";", "first_reg", "<=", "31", ";", "first_reg", "++", ")", "if", "(", "regs_ever_live", "[", "first_reg", "]", "&&", "(", "!", "call_used_regs", "[", "first_reg", "]", "||", "(", "first_reg", "==", "RS6000_PIC_OFFSET_TABLE_REGNUM", "&&", "(", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", "!=", "0", ")", "||", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "flag_pic", ")", "||", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", ")", ")", ")", ")", "break", ";", "if", "(", "flag_pic", "&&", "current_function_uses_pic_offset_table", "&&", "first_reg", ">", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", "return", "RS6000_PIC_OFFSET_TABLE_REGNUM", ";", "return", "first_reg", ";", "}", "</s>" ]

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

[ "rs6000", "13", "31", "0" ]

[]

[ "<s>", "unsigned", "WebAssemblyFastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "if", "(", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "{", "if", "(", "TLI", ".", "isPositionIndependent", "(", ")", ")", "return", "0", ";", "if", "(", "GV", "->", "isThreadLocal", "(", ")", ")", "return", "0", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "Subtarget", "->", "hasAddr64", "(", ")", "?", "&", "WebAssembly", "::", "I64RegClass", ":", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "unsigned", "Opc", "=", "Subtarget", "->", "hasAddr64", "(", ")", "?", "WebAssembly", "::", "CONST_I64", ":", "WebAssembly", "::", "CONST_I32", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addGlobalAddress", "(", "GV", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Emit", "a", "constant", "in", "a", "register", "using", "target-specific", "logic", ",", "such", "as", "constant", "pool", "loads", "." ]

[ "WebAssembly", "WebAssembly", "0", "0", "WebAssembly::I64RegClass", "WebAssembly::I32RegClass", "WebAssembly::CONST_I64", "WebAssembly::CONST_I32", "0" ]

[]

[ "<s>", "static", "sbitmap", "rs6000_get_separate_components", "(", "void", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "if", "(", "WORLD_SAVE_P", "(", "info", ")", ")", "return", "NULL", ";", "gcc_assert", "(", "!", "(", "info", "->", "savres_strategy", "&", "SAVE_MULTIPLE", ")", "&&", "!", "(", "info", "->", "savres_strategy", "&", "REST_MULTIPLE", ")", ")", ";", "cfun", "->", "machine", "->", "n_components", "=", "64", ";", "sbitmap", "components", "=", "sbitmap_alloc", "(", "cfun", "->", "machine", "->", "n_components", ")", ";", "bitmap_clear", "(", "components", ")", ";", "int", "reg_size", "=", "TARGET_32BIT", "?", "4", ":", "8", ";", "int", "fp_reg_size", "=", "8", ";", "if", "(", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_GPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_GPRS", ")", ")", "{", "int", "offset", "=", "info", "->", "gp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "unsigned", "regno", "=", "info", "->", "first_gp_reg_save", ";", "regno", "<", "32", ";", "regno", "++", ")", "{", "if", "(", "IN_RANGE", "(", "offset", ",", "-", "0x8000", ",", "0x7fff", ")", "&&", "save_reg_p", "(", "regno", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "offset", "+=", "reg_size", ";", "}", "}", "if", "(", "frame_pointer_needed", ")", "bitmap_clear_bit", "(", "components", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "if", "(", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", "||", "(", "flag_pic", "==", "1", "&&", "DEFAULT_ABI", "==", "ABI_V4", ")", "||", "(", "flag_pic", "&&", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", ")", "bitmap_clear_bit", "(", "components", ",", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", ";", "if", "(", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_FPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_FPRS", ")", ")", "{", "int", "offset", "=", "info", "->", "fp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "unsigned", "regno", "=", "info", "->", "first_fp_reg_save", ";", "regno", "<", "64", ";", "regno", "++", ")", "{", "if", "(", "IN_RANGE", "(", "offset", ",", "-", "0x8000", ",", "0x7fff", ")", "&&", "save_reg_p", "(", "regno", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "offset", "+=", "fp_reg_size", ";", "}", "}", "if", "(", "info", "->", "lr_save_p", "&&", "!", "(", "flag_pic", "&&", "(", "DEFAULT_ABI", "==", "ABI_V4", "||", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", ")", "&&", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_GPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_GPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_FPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_FPRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "SAVE_INLINE_VRS", ")", "&&", "(", "info", "->", "savres_strategy", "&", "REST_INLINE_VRS", ")", ")", "{", "int", "offset", "=", "info", "->", "lr_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "if", "(", "IN_RANGE", "(", "offset", ",", "-", "0x8000", ",", "0x7fff", ")", ")", "bitmap_set_bit", "(", "components", ",", "0", ")", ";", "}", "if", "(", "cfun", "->", "machine", "->", "save_toc_in_prologue", ")", "bitmap_set_bit", "(", "components", ",", "2", ")", ";", "return", "components", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS", "." ]

[ "rs6000", "64", "4", "8", "8", "32", "0x8000", "0x7fff", "1", "64", "0x8000", "0x7fff", "0x8000", "0x7fff", "0", "2" ]

[]

[ "<s>", "static", "void", "workaround_arc_anomaly", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "succ0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "succ0", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "arc_hazard", "(", "insn", ",", "succ0", ")", ")", "{", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "succ0", ")", ";", "}", "}", "if", "(", "TARGET_ARC700", ")", "{", "rtx_insn", "*", "succ1", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "succ0", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "arc_store_addr_hazard_p", "(", "insn", ",", "succ0", ")", ")", "{", "emit_insn_after", "(", "gen_nopv", "(", ")", ",", "insn", ")", ";", "emit_insn_after", "(", "gen_nopv", "(", ")", ",", "insn", ")", ";", "continue", ";", "}", "succ1", "=", "next_real_insn", "(", "succ0", ")", ";", "if", "(", "succ0", "&&", "!", "JUMP_P", "(", "succ0", ")", "&&", "!", "CALL_P", "(", "succ0", ")", "&&", "arc_store_addr_hazard_p", "(", "insn", ",", "succ1", ")", ")", "emit_insn_after", "(", "gen_nopv", "(", ")", ",", "insn", ")", ";", "}", "}", "}", "</s>" ]

[ "The", "same", "functionality", "as", "arc_hazard", ".", "It", "is", "called", "in", "machine", "reorg", "before", "any", "other", "optimization", ".", "Hence", ",", "the", "NOP", "size", "is", "taken", "into", "account", "when", "doing", "branch", "shortening", "." ]

[ "arc" ]

[]

[ "<s>", "static", "bool", "avr_cannot_modify_jumps_p", "(", "void", ")", "{", "if", "(", "reload_completed", "&&", "cfun", "->", "machine", "&&", "cfun", "->", "machine", "->", "is_naked", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_CANNOT_MODITY_JUMPS_P", "'", "." ]

[ "avr" ]

[]

[ "<s>", "void", "LC3InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "LC3", "::", "LDR", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "LC3", "LC3", "LC3::LDR", "0" ]

[]

[ "<s>", "rtx", "function_value", "(", "tree", "valtype", ",", "tree", "func", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", ")", "{", "unsigned", "int", "regnum", ",", "dummy", ";", "enum", "mode_class", "class", ";", "gcc_assert", "(", "!", "valtype", "||", "!", "alpha_return_in_memory", "(", "valtype", ",", "func", ")", ")", ";", "if", "(", "valtype", ")", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "class", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "switch", "(", "class", ")", "{", "case", "MODE_INT", ":", "PROMOTE_MODE", "(", "mode", ",", "dummy", ",", "valtype", ")", ";", "case", "MODE_COMPLEX_INT", ":", "case", "MODE_VECTOR_INT", ":", "regnum", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "regnum", "=", "32", ";", "break", ";", "case", "MODE_COMPLEX_FLOAT", ":", "{", "enum", "machine_mode", "cmode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "32", ")", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "33", ")", ",", "GEN_INT", "(", "GET_MODE_SIZE", "(", "cmode", ")", ")", ")", ")", ")", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "regnum", ")", ";", "}", "</s>" ]

[ "Handle", "FUNCTION_VALUE", ",", "FUNCTION_OUTGOING_VALUE", ",", "and", "LIBCALL_VALUE", "macros", ".", "For", "v9", ",", "function", "return", "values", "are", "subject", "to", "the", "same", "rules", "as", "arguments", ",", "except", "that", "up", "to", "32", "bytes", "may", "be", "returned", "in", "registers", "." ]

[ "alpha", "0", "32", "2", "32", "33" ]

[]

[ "<s>", "static", "int", "get_element_number", "(", "tree", "vec_type", ",", "tree", "arg", ")", "{", "unsigned", "HOST_WIDE_INT", "elt", ",", "max", "=", "TYPE_VECTOR_SUBPARTS", "(", "vec_type", ")", "-", "1", ";", "if", "(", "!", "host_integerp", "(", "arg", ",", "1", ")", "||", "(", "elt", "=", "tree_low_cst", "(", "arg", ",", "1", ")", ",", "elt", ">", "max", ")", ")", "{", "error", "(", "\"selector must be an integer constant in the range 0..%wi\"", ",", "max", ")", ";", "return", "0", ";", "}", "return", "elt", ";", "}", "</s>" ]

[ "Return", "the", "integer", "constant", "in", "ARG", ".", "Constrain", "it", "to", "be", "in", "the", "range", "of", "the", "subparts", "of", "VEC_TYPE", ";", "issue", "an", "error", "if", "not", "." ]

[ "i386", "1", "1", "1", "\"selector must be an integer constant in the range 0..%wi\"", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI optimize exec mask operations\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI optimize exec mask operations\"" ]

[]

[ "<s>", "static", "void", "aarch64_asm_output_variant_pcs", "(", "FILE", "*", "stream", ",", "const", "tree", "decl", ",", "const", "char", "*", "name", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "arm_pcs", "pcs", "=", "(", "arm_pcs", ")", "fndecl_abi", "(", "decl", ")", ".", "id", "(", ")", ";", "if", "(", "pcs", "==", "ARM_PCS_SIMD", "||", "pcs", "==", "ARM_PCS_SVE", ")", "{", "fprintf", "(", "stream", ",", "\"\\t.variant_pcs\\t\"", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "}", "}", "</s>" ]

[ "Output", ".variant_pcs", "for", "aarch64_vector_pcs", "function", "symbols", "." ]

[ "aarch64", "\"\\t.variant_pcs\\t\"", "\"\\n\"" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCAssignFnForNode", "(", "CallConv", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Only register-returns should be created by PCS\"", ")", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "case", "CCValAssign", "::", "ZExt", ":", "case", "CCValAssign", "::", "AExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "ISD::OutputArg", "16", "4", "1", "0", "\"Only register-returns should be created by PCS\"", "\"Unknown loc info\"", "ISD::ANY_EXTEND", "ISD::BITCAST", "1", "0", "AArch64ISD::Ret", "MVT::Other" ]

[]

[ "<s>", "bool", "RISCVRegisterInfo", "::", "hasReservedSpillSlot", "(", "const", "MachineFunction", "&", "MF", ",", "Register", "Reg", ",", "int", "&", "FrameIdx", ")", "const", "{", "const", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "RVFI", "->", "useSaveRestoreLibCalls", "(", ")", ")", "return", "false", ";", "auto", "FII", "=", "FixedCSRFIMap", ".", "find", "(", "Reg", ")", ";", "if", "(", "FII", "==", "FixedCSRFIMap", ".", "end", "(", ")", ")", "return", "false", ";", "FrameIdx", "=", "FII", "->", "second", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "has", "reserved", "a", "spill", "slot", "in", "the", "stack", "frame", "of", "the", "given", "function", "for", "the", "specified", "register", "." ]

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "enum", "rtx_code", "s390_reverse_condition", "(", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ")", "{", "if", "(", "mode", "==", "CCVFALLmode", "||", "mode", "==", "CCVFANYmode", "||", "mode", "==", "CCSFPSmode", ")", "return", "reverse_condition_maybe_unordered", "(", "code", ")", ";", "else", "if", "(", "mode", "==", "CCVIALLmode", "||", "mode", "==", "CCVIANYmode", ")", "return", "reverse_condition", "(", "code", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Invert", "the", "comparison", "CODE", "applied", "to", "a", "CC", "mode", ".", "This", "is", "only", "safe", "if", "we", "know", "whether", "there", "result", "was", "created", "by", "a", "floating", "point", "compare", "or", "not", ".", "For", "the", "CCV", "modes", "this", "is", "encoded", "as", "part", "of", "the", "mode", "." ]

[ "s390" ]

[]

[ "<s>", "void", "thumb1_gen_const_int", "(", "rtx", "op0", ",", "HOST_WIDE_INT", "op1", ")", "{", "bool", "mov_done_p", "=", "false", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "3", ";", "i", "++", ")", "{", "int", "byte", "=", "(", "op1", ">>", "(", "8", "*", "(", "3", "-", "i", ")", ")", ")", "&", "0xff", ";", "if", "(", "byte", ")", "{", "emit_set_insn", "(", "op0", ",", "mov_done_p", "?", "gen_rtx_PLUS", "(", "SImode", ",", "op0", ",", "GEN_INT", "(", "byte", ")", ")", ":", "GEN_INT", "(", "byte", ")", ")", ";", "mov_done_p", "=", "true", ";", "}", "if", "(", "mov_done_p", ")", "emit_set_insn", "(", "op0", ",", "gen_rtx_ASHIFT", "(", "SImode", ",", "op0", ",", "GEN_INT", "(", "8", ")", ")", ")", ";", "}", "if", "(", "!", "mov_done_p", ")", "emit_set_insn", "(", "op0", ",", "GEN_INT", "(", "op1", "&", "0xff", ")", ")", ";", "else", "if", "(", "op1", "&", "0xff", ")", "emit_set_insn", "(", "op0", ",", "gen_rtx_PLUS", "(", "SImode", ",", "op0", ",", "GEN_INT", "(", "op1", "&", "0xff", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "sequence", "of", "movs/adds/shift", "to", "produce", "a", "32-bit", "constant", ".", "Avoid", "generating", "useless", "code", "when", "one", "of", "the", "bytes", "is", "zero", "." ]

[ "arm", "0", "3", "8", "3", "0xff", "8", "0xff", "0xff", "0xff" ]

[]

[ "<s>", "static", "void", "s390_asm_file_start", "(", "void", ")", "{", "s390_asm_output_machine_for_arch", "(", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FILE_START", "." ]

[ "s390" ]

[]

[ "<s>", "int", "AMDGPUFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AMDGPURegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "OffsetBytes", "=", "2", "*", "(", "getStackWidth", "(", "MF", ")", "*", "4", ")", ";", "int", "UpperBound", "=", "FI", "==", "-", "1", "?", "MFI", ".", "getNumObjects", "(", ")", ":", "FI", ";", "for", "(", "int", "i", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ";", "i", "<", "UpperBound", ";", "++", "i", ")", "{", "OffsetBytes", "=", "alignTo", "(", "OffsetBytes", ",", "MFI", ".", "getObjectAlignment", "(", "i", ")", ")", ";", "OffsetBytes", "+=", "MFI", ".", "getObjectSize", "(", "i", ")", ";", "OffsetBytes", "=", "alignTo", "(", "OffsetBytes", ",", "4", ")", ";", "}", "if", "(", "FI", "!=", "-", "1", ")", "OffsetBytes", "=", "alignTo", "(", "OffsetBytes", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "return", "OffsetBytes", "/", "(", "getStackWidth", "(", "MF", ")", "*", "4", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "2", "4", "1", "4", "1", "4" ]

[]

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

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

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

[]

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

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

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

[]

[ "<s>", "static", "bool", "rs6000_hard_regno_call_part_clobbered", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_32BIT", "&&", "TARGET_POWERPC64", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "INT_REGNO_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "TARGET_VSX", "&&", "FP_REGNO_P", "(", "regno", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "8", "&&", "!", "FLOAT128_2REG_P", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_CALL_PART_CLOBBERED", "." ]

[ "powerpcspe", "4", "8" ]

[]

[ "<s>", "void", "AArch64TTIImpl", "::", "getPeelingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "PeelingPreferences", "&", "PP", ")", "{", "BaseT", "::", "getPeelingPreferences", "(", "L", ",", "SE", ",", "PP", ")", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "peeling", "transformation", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "const", "MCExpr", "*", "PPCAIXAsmPrinter", "::", "lowerConstant", "(", "const", "Constant", "*", "CV", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "CV", ")", ")", "{", "MCSymbolXCOFF", "*", "FSym", "=", "cast", "<", "MCSymbolXCOFF", ">", "(", "getSymbol", "(", "F", ")", ")", ";", "if", "(", "!", "FSym", "->", "hasContainingCsect", "(", ")", ")", "{", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "F", "->", "isDeclaration", "(", ")", "?", "getObjFileLowering", "(", ")", ".", "getSectionForExternalReference", "(", "F", ",", "TM", ")", ":", "getObjFileLowering", "(", ")", ".", "getSectionForFunctionDescriptor", "(", "FSym", ")", ")", ";", "FSym", "->", "setContainingCsect", "(", "Csect", ")", ";", "}", "return", "MCSymbolRefExpr", "::", "create", "(", "FSym", "->", "getContainingCsect", "(", ")", "->", "getQualNameSymbol", "(", ")", ",", "OutContext", ")", ";", "}", "return", "PPCAsmPrinter", "::", "lowerConstant", "(", "CV", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "LLVM", "Constant", "to", "an", "MCExpr", "." ]

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

[]

[ "<s>", "static", "rtx", "move_to_de", "(", "int", "opno", ",", "rtx_insn", "*", "before", ")", "{", "rtx", "src", "=", "OP", "(", "opno", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "src", ")", ";", "rtx", "reg", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "recog_data", ".", "operand_mode", "[", "opno", "]", ";", "reg", "=", "(", "mode", "==", "QImode", ")", "?", "E", ":", "DE", ";", "if", "(", "mode", "==", "QImode", "||", "!", "is_virtual_register", "(", "OP", "(", "opno", ")", ")", ")", "{", "OP", "(", "opno", ")", "=", "move_to_acc", "(", "opno", ",", "before", ")", ";", "OP", "(", "opno", ")", "=", "move_acc_to_reg", "(", "OP", "(", "opno", ")", ",", "E_REG", ",", "before", ")", ";", "}", "else", "{", "gen_and_emit_move", "(", "reg", ",", "src", ",", "before", ",", "true", ")", ";", "}", "return", "reg", ";", "}", "</s>" ]

[ "Copy", "OP", "(", "opno", ")", "to", "E", "or", "DE", ",", "placing", "any", "generated", "insns", "before", "BEFORE", ".", "Returns", "E/DE", "RTX", "." ]

[ "rl78" ]

[]

[ "<s>", "SDValue", "TPCSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "SizeValue", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "assert", "(", "SizeValue", "&&", "\"Size in memset call must be a compile time constant\"", ")", ";", "assert", "(", "SrcPtrInfo", ".", "getAddrSpace", "(", ")", "==", "DstPtrInfo", ".", "getAddrSpace", "(", ")", "&&", "\"Cannot memcpy between different address spaces\"", ")", ";", "int", "AS", "=", "DstPtrInfo", ".", "getAddrSpace", "(", ")", ";", "assert", "(", "(", "AS", "==", "1", "||", "AS", "==", "2", ")", "&&", "\"memcpy may be called only for local memory\"", ")", ";", "unsigned", "Sz", "=", "SizeValue", "->", "getZExtValue", "(", ")", ";", "unsigned", "UnitSz", "=", "(", "AS", "==", "1", ")", "?", "4", ":", "256", ";", "assert", "(", "(", "Sz", "%", "UnitSz", "==", "0", ")", "&&", "\"Size in memcpy must be a multiple of space unit\"", ")", ";", "MVT", "VT", "=", "(", "AS", "==", "1", ")", "?", "MVT", "::", "i32", ":", "MVT", "::", "v64i32", ";", "SmallVector", "<", "SDValue", ",", "8", ">", "Chains", ";", "for", "(", "unsigned", "I", "=", "0", ",", "SZ", "=", "Sz", "/", "UnitSz", ",", "Offs", "=", "0", ";", "I", "!=", "SZ", ";", "++", "I", ",", "Offs", "+=", "UnitSz", ")", "{", "SDValue", "Value", "=", "DAG", ".", "getLoad", "(", "VT", ",", "dl", ",", "Chain", ",", "DAG", ".", "getMemBasePlusOffset", "(", "Src", ",", "Offs", ",", "dl", ")", ",", "SrcPtrInfo", ",", "Align", ")", ";", "SDValue", "NewChain", "=", "DAG", ".", "getStore", "(", "Value", ".", "getValue", "(", "1", ")", ",", "dl", ",", "Value", ",", "DAG", ".", "getMemBasePlusOffset", "(", "Dst", ",", "Offs", ",", "dl", ")", ",", "DstPtrInfo", ".", "getWithOffset", "(", "Offs", ")", ",", "Align", ")", ";", "Chains", ".", "push_back", "(", "NewChain", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "Chains", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

[ "TPC", "TPC", "\"Size in memset call must be a compile time constant\"", "\"Cannot memcpy between different address spaces\"", "1", "2", "\"memcpy may be called only for local memory\"", "1", "4", "256", "0", "\"Size in memcpy must be a multiple of space unit\"", "1", "MVT::i32", "MVT::v64i32", "8", "0", "0", "1", "ISD::TokenFactor", "MVT::Other" ]

[]

[ "<s>", "rtx", "frv_dynamic_chain_address", "(", "rtx", "frame", ")", "{", "cfun", "->", "machine", "->", "frame_needed", "=", "1", ";", "return", "frame", ";", "}", "</s>" ]

[ "The", "default", "is", "correct", ",", "but", "we", "need", "to", "make", "sure", "the", "frame", "gets", "created", "." ]

[ "frv", "1" ]

[]

[ "<s>", "CCAssignFn", "*", "AMDGPUCallLowering", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "{", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "AMDGPU_KERNEL", ":", "case", "CallingConv", "::", "SPIR_KERNEL", ":", "return", "CC_AMDGPU_Kernel", ";", "case", "CallingConv", "::", "AMDGPU_VS", ":", "case", "CallingConv", "::", "AMDGPU_GS", ":", "case", "CallingConv", "::", "AMDGPU_PS", ":", "case", "CallingConv", "::", "AMDGPU_CS", ":", "case", "CallingConv", "::", "AMDGPU_HS", ":", "return", "CC_AMDGPU", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "CC_AMDGPU_Func", ";", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention.\"", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "create_bif_order", "(", "void", ")", "{", "bif_order", "=", "(", "int", "*", ")", "malloc", "(", "(", "curr_bif", "+", "1", ")", "*", "sizeof", "(", "int", ")", ")", ";", "rbt_inorder_callback", "(", "&", "bifo_rbt", ",", "bifo_rbt", ".", "rbt_root", ",", "set_bif_order", ")", ";", "}", "</s>" ]

[ "Create", "a", "mapping", "from", "function", "IDs", "in", "their", "final", "order", "to", "the", "order", "they", "appear", "in", "the", "built-in", "function", "file", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "void", "arc_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "register", "rtx", "base", ",", "index", "=", "0", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "if", "(", "SYMBOL_REF_SMALL_P", "(", "addr", ")", ")", "fprintf", "(", "file", ",", "\"@sda\"", ")", ";", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "MULT", ")", "index", "=", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "index", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "index", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "base", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "base", ")", ";", "if", "(", "CONSTANT_P", "(", "base", ")", "&&", "CONST_INT_P", "(", "index", ")", ")", "fputc", "(", "'+'", ",", "file", ")", ";", "else", "fputc", "(", "','", ",", "file", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "index", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "index", ")", ";", "break", ";", "case", "CONST", ":", "{", "rtx", "c", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "(", "GET_CODE", "(", "c", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "c", ",", "1", ")", "==", "UNSPEC_TLS_OFF", "||", "XINT", "(", "c", ",", "1", ")", "==", "UNSPEC_TLS_IE", ")", ")", "||", "(", "GET_CODE", "(", "c", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "c", ",", "0", ")", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "XEXP", "(", "c", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_TLS_OFF", "||", "XINT", "(", "XEXP", "(", "c", ",", "0", ")", ",", "1", ")", "==", "ARC_UNSPEC_GOTOFFPC", ")", ")", ")", "{", "arc_output_pic_addr_const", "(", "file", ",", "c", ",", "0", ")", ";", "break", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "c", ")", "==", "PLUS", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "output_address", "(", "VOIDmode", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "break", ";", "}", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "if", "(", "flag_pic", ")", "arc_output_pic_addr_const", "(", "file", ",", "addr", ",", "0", ")", ";", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "." ]

[ "arc", "0", "\"@sda\"", "0", "0", "0", "1", "0", "0", "1", "0", "1", "0", "1", "1", "0", "0", "1", "0", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "ARMTargetELFStreamer", "::", "emitLabel", "(", "MCSymbol", "*", "Symbol", ")", "{", "ARMELFStreamer", "&", "Streamer", "=", "getStreamer", "(", ")", ";", "if", "(", "!", "Streamer", ".", "IsThumb", ")", "return", ";", "Streamer", ".", "getAssembler", "(", ")", ".", "registerSymbol", "(", "*", "Symbol", ")", ";", "unsigned", "Type", "=", "cast", "<", "MCSymbolELF", ">", "(", "Symbol", ")", "->", "getType", "(", ")", ";", "if", "(", "Type", "==", "ELF", "::", "STT_FUNC", "||", "Type", "==", "ELF", "::", "STT_GNU_IFUNC", ")", "Streamer", ".", "EmitThumbFunc", "(", "Symbol", ")", ";", "}", "</s>" ]

[ "Emit", "a", "label", "for", "Symbol", "into", "the", "current", "section", "." ]

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

[]

[ "<s>", "static", "int", "frv_arg_partial_bytes", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "machine_mode", "xmode", "=", "(", "arg", ".", "mode", "==", "BLKmode", ")", "?", "SImode", ":", "arg", ".", "mode", ";", "int", "bytes", "=", "GET_MODE_SIZE", "(", "xmode", ")", ";", "int", "words", "=", "(", "bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "int", "arg_num", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "int", "ret", ";", "ret", "=", "(", "(", "arg_num", "<=", "LAST_ARG_REGNUM", "&&", "arg_num", "+", "words", ">", "LAST_ARG_REGNUM", "+", "1", ")", "?", "LAST_ARG_REGNUM", "-", "arg_num", "+", "1", ":", "0", ")", ";", "ret", "*=", "UNITS_PER_WORD", ";", "if", "(", "TARGET_DEBUG_ARG", "&&", "ret", ")", "fprintf", "(", "stderr", ",", "\"frv_arg_partial_bytes: %d\\n\"", ",", "ret", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "A", "C", "expression", "for", "the", "number", "of", "words", ",", "at", "the", "beginning", "of", "an", "argument", ",", "must", "be", "put", "in", "registers", ".", "The", "value", "must", "be", "zero", "for", "arguments", "that", "are", "passed", "entirely", "in", "registers", "or", "that", "are", "entirely", "pushed", "on", "the", "stack", ".", "On", "some", "machines", ",", "certain", "arguments", "must", "be", "passed", "partially", "in", "registers", "and", "partially", "in", "memory", ".", "On", "these", "machines", ",", "typically", "the", "first", "N", "words", "of", "arguments", "are", "passed", "in", "registers", ",", "and", "the", "rest", "on", "the", "stack", ".", "If", "a", "multi-word", "argument", "(", "a", "`", "double", "'", "or", "a", "structure", ")", "crosses", "that", "boundary", ",", "its", "first", "few", "words", "must", "be", "passed", "in", "registers", "and", "the", "rest", "must", "be", "pushed", ".", "This", "macro", "tells", "the", "compiler", "when", "this", "occurs", ",", "and", "how", "many", "of", "the", "words", "should", "go", "in", "registers", ".", "`", "FUNCTION_ARG", "'", "for", "these", "arguments", "should", "return", "the", "first", "register", "to", "be", "used", "by", "the", "caller", "for", "this", "argument", ";", "likewise", "`", "FUNCTION_INCOMING_ARG", "'", ",", "for", "the", "called", "function", "." ]

[ "frv", "1", "1", "1", "0", "\"frv_arg_partial_bytes: %d\\n\"" ]

[]

[ "<s>", "void", "alpha_expand_movmisalign", "(", "enum", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", ")", "{", "rtx", "tmp", ";", "if", "(", "register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "tmp", "=", "operands", "[", "0", "]", ";", "else", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "alpha_expand_unaligned_load", "(", "tmp", ",", "operands", "[", "1", "]", ",", "8", ",", "0", ",", "0", ")", ";", "if", "(", "tmp", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "tmp", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "alpha_expand_unaligned_store", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "8", ",", "0", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "the", "movmisalign", "patterns", ".", "One", "of", "the", "operands", "is", "a", "memory", "that", "is", "not", "naturally", "aligned", ".", "Emit", "instructions", "to", "load", "it", "." ]

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

[]

[ "<s>", "static", "bool", "expand_vec_perm_pblendv", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "i", ",", "which", ",", "nelt", "=", "d", "->", "nelt", ";", "struct", "expand_vec_perm_d", "dcopy", ",", "dcopy1", ";", "machine_mode", "vmode", "=", "d", "->", "vmode", ";", "bool", "ok", ";", "if", "(", "d", "->", "one_operand_p", ")", "return", "false", ";", "if", "(", "TARGET_AVX2", "&&", "GET_MODE_SIZE", "(", "vmode", ")", "==", "32", ")", ";", "else", "if", "(", "TARGET_AVX", "&&", "(", "vmode", "==", "V4DFmode", "||", "vmode", "==", "V8SFmode", ")", ")", ";", "else", "if", "(", "TARGET_SSE4_1", "&&", "(", "GET_MODE_SIZE", "(", "vmode", ")", "==", "16", "||", "(", "TARGET_MMX_WITH_SSE", "&&", "GET_MODE_SIZE", "(", "vmode", ")", "==", "8", ")", "||", "GET_MODE_SIZE", "(", "vmode", ")", "==", "4", ")", ")", ";", "else", "return", "false", ";", "for", "(", "i", "=", "0", ",", "which", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "unsigned", "e", "=", "d", "->", "perm", "[", "i", "]", ";", "if", "(", "e", "!=", "i", ")", "which", "|=", "(", "e", "<", "nelt", "?", "1", ":", "2", ")", ";", "}", "if", "(", "which", "!=", "1", "&&", "which", "!=", "2", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", "&&", "GET_MODE_SIZE", "(", "vmode", ")", "==", "16", ")", "return", "true", ";", "dcopy", "=", "*", "d", ";", "if", "(", "which", "==", "2", ")", "dcopy", ".", "op0", "=", "dcopy", ".", "op1", "=", "d", "->", "op1", ";", "else", "dcopy", ".", "op0", "=", "dcopy", ".", "op1", "=", "d", "->", "op0", ";", "if", "(", "!", "d", "->", "testing_p", ")", "dcopy", ".", "target", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "dcopy", ".", "one_operand_p", "=", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "dcopy", ".", "perm", "[", "i", "]", "=", "d", "->", "perm", "[", "i", "]", "&", "(", "nelt", "-", "1", ")", ";", "ok", "=", "expand_vec_perm_1", "(", "&", "dcopy", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "vmode", ")", "!=", "16", "&&", "!", "ok", ")", "return", "false", ";", "else", "gcc_assert", "(", "ok", ")", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "dcopy1", "=", "*", "d", ";", "if", "(", "which", "==", "2", ")", "dcopy1", ".", "op1", "=", "dcopy", ".", "target", ";", "else", "dcopy1", ".", "op0", "=", "dcopy", ".", "target", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "dcopy1", ".", "perm", "[", "i", "]", "=", "(", "(", "d", "->", "perm", "[", "i", "]", ">=", "nelt", ")", "?", "(", "nelt", "+", "i", ")", ":", "i", ")", ";", "ok", "=", "expand_vec_perm_blend", "(", "&", "dcopy1", ")", ";", "gcc_assert", "(", "ok", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_vec_perm_const_1", ".", "Try", "to", "simplify", "the", "permutation", "using", "the", "SSE4_1", "pblendv", "instruction", ".", "Potentially", "reduces", "permutation", "from", "2", "pshufb", "and", "or", "to", "1", "pshufb", "and", "pblendv", "." ]

[ "i386", "32", "16", "8", "4", "0", "0", "1", "2", "1", "2", "16", "2", "0", "1", "16", "2", "0" ]

[]