Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "void", "aarch64_expand_builtin_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", "ATTRIBUTE_UNUSED", ")", "{", "const", "CUMULATIVE_ARGS", "*", "cum", ";", "tree", "f_stack", ",", "f_grtop", ",", "f_vrtop", ",", "f_groff", ",", "f_vroff", ";", "tree", "stack", ",", "grtop", ",", "vrtop", ",", "groff", ",", "vroff", ";", "tree", "t", ";", "int", "gr_save_area_size", "=", "cfun", "->", "va_list_gpr_size", ";", "int", "vr_save_area_size", "=", "cfun", "->", "va_list_fpr_size", ";", "int", "vr_offset", ";", "cum", "=", "&", "crtl", "->", "args", ".", "info", ";", "if", "(", "cfun", "->", "va_list_gpr_size", ")", "gr_save_area_size", "=", "MIN", "(", "(", "NUM_ARG_REGS", "-", "cum", "->", "aapcs_ncrn", ")", "*", "UNITS_PER_WORD", ",", "cfun", "->", "va_list_gpr_size", ")", ";", "if", "(", "cfun", "->", "va_list_fpr_size", ")", "vr_save_area_size", "=", "MIN", "(", "(", "NUM_FP_ARG_REGS", "-", "cum", "->", "aapcs_nvrn", ")", "*", "UNITS_PER_VREG", ",", "cfun", "->", "va_list_fpr_size", ")", ";", "if", "(", "!", "TARGET_FLOAT", ")", "{", "gcc_assert", "(", "cum", "->", "aapcs_nvrn", "==", "0", ")", ";", "vr_save_area_size", "=", "0", ";", "}", "f_stack", "=", "TYPE_FIELDS", "(", "va_list_type_node", ")", ";", "f_grtop", "=", "DECL_CHAIN", "(", "f_stack", ")", ";", "f_vrtop", "=", "DECL_CHAIN", "(", "f_grtop", ")", ";", "f_groff", "=", "DECL_CHAIN", "(", "f_vrtop", ")", ";", "f_vroff", "=", "DECL_CHAIN", "(", "f_groff", ")", ";", "stack", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_stack", ")", ",", "valist", ",", "f_stack", ",", "NULL_TREE", ")", ";", "grtop", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_grtop", ")", ",", "valist", ",", "f_grtop", ",", "NULL_TREE", ")", ";", "vrtop", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_vrtop", ")", ",", "valist", ",", "f_vrtop", ",", "NULL_TREE", ")", ";", "groff", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_groff", ")", ",", "valist", ",", "f_groff", ",", "NULL_TREE", ")", ";", "vroff", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_vroff", ")", ",", "valist", ",", "f_vroff", ",", "NULL_TREE", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "stack", ")", ",", "virtual_incoming_args_rtx", ")", ";", "if", "(", "cum", "->", "aapcs_stack_size", ">", "0", ")", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "cum", "->", "aapcs_stack_size", "*", "UNITS_PER_WORD", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "stack", ")", ",", "stack", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "grtop", ")", ",", "virtual_incoming_args_rtx", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "grtop", ")", ",", "grtop", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "vrtop", ")", ",", "virtual_incoming_args_rtx", ")", ";", "vr_offset", "=", "ROUND_UP", "(", "gr_save_area_size", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "if", "(", "vr_offset", ")", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "-", "vr_offset", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "vrtop", ")", ",", "vrtop", ",", "t", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "groff", ")", ",", "groff", ",", "build_int_cst", "(", "TREE_TYPE", "(", "groff", ")", ",", "-", "gr_save_area_size", ")", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "vroff", ")", ",", "vroff", ",", "build_int_cst", "(", "TREE_TYPE", "(", "vroff", ")", ",", "-", "vr_save_area_size", ")", ")", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_BUILTIN_VA_START", "." ]

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

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "SHUXI", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_SHUXI_NONE\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_SHUXI_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "{", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "}", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "SHUXI", "SHUXI::NumTargetFixupKinds", "\"fixup_SHUXI_NONE\"", "0", "32", "0", "\"fixup_SHUXI_32\"", "0", "32", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "int", "mcore_expand_insv", "(", "rtx", "operands", "[", "]", ")", "{", "int", "width", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "int", "posn", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "int", "mask", ";", "rtx", "mreg", ",", "sreg", ",", "ereg", ";", "if", "(", "width", "==", "1", "&&", "GET_CODE", "(", "operands", "[", "3", "]", ")", "==", "CONST_INT", ")", "{", "if", "(", "(", "INTVAL", "(", "operands", "[", "3", "]", ")", "&", "1", ")", "==", "0", ")", "{", "mask", "=", "~", "(", "1", "<<", "posn", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_AND", "(", "SImode", ",", "operands", "[", "0", "]", ",", "GEN_INT", "(", "mask", ")", ")", ")", ")", ";", "}", "else", "{", "mask", "=", "1", "<<", "posn", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "SImode", ",", "operands", "[", "0", "]", ",", "GEN_INT", "(", "mask", ")", ")", ")", ")", ";", "}", "return", "1", ";", "}", "if", "(", "!", "TARGET_W_FIELD", ")", "return", "0", ";", "if", "(", "width", "==", "8", "&&", "posn", "%", "8", "==", "0", ")", "return", "0", ";", "if", "(", "width", "==", "16", "&&", "posn", "%", "16", "==", "0", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "operands", "[", "3", "]", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "operands", "[", "3", "]", ")", "==", "(", "(", "1", "<<", "width", ")", "-", "1", ")", ")", "{", "mreg", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "3", "]", ")", "<<", "posn", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "SImode", ",", "operands", "[", "0", "]", ",", "mreg", ")", ")", ")", ";", "return", "1", ";", "}", "mreg", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "~", "(", "(", "(", "1", "<<", "width", ")", "-", "1", ")", "<<", "posn", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_AND", "(", "SImode", ",", "operands", "[", "0", "]", ",", "mreg", ")", ")", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "3", "]", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "operands", "[", "3", "]", ")", "==", "0", ")", "return", "1", ";", "sreg", "=", "copy_to_mode_reg", "(", "SImode", ",", "operands", "[", "3", "]", ")", ";", "if", "(", "width", "+", "posn", "!=", "(", "int", ")", "GET_MODE_SIZE", "(", "SImode", ")", ")", "{", "ereg", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "(", "1", "<<", "width", ")", "-", "1", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "sreg", ",", "gen_rtx_AND", "(", "SImode", ",", "sreg", ",", "ereg", ")", ")", ")", ";", "}", "if", "(", "posn", "!=", "0", ")", "emit_insn", "(", "gen_rtx_SET", "(", "sreg", ",", "gen_rtx_ASHIFT", "(", "SImode", ",", "sreg", ",", "GEN_INT", "(", "posn", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "SImode", ",", "operands", "[", "0", "]", ",", "sreg", ")", ")", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Expand", "insert", "bit", "field", ".", "BRC" ]

[ "mcore", "1", "2", "1", "3", "3", "1", "0", "1", "0", "0", "1", "0", "0", "1", "0", "8", "8", "0", "0", "16", "16", "0", "0", "3", "3", "1", "1", "3", "0", "0", "1", "1", "1", "0", "0", "3", "3", "0", "1", "3", "1", "1", "0", "0", "0", "1" ]

[]

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

[ "Tests", "whether", "the", "target", "triple", "is", "little", "endian", "." ]

[ "SIC" ]

[]

[ "<s>", "void", "ix86_split_convert_uns_si_sse", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "vecmode", ";", "rtx", "value", ",", "large", ",", "zero_or_two31", ",", "input", ",", "two31", ",", "x", ";", "large", "=", "operands", "[", "1", "]", ";", "zero_or_two31", "=", "operands", "[", "2", "]", ";", "input", "=", "operands", "[", "3", "]", ";", "two31", "=", "operands", "[", "4", "]", ";", "vecmode", "=", "GET_MODE", "(", "large", ")", ";", "value", "=", "gen_rtx_REG", "(", "vecmode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", ")", ";", "if", "(", "MEM_P", "(", "input", ")", ")", "{", "if", "(", "vecmode", "==", "V4SFmode", ")", "emit_insn", "(", "gen_vec_setv4sf_0", "(", "value", ",", "CONST0_RTX", "(", "V4SFmode", ")", ",", "input", ")", ")", ";", "else", "emit_insn", "(", "gen_sse2_loadlpd", "(", "value", ",", "CONST0_RTX", "(", "V2DFmode", ")", ",", "input", ")", ")", ";", "}", "else", "{", "input", "=", "gen_rtx_REG", "(", "vecmode", ",", "REGNO", "(", "input", ")", ")", ";", "emit_move_insn", "(", "value", ",", "CONST0_RTX", "(", "vecmode", ")", ")", ";", "if", "(", "vecmode", "==", "V4SFmode", ")", "emit_insn", "(", "gen_sse_movss_v4sf", "(", "value", ",", "value", ",", "input", ")", ")", ";", "else", "emit_insn", "(", "gen_sse2_movsd_v2df", "(", "value", ",", "value", ",", "input", ")", ")", ";", "}", "emit_move_insn", "(", "large", ",", "two31", ")", ";", "emit_move_insn", "(", "zero_or_two31", ",", "MEM_P", "(", "two31", ")", "?", "large", ":", "two31", ")", ";", "x", "=", "gen_rtx_fmt_ee", "(", "LE", ",", "vecmode", ",", "large", ",", "value", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "large", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_AND", "(", "vecmode", ",", "zero_or_two31", ",", "large", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "zero_or_two31", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_MINUS", "(", "vecmode", ",", "value", ",", "zero_or_two31", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "value", ",", "x", ")", ")", ";", "large", "=", "gen_rtx_REG", "(", "V4SImode", ",", "REGNO", "(", "large", ")", ")", ";", "emit_insn", "(", "gen_ashlv4si3", "(", "large", ",", "large", ",", "GEN_INT", "(", "31", ")", ")", ")", ";", "x", "=", "gen_rtx_REG", "(", "V4SImode", ",", "REGNO", "(", "value", ")", ")", ";", "if", "(", "vecmode", "==", "V4SFmode", ")", "emit_insn", "(", "gen_fix_truncv4sfv4si2", "(", "x", ",", "value", ")", ")", ";", "else", "emit_insn", "(", "gen_sse2_cvttpd2dq", "(", "x", ",", "value", ")", ")", ";", "value", "=", "x", ";", "emit_insn", "(", "gen_xorv4si3", "(", "value", ",", "value", ",", "large", ")", ")", ";", "}", "</s>" ]

[ "Post-reload", "splitter", "for", "converting", "an", "SF", "or", "DFmode", "value", "in", "an", "SSE", "register", "into", "an", "unsigned", "SImode", "." ]

[ "i386", "1", "2", "3", "4", "0", "31" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "XNCMRegisterInfo", "::", "getPointerRegClass", "(", "unsigned", "Kind", ")", "const", "{", "return", "&", "XNCM", "::", "GR16RegClass", ";", "}", "</s>" ]

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

[ "XNCM", "XNCM", "XNCM::GR16RegClass" ]

[]

[ "<s>", "bool", "fp_zero_operand", "(", "rtx", "op", ")", "{", "const", "REAL_VALUE_TYPE", "*", "r", ";", "if", "(", "GET_MODE", "(", "op", ")", "!=", "SFmode", ")", "return", "false", ";", "r", "=", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ";", "return", "real_equal", "(", "r", ",", "&", "dconst0", ")", "&&", "!", "REAL_VALUE_MINUS_ZERO", "(", "*", "r", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "OP", "is", "a", "floating", "point", "value", "with", "value", "0.0", "." ]

[ "sh" ]

[]

[ "<s>", "static", "std", "::", "string", "getEdgeAttributes", "(", "const", "SUnit", "*", "Node", ",", "SUnitIterator", "EI", ",", "const", "ScheduleDAG", "*", "Graph", ")", "{", "if", "(", "EI", ".", "isArtificialDep", "(", ")", ")", "return", "\"color=cyan,style=dashed\"", ";", "if", "(", "EI", ".", "isCtrlDep", "(", ")", ")", "return", "\"color=blue,style=dashed\"", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "If", "you", "want", "to", "override", "the", "dot", "attributes", "printed", "for", "a", "particular", "edge", ",", "override", "this", "method", "." ]

[ "Patmos", "\"color=cyan,style=dashed\"", "\"color=blue,style=dashed\"", "\"\"" ]

[]

[ "<s>", "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "MCInst", "Inst", ";", "unsigned", "ErrorInfo", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "return", "true", ";", "}", "while", "(", "processInstruction", "(", "Inst", ",", "Operands", ")", ")", ";", "forwardITPosition", "(", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "return", "true", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_ConversionFail", ":", "return", "true", ";", "case", "Match_RequiresNotITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"flag setting instruction only valid outside IT block\"", ")", ";", "case", "Match_RequiresITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction only valid inside IT block\"", ")", ";", "case", "Match_RequiresV6", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires ARMv6 or later\"", ")", ";", "case", "Match_RequiresThumb2", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires Thumb2\"", ")", ";", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"instruction requires a CPU feature not currently enabled\"", "0U", "\"too few operands for instruction\"", "ARM", "\"invalid operand for instruction\"", "\"invalid instruction\"", "\"flag setting instruction only valid outside IT block\"", "\"instruction only valid inside IT block\"", "\"instruction variant requires ARMv6 or later\"", "\"instruction variant requires Thumb2\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "unsigned", "WebAssemblyFastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "if", "(", "const", "auto", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "{", "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", "WebAssembly::I64RegClass", "WebAssembly::I32RegClass", "WebAssembly::CONST_I64", "WebAssembly::CONST_I32", "0" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "VE", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "VE", "VE::NumTargetFixupKinds" ]

[]

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

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

[ "LC3" ]

[]

[ "<s>", "Value", "*", "ARMTargetLowering", "::", "emitLoadLinked", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "ValTy", "=", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ";", "bool", "IsAcquire", "=", "isAcquireOrStronger", "(", "Ord", ")", ";", "if", "(", "ValTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "arm_ldaexd", ":", "Intrinsic", "::", "arm_ldrexd", ";", "Function", "*", "Ldrex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "Ldrex", ",", "Addr", ",", "\"lohi\"", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "0", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "1", ",", "\"hi\"", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValTy", ",", "32", ")", ")", ",", "\"val64\"", ")", ";", "}", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "arm_ldaex", ":", "Intrinsic", "::", "arm_ldrex", ";", "Function", "*", "Ldrex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "return", "Builder", ".", "CreateTruncOrBitCast", "(", "Builder", ".", "CreateCall", "(", "Ldrex", ",", "Addr", ")", ",", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ")", ";", "}", "</s>" ]

[ "Perform", "a", "load-linked", "operation", "on", "Addr", ",", "returning", "a", "``", "Value", "*", "''", "with", "the", "corresponding", "pointee", "type", "." ]

[ "ARM", "ARM", "64", "Intrinsic::ID", "Intrinsic::arm_ldaexd", "Intrinsic::arm_ldrexd", "Intrinsic::getDeclaration", "\"lohi\"", "0", "\"lo\"", "1", "\"hi\"", "\"lo64\"", "\"hi64\"", "32", "\"val64\"", "Intrinsic::ID", "Intrinsic::arm_ldaex", "Intrinsic::arm_ldrex", "Intrinsic::getDeclaration" ]

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "emitMachineConstantPoolValue", "(", "MachineConstantPoolValue", "*", "MCPV", ")", "{", "const", "DataLayout", "&", "DL", "=", "getDataLayout", "(", ")", ";", "int", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "MCPV", "->", "getType", "(", ")", ")", ";", "ARMConstantPoolValue", "*", "ACPV", "=", "static_cast", "<", "ARMConstantPoolValue", "*", ">", "(", "MCPV", ")", ";", "if", "(", "ACPV", "->", "isPromotedGlobal", "(", ")", ")", "{", "auto", "*", "ACPC", "=", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", ";", "for", "(", "const", "auto", "*", "GV", ":", "ACPC", "->", "promotedGlobals", "(", ")", ")", "{", "if", "(", "!", "EmittedPromotedGlobalLabels", ".", "count", "(", "GV", ")", ")", "{", "MCSymbol", "*", "GVSym", "=", "getSymbol", "(", "GV", ")", ";", "OutStreamer", "->", "emitLabel", "(", "GVSym", ")", ";", "EmittedPromotedGlobalLabels", ".", "insert", "(", "GV", ")", ";", "}", "}", "return", "emitGlobalConstant", "(", "DL", ",", "ACPC", "->", "getPromotedGlobalInit", "(", ")", ",", "0", ")", ";", "}", "MCSymbol", "*", "MCSym", ";", "if", "(", "ACPV", "->", "isLSDA", "(", ")", ")", "{", "MCSym", "=", "getMBBExceptionSym", "(", "MF", "->", "front", "(", ")", ")", ";", "}", "else", "if", "(", "ACPV", "->", "isBlockAddress", "(", ")", ")", "{", "const", "BlockAddress", "*", "BA", "=", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", "->", "getBlockAddress", "(", ")", ";", "MCSym", "=", "GetBlockAddressSymbol", "(", "BA", ")", ";", "}", "else", "if", "(", "ACPV", "->", "isGlobalValue", "(", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", "->", "getGV", "(", ")", ";", "unsigned", "char", "TF", "=", "Subtarget", "->", "isTargetMachO", "(", ")", "?", "ARMII", "::", "MO_NONLAZY", ":", "0", ";", "MCSym", "=", "GetARMGVSymbol", "(", "GV", ",", "TF", ")", ";", "}", "else", "if", "(", "ACPV", "->", "isMachineBasicBlock", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "cast", "<", "ARMConstantPoolMBB", ">", "(", "ACPV", ")", "->", "getMBB", "(", ")", ";", "MCSym", "=", "MBB", "->", "getSymbol", "(", ")", ";", "}", "else", "{", "assert", "(", "ACPV", "->", "isExtSymbol", "(", ")", "&&", "\"unrecognized constant pool value\"", ")", ";", "auto", "Sym", "=", "cast", "<", "ARMConstantPoolSymbol", ">", "(", "ACPV", ")", "->", "getSymbol", "(", ")", ";", "MCSym", "=", "GetExternalSymbolSymbol", "(", "Sym", ")", ";", "}", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "MCSym", ",", "getModifierVariantKind", "(", "ACPV", "->", "getModifier", "(", ")", ")", ",", "OutContext", ")", ";", "if", "(", "ACPV", "->", "getPCAdjustment", "(", ")", ")", "{", "MCSymbol", "*", "PCLabel", "=", "getPICLabel", "(", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ",", "getFunctionNumber", "(", ")", ",", "ACPV", "->", "getLabelId", "(", ")", ",", "OutContext", ")", ";", "const", "MCExpr", "*", "PCRelExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "PCLabel", ",", "OutContext", ")", ";", "PCRelExpr", "=", "MCBinaryExpr", "::", "createAdd", "(", "PCRelExpr", ",", "MCConstantExpr", "::", "create", "(", "ACPV", "->", "getPCAdjustment", "(", ")", ",", "OutContext", ")", ",", "OutContext", ")", ";", "if", "(", "ACPV", "->", "mustAddCurrentAddress", "(", ")", ")", "{", "MCSymbol", "*", "DotSym", "=", "OutContext", ".", "createTempSymbol", "(", ")", ";", "OutStreamer", "->", "emitLabel", "(", "DotSym", ")", ";", "const", "MCExpr", "*", "DotExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "DotSym", ",", "OutContext", ")", ";", "PCRelExpr", "=", "MCBinaryExpr", "::", "createSub", "(", "PCRelExpr", ",", "DotExpr", ",", "OutContext", ")", ";", "}", "Expr", "=", "MCBinaryExpr", "::", "createSub", "(", "Expr", ",", "PCRelExpr", ",", "OutContext", ")", ";", "}", "OutStreamer", "->", "emitValue", "(", "Expr", ",", "Size", ")", ";", "}", "</s>" ]

[ "EmitMachineConstantPoolValue", "-", "Print", "a", "machine", "constantpool", "value", "to", "the", ".s", "file", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "0", "ARM", "ARM", "ARMII::MO_NONLAZY", "0", "ARM", "ARM", "\"unrecognized constant pool value\"", "ARM" ]

[]

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

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

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

[]

[ "<s>", "virtual", "const", "MCObjectFormat", "&", "getObjectFormat", "(", ")", "const", "{", "return", "Format", ";", "}", "</s>" ]

[ "Get", "the", "object", "format", "for", "this", "triple", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "unsigned", "int", "frv_function_arg_boundary", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ")", "{", "return", "BITS_PER_WORD", ";", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "expression", "that", "gives", "the", "alignment", "boundary", ",", "in", "bits", ",", "of", "an", "argument", "with", "the", "specified", "mode", "and", "type", ".", "If", "it", "is", "not", "defined", ",", "`", "PARM_BOUNDARY", "'", "is", "used", "for", "all", "arguments", "." ]

[ "frv" ]

[]

[ "<s>", "void", "Z80PassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "addPass", "(", "createLowerSwitchPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addCodeGenPrepare", "(", ")", ";", "}", "</s>" ]

[ "Add", "pass", "to", "prepare", "the", "LLVM", "IR", "for", "code", "generation", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isCoalescableExtInstr", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "DstReg", ",", "unsigned", "&", "SubIdx", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "PPC", "::", "EXTSW", ":", "case", "PPC", "::", "EXTSW_32", ":", "case", "PPC", "::", "EXTSW_32_64", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SubIdx", "=", "PPC", "::", "sub_32", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "isCoalescableExtInstr", "-", "Return", "true", "if", "the", "instruction", "is", "a", "``", "coalescable", "''", "extension", "instruction", "." ]

[ "PowerPC", "PPC", "PPC::EXTSW", "PPC::EXTSW_32", "PPC::EXTSW_32_64", "1", "0", "PPC::sub_32" ]

[]

[ "<s>", "static", "bool", "convertible_comparison_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "TARGET_SSE4_1", ")", "return", "false", ";", "rtx", "def_set", "=", "single_set", "(", "insn", ")", ";", "gcc_assert", "(", "def_set", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "def_set", ")", ";", "rtx", "dst", "=", "SET_DEST", "(", "def_set", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "src", ")", "==", "COMPARE", ")", ";", "if", "(", "GET_CODE", "(", "dst", ")", "!=", "REG", "||", "REGNO", "(", "dst", ")", "!=", "FLAGS_REG", "||", "GET_MODE", "(", "dst", ")", "!=", "CCZmode", ")", "return", "false", ";", "rtx", "op1", "=", "XEXP", "(", "src", ",", "0", ")", ";", "rtx", "op2", "=", "XEXP", "(", "src", ",", "1", ")", ";", "if", "(", "op2", "!=", "CONST0_RTX", "(", "GET_MODE", "(", "op2", ")", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "IOR", ")", "return", "false", ";", "op2", "=", "XEXP", "(", "op1", ",", "1", ")", ";", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "if", "(", "!", "SUBREG_P", "(", "op1", ")", "||", "!", "SUBREG_P", "(", "op2", ")", "||", "GET_MODE", "(", "op1", ")", "!=", "SImode", "||", "GET_MODE", "(", "op2", ")", "!=", "SImode", "||", "(", "(", "SUBREG_BYTE", "(", "op1", ")", "!=", "0", "||", "SUBREG_BYTE", "(", "op2", ")", "!=", "GET_MODE_SIZE", "(", "SImode", ")", ")", "&&", "(", "SUBREG_BYTE", "(", "op2", ")", "!=", "0", "||", "SUBREG_BYTE", "(", "op1", ")", "!=", "GET_MODE_SIZE", "(", "SImode", ")", ")", ")", ")", "return", "false", ";", "op1", "=", "SUBREG_REG", "(", "op1", ")", ";", "op2", "=", "SUBREG_REG", "(", "op2", ")", ";", "if", "(", "op1", "!=", "op2", "||", "!", "REG_P", "(", "op1", ")", "||", "GET_MODE", "(", "op1", ")", "!=", "DImode", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Check", "if", "comparison", "INSN", "may", "be", "transformed", "into", "vector", "comparison", ".", "Currently", "we", "transform", "equality/inequality", "checks", "which", "look", "like", ":", "(", "set", "(", "reg", ":", "CCZ", "17", "flags", ")", "(", "compare", ":", "CCZ", "(", "reg", ":", "TI", "x", ")", "(", "reg", ":", "TI", "y", ")", ")", ")" ]

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

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "AMDGPU", "::", "NoRegister", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::NoRegister" ]

[]

[ "<s>", "static", "void", "emit_soft_tfmode_libcall", "(", "const", "char", "*", "func_name", ",", "int", "nargs", ",", "rtx", "*", "operands", ")", "{", "rtx", "ret_slot", "=", "NULL", ",", "arg", "[", "3", "]", ",", "func_sym", ";", "int", "i", ";", "gcc_assert", "(", "nargs", "==", "2", "||", "nargs", "==", "3", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nargs", ";", "++", "i", ")", "{", "rtx", "this_arg", "=", "operands", "[", "i", "]", ";", "rtx", "this_slot", ";", "if", "(", "GET_MODE", "(", "this_arg", ")", "==", "TFmode", ")", "{", "int", "force_stack_temp", ";", "force_stack_temp", "=", "0", ";", "if", "(", "TARGET_BUGGY_QP_LIB", "&&", "i", "==", "0", ")", "force_stack_temp", "=", "1", ";", "if", "(", "GET_CODE", "(", "this_arg", ")", "==", "MEM", "&&", "!", "force_stack_temp", ")", "{", "tree", "expr", "=", "MEM_EXPR", "(", "this_arg", ")", ";", "if", "(", "expr", ")", "mark_addressable", "(", "expr", ")", ";", "this_arg", "=", "XEXP", "(", "this_arg", ",", "0", ")", ";", "}", "else", "if", "(", "CONSTANT_P", "(", "this_arg", ")", "&&", "!", "force_stack_temp", ")", "{", "this_slot", "=", "force_const_mem", "(", "TFmode", ",", "this_arg", ")", ";", "this_arg", "=", "XEXP", "(", "this_slot", ",", "0", ")", ";", "}", "else", "{", "this_slot", "=", "assign_stack_temp", "(", "TFmode", ",", "GET_MODE_SIZE", "(", "TFmode", ")", ")", ";", "if", "(", "i", ">", "0", ")", "emit_move_insn", "(", "this_slot", ",", "this_arg", ")", ";", "else", "ret_slot", "=", "this_slot", ";", "this_arg", "=", "XEXP", "(", "this_slot", ",", "0", ")", ";", "}", "}", "arg", "[", "i", "]", "=", "this_arg", ";", "}", "func_sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "func_name", ")", ";", "if", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", "==", "TFmode", ")", "{", "if", "(", "nargs", "==", "2", ")", "emit_library_call", "(", "func_sym", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "arg", "[", "0", "]", ",", "GET_MODE", "(", "arg", "[", "0", "]", ")", ",", "arg", "[", "1", "]", ",", "GET_MODE", "(", "arg", "[", "1", "]", ")", ")", ";", "else", "emit_library_call", "(", "func_sym", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "arg", "[", "0", "]", ",", "GET_MODE", "(", "arg", "[", "0", "]", ")", ",", "arg", "[", "1", "]", ",", "GET_MODE", "(", "arg", "[", "1", "]", ")", ",", "arg", "[", "2", "]", ",", "GET_MODE", "(", "arg", "[", "2", "]", ")", ")", ";", "if", "(", "ret_slot", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "ret_slot", ")", ";", "}", "else", "{", "rtx", "ret", ";", "gcc_assert", "(", "nargs", "==", "2", ")", ";", "ret", "=", "emit_library_call_value", "(", "func_sym", ",", "operands", "[", "0", "]", ",", "LCT_NORMAL", ",", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "arg", "[", "1", "]", ",", "GET_MODE", "(", "arg", "[", "1", "]", ")", ")", ";", "if", "(", "ret", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "ret", ")", ";", "}", "}", "</s>" ]

[ "Generate", "a", "call", "to", "FUNC", "with", "OPERANDS", ".", "Operand", "0", "is", "the", "return", "value", ".", "Unlike", "normal", "calls", ",", "TFmode", "operands", "are", "passed", "by", "reference", ".", "It", "is", "assumed", "that", "no", "more", "than", "3", "operands", "are", "required", "." ]

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

[]

[ "<s>", "void", "OR1KTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "dl", "(", "Op", ")", ";", "SDValue", "Result", "(", "0", ",", "0", ")", ";", "if", "(", "Constraint", ".", "length", "(", ")", ">", "1", ")", "return", ";", "char", "ConstraintLetter", "=", "Constraint", "[", "0", "]", ";", "switch", "(", "ConstraintLetter", ")", "{", "default", ":", "break", ";", "case", "'I'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "isInt", "<", "16", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "C", "->", "getSExtValue", "(", ")", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'J'", ":", "case", "'O'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "C", "->", "getZExtValue", "(", ")", "==", "0", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "0", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'K'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "isUInt", "<", "16", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "C", "->", "getSExtValue", "(", ")", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'L'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "C", "->", "getZExtValue", "(", ")", "<=", "31", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "C", "->", "getZExtValue", "(", ")", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'M'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "int64_t", "Val", "=", "C", "->", "getSExtValue", "(", ")", ";", "if", "(", "(", "isInt", "<", "32", ">", "(", "Val", ")", ")", "&&", "(", "(", "Val", "&", "0xffff", ")", "==", "0", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Val", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'N'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "int64_t", "Val", "=", "C", "->", "getSExtValue", "(", ")", ";", "if", "(", "(", "Val", ">=", "-", "33554432", ")", "&&", "(", "Val", "<=", "33554431", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Val", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "}", "if", "(", "Result", ".", "getNode", "(", ")", ")", "{", "Ops", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "OR1K", "OR1K", "0", "0", "1", "0", "16", "0", "0", "16", "31", "32", "0xffff", "0", "33554432", "33554431" ]

[]

[ "<s>", "void", "PTXPassConfig", "::", "addMachineLateOptimization", "(", ")", "{", "if", "(", "addPass", "(", "BranchFolderPassID", ")", "!=", "&", "NoPassID", ")", "printNoVerify", "(", "\"After BranchFolding\"", ")", ";", "if", "(", "addPass", "(", "TailDuplicateID", ")", "!=", "&", "NoPassID", ")", "printNoVerify", "(", "\"After TailDuplicate\"", ")", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "machine", "instructions", "after", "register", "allocation", "." ]

[ "PTX", "PTX", "\"After BranchFolding\"", "\"After TailDuplicate\"" ]

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "addPass", "(", "createNVPTXPrologEpilogPass", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SystemZElimCompare", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "TII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "F", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "Changed", "|=", "processBlock", "(", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "SITypeRewriter", "::", "visitCallInst", "(", "CallInst", "&", "I", ")", "{", "IRBuilder", "<", ">", "Builder", "(", "&", "I", ")", ";", "SmallVector", "<", "Value", "*", ",", "8", ">", "Args", ";", "SmallVector", "<", "Type", "*", ",", "8", ">", "Types", ";", "bool", "NeedToReplace", "=", "false", ";", "Function", "*", "F", "=", "I", ".", "getCalledFunction", "(", ")", ";", "if", "(", "!", "F", ")", "return", ";", "std", "::", "string", "Name", "=", "F", "->", "getName", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "I", ".", "getNumArgOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Value", "*", "Arg", "=", "I", ".", "getArgOperand", "(", "i", ")", ";", "if", "(", "Arg", "->", "getType", "(", ")", "==", "v16i8", ")", "{", "Args", ".", "push_back", "(", "Builder", ".", "CreateBitCast", "(", "Arg", ",", "v4i32", ")", ")", ";", "Types", ".", "push_back", "(", "v4i32", ")", ";", "NeedToReplace", "=", "true", ";", "Name", "=", "Name", "+", "\".v4i32\"", ";", "}", "else", "if", "(", "Arg", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", "&&", "Arg", "->", "getType", "(", ")", "->", "getVectorNumElements", "(", ")", "==", "1", "&&", "Arg", "->", "getType", "(", ")", "->", "getVectorElementType", "(", ")", "==", "Type", "::", "getInt32Ty", "(", "I", ".", "getContext", "(", ")", ")", ")", "{", "Type", "*", "ElementTy", "=", "Arg", "->", "getType", "(", ")", "->", "getVectorElementType", "(", ")", ";", "std", "::", "string", "TypeName", "=", "\"i32\"", ";", "InsertElementInst", "*", "Def", "=", "cast", "<", "InsertElementInst", ">", "(", "Arg", ")", ";", "Args", ".", "push_back", "(", "Def", "->", "getOperand", "(", "1", ")", ")", ";", "Types", ".", "push_back", "(", "ElementTy", ")", ";", "std", "::", "string", "VecTypeName", "=", "\"v1\"", "+", "TypeName", ";", "Name", "=", "Name", ".", "replace", "(", "Name", ".", "find", "(", "VecTypeName", ")", ",", "VecTypeName", ".", "length", "(", ")", ",", "TypeName", ")", ";", "NeedToReplace", "=", "true", ";", "}", "else", "{", "Args", ".", "push_back", "(", "Arg", ")", ";", "Types", ".", "push_back", "(", "Arg", "->", "getType", "(", ")", ")", ";", "}", "}", "if", "(", "!", "NeedToReplace", ")", "{", "return", ";", "}", "Function", "*", "NewF", "=", "Mod", "->", "getFunction", "(", "Name", ")", ";", "if", "(", "!", "NewF", ")", "{", "NewF", "=", "Function", "::", "Create", "(", "FunctionType", "::", "get", "(", "F", "->", "getReturnType", "(", ")", ",", "Types", ",", "false", ")", ",", "GlobalValue", "::", "ExternalLinkage", ",", "Name", ",", "Mod", ")", ";", "NewF", "->", "setAttributes", "(", "F", "->", "getAttributes", "(", ")", ")", ";", "}", "I", ".", "replaceAllUsesWith", "(", "Builder", ".", "CreateCall", "(", "NewF", ",", "Args", ")", ")", ";", "I", ".", "eraseFromParent", "(", ")", ";", "}", "</s>" ]

[ "CallInst", "simplification", "." ]

[ "AMDGPU", "SI", "8", "8", "0", "\".v4i32\"", "1", "\"i32\"", "1", "\"v1\"" ]

[]

[ "<s>", "bool", "MipsSETargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AS", ",", "Align", ",", "MachineMemOperand", "::", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "VT", ".", "isFatPointer", "(", ")", ")", "return", "false", ";", "MVT", "::", "SimpleValueType", "SVT", "=", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ";", "if", "(", "Subtarget", ".", "systemSupportsUnalignedAccess", "(", "AS", ")", ")", "{", "if", "(", "Fast", ")", "{", "if", "(", "Subtarget", ".", "isCheri", "(", ")", ")", "*", "Fast", "=", "false", ";", "else", "*", "Fast", "=", "true", ";", "}", "return", "true", ";", "}", "switch", "(", "SVT", ")", "{", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "i32", ":", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "AS", "==", "0", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "MVT::SimpleValueType", "MVT::i64", "MVT::i32", "0" ]

[]

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

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

[ "SPIRV", "SPIRV" ]

[]

[ "<s>", "const", "RegisterBank", "&", "AArch64RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ",", "LLT", ")", "const", "{", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR16_loRegClassID", ":", "case", "AArch64", "::", "FPR32_with_hsub_in_FPR16_loRegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR64_loRegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "FPRRegBankID", ")", ";", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32sponlyRegClassID", ":", "case", "AArch64", "::", "GPR32argRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64sponlyRegClassID", ":", "case", "AArch64", "::", "GPR64argRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64common_and_GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64noip_and_tcGPR64RegClassID", ":", "case", "AArch64", "::", "tcGPR64RegClassID", ":", "case", "AArch64", "::", "WSeqPairsClassRegClassID", ":", "case", "AArch64", "::", "XSeqPairsClassRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "GPRRegBankID", ")", ";", "case", "AArch64", "::", "CCRRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "CCRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "AArch64", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR16_loRegClassID", "AArch64::FPR32_with_hsub_in_FPR16_loRegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR64_loRegClassID", "AArch64::FPR128RegClassID", "AArch64::FPR128_loRegClassID", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "AArch64::FPRRegBankID", "AArch64::GPR32commonRegClassID", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32sponlyRegClassID", "AArch64::GPR32argRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64commonRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64sponlyRegClassID", "AArch64::GPR64argRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64noipRegClassID", "AArch64::GPR64common_and_GPR64noipRegClassID", "AArch64::GPR64noip_and_tcGPR64RegClassID", "AArch64::tcGPR64RegClassID", "AArch64::WSeqPairsClassRegClassID", "AArch64::XSeqPairsClassRegClassID", "AArch64::GPRRegBankID", "AArch64::CCRRegClassID", "AArch64::CCRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "static", "int", "s390_adjust_priority", "(", "rtx_insn", "*", "insn", ",", "int", "priority", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "return", "priority", ";", "if", "(", "s390_tune", "<=", "PROCESSOR_2064_Z900", ")", "return", "priority", ";", "switch", "(", "s390_safe_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_FSTOREDF", ":", "case", "TYPE_FSTORESF", ":", "priority", "=", "priority", "<<", "3", ";", "break", ";", "case", "TYPE_STORE", ":", "case", "TYPE_STM", ":", "priority", "=", "priority", "<<", "1", ";", "break", ";", "default", ":", "break", ";", "}", "return", "priority", ";", "}", "</s>" ]

[ "A", "C", "statement", "(", "sans", "semicolon", ")", "to", "update", "the", "integer", "scheduling", "priority", "INSN_PRIORITY", "(", "INSN", ")", ".", "Reduce", "the", "priority", "to", "execute", "the", "INSN", "earlier", ",", "increase", "the", "priority", "to", "execute", "INSN", "later", ".", "Do", "not", "define", "this", "macro", "if", "you", "do", "not", "need", "to", "adjust", "the", "scheduling", "priorities", "of", "insns", ".", "A", "LA", "instruction", "maybe", "scheduled", "later", ",", "since", "the", "pipeline", "bypasses", "the", "calculated", "value", "." ]

[ "s390", "3", "1" ]

[]

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

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

[ "ARCompact", "ARC" ]

[]

[ "<s>", "static", "void", "rs6000_elf_asm_out_constructor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "const", "char", "*", "section", "=", "\".ctors\"", ";", "char", "buf", "[", "18", "]", ";", "if", "(", "priority", "!=", "DEFAULT_INIT_PRIORITY", ")", "{", "sprintf", "(", "buf", ",", "\".ctors.%.5u\"", ",", "MAX_INIT_PRIORITY", "-", "priority", ")", ";", "section", "=", "buf", ";", "}", "switch_to_section", "(", "get_section", "(", "section", ",", "SECTION_WRITE", ",", "NULL", ")", ")", ";", "assemble_align", "(", "POINTER_SIZE", ")", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "(", "TARGET_RELOCATABLE", "||", "flag_pic", ">", "1", ")", ")", "{", "fputs", "(", "\"\\t.long (\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "symbol", ")", ";", "fputs", "(", "\")@fixup\\n\"", ",", "asm_out_file", ")", ";", "}", "else", "assemble_integer", "(", "symbol", ",", "POINTER_SIZE", "/", "BITS_PER_UNIT", ",", "POINTER_SIZE", ",", "1", ")", ";", "}", "</s>" ]

[ "Record", "an", "element", "in", "the", "table", "of", "global", "constructors", ".", "SYMBOL", "is", "a", "SYMBOL_REF", "of", "the", "function", "to", "be", "called", ";", "PRIORITY", "is", "a", "number", "between", "0", "and", "MAX_INIT_PRIORITY", ".", "This", "differs", "from", "default_named_section_asm_out_constructor", "in", "that", "we", "have", "special", "handling", "for", "-mrelocatable", "." ]

[ "rs6000", "\".ctors\"", "18", "\".ctors.%.5u\"", "1", "\"\\t.long (\"", "\")@fixup\\n\"", "1" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Darwin PPC Assembly Printer\"", ";", "}", "</s>" ]

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

[ "PowerPC", "\"Darwin PPC Assembly Printer\"" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "ARM", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRi12", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", ";", "}", "if", "(", "ARM", "::", "GPRPairRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "Register", "::", "isVirtualRegister", "(", "SrcReg", ")", ")", "{", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MRI", "->", "constrainRegClass", "(", "SrcReg", ",", "&", "ARM", "::", "GPRPair_with_gsub_1_in_GPRwithAPSRnospRegClass", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRDi8", ")", ")", ";", "AddDReg", "(", "MIB", ",", "SrcReg", ",", "ARM", "::", "gsub_0", ",", "getKillRegState", "(", "isKill", ")", ",", "TRI", ")", ";", "AddDReg", "(", "MIB", ",", "SrcReg", ",", "ARM", "::", "gsub_1", ",", "0", ",", "TRI", ")", ";", "MIB", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "storeRegToStackSlot", "(", "MBB", ",", "I", ",", "SrcReg", ",", "isKill", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM::t2STRi12", "0", "ARMCC::AL", "ARM::GPRPairRegClass", "ARM::GPRPair_with_gsub_1_in_GPRwithAPSRnospRegClass", "ARM::t2STRDi8", "ARM::gsub_0", "ARM::gsub_1", "0", "0", "ARMCC::AL", "ARM" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isEligibleForTailCallOptimization", "(", "CCState", "&", "CCInfo", ",", "CallLoweringInfo", "&", "CLI", ",", "MachineFunction", "&", "MF", ",", "const", "SmallVector", "<", "CCValAssign", ",", "16", ">", "&", "ArgLocs", ")", "const", "{", "auto", "&", "Callee", "=", "CLI", ".", "Callee", ";", "auto", "CalleeCC", "=", "CLI", ".", "CallConv", ";", "auto", "&", "Outs", "=", "CLI", ".", "Outs", ";", "auto", "&", "Caller", "=", "MF", ".", "getFunction", "(", ")", ";", "auto", "CallerCC", "=", "Caller", ".", "getCallingConv", "(", ")", ";", "if", "(", "Caller", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "return", "false", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "Indirect", ")", "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", "RISCVRegisterInfo", "*", "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>" ]

[ "Returns", "true", "if", "the", "call", "can", "be", "lowered", "as", "a", "tail", "call", "." ]

[ "RI5CY", "RISCV", "16", "\"interrupt\"", "0", "0", "RISCV" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Register Coloring\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Register Coloring\"" ]

[]

[ "<s>", "MCInstrDesc", "const", "&", "HexagonMCInst", "::", "getDesc", "(", ")", "const", "{", "return", "(", "MCII", "->", "get", "(", "getOpcode", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "target", "instruction", "descriptor", "of", "this", "MachineInstr", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "ConvergingVLIWScheduler", "::", "releaseTopNode", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "SU", "->", "isScheduled", ")", "return", ";", "for", "(", "SUnit", "::", "succ_iterator", "I", "=", "SU", "->", "Preds", ".", "begin", "(", ")", ",", "E", "=", "SU", "->", "Preds", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "PredReadyCycle", "=", "I", "->", "getSUnit", "(", ")", "->", "TopReadyCycle", ";", "unsigned", "MinLatency", "=", "I", "->", "getLatency", "(", ")", ";", "Top", ".", "MaxMinLatency", "=", "std", "::", "max", "(", "MinLatency", ",", "Top", ".", "MaxMinLatency", ")", ";", "if", "(", "SU", "->", "TopReadyCycle", "<", "PredReadyCycle", "+", "MinLatency", ")", "SU", "->", "TopReadyCycle", "=", "PredReadyCycle", "+", "MinLatency", ";", "}", "Top", ".", "releaseNode", "(", "SU", ",", "SU", "->", "TopReadyCycle", ")", ";", "}", "</s>" ]

[ "SU", "has", "had", "all", "predecessor", "dependencies", "resolved", "." ]

[ "Hexagon" ]

[]

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

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

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

[]

[ "<s>", "void", "tilepro_expand_unaligned_load", "(", "rtx", "dest_reg", ",", "rtx", "mem", ",", "HOST_WIDE_INT", "bitsize", ",", "HOST_WIDE_INT", "bit_offset", ",", "bool", "sign", ")", "{", "machine_mode", "mode", ";", "rtx", "addr_lo", ",", "addr_hi", ";", "rtx", "mem_lo", ",", "mem_hi", ",", "hi", ";", "rtx", "mema", ",", "wide_result", ";", "int", "last_byte_offset", ";", "HOST_WIDE_INT", "byte_offset", "=", "bit_offset", "/", "BITS_PER_UNIT", ";", "mode", "=", "GET_MODE", "(", "dest_reg", ")", ";", "hi", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "bitsize", "==", "2", "*", "BITS_PER_UNIT", "&&", "(", "bit_offset", "%", "BITS_PER_UNIT", ")", "==", "0", ")", "{", "rtx", "lo", ";", "mem_lo", "=", "adjust_address", "(", "mem", ",", "QImode", ",", "byte_offset", ")", ";", "mem_hi", "=", "adjust_address", "(", "mem", ",", "QImode", ",", "byte_offset", "+", "1", ")", ";", "lo", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_zero_extendqisi2", "(", "lo", ",", "mem_lo", ")", ")", ";", "if", "(", "sign", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_extendqisi2", "(", "gen_lowpart", "(", "SImode", ",", "hi", ")", ",", "mem_hi", ")", ")", ";", "emit_insn", "(", "gen_ashlsi3", "(", "gen_lowpart", "(", "SImode", ",", "tmp", ")", ",", "gen_lowpart", "(", "SImode", ",", "hi", ")", ",", "GEN_INT", "(", "8", ")", ")", ")", ";", "emit_insn", "(", "gen_iorsi3", "(", "gen_lowpart", "(", "SImode", ",", "dest_reg", ")", ",", "gen_lowpart", "(", "SImode", ",", "lo", ")", ",", "gen_lowpart", "(", "SImode", ",", "tmp", ")", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_zero_extendqisi2", "(", "gen_lowpart", "(", "SImode", ",", "hi", ")", ",", "mem_hi", ")", ")", ";", "emit_insn", "(", "gen_insn_intlb", "(", "gen_lowpart", "(", "SImode", ",", "dest_reg", ")", ",", "gen_lowpart", "(", "SImode", ",", "hi", ")", ",", "gen_lowpart", "(", "SImode", ",", "lo", ")", ")", ")", ";", "}", "return", ";", "}", "mema", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "addr_lo", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "mema", ",", "byte_offset", ")", ")", ";", "mem_lo", "=", "change_address", "(", "mem", ",", "mode", ",", "gen_rtx_AND", "(", "Pmode", ",", "addr_lo", ",", "GEN_INT", "(", "-", "4", ")", ")", ")", ";", "set_mem_alias_set", "(", "mem_lo", ",", "0", ")", ";", "last_byte_offset", "=", "(", "bit_offset", "+", "bitsize", "-", "1", ")", "/", "BITS_PER_UNIT", ";", "addr_hi", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "mema", ",", "last_byte_offset", ")", ")", ";", "mem_hi", "=", "change_address", "(", "mem", ",", "mode", ",", "gen_rtx_AND", "(", "Pmode", ",", "addr_hi", ",", "GEN_INT", "(", "-", "4", ")", ")", ")", ";", "set_mem_alias_set", "(", "mem_hi", ",", "0", ")", ";", "if", "(", "bitsize", "==", "32", ")", "{", "addr_lo", "=", "make_safe_from", "(", "addr_lo", ",", "dest_reg", ")", ";", "wide_result", "=", "dest_reg", ";", "}", "else", "{", "wide_result", "=", "gen_reg_rtx", "(", "mode", ")", ";", "}", "emit_move_insn", "(", "hi", ",", "mem_hi", ")", ";", "emit_move_insn", "(", "wide_result", ",", "mem_lo", ")", ";", "emit_insn", "(", "gen_insn_dword_align", "(", "gen_lowpart", "(", "SImode", ",", "wide_result", ")", ",", "gen_lowpart", "(", "SImode", ",", "wide_result", ")", ",", "gen_lowpart", "(", "SImode", ",", "hi", ")", ",", "addr_lo", ")", ")", ";", "if", "(", "bitsize", "!=", "32", ")", "{", "rtx", "extracted", "=", "extract_bit_field", "(", "gen_lowpart", "(", "SImode", ",", "wide_result", ")", ",", "bitsize", ",", "bit_offset", "%", "BITS_PER_UNIT", ",", "!", "sign", ",", "gen_lowpart", "(", "SImode", ",", "dest_reg", ")", ",", "SImode", ",", "SImode", ",", "false", ")", ";", "if", "(", "extracted", "!=", "dest_reg", ")", "emit_move_insn", "(", "dest_reg", ",", "gen_lowpart", "(", "SImode", ",", "extracted", ")", ")", ";", "}", "}", "</s>" ]

[ "Expand", "unaligned", "loads", "." ]

[ "tilepro", "2", "0", "1", "8", "0", "4", "0", "1", "4", "0", "32", "32" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitLinkage", "(", "const", "GlobalValue", "*", "GV", ",", "MCSymbol", "*", "GVSym", ")", "const", "{", "assert", "(", "MAI", "->", "hasVisibilityOnlyWithLinkage", "(", ")", "&&", "\"AIX's linkage directives take a visibility setting.\"", ")", ";", "MCSymbolAttr", "LinkageAttr", "=", "MCSA_Invalid", ";", "switch", "(", "GV", "->", "getLinkage", "(", ")", ")", "{", "case", "GlobalValue", "::", "ExternalLinkage", ":", "LinkageAttr", "=", "GV", "->", "isDeclaration", "(", ")", "?", "MCSA_Extern", ":", "MCSA_Global", ";", "break", ";", "case", "GlobalValue", "::", "LinkOnceAnyLinkage", ":", "case", "GlobalValue", "::", "LinkOnceODRLinkage", ":", "case", "GlobalValue", "::", "WeakAnyLinkage", ":", "case", "GlobalValue", "::", "WeakODRLinkage", ":", "case", "GlobalValue", "::", "ExternalWeakLinkage", ":", "LinkageAttr", "=", "MCSA_Weak", ";", "break", ";", "case", "GlobalValue", "::", "AvailableExternallyLinkage", ":", "LinkageAttr", "=", "MCSA_Extern", ";", "break", ";", "case", "GlobalValue", "::", "PrivateLinkage", ":", "return", ";", "case", "GlobalValue", "::", "InternalLinkage", ":", "assert", "(", "GV", "->", "getVisibility", "(", ")", "==", "GlobalValue", "::", "DefaultVisibility", "&&", "\"InternalLinkage should not have other visibility setting.\"", ")", ";", "LinkageAttr", "=", "MCSA_LGlobal", ";", "break", ";", "case", "GlobalValue", "::", "AppendingLinkage", ":", "llvm_unreachable", "(", "\"Should never emit this\"", ")", ";", "case", "GlobalValue", "::", "CommonLinkage", ":", "llvm_unreachable", "(", "\"CommonLinkage of XCOFF should not come to this path\"", ")", ";", "}", "assert", "(", "LinkageAttr", "!=", "MCSA_Invalid", "&&", "\"LinkageAttr should not MCSA_Invalid.\"", ")", ";", "MCSymbolAttr", "VisibilityAttr", "=", "MCSA_Invalid", ";", "if", "(", "!", "TM", ".", "getIgnoreXCOFFVisibility", "(", ")", ")", "{", "if", "(", "GV", "->", "hasDLLExportStorageClass", "(", ")", "&&", "!", "GV", "->", "hasDefaultVisibility", "(", ")", ")", "report_fatal_error", "(", "\"Cannot not be both dllexport and non-default visibility\"", ")", ";", "switch", "(", "GV", "->", "getVisibility", "(", ")", ")", "{", "case", "GlobalValue", "::", "DefaultVisibility", ":", "if", "(", "GV", "->", "hasDLLExportStorageClass", "(", ")", ")", "VisibilityAttr", "=", "MAI", "->", "getExportedVisibilityAttr", "(", ")", ";", "break", ";", "case", "GlobalValue", "::", "HiddenVisibility", ":", "VisibilityAttr", "=", "MAI", "->", "getHiddenVisibilityAttr", "(", ")", ";", "break", ";", "case", "GlobalValue", "::", "ProtectedVisibility", ":", "VisibilityAttr", "=", "MAI", "->", "getProtectedVisibilityAttr", "(", ")", ";", "break", ";", "}", "}", "OutStreamer", "->", "emitXCOFFSymbolLinkageWithVisibility", "(", "GVSym", ",", "LinkageAttr", ",", "VisibilityAttr", ")", ";", "}", "</s>" ]

[ "This", "emits", "linkage", "information", "about", "GVSym", "based", "on", "GV", ",", "if", "this", "is", "supported", "by", "the", "target", "." ]

[ "PowerPC", "PPC", "\"AIX's linkage directives take a visibility setting.\"", "\"InternalLinkage should not have other visibility setting.\"", "\"Should never emit this\"", "\"CommonLinkage of XCOFF should not come to this path\"", "\"LinkageAttr should not MCSA_Invalid.\"", "\"Cannot not be both dllexport and non-default visibility\"" ]

[]

[ "<s>", "static", "bool", "nds32_ict_const_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "{", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "return", "nds32_indirect_call_referenced_p", "(", "x", ")", ";", "}", "return", "FALSE", ";", "}", "</s>" ]

[ "Return", "true", "if", "x", "is", "const", "and", "the", "referance", "is", "ict", "symbol", "." ]

[ "nds32", "0" ]

[]

[ "<s>", "void", "RISCVTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Constraint", ".", "length", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'I'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "if", "(", "isUInt", "<", "8", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "C", "->", "getZExtValue", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ")", ";", "return", ";", "case", "'J'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "if", "(", "isUInt", "<", "12", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "C", "->", "getZExtValue", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ")", ";", "return", ";", "case", "'K'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "if", "(", "isInt", "<", "16", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "C", "->", "getSExtValue", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ")", ";", "return", ";", "case", "'L'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "if", "(", "isInt", "<", "20", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "C", "->", "getSExtValue", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ")", ";", "return", ";", "case", "'M'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "if", "(", "C", "->", "getZExtValue", "(", ")", "==", "0x7fffffff", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "C", "->", "getZExtValue", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ")", ";", "return", ";", "}", "}", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "RISCV", "RISCV", "1", "0", "8", "12", "16", "20", "0x7fffffff" ]

[]

[ "<s>", "static", "tree", "bpf_core_newdecl", "(", "tree", "type", ",", "enum", "bpf_builtins", "which", ")", "{", "tree", "rettype", ";", "char", "name", "[", "80", "]", ";", "static", "unsigned", "long", "pai_count", "=", "0", ";", "static", "unsigned", "long", "pfi_count", "=", "0", ";", "switch", "(", "which", ")", "{", "case", "BPF_BUILTIN_PRESERVE_ACCESS_INDEX", ":", "{", "rettype", "=", "build_function_type_list", "(", "type", ",", "type", ",", "NULL", ")", ";", "int", "len", "=", "snprintf", "(", "name", ",", "sizeof", "(", "name", ")", ",", "\"%s\"", ",", "\"__builtin_pai_\"", ")", ";", "len", "=", "snprintf", "(", "name", "+", "len", ",", "sizeof", "(", "name", ")", "-", "len", ",", "\"%lu\"", ",", "pai_count", "++", ")", ";", "}", "break", ";", "case", "BPF_BUILTIN_PRESERVE_FIELD_INFO", ":", "{", "rettype", "=", "build_function_type_list", "(", "unsigned_type_node", ",", "type", ",", "unsigned_type_node", ",", "NULL", ")", ";", "int", "len", "=", "snprintf", "(", "name", ",", "sizeof", "(", "name", ")", ",", "\"%s\"", ",", "\"__builtin_pfi_\"", ")", ";", "len", "=", "snprintf", "(", "name", "+", "len", ",", "sizeof", "(", "name", ")", "-", "len", ",", "\"%lu\"", ",", "pfi_count", "++", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "add_builtin_function_ext_scope", "(", "name", ",", "rettype", ",", "-", "which", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "}", "</s>" ]

[ "Synthesize", "a", "new", "builtin", "function", "declaration", "with", "signature", "TYPE", ".", "Used", "by", "bpf_resolve_overloaded_builtin", "to", "resolve", "calls", "to", "__builtin_preserve_access_index", "." ]

[ "bpf", "80", "0", "0", "\"%s\"", "\"__builtin_pai_\"", "\"%lu\"", "\"%s\"", "\"__builtin_pfi_\"", "\"%lu\"" ]

[]

[ "<s>", "vector_type_index", "function_resolver", "::", "infer_vector_displacement_type", "(", "unsigned", "int", "argno", ")", "{", "type_suffix_index", "type", "=", "infer_integer_vector_type", "(", "argno", ")", ";", "if", "(", "type", "==", "NUM_TYPE_SUFFIXES", ")", "return", "NUM_VECTOR_TYPES", ";", "if", "(", "type_suffixes", "[", "type", "]", ".", "integer_p", "&&", "(", "type_suffixes", "[", "type", "]", ".", "element_bits", "==", "32", "||", "type_suffixes", "[", "type", "]", ".", "element_bits", "==", "64", ")", ")", "return", "type_suffixes", "[", "type", "]", ".", "vector_type", ";", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects a vector of 32-bit or 64-bit integers\"", ",", "get_argument_type", "(", "argno", ")", ",", "argno", "+", "1", ",", "fndecl", ")", ";", "return", "NUM_VECTOR_TYPES", ";", "}", "</s>" ]

[ "Require", "argument", "ARGNO", "to", "be", "a", "vector", "displacement", "in", "a", "gather-style", "address", ".", "Return", "its", "type", "on", "success", ",", "otherwise", "return", "NUM_VECTOR_TYPES", "." ]

[ "aarch64", "32", "64", "\"passing %qT to argument %d of %qE, which\"", "\" expects a vector of 32-bit or 64-bit integers\"", "1" ]

[]

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

[ "Return", "an", "RTX", "indicating", "where", "the", "return", "address", "to", "the", "calling", "function", "can", "be", "found", "." ]

[ "arm", "0" ]

[]

[ "<s>", "AArch64TTI", "::", "PopcntSupportKind", "AArch64TTI", "::", "getPopcntSupport", "(", "unsigned", "TyWidth", ")", "const", "{", "assert", "(", "isPowerOf2_32", "(", "TyWidth", ")", "&&", "\"Ty width must be power of 2\"", ")", ";", "if", "(", "TyWidth", "==", "32", "||", "TyWidth", "==", "64", ")", "return", "PSK_FastHardware", ";", "return", "PSK_Software", ";", "}", "</s>" ]

[ "Return", "hardware", "support", "for", "population", "count", "." ]

[ "AArch64", "AArch64", "AArch64", "\"Ty width must be power of 2\"", "32", "64" ]

[]

[ "<s>", "bool", "TriCorePassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createTriCoreISelDag", "(", "getTriCoreTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "TriCore", "TriCore", "TriCore", "TriCore" ]

[]

[ "<s>", "void", "LoongArchInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "O", ",", "unsigned", "RegNo", ")", "const", "{", "O", "<<", "'$'", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "LoongArch", "LoongArch" ]

[]

[ "<s>", "bool", "ARM64RegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "assert", "(", "Offset", "<=", "INT_MAX", "&&", "\"Offset too big to fit in int.\"", ")", ";", "assert", "(", "MI", "&&", "\"Unable to get the legal offset for nil instruction.\"", ")", ";", "int", "SaveOffset", "=", "Offset", ";", "return", "isARM64FrameOffsetLegal", "(", "*", "MI", ",", "SaveOffset", ")", "&", "ARM64FrameOffsetIsLegal", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "ARM64", "ARM64", "\"Offset too big to fit in int.\"", "\"Unable to get the legal offset for nil instruction.\"", "ARM64", "ARM64" ]

[]

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

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

[ "JVM" ]

[]

[ "<s>", "void", "PTXAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "TmpInst", ";", "LowerPTXMachineInstrToMCInst", "(", "MI", ",", "TmpInst", ",", "*", "this", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "PTX" ]

[]

[ "<s>", "bool", "ARMTTIImpl", "::", "isLoweredToCall", "(", "const", "Function", "*", "F", ")", "{", "if", "(", "!", "F", "->", "isIntrinsic", "(", ")", ")", "return", "BaseT", "::", "isLoweredToCall", "(", "F", ")", ";", "if", "(", "F", "->", "getName", "(", ")", ".", "startswith", "(", "\"llvm.arm\"", ")", ")", "return", "false", ";", "switch", "(", "F", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "powi", ":", "case", "Intrinsic", "::", "sin", ":", "case", "Intrinsic", "::", "cos", ":", "case", "Intrinsic", "::", "pow", ":", "case", "Intrinsic", "::", "log", ":", "case", "Intrinsic", "::", "log10", ":", "case", "Intrinsic", "::", "log2", ":", "case", "Intrinsic", "::", "exp", ":", "case", "Intrinsic", "::", "exp2", ":", "return", "true", ";", "case", "Intrinsic", "::", "sqrt", ":", "case", "Intrinsic", "::", "fabs", ":", "case", "Intrinsic", "::", "copysign", ":", "case", "Intrinsic", "::", "floor", ":", "case", "Intrinsic", "::", "ceil", ":", "case", "Intrinsic", "::", "trunc", ":", "case", "Intrinsic", "::", "rint", ":", "case", "Intrinsic", "::", "nearbyint", ":", "case", "Intrinsic", "::", "round", ":", "case", "Intrinsic", "::", "canonicalize", ":", "case", "Intrinsic", "::", "lround", ":", "case", "Intrinsic", "::", "llround", ":", "case", "Intrinsic", "::", "lrint", ":", "case", "Intrinsic", "::", "llrint", ":", "if", "(", "F", "->", "getReturnType", "(", ")", "->", "isDoubleTy", "(", ")", "&&", "!", "ST", "->", "hasFP64", "(", ")", ")", "return", "true", ";", "if", "(", "F", "->", "getReturnType", "(", ")", "->", "isHalfTy", "(", ")", "&&", "!", "ST", "->", "hasFullFP16", "(", ")", ")", "return", "true", ";", "return", "!", "ST", "->", "hasFPARMv8Base", "(", ")", "&&", "!", "ST", "->", "hasVFP2Base", "(", ")", ";", "case", "Intrinsic", "::", "masked_store", ":", "case", "Intrinsic", "::", "masked_load", ":", "case", "Intrinsic", "::", "masked_gather", ":", "case", "Intrinsic", "::", "masked_scatter", ":", "return", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ";", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "case", "Intrinsic", "::", "ssub_with_overflow", ":", "case", "Intrinsic", "::", "usub_with_overflow", ":", "case", "Intrinsic", "::", "sadd_sat", ":", "case", "Intrinsic", "::", "uadd_sat", ":", "case", "Intrinsic", "::", "ssub_sat", ":", "case", "Intrinsic", "::", "usub_sat", ":", "return", "false", ";", "}", "return", "BaseT", "::", "isLoweredToCall", "(", "F", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"llvm.arm\"", "Intrinsic::powi", "Intrinsic::sin", "Intrinsic::cos", "Intrinsic::pow", "Intrinsic::log", "Intrinsic::log10", "Intrinsic::log2", "Intrinsic::exp", "Intrinsic::exp2", "Intrinsic::sqrt", "Intrinsic::fabs", "Intrinsic::copysign", "Intrinsic::floor", "Intrinsic::ceil", "Intrinsic::trunc", "Intrinsic::rint", "Intrinsic::nearbyint", "Intrinsic::round", "Intrinsic::canonicalize", "Intrinsic::lround", "Intrinsic::llround", "Intrinsic::lrint", "Intrinsic::llrint", "ARM", "Intrinsic::masked_store", "Intrinsic::masked_load", "Intrinsic::masked_gather", "Intrinsic::masked_scatter", "Intrinsic::sadd_with_overflow", "Intrinsic::uadd_with_overflow", "Intrinsic::ssub_with_overflow", "Intrinsic::usub_with_overflow", "Intrinsic::sadd_sat", "Intrinsic::uadd_sat", "Intrinsic::ssub_sat", "Intrinsic::usub_sat" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getTarget", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Sparc32", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "Outs", "[", "i", "]", ".", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "SPISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "SPISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "ISD::OutputArg", "16", "Sparc", "0", "0", "\"Can only return in registers!\"", "1", "SPISD::RET_FLAG", "MVT::Other", "SPISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "bool", "GCNRegBankReassign", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", "->", "hasRegisterBanking", "(", ")", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "VRM", "=", "&", "getAnalysis", "<", "VirtRegMap", ">", "(", ")", ";", "LRM", "=", "&", "getAnalysis", "<", "LiveRegMatrix", ">", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Occupancy", "=", "MFI", "->", "getOccupancy", "(", ")", ";", "MaxNumVGPRs", "=", "ST", "->", "getMaxNumVGPRs", "(", "MF", ")", ";", "MaxNumSGPRs", "=", "ST", "->", "getMaxNumSGPRs", "(", "MF", ")", ";", "MaxNumVGPRs", "=", "std", "::", "min", "(", "ST", "->", "getMaxNumVGPRs", "(", "Occupancy", ")", ",", "MaxNumVGPRs", ")", ";", "MaxNumSGPRs", "=", "std", "::", "min", "(", "ST", "->", "getMaxNumSGPRs", "(", "Occupancy", ",", "true", ")", ",", "MaxNumSGPRs", ")", ";", "CSRegs", "=", "MRI", "->", "getCalleeSavedRegs", "(", ")", ";", "RegsUsed", ".", "resize", "(", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", "+", "TRI", "->", "getEncodingValue", "(", "AMDGPU", "::", "SGPR_NULL", ")", "/", "2", "+", "1", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== RegBanks reassign analysis on function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "unsigned", "StallCycles", "=", "collectCandidates", "(", "MF", ")", ";", "NumStallsDetected", "+=", "StallCycles", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== \"", "<<", "StallCycles", "<<", "\" stall cycles detected in \"", "\"function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Candidates", ".", "sort", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nCandidates:\\n\\n\"", ";", "for", "(", "auto", "C", ":", "Candidates", ")", "C", ".", "dump", "(", "this", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\\n\"", ")", ";", "unsigned", "CyclesSaved", "=", "0", ";", "while", "(", "!", "Candidates", ".", "empty", "(", ")", ")", "{", "Candidate", "C", "=", "Candidates", ".", "back", "(", ")", ";", "unsigned", "LocalCyclesSaved", "=", "tryReassign", "(", "C", ")", ";", "CyclesSaved", "+=", "LocalCyclesSaved", ";", "if", "(", "VerifyStallCycles", ">", "1", "&&", "!", "verifyCycles", "(", "MF", ",", "StallCycles", ",", "CyclesSaved", ")", ")", "report_fatal_error", "(", "\"RegBank reassign stall cycles verification failed.\"", ")", ";", "Candidates", ".", "pop_back", "(", ")", ";", "if", "(", "LocalCyclesSaved", ")", "{", "removeCandidates", "(", "C", ".", "Reg", ")", ";", "computeStallCycles", "(", "C", ".", "Reg", ",", "AMDGPU", "::", "NoRegister", ",", "0", ",", "-", "1", ",", "true", ")", ";", "Candidates", ".", "sort", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nCandidates:\\n\\n\"", ";", "for", "(", "auto", "C", ":", "Candidates", ")", "C", ".", "dump", "(", "this", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\\n\"", ")", ";", "}", "}", "NumStallsRecovered", "+=", "CyclesSaved", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"=== After the pass \"", "<<", "CyclesSaved", "<<", "\" cycles saved in function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Candidates", ".", "clear", "(", ")", ";", "if", "(", "VerifyStallCycles", "==", "1", "&&", "!", "verifyCycles", "(", "MF", ",", "StallCycles", ",", "CyclesSaved", ")", ")", "report_fatal_error", "(", "\"RegBank reassign stall cycles verification failed.\"", ")", ";", "RegsUsed", ".", "clear", "(", ")", ";", "return", "CyclesSaved", ">", "0", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "AMDGPU::VGPR_32RegClass", "AMDGPU::SGPR_NULL", "2", "1", "\"=== RegBanks reassign analysis on function \"", "\"=== \"", "\" stall cycles detected in \"", "\"function \"", "\"\\nCandidates:\\n\\n\"", "\"\\n\\n\"", "0", "1", "\"RegBank reassign stall cycles verification failed.\"", "AMDGPU::NoRegister", "0", "1", "\"\\nCandidates:\\n\\n\"", "\"\\n\\n\"", "\"=== After the pass \"", "\" cycles saved in function \"", "1", "\"RegBank reassign stall cycles verification failed.\"", "0" ]

[]

[ "<s>", "static", "bool", "riscv_print_operand_punct_valid_p", "(", "unsigned", "char", "code", ")", "{", "return", "(", "code", "==", "'~'", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_PUNCT_VALID_P" ]

[ "riscv" ]

[]

[ "<s>", "bool", "X86RetpolineThunks", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "'\\n'", ")", ";", "TM", "=", "&", "MF", ".", "getTarget", "(", ")", ";", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "Is64Bit", "=", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "Module", "&", "M", "=", "const_cast", "<", "Module", "&", ">", "(", "*", "MMI", "->", "getModule", "(", ")", ")", ";", "if", "(", "!", "MF", ".", "getName", "(", ")", ".", "startswith", "(", "ThunkNamePrefix", ")", ")", "{", "if", "(", "InsertedThunks", ")", "return", "false", ";", "if", "(", "!", "STI", "->", "useRetpoline", "(", ")", "||", "STI", "->", "useRetpolineExternalThunk", "(", ")", ")", "return", "false", ";", "if", "(", "Is64Bit", ")", "createThunkFunction", "(", "M", ",", "R11ThunkName", ")", ";", "else", "for", "(", "StringRef", "Name", ":", "{", "EAXThunkName", ",", "ECXThunkName", ",", "EDXThunkName", ",", "PushThunkName", "}", ")", "createThunkFunction", "(", "M", ",", "Name", ")", ";", "InsertedThunks", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Is64Bit", ")", "{", "assert", "(", "MF", ".", "getName", "(", ")", "==", "\"__llvm_retpoline_r11\"", "&&", "\"Should only have an r11 thunk on 64-bit targets\"", ")", ";", "populateThunk", "(", "MF", ",", "X86", "::", "R11", ")", ";", "}", "else", "{", "if", "(", "MF", ".", "getName", "(", ")", "==", "EAXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EAX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "ECXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "ECX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "EDXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EDX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "PushThunkName", ")", "populateThunk", "(", "MF", ")", ";", "else", "llvm_unreachable", "(", "\"Invalid thunk name on x86-32!\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"__llvm_retpoline_r11\"", "\"Should only have an r11 thunk on 64-bit targets\"", "X86::R11", "X86::EAX", "X86::ECX", "X86::EDX", "\"Invalid thunk name on x86-32!\"" ]

[]

[ "<s>", "static", "const", "char", "*", "avr_out_movhi_r_mr_reg_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "reg_dest", "=", "true_regnum", "(", "dest", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "XEXP", "(", "base", ",", "0", ")", ")", ";", "if", "(", "reg_base", "==", "reg_dest", ")", "{", "return", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", "CR_TAB", "\"ld __tmp_reg__,%b1+\"", "CR_TAB", "\"ld %B0,%b1\"", "CR_TAB", "\"mov %A0,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "5", ")", ";", "}", "else", "{", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", "CR_TAB", "\"ld %A0,%b1+\"", "CR_TAB", "\"ld %B0,%b1\"", ",", "op", ",", "plen", ",", "-", "4", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "XEXP", "(", "base", ",", "0", ")", ")", ")", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", "+", "1", ")", ",", "op", ",", "plen", ",", "2", ")", ";", "return", "\"\"", ";", "}", "}", "</s>" ]

[ "Same", "as", "movhi_r_mr", ",", "but", "TINY", "does", "not", "have", "ADIW", ",", "SBIW", "and", "LDD" ]

[ "avr", "0", "1", "0", "0", "\"ld __tmp_reg__,%b1+\"", "\"ld %B0,%b1\"", "\"mov %A0,__tmp_reg__\"", "5", "\"ld %A0,%b1+\"", "\"ld %B0,%b1\"", "4", "0", "1", "2", "\"\"" ]

[]

[ "<s>", "SDValue", "XCoreSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "unsigned", "SizeBitWidth", "=", "Size", ".", "getValueType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "if", "(", "!", "AlwaysInline", "&&", "(", "Align", "&", "3", ")", "==", "0", "&&", "DAG", ".", "MaskedValueIsZero", "(", "Size", ",", "APInt", "(", "SizeBitWidth", ",", "3", ")", ")", ")", "{", "const", "TargetLowering", "&", "TLI", "=", "*", "DAG", ".", "getTarget", "(", ")", ".", "getTargetLowering", "(", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Ty", "=", "TLI", ".", "getDataLayout", "(", ")", "->", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMCPY", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "\"__memcpy_4\"", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ",", "&", "Args", ",", "0", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "3", "0", "3", "\"__memcpy_4\"", "0" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyFixFunctionBitcasts", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyOptimizeReturned", "(", ")", ")", ";", "if", "(", "!", "EnableEmException", ")", "{", "addPass", "(", "createLowerInvokePass", "(", ")", ")", ";", "addPass", "(", "createUnreachableBlockEliminationPass", "(", ")", ")", ";", "}", "if", "(", "EnableEmException", "||", "EnableEmSjLj", ")", "addPass", "(", "createWebAssemblyLowerEmscriptenEHSjLj", "(", "EnableEmException", ",", "EnableEmSjLj", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "GCNHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "auto", "HazardType", "=", "IsHazardRecognizerMode", "?", "NoopHazard", ":", "Hazard", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "return", "NoHazard", ";", "if", "(", "SIInstrInfo", "::", "isSMRD", "(", "*", "MI", ")", "&&", "checkSMRDHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "ST", ".", "hasNSAtoVMEMBug", "(", ")", "&&", "checkNSAtoVMEMHazard", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "checkFPAtomicToDenormModeHazard", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "ST", ".", "hasNoDataDepHazard", "(", ")", ")", "return", "NoHazard", ";", "if", "(", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", ")", "&&", "checkVMEMHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", "&&", "checkVALUHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", "&&", "checkDPPHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "isDivFMas", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkDivFMasHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "isRWLane", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRWLaneHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isDS", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isEXP", "(", "*", "MI", ")", ")", "&&", "checkMAIVALUHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "isSGetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkGetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "isSSetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkSetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "isRFE", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRFEHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "(", "(", "ST", ".", "hasReadM0MovRelInterpHazard", "(", ")", "&&", "(", "TII", ".", "isVINTRP", "(", "*", "MI", ")", "||", "isSMovRel", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", "||", "(", "ST", ".", "hasReadM0SendMsgHazard", "(", ")", "&&", "isSendMsgTraceDataOrGDS", "(", "TII", ",", "*", "MI", ")", ")", "||", "(", "ST", ".", "hasReadM0LdsDmaHazard", "(", ")", "&&", "isLdsDma", "(", "*", "MI", ")", ")", "||", "(", "ST", ".", "hasReadM0LdsDirectHazard", "(", ")", "&&", "MI", "->", "readsRegister", "(", "AMDGPU", "::", "LDS_DIRECT", ")", ")", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "SIInstrInfo", "::", "isMAI", "(", "*", "MI", ")", "&&", "checkMAIHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isDS", "(", "*", "MI", ")", ")", "&&", "checkMAILdStHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "&&", "checkInlineAsmHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "AMDGPU", "SI", "0", "0", "0", "SI", "SI", "0", "SI", "0", "SI", "0", "0", "0", "SI", "SI", "SI", "SI", "SI", "0", "0", "0", "0", "AMDGPU::LDS_DIRECT", "0", "SI", "0", "SI", "SI", "SI", "0", "0" ]

[]

[ "<s>", "void", "ARMAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "IsPCRel", ",", "nullptr", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FullSizeBytes", ";", "if", "(", "!", "IsLittleEndian", ")", "FullSizeBytes", "=", "getFixupKindContainerSizeBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "(", "FullSizeBytes", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "RV16K", "::", "fixup_rv16k_pcrel_8bit", ":", "{", "const", "static", "MCFixupKindInfo", "info", "{", "\"fixup_rv16k_pcrel_8bit\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ";", "return", "info", ";", "}", "case", "RV16K", "::", "fixup_rv16k_pcrel_16bit", ":", "{", "const", "static", "MCFixupKindInfo", "info", "{", "\"fixup_rv16k_pcrel_16bit\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ";", "return", "info", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Invalid kind!\"", ")", ";", "}", "}", "</s>" ]

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

[ "RV16K", "RV16K::fixup_rv16k_pcrel_8bit", "\"fixup_rv16k_pcrel_8bit\"", "0", "8", "RV16K::fixup_rv16k_pcrel_16bit", "\"fixup_rv16k_pcrel_16bit\"", "0", "16", "\"Invalid kind!\"" ]

[]

[ "<s>", "bool", "ix86_check_builtin_isa_match", "(", "unsigned", "int", "fcode", ",", "HOST_WIDE_INT", "*", "pbisa", ",", "HOST_WIDE_INT", "*", "pbisa2", ")", "{", "HOST_WIDE_INT", "isa", "=", "ix86_isa_flags", ";", "HOST_WIDE_INT", "isa2", "=", "ix86_isa_flags2", ";", "HOST_WIDE_INT", "bisa", "=", "ix86_builtins_isa", "[", "fcode", "]", ".", "isa", ";", "HOST_WIDE_INT", "bisa2", "=", "ix86_builtins_isa", "[", "fcode", "]", ".", "isa2", ";", "if", "(", "(", "(", "bisa", "&", "(", "OPTION_MASK_ISA_SSE", "|", "OPTION_MASK_ISA_3DNOW_A", ")", ")", "==", "(", "OPTION_MASK_ISA_SSE", "|", "OPTION_MASK_ISA_3DNOW_A", ")", ")", "&&", "(", "isa", "&", "(", "OPTION_MASK_ISA_SSE", "|", "OPTION_MASK_ISA_3DNOW_A", ")", ")", "!=", "0", ")", "isa", "|=", "(", "OPTION_MASK_ISA_SSE", "|", "OPTION_MASK_ISA_3DNOW_A", ")", ";", "if", "(", "(", "(", "bisa", "&", "(", "OPTION_MASK_ISA_SSE4_2", "|", "OPTION_MASK_ISA_CRC32", ")", ")", "==", "(", "OPTION_MASK_ISA_SSE4_2", "|", "OPTION_MASK_ISA_CRC32", ")", ")", "&&", "(", "isa", "&", "(", "OPTION_MASK_ISA_SSE4_2", "|", "OPTION_MASK_ISA_CRC32", ")", ")", "!=", "0", ")", "isa", "|=", "(", "OPTION_MASK_ISA_SSE4_2", "|", "OPTION_MASK_ISA_CRC32", ")", ";", "if", "(", "(", "(", "bisa", "&", "(", "OPTION_MASK_ISA_FMA", "|", "OPTION_MASK_ISA_FMA4", ")", ")", "==", "(", "OPTION_MASK_ISA_FMA", "|", "OPTION_MASK_ISA_FMA4", ")", ")", "&&", "(", "isa", "&", "(", "OPTION_MASK_ISA_FMA", "|", "OPTION_MASK_ISA_FMA4", ")", ")", "!=", "0", ")", "isa", "|=", "(", "OPTION_MASK_ISA_FMA", "|", "OPTION_MASK_ISA_FMA4", ")", ";", "if", "(", "(", "(", "(", "bisa", "&", "(", "OPTION_MASK_ISA_AVX512VNNI", "|", "OPTION_MASK_ISA_AVX512VL", ")", ")", "==", "(", "OPTION_MASK_ISA_AVX512VNNI", "|", "OPTION_MASK_ISA_AVX512VL", ")", ")", "||", "(", "bisa2", "&", "OPTION_MASK_ISA2_AVXVNNI", ")", "!=", "0", ")", "&&", "(", "(", "(", "isa", "&", "(", "OPTION_MASK_ISA_AVX512VNNI", "|", "OPTION_MASK_ISA_AVX512VL", ")", ")", "==", "(", "OPTION_MASK_ISA_AVX512VNNI", "|", "OPTION_MASK_ISA_AVX512VL", ")", ")", "||", "(", "isa2", "&", "OPTION_MASK_ISA2_AVXVNNI", ")", "!=", "0", ")", ")", "{", "isa", "|=", "OPTION_MASK_ISA_AVX512VNNI", "|", "OPTION_MASK_ISA_AVX512VL", ";", "isa2", "|=", "OPTION_MASK_ISA2_AVXVNNI", ";", "}", "if", "(", "(", "(", "(", "bisa", "&", "(", "OPTION_MASK_ISA_AVX512IFMA", "|", "OPTION_MASK_ISA_AVX512VL", ")", ")", "==", "(", "OPTION_MASK_ISA_AVX512IFMA", "|", "OPTION_MASK_ISA_AVX512VL", ")", ")", "||", "(", "bisa2", "&", "OPTION_MASK_ISA2_AVXIFMA", ")", "!=", "0", ")", "&&", "(", "(", "(", "isa", "&", "(", "OPTION_MASK_ISA_AVX512IFMA", "|", "OPTION_MASK_ISA_AVX512VL", ")", ")", "==", "(", "OPTION_MASK_ISA_AVX512IFMA", "|", "OPTION_MASK_ISA_AVX512VL", ")", ")", "||", "(", "isa2", "&", "OPTION_MASK_ISA2_AVXIFMA", ")", "!=", "0", ")", ")", "{", "isa", "|=", "OPTION_MASK_ISA_AVX512IFMA", "|", "OPTION_MASK_ISA_AVX512VL", ";", "isa2", "|=", "OPTION_MASK_ISA2_AVXIFMA", ";", "}", "if", "(", "(", "(", "(", "bisa", "&", "OPTION_MASK_ISA_AVX512VL", ")", "!=", "0", "&&", "(", "bisa2", "&", "OPTION_MASK_ISA2_AVX512BF16", ")", "!=", "0", ")", "&&", "(", "bisa2", "&", "OPTION_MASK_ISA2_AVXNECONVERT", ")", "!=", "0", ")", "&&", "(", "(", "(", "isa", "&", "OPTION_MASK_ISA_AVX512VL", ")", "!=", "0", "&&", "(", "isa2", "&", "OPTION_MASK_ISA2_AVX512BF16", ")", "!=", "0", ")", "||", "(", "isa2", "&", "OPTION_MASK_ISA2_AVXNECONVERT", ")", "!=", "0", ")", ")", "{", "isa", "|=", "OPTION_MASK_ISA_AVX512VL", ";", "isa2", "|=", "OPTION_MASK_ISA2_AVXNECONVERT", "|", "OPTION_MASK_ISA2_AVX512BF16", ";", "}", "if", "(", "(", "bisa", "&", "OPTION_MASK_ISA_MMX", ")", "&&", "!", "TARGET_MMX", "&&", "TARGET_MMX_WITH_SSE", "&&", "fcode", "!=", "IX86_BUILTIN_MASKMOVQ", ")", "{", "bisa", "&=", "~", "OPTION_MASK_ISA_MMX", ";", "bisa", "|=", "OPTION_MASK_ISA_SSE2", ";", "}", "if", "(", "pbisa", ")", "*", "pbisa", "=", "bisa", ";", "if", "(", "pbisa2", ")", "*", "pbisa2", "=", "bisa2", ";", "return", "(", "bisa", "&", "isa", ")", "==", "bisa", "&&", "(", "bisa2", "&", "isa2", ")", "==", "bisa2", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "necessary", "isa", "options", "for", "this", "builtin", "exist", ",", "else", "false", ".", "fcode", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";" ]

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

[]

[ "<s>", "static", "rtx", "nios2_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "unsigned", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "if", "(", "fcode", "<", "nios2_fpu_builtin_base", ")", "{", "const", "struct", "nios2_builtin_desc", "*", "d", "=", "&", "nios2_builtins", "[", "fcode", "]", ";", "if", "(", "d", "->", "arch", ">", "nios2_arch_option", ")", "{", "error", "(", "\"Builtin function %s requires Nios II R%d\"", ",", "d", "->", "name", ",", "(", "int", ")", "d", "->", "arch", ")", ";", "return", "expand_call", "(", "exp", ",", "target", ",", "ignore", ")", ";", "}", "switch", "(", "fcode", ")", "{", "case", "NIOS2_BUILTIN_sync", ":", "emit_insn", "(", "gen_sync", "(", ")", ")", ";", "return", "const0_rtx", ";", "case", "NIOS2_BUILTIN_ldbio", ":", "case", "NIOS2_BUILTIN_ldbuio", ":", "case", "NIOS2_BUILTIN_ldhio", ":", "case", "NIOS2_BUILTIN_ldhuio", ":", "case", "NIOS2_BUILTIN_ldwio", ":", "case", "NIOS2_BUILTIN_stbio", ":", "case", "NIOS2_BUILTIN_sthio", ":", "case", "NIOS2_BUILTIN_stwio", ":", "case", "NIOS2_BUILTIN_ldex", ":", "case", "NIOS2_BUILTIN_ldsex", ":", "case", "NIOS2_BUILTIN_stex", ":", "case", "NIOS2_BUILTIN_stsex", ":", "return", "nios2_expand_ldst_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "case", "NIOS2_BUILTIN_rdctl", ":", "case", "NIOS2_BUILTIN_wrctl", ":", "return", "nios2_expand_rdwrctl_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "case", "NIOS2_BUILTIN_rdprs", ":", "return", "nios2_expand_rdprs_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "case", "NIOS2_BUILTIN_flushd", ":", "case", "NIOS2_BUILTIN_flushda", ":", "return", "nios2_expand_cache_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "case", "NIOS2_BUILTIN_wrpie", ":", "return", "nios2_expand_wrpie_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "case", "NIOS2_BUILTIN_eni", ":", "return", "nios2_expand_eni_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "fcode", "<", "nios2_custom_builtin_base", ")", "return", "nios2_expand_fpu_builtin", "(", "exp", ",", "fcode", "-", "nios2_fpu_builtin_base", ",", "target", ")", ";", "else", "if", "(", "fcode", "<", "nios2_custom_builtin_end", ")", "return", "nios2_expand_custom_builtin", "(", "exp", ",", "fcode", "-", "nios2_custom_builtin_base", ",", "target", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_BUILTIN", ".", "Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "." ]

[ "nios2", "0", "\"Builtin function %s requires Nios II R%d\"" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "bool", "HasStdExtC", "=", "STI", "->", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtC", "]", ";", "unsigned", "MinNopLen", "=", "HasStdExtC", "?", "2", ":", "4", ";", "if", "(", "(", "Count", "%", "MinNopLen", ")", "!=", "0", ")", "return", "false", ";", "for", "(", ";", "Count", ">=", "4", ";", "Count", "-=", "4", ")", "OS", ".", "write", "(", "\"\\x13\\0\\0\\0\"", ",", "4", ")", ";", "if", "(", "Count", "&&", "HasStdExtC", ")", "OS", ".", "write", "(", "\"\\x01\\0\"", ",", "2", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::FeatureStdExtC", "2", "4", "0", "4", "4", "\"\\x13\\0\\0\\0\"", "4", "\"\\x01\\0\"", "2" ]

[]

[ "<s>", "VariantKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "NVPTX" ]

[]

[ "<s>", "static", "tree", "spu_build_builtin_va_list", "(", "void", ")", "{", "tree", "f_args", ",", "f_skip", ",", "record", ",", "type_decl", ";", "bool", "owp", ";", "record", "=", "(", "*", "lang_hooks", ".", "types", ".", "make_type", ")", "(", "RECORD_TYPE", ")", ";", "type_decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list_tag\"", ")", ",", "record", ")", ";", "f_args", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__args\"", ")", ",", "ptr_type_node", ")", ";", "f_skip", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__skip\"", ")", ",", "ptr_type_node", ")", ";", "DECL_FIELD_CONTEXT", "(", "f_args", ")", "=", "record", ";", "DECL_ALIGN", "(", "f_args", ")", "=", "128", ";", "DECL_USER_ALIGN", "(", "f_args", ")", "=", "1", ";", "DECL_FIELD_CONTEXT", "(", "f_skip", ")", "=", "record", ";", "DECL_ALIGN", "(", "f_skip", ")", "=", "128", ";", "DECL_USER_ALIGN", "(", "f_skip", ")", "=", "1", ";", "TYPE_STUB_DECL", "(", "record", ")", "=", "type_decl", ";", "TYPE_NAME", "(", "record", ")", "=", "type_decl", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_args", ";", "DECL_CHAIN", "(", "f_args", ")", "=", "f_skip", ";", "owp", "=", "warn_padded", ";", "warn_padded", "=", "false", ";", "layout_type", "(", "record", ")", ";", "warn_padded", "=", "owp", ";", "return", "build_array_type", "(", "record", ",", "build_index_type", "(", "size_zero_node", ")", ")", ";", "}", "</s>" ]

[ "Create", "and", "return", "the", "va_list", "datatype", ".", "On", "SPU", ",", "va_list", "is", "an", "array", "type", "equivalent", "to", "typedef", "struct", "__va_list_tag", "{", "void", "*", "__args", "__attribute__", "(", "(", "__aligned", "(", "16", ")", ")", ")", ";", "void", "*", "__skip", "__attribute__", "(", "(", "__aligned", "(", "16", ")", ")", ")", ";", "}", "va_list", "[", "1", "]", ";", "where", "__args", "points", "to", "the", "arg", "that", "will", "be", "returned", "by", "the", "next", "va_arg", "(", ")", ",", "and", "__skip", "points", "to", "the", "previous", "stack", "frame", "such", "that", "when", "__args", "==", "__skip", "we", "should", "advance", "__args", "by", "32", "bytes", "." ]

[ "spu", "\"__va_list_tag\"", "\"__args\"", "\"__skip\"", "128", "1", "128", "1" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "assert", "(", "!", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "&&", "\"No stack realignment on AArch64!\"", ")", ";", "return", "(", "MFI", "->", "hasCalls", "(", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"No stack realignment on AArch64!\"" ]

[]

[ "<s>", "unsigned", "X86AsmBackend", "::", "getMaximumNopSize", "(", ")", "const", "{", "if", "(", "STI", ".", "hasFeature", "(", "X86", "::", "Mode16Bit", ")", ")", "return", "4", ";", "if", "(", "!", "STI", ".", "hasFeature", "(", "X86", "::", "FeatureNOPL", ")", "&&", "!", "STI", ".", "hasFeature", "(", "X86", "::", "Mode64Bit", ")", ")", "return", "1", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureFast7ByteNOP", "]", ")", "return", "7", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureFast15ByteNOP", "]", ")", "return", "15", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureFast11ByteNOP", "]", ")", "return", "11", ";", "return", "10", ";", "}", "</s>" ]

[ "Returns", "the", "maximum", "size", "of", "a", "nop", "in", "bytes", "on", "this", "target", "." ]

[ "X86", "X86", "X86::Mode16Bit", "4", "X86::FeatureNOPL", "X86::Mode64Bit", "1", "X86::FeatureFast7ByteNOP", "7", "X86::FeatureFast15ByteNOP", "15", "X86::FeatureFast11ByteNOP", "11", "10" ]

[]

[ "<s>", "bool", "AMDGPUPreLegalizerCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "EnableOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "skipFunction", "(", "F", ")", ";", "GISelKnownBits", "*", "KB", "=", "&", "getAnalysis", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ".", "get", "(", "MF", ")", ";", "MachineDominatorTree", "*", "MDT", "=", "IsOptNone", "?", "nullptr", ":", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "AMDGPUPreLegalizerCombinerInfo", "PCInfo", "(", "EnableOpt", ",", "F", ".", "hasOptSize", "(", ")", ",", "F", ".", "hasMinSize", "(", ")", ",", "KB", ",", "MDT", ")", ";", "Combiner", "C", "(", "PCInfo", ",", "TPC", ")", ";", "return", "C", ".", "combineMachineInstrs", "(", "MF", ",", "nullptr", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "R600SchedStrategy", "::", "schedNode", "(", "SUnit", "*", "SU", ",", "bool", "IsTopNode", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"scheduled: \"", ")", ";", "DEBUG", "(", "SU", "->", "dump", "(", "DAG", ")", ")", ";", "if", "(", "NextInstKind", "!=", "CurInstKind", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Instruction Type Switch\\n\"", ")", ";", "if", "(", "NextInstKind", "!=", "IDAlu", ")", "OccupedSlotsMask", "=", "15", ";", "CurEmitted", "=", "0", ";", "CurInstKind", "=", "NextInstKind", ";", "}", "if", "(", "CurInstKind", "==", "IDAlu", ")", "{", "switch", "(", "getAluKind", "(", "SU", ")", ")", "{", "case", "AluT_XYZW", ":", "CurEmitted", "+=", "4", ";", "break", ";", "case", "AluDiscarded", ":", "break", ";", "default", ":", "{", "++", "CurEmitted", ";", "for", "(", "MachineInstr", "::", "mop_iterator", "It", "=", "SU", "->", "getInstr", "(", ")", "->", "operands_begin", "(", ")", ",", "E", "=", "SU", "->", "getInstr", "(", ")", "->", "operands_end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "MachineOperand", "&", "MO", "=", "*", "It", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "ALU_LITERAL_X", ")", "++", "CurEmitted", ";", "}", "}", "}", "}", "else", "{", "++", "CurEmitted", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "CurEmitted", "<<", "\" Instructions Emitted in this clause\\n\"", ")", ";", "if", "(", "CurInstKind", "!=", "IDFetch", ")", "{", "MoveUnits", "(", "Pending", "[", "IDFetch", "]", ",", "Available", "[", "IDFetch", "]", ")", ";", "}", "MoveUnits", "(", "Pending", "[", "IDOther", "]", ",", "Available", "[", "IDOther", "]", ")", ";", "}", "</s>" ]

[ "ScheduleDAGMI", "has", "scheduled", "an", "instruction", "-", "tell", "HazardRec", "about", "it", "." ]

[ "R600", "\"scheduled: \"", "\"Instruction Type Switch\\n\"", "15", "0", "4", "\" Instructions Emitted in this clause\\n\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "{", "return", "\"SNES dynalloca stack pointer save/restore\"", ";", "}", "</s>" ]

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

[ "SNES", "\"SNES dynalloca stack pointer save/restore\"" ]

[]

[ "<s>", "void", "AZPRAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\">> AZPRAsmPinter::EmitInstruction <<\\n\"", ")", ";", "DEBUG", "(", "MI", "->", "dump", "(", ")", ")", ";", "AZPRMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "Mang", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "AZPR", "AZPR", "\">> AZPRAsmPinter::EmitInstruction <<\\n\"", "AZPR" ]

[]

[ "<s>", "bool", "AArch64A57FPLoadBalancing", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "F", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "balanceFPOps", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64A57FPLoadBalancing *****\\n\"", ")", ";", "MRI", "=", "&", "F", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "F", ".", "getRegInfo", "(", ")", ".", "getTargetRegisterInfo", "(", ")", ";", "RCI", ".", "runOnMachineFunction", "(", "F", ")", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "{", "Changed", "|=", "runOnBasicBlock", "(", "MBB", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"***** AArch64A57FPLoadBalancing *****\\n\"" ]

[]

[ "<s>", "static", "rtx", "fr30_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fntype_or_decli", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "valtype", ")", ",", "RETURN_VALUE_REGNUM", ")", ";", "}", "</s>" ]

[ "Implements", "TARGET_FUNCTION_VALUE", "." ]

[ "fr30" ]

[]

[ "<s>", "static", "void", "s390_function_num_hotpatch_hw", "(", "tree", "decl", ",", "int", "*", "hw_before", ",", "int", "*", "hw_after", ")", "{", "tree", "attr", ";", "attr", "=", "lookup_attribute", "(", "\"hotpatch\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "if", "(", "attr", ")", "{", "tree", "args", "=", "TREE_VALUE", "(", "attr", ")", ";", "*", "hw_before", "=", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "args", ")", ")", ";", "*", "hw_after", "=", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "TREE_CHAIN", "(", "args", ")", ")", ")", ";", "}", "else", "{", "*", "hw_before", "=", "s390_hotpatch_hw_before_label", ";", "*", "hw_after", "=", "s390_hotpatch_hw_after_label", ";", "}", "}", "</s>" ]

[ "Assigns", "the", "number", "of", "NOP", "halfwords", "to", "be", "emitted", "before", "and", "after", "the", "function", "label", "to", "*", "HW_BEFORE", "and", "*", "HW_AFTER", ".", "Both", "pointers", "must", "not", "be", "NULL", ".", "If", "hotpatching", "is", "disabled", "for", "the", "function", ",", "the", "values", "are", "set", "to", "zero", "." ]

[ "s390", "\"hotpatch\"" ]

[]

[ "<s>", "void", "aarch64_expand_vector_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "n_var", "=", "0", ";", "rtx", "any_const", "=", "NULL_RTX", ";", "rtx", "v0", "=", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ";", "bool", "all_same", "=", "true", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "(", "CONST_INT_P", "(", "x", ")", "||", "CONST_DOUBLE_P", "(", "x", ")", ")", ")", "++", "n_var", ";", "else", "any_const", "=", "x", ";", "all_same", "&=", "rtx_equal_p", "(", "x", ",", "v0", ")", ";", "}", "if", "(", "n_var", "==", "0", ")", "{", "rtx", "constant", "=", "aarch64_simd_make_constant", "(", "vals", ")", ";", "if", "(", "constant", "!=", "NULL_RTX", ")", "{", "emit_move_insn", "(", "target", ",", "constant", ")", ";", "return", ";", "}", "}", "if", "(", "all_same", ")", "{", "rtx", "x", "=", "copy_to_mode_reg", "(", "inner_mode", ",", "v0", ")", ";", "aarch64_emit_move", "(", "target", ",", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "x", ")", ")", ";", "return", ";", "}", "if", "(", "n_var", "!=", "n_elts", ")", "{", "rtx", "copy", "=", "copy_rtx", "(", "vals", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "CONST_INT_P", "(", "x", ")", "||", "CONST_DOUBLE_P", "(", "x", ")", ")", "continue", ";", "rtx", "subst", "=", "any_const", ";", "for", "(", "int", "bit", "=", "n_elts", "/", "2", ";", "bit", ">", "0", ";", "bit", "/=", "2", ")", "{", "rtx", "test", "=", "XVECEXP", "(", "copy", ",", "0", ",", "i", "^", "bit", ")", ";", "if", "(", "CONST_INT_P", "(", "test", ")", "||", "CONST_DOUBLE_P", "(", "test", ")", ")", "{", "subst", "=", "test", ";", "break", ";", "}", "}", "XVECEXP", "(", "copy", ",", "0", ",", "i", ")", "=", "subst", ";", "}", "aarch64_expand_vector_init", "(", "target", ",", "copy", ")", ";", "}", "enum", "insn_code", "icode", "=", "optab_handler", "(", "vec_set_optab", ",", "mode", ")", ";", "gcc_assert", "(", "icode", "!=", "CODE_FOR_nothing", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "CONST_INT_P", "(", "x", ")", "||", "CONST_DOUBLE_P", "(", "x", ")", ")", "continue", ";", "x", "=", "copy_to_mode_reg", "(", "inner_mode", ",", "x", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "x", ",", "GEN_INT", "(", "i", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Expand", "a", "vector", "initialisation", "sequence", ",", "such", "that", "TARGET", "is", "initialised", "to", "contain", "VALS", "." ]

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

[]

[ "<s>", "unsigned", "Z80oldInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"InsertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "Cond", ".", "size", "(", ")", "<=", "1", "&&", "\"Z80old branch conditions have one component!\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Z80old", "::", "JQ", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "unsigned", "Count", "=", "0", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Z80old", "::", "JQCC", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "++", "Count", ";", "if", "(", "FBB", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Z80old", "::", "JQ", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "Z80old", "Z80old", "\"InsertBranch must not be told to insert a fallthrough\"", "1", "\"Z80old branch conditions have one component!\"", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "Z80old::JQ", "1", "0", "Z80old::JQCC", "0", "Z80old::JQ" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "Sparc" ]

[]

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

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

[ "MCS51", "MCS51", "MCS51" ]

[]

[ "<s>", "void", "recordRelocation", "(", "MachObjectWriter", "*", "Writer", ",", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "MCFragment", "*", "Fragment", ",", "const", "MCFixup", "&", "Fixup", ",", "MCValue", "Target", ",", "uint64_t", "&", "FixedValue", ")", "override", "{", "const", "MCFixupKind", "FK", "=", "Fixup", ".", "getKind", "(", ")", ";", "bool", "ADefined", "=", "false", ";", "const", "MCSymbol", "*", "A", "=", "nullptr", ";", "int32_t", "AOffs", "=", "0", ";", "if", "(", "Target", ".", "getSymA", "(", ")", ")", "A", "=", "&", "Target", ".", "getSymA", "(", ")", "->", "getSymbol", "(", ")", ";", "if", "(", "A", "!=", "nullptr", "&&", "A", "->", "getFragment", "(", ")", "!=", "nullptr", ")", "{", "ADefined", "=", "true", ";", "AOffs", "=", "Target", ".", "getConstant", "(", ")", "+", "Layout", ".", "getFragmentOffset", "(", "Fragment", ")", ";", "}", "if", "(", "!", "Target", ".", "getSymB", "(", ")", "&&", "(", "!", "ADefined", "||", "Target", ".", "getConstant", "(", ")", "==", "0", "||", "AOffs", ">", "0x00ffffff", ")", ")", "recordRegularRelocation", "(", "Writer", ",", "Asm", ",", "Layout", ",", "Fragment", ",", "Fixup", ",", "Target", ",", "FixedValue", ",", "FK", ")", ";", "else", "if", "(", "!", "ADefined", ")", "report_fatal_error", "(", "\"target symbol '\"", "+", "(", "(", "A", "!=", "nullptr", ")", "?", "A", "->", "getName", "(", ")", ":", "\"\"", ")", "+", "\"' can not be undefined in a subtraction expression\"", ")", ";", "else", "recordScatteredRelocation", "(", "Writer", ",", "Asm", ",", "Layout", ",", "Fragment", ",", "Fixup", ",", "Target", ",", "FixedValue", ",", "FK", ")", ";", "}", "</s>" ]

[ "Record", "a", "relocation", "entry", "." ]

[ "PowerPC", "0", "0", "0x00ffffff", "\"target symbol '\"", "\"\"", "\"' can not be undefined in a subtraction expression\"" ]

[]

[ "<s>", "static", "void", "ix86_recompute_optlev_based_flags", "(", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ")", "{", "if", "(", "TARGET_64BIT_P", "(", "opts", "->", "x_ix86_isa_flags", ")", ")", "{", "if", "(", "opts", "->", "x_optimize", ">=", "1", ")", "SET_OPTION_IF_UNSET", "(", "opts", ",", "opts_set", ",", "flag_omit_frame_pointer", ",", "!", "USE_IX86_FRAME_POINTER", ")", ";", "if", "(", "opts", "->", "x_flag_asynchronous_unwind_tables", "&&", "TARGET_64BIT_MS_ABI", ")", "SET_OPTION_IF_UNSET", "(", "opts", ",", "opts_set", ",", "flag_unwind_tables", ",", "1", ")", ";", "if", "(", "opts", "->", "x_flag_asynchronous_unwind_tables", "==", "2", ")", "opts", "->", "x_flag_unwind_tables", "=", "opts", "->", "x_flag_asynchronous_unwind_tables", "=", "1", ";", "if", "(", "opts", "->", "x_flag_pcc_struct_return", "==", "2", ")", "opts", "->", "x_flag_pcc_struct_return", "=", "0", ";", "}", "else", "{", "if", "(", "opts", "->", "x_optimize", ">=", "1", ")", "SET_OPTION_IF_UNSET", "(", "opts", ",", "opts_set", ",", "flag_omit_frame_pointer", ",", "!", "(", "USE_IX86_FRAME_POINTER", "||", "opts", "->", "x_optimize_size", ")", ")", ";", "if", "(", "opts", "->", "x_flag_asynchronous_unwind_tables", "==", "2", ")", "opts", "->", "x_flag_asynchronous_unwind_tables", "=", "!", "USE_IX86_FRAME_POINTER", ";", "if", "(", "opts", "->", "x_flag_pcc_struct_return", "==", "2", ")", "{", "if", "(", "TARGET_IAMCU_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_pcc_struct_return", "=", "0", ";", "else", "opts", "->", "x_flag_pcc_struct_return", "=", "DEFAULT_PCC_STRUCT_RETURN", ";", "}", "}", "}", "</s>" ]

[ "(", "Re", ")", "compute", "option", "overrides", "affected", "by", "optimization", "levels", "in", "target-specific", "ways", "." ]

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

[]

[ "<s>", "void", "MipsRegisterBankInfo", "::", "setRegBank", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ")", "const", "{", "Register", "Dest", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_STORE", ":", "break", ";", "case", "TargetOpcode", "::", "G_CONSTANT", ":", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_SELECT", ":", "case", "TargetOpcode", "::", "G_PHI", ":", "case", "TargetOpcode", "::", "G_IMPLICIT_DEF", ":", "{", "assert", "(", "MRI", ".", "getType", "(", "Dest", ")", "==", "LLT", "::", "scalar", "(", "32", ")", "&&", "\"Unexpected operand type.\"", ")", ";", "MRI", ".", "setRegBank", "(", "Dest", ",", "getRegBank", "(", "Mips", "::", "GPRBRegBankID", ")", ")", ";", "break", ";", "}", "case", "TargetOpcode", "::", "G_PTR_ADD", ":", "{", "assert", "(", "MRI", ".", "getType", "(", "Dest", ")", ".", "isPointer", "(", ")", "&&", "\"Unexpected operand type.\"", ")", ";", "MRI", ".", "setRegBank", "(", "Dest", ",", "getRegBank", "(", "Mips", "::", "GPRBRegBankID", ")", ")", ";", "break", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Unexpected opcode.\"", ")", ";", "}", "}", "</s>" ]

[ "RegBankSelect", "determined", "that", "s64", "operand", "is", "better", "to", "be", "split", "into", "two", "s32", "operands", "in", "gprb", "." ]

[ "Mips", "Mips", "0", "32", "\"Unexpected operand type.\"", "Mips::GPRBRegBankID", "\"Unexpected operand type.\"", "Mips::GPRBRegBankID", "\"Unexpected opcode.\"" ]

[]

[ "<s>", "bool", "areInlineCompatible", "(", "const", "Function", "*", "Caller", ",", "const", "Function", "*", "Callee", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "callee", "with", "the", "given", "TLI", "can", "be", "inlined", "into", "caller", "with", "this", "TLI", ",", "based", "on", "'nobuiltin", "'", "attributes", "." ]

[ "NVPTX" ]

[]

[ "<s>", "static", "bool", "mn10300_return_in_memory", "(", "tree", "type", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "int_size_in_bytes", "(", "type", ")", ">", "8", "||", "int_size_in_bytes", "(", "type", ")", "==", "0", "||", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", ")", ";", "}", "</s>" ]

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

[ "mn10300", "8", "0" ]

[]

[ "<s>", "void", "aarch64_split_combinev16qi", "(", "rtx", "operands", "[", "3", "]", ")", "{", "unsigned", "int", "dest", "=", "REGNO", "(", "operands", "[", "0", "]", ")", ";", "unsigned", "int", "src1", "=", "REGNO", "(", "operands", "[", "1", "]", ")", ";", "unsigned", "int", "src2", "=", "REGNO", "(", "operands", "[", "2", "]", ")", ";", "machine_mode", "halfmode", "=", "GET_MODE", "(", "operands", "[", "1", "]", ")", ";", "unsigned", "int", "halfregs", "=", "HARD_REGNO_NREGS", "(", "src1", ",", "halfmode", ")", ";", "rtx", "destlo", ",", "desthi", ";", "gcc_assert", "(", "halfmode", "==", "V16QImode", ")", ";", "if", "(", "src1", "==", "dest", "&&", "src2", "==", "dest", "+", "halfregs", ")", "{", "emit_note", "(", "NOTE_INSN_DELETED", ")", ";", "return", ";", "}", "destlo", "=", "gen_rtx_REG_offset", "(", "operands", "[", "0", "]", ",", "halfmode", ",", "dest", ",", "0", ")", ";", "desthi", "=", "gen_rtx_REG_offset", "(", "operands", "[", "0", "]", ",", "halfmode", ",", "dest", "+", "halfregs", ",", "GET_MODE_SIZE", "(", "halfmode", ")", ")", ";", "if", "(", "reg_overlap_mentioned_p", "(", "operands", "[", "2", "]", ",", "destlo", ")", "&&", "reg_overlap_mentioned_p", "(", "operands", "[", "1", "]", ",", "desthi", ")", ")", "{", "emit_insn", "(", "gen_xorv16qi3", "(", "operands", "[", "1", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", ";", "emit_insn", "(", "gen_xorv16qi3", "(", "operands", "[", "2", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", ";", "emit_insn", "(", "gen_xorv16qi3", "(", "operands", "[", "1", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", ";", "}", "else", "if", "(", "!", "reg_overlap_mentioned_p", "(", "operands", "[", "2", "]", ",", "destlo", ")", ")", "{", "if", "(", "src1", "!=", "dest", ")", "emit_move_insn", "(", "destlo", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "src2", "!=", "dest", "+", "halfregs", ")", "emit_move_insn", "(", "desthi", ",", "operands", "[", "2", "]", ")", ";", "}", "else", "{", "if", "(", "src2", "!=", "dest", "+", "halfregs", ")", "emit_move_insn", "(", "desthi", ",", "operands", "[", "2", "]", ")", ";", "if", "(", "src1", "!=", "dest", ")", "emit_move_insn", "(", "destlo", ",", "operands", "[", "1", "]", ")", ";", "}", "}", "</s>" ]

[ "Split", "operands", "into", "moves", "from", "op", "[", "1", "]", "+", "op", "[", "2", "]", "into", "op", "[", "0", "]", "." ]

[ "aarch64", "3", "0", "1", "2", "1", "0", "0", "0", "2", "1", "1", "1", "2", "2", "1", "2", "1", "1", "2", "2", "1", "2", "2", "1" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegNo", "=", "getMipsRegisterNumbering", "(", "Reg", ")", ";", "return", "RegNo", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "if", "(", "Kind", "==", "MCExpr", "::", "Binary", ")", "{", "Expr", "=", "static_cast", "<", "const", "MCBinaryExpr", "*", ">", "(", "Expr", ")", "->", "getLHS", "(", ")", ";", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "}", "assert", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", ")", ";", "Mips", "::", "Fixups", "FixupKind", "=", "Mips", "::", "Fixups", "(", "0", ")", ";", "switch", "(", "cast", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", "->", "getKind", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown fixup kind!\"", ")", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GOT_DISP", ":", "llvm_unreachable", "(", "\"fixup kind VK_Mips_GOT_DISP not supported for direct object!\"", ")", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GPOFF_HI", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_GPOFF_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GPOFF_LO", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_GPOFF_LO", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GOT_PAGE", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_GOT_PAGE", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GOT_OFST", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_GOT_OFST", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GPREL", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_GPREL16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GOT_CALL", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_CALL16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GOT16", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_GOT_Global", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GOT", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_GOT_Local", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_ABS_HI", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_HI16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_ABS_LO", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_LO16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_TLSGD", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_TLSGD", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_TLSLDM", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_TLSLDM", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_DTPREL_HI", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_DTPREL_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_DTPREL_LO", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_DTPREL_LO", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_GOTTPREL", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_GOTTPREL", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_TPREL_HI", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_TPREL_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_TPREL_LO", ":", "FixupKind", "=", "Mips", "::", "fixup_Mips_TPREL_LO", ";", "break", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "FixupKind", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "Mips", "Mips", "Mips", "32", "Mips::Fixups", "Mips::Fixups", "0", "\"Unknown fixup kind!\"", "Mips", "\"fixup kind VK_Mips_GOT_DISP not supported for direct object!\"", "Mips", "Mips::fixup_Mips_GPOFF_HI", "Mips", "Mips::fixup_Mips_GPOFF_LO", "Mips", "Mips::fixup_Mips_GOT_PAGE", "Mips", "Mips::fixup_Mips_GOT_OFST", "Mips", "Mips::fixup_Mips_GPREL16", "Mips", "Mips::fixup_Mips_CALL16", "Mips", "Mips::fixup_Mips_GOT_Global", "Mips", "Mips::fixup_Mips_GOT_Local", "Mips", "Mips::fixup_Mips_HI16", "Mips", "Mips::fixup_Mips_LO16", "Mips", "Mips::fixup_Mips_TLSGD", "Mips", "Mips::fixup_Mips_TLSLDM", "Mips", "Mips::fixup_Mips_DTPREL_HI", "Mips", "Mips::fixup_Mips_DTPREL_LO", "Mips", "Mips::fixup_Mips_GOTTPREL", "Mips", "Mips::fixup_Mips_TPREL_HI", "Mips", "Mips::fixup_Mips_TPREL_LO", "0", "0" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "RISCVFunctionInfo", "*", "RISCVFI", "=", "MF", ".", "getInfo", "<", "RISCVFunctionInfo", ">", "(", ")", ";", "const", "RISCVSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "unsigned", "FP", "=", "STI", ".", "isRV64", "(", ")", "?", "RISCV", "::", "fp_64", ":", "RISCV", "::", "fp", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "SavedRegs", ".", "set", "(", "FP", ")", ";", "if", "(", "RISCVFI", "->", "getCallsEhReturn", "(", ")", ")", "RISCVFI", "->", "createEhDataRegsFI", "(", ")", ";", "uint64_t", "MaxSPOffset", "=", "MF", ".", "getInfo", "<", "RISCVFunctionInfo", ">", "(", ")", "->", "getIncomingArgSize", "(", ")", "+", "MFI", "->", "estimateStackSize", "(", "MF", ")", ";", "if", "(", "isInt", "<", "12", ">", "(", "MaxSPOffset", ")", ")", "return", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "RISCV", "::", "GR32BitRegClass", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "RC", "->", "getAlignment", "(", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "RISCV::fp_64", "RISCV::fp", "RISCV", "RISCV", "RISCV", "12", "RISCV::GR32BitRegClass" ]

[]

[ "<s>", "bool", "rvexVLIWPacketizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Voor VLIW packetizer!\\n\"", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Fn", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "rvexVLIWPacketizerList", "Packetizer", "(", "Fn", ",", "MLI", ",", "MDT", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "RegionEnd", "=", "MBB", "->", "end", "(", ")", ",", "MBBb", "=", "MBB", "->", "begin", "(", ")", ";", "RegionEnd", "!=", "MBBb", ";", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "RegionEnd", ";", "for", "(", ";", "I", "!=", "MBBb", ";", "--", "I", ")", "{", "if", "(", "TII", "->", "isSchedulingBoundary", "(", "llvm", "::", "prior", "(", "I", ")", ",", "MBB", ",", "Fn", ")", ")", "break", ";", "}", "MachineBasicBlock", "::", "iterator", "priorEnd", "=", "llvm", "::", "prior", "(", "RegionEnd", ")", ";", "if", "(", "I", "==", "RegionEnd", "||", "I", "==", "priorEnd", ")", "{", "RegionEnd", "=", "priorEnd", ";", "continue", ";", "}", "Packetizer", ".", "PacketizeMIs", "(", "MBB", ",", "I", ",", "RegionEnd", ")", ";", "RegionEnd", "=", "I", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "rvex", "rvex", "\"Voor VLIW packetizer!\\n\"", "rvex", "\"Empty DFA table!\"" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "lowerInterleavedStore", "(", "StoreInst", "*", "SI", ",", "ShuffleVectorInst", "*", "SVI", ",", "unsigned", "Factor", ")", "const", "{", "assert", "(", "Factor", ">=", "2", "&&", "Factor", "<=", "getMaxSupportedInterleaveFactor", "(", ")", "&&", "\"Invalid interleave factor\"", ")", ";", "VectorType", "*", "VecTy", "=", "SVI", "->", "getType", "(", ")", ";", "assert", "(", "VecTy", "->", "getVectorNumElements", "(", ")", "%", "Factor", "==", "0", "&&", "\"Invalid interleaved store\"", ")", ";", "unsigned", "NumSubElts", "=", "VecTy", "->", "getVectorNumElements", "(", ")", "/", "Factor", ";", "Type", "*", "EltTy", "=", "VecTy", "->", "getVectorElementType", "(", ")", ";", "VectorType", "*", "SubVecTy", "=", "VectorType", "::", "get", "(", "EltTy", ",", "NumSubElts", ")", ";", "const", "DataLayout", "&", "DL", "=", "SI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "SubVecSize", "=", "DL", ".", "getTypeSizeInBits", "(", "SubVecTy", ")", ";", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", "||", "(", "SubVecSize", "!=", "64", "&&", "SubVecSize", "!=", "128", ")", ")", "return", "false", ";", "Value", "*", "Op0", "=", "SVI", "->", "getOperand", "(", "0", ")", ";", "Value", "*", "Op1", "=", "SVI", "->", "getOperand", "(", "1", ")", ";", "IRBuilder", "<", ">", "Builder", "(", "SI", ")", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "{", "Type", "*", "IntTy", "=", "DL", ".", "getIntPtrType", "(", "EltTy", ")", ";", "unsigned", "NumOpElts", "=", "dyn_cast", "<", "VectorType", ">", "(", "Op0", "->", "getType", "(", ")", ")", "->", "getVectorNumElements", "(", ")", ";", "Type", "*", "IntVecTy", "=", "VectorType", "::", "get", "(", "IntTy", ",", "NumOpElts", ")", ";", "Op0", "=", "Builder", ".", "CreatePtrToInt", "(", "Op0", ",", "IntVecTy", ")", ";", "Op1", "=", "Builder", ".", "CreatePtrToInt", "(", "Op1", ",", "IntVecTy", ")", ";", "SubVecTy", "=", "VectorType", "::", "get", "(", "IntTy", ",", "NumSubElts", ")", ";", "}", "Type", "*", "PtrTy", "=", "SubVecTy", "->", "getPointerTo", "(", "SI", "->", "getPointerAddressSpace", "(", ")", ")", ";", "Type", "*", "Tys", "[", "2", "]", "=", "{", "SubVecTy", ",", "PtrTy", "}", ";", "static", "const", "Intrinsic", "::", "ID", "StoreInts", "[", "3", "]", "=", "{", "Intrinsic", "::", "aarch64_neon_st2", ",", "Intrinsic", "::", "aarch64_neon_st3", ",", "Intrinsic", "::", "aarch64_neon_st4", "}", ";", "Function", "*", "StNFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "SI", "->", "getModule", "(", ")", ",", "StoreInts", "[", "Factor", "-", "2", "]", ",", "Tys", ")", ";", "SmallVector", "<", "Value", "*", ",", "5", ">", "Ops", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Factor", ";", "i", "++", ")", "Ops", ".", "push_back", "(", "Builder", ".", "CreateShuffleVector", "(", "Op0", ",", "Op1", ",", "getSequentialMask", "(", "Builder", ",", "NumSubElts", "*", "i", ",", "NumSubElts", ")", ")", ")", ";", "Ops", ".", "push_back", "(", "Builder", ".", "CreateBitCast", "(", "SI", "->", "getPointerOperand", "(", ")", ",", "PtrTy", ")", ")", ";", "Builder", ".", "CreateCall", "(", "StNFunc", ",", "Ops", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Lower", "interleaved", "store", "(", "s", ")", "into", "target", "specific", "instructions/intrinsics", "." ]

[ "AArch64", "AArch64", "2", "\"Invalid interleave factor\"", "0", "\"Invalid interleaved store\"", "64", "128", "0", "1", "2", "Intrinsic::ID", "3", "Intrinsic::aarch64_neon_st2", "Intrinsic::aarch64_neon_st3", "Intrinsic::aarch64_neon_st4", "Intrinsic::getDeclaration", "2", "5", "0" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "LanaiTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "Info", ",", "const", "char", "*", "Constraint", ")", "const", "{", "ConstraintWeight", "Weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "Info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "switch", "(", "*", "Constraint", ")", "{", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'O'", ":", "if", "(", "isa", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "Weight", "=", "CW_Constant", ";", "break", ";", "default", ":", "Weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "Info", ",", "Constraint", ")", ";", "break", ";", "}", "return", "Weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "bool", "addInstSelector", "(", ")", "override", "{", "addPass", "(", "createUPTISelDag", "(", "getUPTTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "UPT", "UPT", "UPT" ]

[]

[ "<s>", "static", "const", "char", "*", "mips_mdebug_abi_name", "(", "void", ")", "{", "switch", "(", "mips_abi", ")", "{", "case", "ABI_32", ":", "return", "\"abi32\"", ";", "case", "ABI_O64", ":", "return", "\"abiO64\"", ";", "case", "ABI_N32", ":", "return", "\"abiN32\"", ";", "case", "ABI_64", ":", "return", "\"abi64\"", ";", "case", "ABI_EABI", ":", "return", "TARGET_64BIT", "?", "\"eabi64\"", ":", "\"eabi32\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "FOO", "in", "the", "name", "of", "the", "``", ".mdebug.FOO", "''", "section", "associated", "with", "the", "current", "ABI", "." ]

[ "mips", "\"abi32\"", "\"abiO64\"", "\"abiN32\"", "\"abi64\"", "\"eabi64\"", "\"eabi32\"" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "areInlineCompatible", "(", "const", "Function", "*", "Caller", ",", "const", "Function", "*", "Callee", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTLI", "(", ")", "->", "getTargetMachine", "(", ")", ";", "const", "FeatureBitset", "&", "CallerBits", "=", "TM", ".", "getSubtargetImpl", "(", "*", "Caller", ")", "->", "getFeatureBits", "(", ")", ";", "const", "FeatureBitset", "&", "CalleeBits", "=", "TM", ".", "getSubtargetImpl", "(", "*", "Callee", ")", "->", "getFeatureBits", "(", ")", ";", "FeatureBitset", "RealCallerBits", "=", "CallerBits", "&", "~", "InlineFeatureIgnoreList", ";", "FeatureBitset", "RealCalleeBits", "=", "CalleeBits", "&", "~", "InlineFeatureIgnoreList", ";", "if", "(", "(", "RealCallerBits", "&", "RealCalleeBits", ")", "!=", "RealCalleeBits", ")", "return", "false", ";", "AMDGPU", "::", "SIModeRegisterDefaults", "CallerMode", "(", "*", "Caller", ")", ";", "AMDGPU", "::", "SIModeRegisterDefaults", "CalleeMode", "(", "*", "Callee", ")", ";", "return", "CallerMode", ".", "isInlineCompatible", "(", "CalleeMode", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "callee", "with", "the", "given", "TLI", "can", "be", "inlined", "into", "caller", "with", "this", "TLI", ",", "based", "on", "'nobuiltin", "'", "attributes", "." ]

[ "AMDGPU", "AMDGPU::SIModeRegisterDefaults", "AMDGPU::SIModeRegisterDefaults" ]

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", ")", "const", "{", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "int", "FrameIdx", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "2", ",", "-", "4", ",", "true", ")", ";", "(", "void", ")", "FrameIdx", ";", "assert", "(", "FrameIdx", "==", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectIndexBegin", "(", ")", "&&", "\"Slot for FP register must be last in order to be found!\"", ")", ";", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "MSP430", "MSP430", "2", "4", "\"Slot for FP register must be last in order to be found!\"" ]

[]

[ "<s>", "static", "int", "avr_num_arg_regs", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "int", "size", ";", "if", "(", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "size", "+", "1", ")", "&", "~", "1", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "registers", "to", "allocate", "for", "a", "function", "argument", "." ]

[ "avr", "1", "1" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "int64_t", "Offset", "=", "int64_t", "(", "Value", ")", ";", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "RISCV", "::", "fixup_riscv_rvc_branch", ":", "return", "Offset", ">", "254", "||", "Offset", "<", "-", "256", ";", "case", "RISCV", "::", "fixup_riscv_rvc_jump", ":", "return", "Offset", ">", "2046", "||", "Offset", "<", "-", "2048", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::fixup_riscv_rvc_branch", "254", "256", "RISCV::fixup_riscv_rvc_jump", "2046", "2048" ]

[]

[ "<s>", "EVT", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "Size", ">=", "8", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "BPF", "8", "MVT::i64", "MVT::i32" ]

[]