Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "arc_needs_pcl_p", "(", "rtx", "x", ")", "{", "register", "const", "char", "*", "fmt", ";", "register", "int", "i", ",", "j", ";", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "&&", "(", "XVECLEN", "(", "x", ",", "0", ")", "==", "1", ")", "&&", "(", "GET_CODE", "(", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "ARC_UNSPEC_GOT", ":", "case", "ARC_UNSPEC_GOTOFFPC", ":", "case", "UNSPEC_TLS_GD", ":", "case", "UNSPEC_TLS_IE", ":", "return", "true", ";", "default", ":", "break", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "{", "if", "(", "arc_needs_pcl_p", "(", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "arc_needs_pcl_p", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Helper", "used", "by", "arc_legitimate_pc_offset_p", "." ]

[ "arc", "0", "1", "0", "0", "1", "1", "0", "1", "0" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "CCAssignFn", "*", "RetCC", "=", "CallConv", "==", "CallingConv", "::", "WebKit_JS", "?", "RetCC_AArch64_WebKit_JS", ":", "RetCC_AArch64_AAPCS", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "realRVLocIdx", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ",", "++", "realRVLocIdx", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "Arg", "=", "OutVals", "[", "realRVLocIdx", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "if", "(", "Outs", "[", "i", "]", ".", "ArgVT", "==", "MVT", "::", "i1", ")", "{", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i1", ",", "Arg", ")", ";", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "}", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "const", "AArch64RegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "I", "=", "TRI", "->", "getCalleeSavedRegsViaCopy", "(", "&", "DAG", ".", "getMachineFunction", "(", ")", ")", ";", "if", "(", "I", ")", "{", "for", "(", ";", "*", "I", ";", "++", "I", ")", "{", "if", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "*", "I", ",", "MVT", "::", "i64", ")", ")", ";", "else", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "*", "I", ",", "MVT", "::", "getFloatingPointVT", "(", "64", ")", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class in CSRsViaCopy!\"", ")", ";", "}", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "ISD::OutputArg", "AArch64", "AArch64", "16", "4", "1", "0", "0", "\"Can only return in registers!\"", "\"Unknown loc info!\"", "MVT::i1", "ISD::TRUNCATE", "MVT::i1", "ISD::ZERO_EXTEND", "ISD::BITCAST", "1", "AArch64", "AArch64::GPR64RegClass", "MVT::i64", "AArch64::FPR64RegClass", "MVT::getFloatingPointVT", "64", "\"Unexpected register class in CSRsViaCopy!\"", "0", "AArch64ISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "virtual", "const", "ARMFrameInfo", "*", "getFrameInfo", "(", ")", "const", "{", "return", "&", "FrameInfo", ";", "}", "</s>" ]

[ "getFrameInfo", "-", "Return", "the", "frame", "info", "object", "for", "the", "current", "function", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "rs6000_split_logical_inner", "(", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ",", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "bool", "complement_final_p", ",", "bool", "complement_op1_p", ",", "bool", "complement_op2_p", ")", "{", "rtx", "bool_rtx", ";", "if", "(", "op2", "&&", "GET_CODE", "(", "op2", ")", "==", "CONST_INT", "&&", "(", "mode", "==", "SImode", "||", "(", "mode", "==", "DImode", "&&", "TARGET_POWERPC64", ")", ")", "&&", "!", "complement_final_p", "&&", "!", "complement_op1_p", "&&", "!", "complement_op2_p", ")", "{", "HOST_WIDE_INT", "mask", "=", "GET_MODE_MASK", "(", "mode", ")", ";", "HOST_WIDE_INT", "value", "=", "INTVAL", "(", "op2", ")", "&", "mask", ";", "if", "(", "code", "==", "AND", ")", "{", "if", "(", "value", "==", "0", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "const0_rtx", ")", ")", ";", "return", ";", "}", "else", "if", "(", "value", "==", "mask", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "op1", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "op1", ")", ")", ";", "return", ";", "}", "}", "else", "if", "(", "code", "==", "IOR", "||", "code", "==", "XOR", ")", "{", "if", "(", "value", "==", "0", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "op1", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "op1", ")", ")", ";", "return", ";", "}", "}", "}", "if", "(", "code", "==", "AND", "&&", "mode", "==", "SImode", "&&", "!", "complement_final_p", "&&", "!", "complement_op1_p", "&&", "!", "complement_op2_p", ")", "{", "emit_insn", "(", "gen_andsi3", "(", "dest", ",", "op1", ",", "op2", ")", ")", ";", "return", ";", "}", "if", "(", "complement_op1_p", ")", "op1", "=", "gen_rtx_NOT", "(", "mode", ",", "op1", ")", ";", "if", "(", "complement_op2_p", ")", "op2", "=", "gen_rtx_NOT", "(", "mode", ",", "op2", ")", ";", "if", "(", "!", "complement_op1_p", "&&", "complement_op2_p", ")", "std", "::", "swap", "(", "op1", ",", "op2", ")", ";", "bool_rtx", "=", "(", "(", "code", "==", "NOT", ")", "?", "gen_rtx_NOT", "(", "mode", ",", "op1", ")", ":", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "op1", ",", "op2", ")", ")", ";", "if", "(", "complement_final_p", ")", "bool_rtx", "=", "gen_rtx_NOT", "(", "mode", ",", "bool_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "bool_rtx", ")", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "rs6000_split_logical", "to", "emit", "a", "logical", "instruction", "after", "spliting", "the", "operation", "to", "single", "GPR", "registers", ".", "DEST", "is", "the", "destination", "register", ".", "OP1", "and", "OP2", "are", "the", "input", "source", "registers", ".", "CODE", "is", "the", "base", "operation", "(", "AND", ",", "IOR", ",", "XOR", ",", "NOT", ")", ".", "MODE", "is", "the", "machine", "mode", ".", "If", "COMPLEMENT_FINAL_P", "is", "true", ",", "wrap", "the", "whole", "operation", "with", "NOT", ".", "If", "COMPLEMENT_OP1_P", "is", "true", ",", "wrap", "operand1", "with", "NOT", ".", "If", "COMPLEMENT_OP2_P", "is", "true", ",", "wrap", "operand2", "with", "NOT", "." ]

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

[]

[ "<s>", "void", "function_builder", "::", "add_overloaded_function", "(", "const", "function_instance", "&", "instance", ",", "aarch64_feature_flags", "required_extensions", ")", "{", "char", "*", "name", "=", "get_name", "(", "instance", ",", "true", ")", ";", "if", "(", "registered_function", "*", "*", "map_value", "=", "m_overload_names", ".", "get", "(", "name", ")", ")", "{", "gcc_assert", "(", "(", "*", "map_value", ")", "->", "instance", "==", "instance", "&&", "(", "(", "*", "map_value", ")", "->", "required_extensions", "&", "~", "required_extensions", ")", "==", "0", ")", ";", "obstack_free", "(", "&", "m_string_obstack", ",", "name", ")", ";", "}", "else", "{", "registered_function", "&", "rfn", "=", "add_function", "(", "instance", ",", "name", ",", "m_overload_type", ",", "NULL_TREE", ",", "required_extensions", ",", "true", ",", "m_direct_overloads", ")", ";", "m_overload_names", ".", "put", "(", "name", ",", "&", "rfn", ")", ";", "}", "}", "</s>" ]

[ "Add", "one", "function", "decl", "for", "INSTANCE", ",", "to", "be", "used", "with", "manual", "overload", "resolution", ".", "REQUIRED_EXTENSIONS", "are", "the", "set", "of", "architecture", "extensions", "that", "the", "function", "requires", ".", "For", "simplicity", ",", "deal", "with", "duplicate", "attempts", "to", "add", "the", "same", "function", ",", "including", "cases", "in", "which", "the", "new", "function", "requires", "more", "features", "than", "the", "original", "one", "did", ".", "In", "that", "case", "we", "'ll", "check", "whether", "the", "required", "features", "are", "available", "as", "part", "of", "resolving", "the", "function", "to", "the", "relevant", "unique", "function", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "AVRPassConfig", "::", "addInstSelector", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "AVR", "AVR" ]

[]

[ "<s>", "rtx", "create_TOC_reference", "(", "rtx", "symbol", ")", "{", "if", "(", "no_new_pseudos", ")", "regs_ever_live", "[", "TOC_REGISTER", "]", "=", "1", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "TOC_REGISTER", ")", ",", "gen_rtx_CONST", "(", "Pmode", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "symbol", ",", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "toc_label_name", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Create", "a", "TOC", "reference", "for", "symbol_ref", "SYMBOL", ".", "If", "LARGETOC_REG", "is", "non-null", ",", "use", "that", "as", "the", "register", "to", "put", "the", "HIGH", "value", "into", "if", "register", "allocation", "is", "already", "done", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "rounded_frame_size", "(", "int", "pushed", ")", "{", "HOST_WIDE_INT", "size", "=", "get_frame_size", "(", ")", ";", "HOST_WIDE_INT", "align", "=", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ";", "return", "(", "(", "size", "+", "pushed", "+", "align", "-", "1", ")", "&", "-", "align", ")", "-", "pushed", ";", "}", "</s>" ]

[ "PUSHED", "is", "the", "number", "of", "bytes", "that", "are", "bing", "pushed", "on", "the", "stack", "for", "register", "saves", ".", "Return", "the", "frame", "size", ",", "padded", "appropriately", "so", "that", "the", "stack", "stays", "properly", "aligned", "." ]

[ "sh", "1" ]

[]

[ "<s>", "static", "std", "::", "string", "toString", "(", "const", "APFloat", "&", "FP", ")", "{", "if", "(", "FP", ".", "isNaN", "(", ")", "&&", "!", "FP", ".", "bitwiseIsEqual", "(", "APFloat", "::", "getQNaN", "(", "FP", ".", "getSemantics", "(", ")", ")", ")", "&&", "!", "FP", ".", "bitwiseIsEqual", "(", "APFloat", "::", "getQNaN", "(", "FP", ".", "getSemantics", "(", ")", ",", "true", ")", ")", ")", "{", "APInt", "AI", "=", "FP", ".", "bitcastToAPInt", "(", ")", ";", "return", "std", "::", "string", "(", "AI", ".", "isNegative", "(", ")", "?", "\"-\"", ":", "\"\"", ")", "+", "\"nan:0x\"", "+", "utohexstr", "(", "AI", ".", "getZExtValue", "(", ")", "&", "(", "AI", ".", "getBitWidth", "(", ")", "==", "32", "?", "INT64_C", "(", "0x007fffff", ")", ":", "INT64_C", "(", "0x000fffffffffffff", ")", ")", ",", "true", ")", ";", "}", "static", "const", "size_t", "BufBytes", "=", "128", ";", "char", "buf", "[", "BufBytes", "]", ";", "auto", "Written", "=", "FP", ".", "convertToHexString", "(", "buf", ",", "0", ",", "false", ",", "APFloat", "::", "rmNearestTiesToEven", ")", ";", "(", "void", ")", "Written", ";", "assert", "(", "Written", "!=", "0", ")", ";", "assert", "(", "Written", "<", "BufBytes", ")", ";", "return", "buf", ";", "}", "</s>" ]

[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]

[ "WebAssembly", "\"-\"", "\"\"", "\"nan:0x\"", "32", "0x007fffff", "0x000fffffffffffff", "128", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "fp_immediate_constant", "(", "rtx", "x", ")", "{", "REAL_VALUE_TYPE", "r", ";", "int", "i", ";", "if", "(", "!", "fp_consts_inited", ")", "init_fp_table", "(", ")", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "x", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "REAL_VALUES_EQUAL", "(", "r", ",", "values_fp", "[", "i", "]", ")", ")", "return", "strings_fp", "[", "i", "]", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "If", "the", "rtx", "is", "the", "correct", "value", "then", "return", "the", "string", "of", "the", "number", ".", "In", "this", "way", "we", "can", "ensure", "that", "valid", "double", "constants", "are", "generated", "even", "when", "cross", "compiling", "." ]

[ "arm", "0", "8" ]

[]

[ "<s>", "void", "order_regs_for_local_alloc", "(", ")", "{", "static", "int", "last_order_nonleaf", "=", "1", ";", "if", "(", "regs_ever_live", "[", "15", "]", "!=", "last_order_nonleaf", ")", "{", "last_order_nonleaf", "=", "!", "last_order_nonleaf", ";", "memcpy", "(", "(", "char", "*", ")", "reg_alloc_order", ",", "(", "const", "char", "*", ")", "reg_alloc_orders", "[", "last_order_nonleaf", "]", ",", "FIRST_PSEUDO_REGISTER", "*", "sizeof", "(", "int", ")", ")", ";", "}", "}", "</s>" ]

[ "Choose", "the", "order", "in", "which", "to", "allocate", "hard", "registers", "for", "pseudo-registers", "local", "to", "a", "basic", "block", ".", "Store", "the", "desired", "register", "order", "in", "the", "array", "`", "reg_alloc_order", "'", ".", "Element", "0", "should", "be", "the", "register", "to", "allocate", "first", ";", "element", "1", ",", "the", "next", "register", ";", "and", "so", "on", "." ]

[ "sparc", "1", "15" ]

[]

[ "<s>", "bool", "aarch64_sve_same_pred_for_ptest_p", "(", "rtx", "*", "pred1", ",", "rtx", "*", "pred2", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "pred1", "[", "0", "]", ")", ";", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_BOOL", "&&", "mode", "==", "GET_MODE", "(", "pred2", "[", "0", "]", ")", "&&", "aarch64_sve_ptrue_flag", "(", "pred1", "[", "1", "]", ",", "SImode", ")", "&&", "aarch64_sve_ptrue_flag", "(", "pred2", "[", "1", "]", ",", "SImode", ")", ")", ";", "bool", "ptrue1_p", "=", "(", "pred1", "[", "0", "]", "==", "CONSTM1_RTX", "(", "mode", ")", "||", "INTVAL", "(", "pred1", "[", "1", "]", ")", "==", "SVE_KNOWN_PTRUE", ")", ";", "bool", "ptrue2_p", "=", "(", "pred2", "[", "0", "]", "==", "CONSTM1_RTX", "(", "mode", ")", "||", "INTVAL", "(", "pred2", "[", "1", "]", ")", "==", "SVE_KNOWN_PTRUE", ")", ";", "return", "(", "ptrue1_p", "&&", "ptrue2_p", ")", "||", "rtx_equal_p", "(", "pred1", "[", "0", "]", ",", "pred2", "[", "0", "]", ")", ";", "}", "</s>" ]

[ "PRED1", "[", "0", "]", "is", "a", "PTEST", "predicate", "and", "PRED1", "[", "1", "]", "is", "an", "aarch64_sve_ptrue_flag", "for", "it", ".", "PRED2", "[", "0", "]", "is", "the", "predicate", "for", "the", "instruction", "whose", "result", "is", "tested", "by", "the", "PTEST", "and", "PRED2", "[", "1", "]", "is", "again", "an", "aarch64_sve_ptrue_flag", "for", "it", ".", "Return", "true", "if", "we", "can", "prove", "that", "the", "two", "predicates", "are", "equivalent", "for", "PTEST", "purposes", ";", "that", "is", ",", "if", "we", "can", "replace", "PRED2", "[", "0", "]", "with", "PRED1", "[", "0", "]", "without", "changing", "behavior", "." ]

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

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "auto", "*", "ZII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", ";", "assert", "(", "MBBI", "->", "isReturn", "(", ")", "&&", "\"Can only insert epilogue into returning blocks\"", ")", ";", "uint64_t", "StackSize", "=", "MFFrame", ".", "getStackSize", "(", ")", ";", "if", "(", "ZFI", "->", "getRestoreGPRRegs", "(", ")", ".", "LowGPR", ")", "{", "--", "MBBI", ";", "unsigned", "Opcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "!=", "SystemZ", "::", "LMG", ")", "llvm_unreachable", "(", "\"Expected to see callee-save register restore code\"", ")", ";", "unsigned", "AddrOpNo", "=", "2", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Offset", "=", "StackSize", "+", "MBBI", "->", "getOperand", "(", "AddrOpNo", "+", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NewOpcode", "=", "ZII", "->", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "if", "(", "!", "NewOpcode", ")", "{", "uint64_t", "NumBytes", "=", "Offset", "-", "0x7fff8", ";", "emitIncrement", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MBBI", "->", "getOperand", "(", "AddrOpNo", ")", ".", "getReg", "(", ")", ",", "NumBytes", ",", "ZII", ")", ";", "Offset", "-=", "NumBytes", ";", "NewOpcode", "=", "ZII", "->", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "assert", "(", "NewOpcode", "&&", "\"No restore instruction available\"", ")", ";", "}", "MBBI", "->", "setDesc", "(", "ZII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MBBI", "->", "getOperand", "(", "AddrOpNo", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "if", "(", "StackSize", ")", "{", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "emitIncrement", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SystemZ", "::", "R15D", ",", "StackSize", ",", "ZII", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "\"Can only insert epilogue into returning blocks\"", "SystemZ::LMG", "\"Expected to see callee-save register restore code\"", "2", "1", "0x7fff8", "\"No restore instruction available\"", "1", "SystemZ::R15D" ]

[]

[ "<s>", "rtx", "microblaze_return_addr", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "get_hard_reg_initial_val", "(", "Pmode", ",", "MB_ABI_SUB_RETURN_ADDR_REGNUM", ")", ",", "GEN_INT", "(", "8", ")", ")", ";", "}", "</s>" ]

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

[ "microblaze", "0", "8" ]

[]

[ "<s>", "bool", "xstormy16_splittable_below100_operand", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "MEM_P", "(", "x", ")", "&&", "MEM_VOLATILE_P", "(", "x", ")", ")", "return", "0", ";", "return", "xstormy16_below100_operand", "(", "x", ",", "mode", ")", ";", "}", "</s>" ]

[ "Likewise", ",", "but", "only", "for", "non-volatile", "MEMs", ",", "for", "patterns", "where", "the", "MEM", "will", "get", "split", "into", "smaller", "sized", "accesses", "." ]

[ "stormy16", "0" ]

[]

[ "<s>", "static", "machine_mode", "pa_promote_function_mode", "(", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", "ATTRIBUTE_UNUSED", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "for_return", ")", "{", "if", "(", "for_return", "==", "0", ")", "return", "mode", ";", "return", "promote_mode", "(", "type", ",", "mode", ",", "punsignedp", ")", ";", "}", "</s>" ]

[ "Promote", "the", "return", "value", ",", "but", "not", "the", "arguments", "." ]

[ "pa", "0" ]

[]

[ "<s>", "static", "void", "dump_swap_insn_table", "(", "swap_web_entry", "*", "insn_entry", ")", "{", "int", "e", "=", "get_max_uid", "(", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\nRelevant insns with their flag settings\\n\\n\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "e", ";", "++", "i", ")", "if", "(", "insn_entry", "[", "i", "]", ".", "is_relevant", ")", "{", "swap_web_entry", "*", "pred_entry", "=", "(", "swap_web_entry", "*", ")", "insn_entry", "[", "i", "]", ".", "pred", "(", ")", ";", "fprintf", "(", "dump_file", ",", "\"%6d %6d \"", ",", "i", ",", "pred_entry", "&&", "pred_entry", "->", "insn", "?", "INSN_UID", "(", "pred_entry", "->", "insn", ")", ":", "0", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "is_load", ")", "fputs", "(", "\"load \"", ",", "dump_file", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "is_store", ")", "fputs", "(", "\"store \"", ",", "dump_file", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "is_swap", ")", "fputs", "(", "\"swap \"", ",", "dump_file", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "is_live_in", ")", "fputs", "(", "\"live-in \"", ",", "dump_file", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "is_live_out", ")", "fputs", "(", "\"live-out \"", ",", "dump_file", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "contains_subreg", ")", "fputs", "(", "\"subreg \"", ",", "dump_file", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "is_128_int", ")", "fputs", "(", "\"int128 \"", ",", "dump_file", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "is_call", ")", "fputs", "(", "\"call \"", ",", "dump_file", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "is_swappable", ")", "{", "fputs", "(", "\"swappable \"", ",", "dump_file", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "special_handling", "==", "SH_CONST_VECTOR", ")", "fputs", "(", "\"special:constvec \"", ",", "dump_file", ")", ";", "else", "if", "(", "insn_entry", "[", "i", "]", ".", "special_handling", "==", "SH_SUBREG", ")", "fputs", "(", "\"special:subreg \"", ",", "dump_file", ")", ";", "else", "if", "(", "insn_entry", "[", "i", "]", ".", "special_handling", "==", "SH_NOSWAP_LD", ")", "fputs", "(", "\"special:load \"", ",", "dump_file", ")", ";", "else", "if", "(", "insn_entry", "[", "i", "]", ".", "special_handling", "==", "SH_NOSWAP_ST", ")", "fputs", "(", "\"special:store \"", ",", "dump_file", ")", ";", "else", "if", "(", "insn_entry", "[", "i", "]", ".", "special_handling", "==", "SH_EXTRACT", ")", "fputs", "(", "\"special:extract \"", ",", "dump_file", ")", ";", "else", "if", "(", "insn_entry", "[", "i", "]", ".", "special_handling", "==", "SH_SPLAT", ")", "fputs", "(", "\"special:splat \"", ",", "dump_file", ")", ";", "else", "if", "(", "insn_entry", "[", "i", "]", ".", "special_handling", "==", "SH_XXPERMDI", ")", "fputs", "(", "\"special:xxpermdi \"", ",", "dump_file", ")", ";", "else", "if", "(", "insn_entry", "[", "i", "]", ".", "special_handling", "==", "SH_CONCAT", ")", "fputs", "(", "\"special:concat \"", ",", "dump_file", ")", ";", "else", "if", "(", "insn_entry", "[", "i", "]", ".", "special_handling", "==", "SH_VPERM", ")", "fputs", "(", "\"special:vperm \"", ",", "dump_file", ")", ";", "}", "if", "(", "insn_entry", "[", "i", "]", ".", "web_not_optimizable", ")", "fputs", "(", "\"unoptimizable \"", ",", "dump_file", ")", ";", "if", "(", "insn_entry", "[", "i", "]", ".", "will_delete", ")", "fputs", "(", "\"delete \"", ",", "dump_file", ")", ";", "fputs", "(", "\"\\n\"", ",", "dump_file", ")", ";", "}", "fputs", "(", "\"\\n\"", ",", "dump_file", ")", ";", "}", "</s>" ]

[ "Dump", "the", "swap", "table", "to", "DUMP_FILE", "." ]

[ "rs6000", "\"\\nRelevant insns with their flag settings\\n\\n\"", "0", "\"%6d %6d \"", "0", "\"load \"", "\"store \"", "\"swap \"", "\"live-in \"", "\"live-out \"", "\"subreg \"", "\"int128 \"", "\"call \"", "\"swappable \"", "\"special:constvec \"", "\"special:subreg \"", "\"special:load \"", "\"special:store \"", "\"special:extract \"", "\"special:splat \"", "\"special:xxpermdi \"", "\"special:concat \"", "\"special:vperm \"", "\"unoptimizable \"", "\"delete \"", "\"\\n\"", "\"\\n\"" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "RealignStack", ")", "return", "false", ";", "if", "(", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MRI", "->", "canReserveReg", "(", "FramePtr", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "true", ";", "if", "(", "!", "EnableBasePointer", ")", "return", "false", ";", "return", "MRI", "->", "canReserveReg", "(", "BasePtr", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", ")", "{", "timevar_push", "(", "TV_MACH_DEP", ")", ";", "rest_of_insert_endbr_and_patchable_area", "(", "need_endbr", ",", "patchable_area_size", ")", ";", "timevar_pop", "(", "TV_MACH_DEP", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "lowerCRSpilling", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "unsigned", "FrameIndex", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "(", "void", ")", "SPAdj", ";", "(", "void", ")", "RS", ";", "bool", "LP64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "unsigned", "Reg", "=", "Subtarget", ".", "isDarwinABI", "(", ")", "?", "(", "LP64", "?", "PPC", "::", "X2", ":", "PPC", "::", "R2", ")", ":", "(", "LP64", "?", "PPC", "::", "X0", ":", "PPC", "::", "R0", ")", ";", "unsigned", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "MFCR8pseud", ":", "PPC", "::", "MFCRpseud", ")", ",", "Reg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isKill", "(", ")", ")", ")", ";", "if", "(", "SrcReg", "!=", "PPC", "::", "CR0", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "RLWINM8", ":", "PPC", "::", "RLWINM", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "getPPCRegisterNumbering", "(", "SrcReg", ")", "*", "4", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "31", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "STW8", ":", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ")", ",", "FrameIndex", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "lowerCRSpilling", "-", "Generate", "the", "code", "for", "spilling", "a", "CR", "register", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::X2", "PPC::R2", "PPC::X0", "PPC::R0", "0", "PPC::MFCR8pseud", "PPC::MFCRpseud", "0", "PPC::CR0", "PPC::RLWINM8", "PPC::RLWINM", "PPC", "4", "0", "31", "PPC::STW8", "PPC::STW", "1" ]

[]

[ "<s>", "void", "RISCVTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "assert", "(", "(", "Opc", ">=", "ISD", "::", "BUILTIN_OP_END", "||", "Opc", "==", "ISD", "::", "INTRINSIC_WO_CHAIN", "||", "Opc", "==", "ISD", "::", "INTRINSIC_W_CHAIN", "||", "Opc", "==", "ISD", "::", "INTRINSIC_VOID", ")", "&&", "\"Should use MaskedValueIsZero if you don't know whether Op\"", "\" is a target node!\"", ")", ";", "Known", ".", "resetAll", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "RISCVISD", "::", "REMUW", ":", "{", "KnownBits", "Known2", ";", "Known", "=", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "DemandedElts", ",", "Depth", "+", "1", ")", ";", "Known2", "=", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "DemandedElts", ",", "Depth", "+", "1", ")", ";", "Known", "=", "KnownBits", "::", "urem", "(", "Known", ".", "trunc", "(", "32", ")", ",", "Known2", ".", "trunc", "(", "32", ")", ")", ";", "Known", "=", "Known", ".", "sext", "(", "BitWidth", ")", ";", "break", ";", "}", "case", "RISCVISD", "::", "DIVUW", ":", "{", "KnownBits", "Known2", ";", "Known", "=", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "DemandedElts", ",", "Depth", "+", "1", ")", ";", "Known2", "=", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "DemandedElts", ",", "Depth", "+", "1", ")", ";", "Known", "=", "KnownBits", "::", "udiv", "(", "Known", ".", "trunc", "(", "32", ")", ",", "Known2", ".", "trunc", "(", "32", ")", ")", ";", "Known", "=", "Known", ".", "sext", "(", "BitWidth", ")", ";", "break", ";", "}", "case", "RISCVISD", "::", "READ_VLENB", ":", "Known", ".", "Zero", ".", "setLowBits", "(", "3", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "RISCV", "RISCV", "ISD::BUILTIN_OP_END", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_VOID", "\"Should use MaskedValueIsZero if you don't know whether Op\"", "\" is a target node!\"", "RISCVISD::REMUW", "0", "1", "1", "1", "32", "32", "RISCVISD::DIVUW", "0", "1", "1", "1", "32", "32", "RISCVISD::READ_VLENB", "3" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createAMDGPUPeepholeOpt", "(", "*", "TM", ")", ")", ";", "addPass", "(", "createAMDGPUISelDag", "(", "getAMDGPUTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "HOST_WIDE_INT", "bfin_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "HOST_WIDE_INT", "offset", "=", "0", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", ")", "offset", "=", "n_regs_saved_by_prologue", "(", ")", "*", "4", ";", "if", "(", "to", "==", "STACK_POINTER_REGNUM", ")", "{", "if", "(", "current_function_outgoing_args_size", ">=", "FIXED_STACK_AREA", ")", "offset", "+=", "current_function_outgoing_args_size", ";", "else", "if", "(", "current_function_outgoing_args_size", ")", "offset", "+=", "FIXED_STACK_AREA", ";", "offset", "+=", "get_frame_size", "(", ")", ";", "}", "return", "offset", ";", "}", "</s>" ]

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

[ "bfin", "0", "4" ]

[]

[ "<s>", "static", "const", "char", "*", "rs6000_xcoff_strip_name_encoding", "(", "const", "char", "*", "name", ")", "{", "size_t", "len", ";", "if", "(", "*", "name", "==", "'*'", ")", "name", "++", ";", "len", "=", "strlen", "(", "name", ")", ";", "if", "(", "name", "[", "len", "-", "1", "]", "==", "']'", ")", "return", "ggc_alloc_string", "(", "name", ",", "len", "-", "4", ")", ";", "else", "return", "name", ";", "}", "</s>" ]

[ "Remove", "any", "trailing", "[", "DS", "]", "or", "the", "like", "from", "the", "symbol", "name", "." ]

[ "powerpcspe", "1", "4" ]

[]

[ "<s>", "static", "void", "rs6000_debug_reg_print", "(", "int", "first_regno", ",", "int", "last_regno", ",", "const", "char", "*", "reg_name", ")", "{", "int", "r", ",", "m", ";", "for", "(", "r", "=", "first_regno", ";", "r", "<=", "last_regno", ";", "++", "r", ")", "{", "const", "char", "*", "comma", "=", "\"\"", ";", "int", "len", ";", "if", "(", "first_regno", "==", "last_regno", ")", "fprintf", "(", "stderr", ",", "\"%s:\\t\"", ",", "reg_name", ")", ";", "else", "fprintf", "(", "stderr", ",", "\"%s%d:\\t\"", ",", "reg_name", ",", "r", "-", "first_regno", ")", ";", "len", "=", "8", ";", "for", "(", "m", "=", "0", ";", "m", "<", "NUM_MACHINE_MODES", ";", "++", "m", ")", "if", "(", "rs6000_hard_regno_mode_ok_p", "[", "m", "]", "[", "r", "]", "&&", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "r", "]", ")", "{", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "len", "=", "8", ";", "comma", "=", "\"\"", ";", "}", "if", "(", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "r", "]", ">", "1", ")", "len", "+=", "fprintf", "(", "stderr", ",", "\"%s%s/%d\"", ",", "comma", ",", "GET_MODE_NAME", "(", "m", ")", ",", "rs6000_hard_regno_nregs", "[", "m", "]", "[", "r", "]", ")", ";", "else", "len", "+=", "fprintf", "(", "stderr", ",", "\"%s%s\"", ",", "comma", ",", "GET_MODE_NAME", "(", "m", ")", ")", ";", "comma", "=", "\", \"", ";", "}", "if", "(", "call_used_or_fixed_reg_p", "(", "r", ")", ")", "{", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "len", "=", "8", ";", "comma", "=", "\"\"", ";", "}", "len", "+=", "fprintf", "(", "stderr", ",", "\"%s%s\"", ",", "comma", ",", "\"call-used\"", ")", ";", "comma", "=", "\", \"", ";", "}", "if", "(", "fixed_regs", "[", "r", "]", ")", "{", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "len", "=", "8", ";", "comma", "=", "\"\"", ";", "}", "len", "+=", "fprintf", "(", "stderr", ",", "\"%s%s\"", ",", "comma", ",", "\"fixed\"", ")", ";", "comma", "=", "\", \"", ";", "}", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "comma", "=", "\"\"", ";", "}", "len", "+=", "fprintf", "(", "stderr", ",", "\"%sreg-class = %s\"", ",", "comma", ",", "reg_class_names", "[", "(", "int", ")", "rs6000_regno_regclass", "[", "r", "]", "]", ")", ";", "comma", "=", "\", \"", ";", "if", "(", "len", ">", "70", ")", "{", "fprintf", "(", "stderr", ",", "\",\\n\\t\"", ")", ";", "comma", "=", "\"\"", ";", "}", "fprintf", "(", "stderr", ",", "\"%sregno = %d\\n\"", ",", "comma", ",", "r", ")", ";", "}", "}", "</s>" ]

[ "Print", "interesting", "facts", "about", "registers", "." ]

[ "rs6000", "\"\"", "\"%s:\\t\"", "\"%s%d:\\t\"", "8", "0", "70", "\",\\n\\t\"", "8", "\"\"", "1", "\"%s%s/%d\"", "\"%s%s\"", "\", \"", "70", "\",\\n\\t\"", "8", "\"\"", "\"%s%s\"", "\"call-used\"", "\", \"", "70", "\",\\n\\t\"", "8", "\"\"", "\"%s%s\"", "\"fixed\"", "\", \"", "70", "\",\\n\\t\"", "\"\"", "\"%sreg-class = %s\"", "\", \"", "70", "\",\\n\\t\"", "\"\"", "\"%sregno = %d\\n\"" ]

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "const", "auto", "&", "NonLibcallCSI", "=", "getNonLibcallCSI", "(", "*", "MF", ",", "CSI", ")", ";", "for", "(", "auto", "&", "CS", ":", "reverse", "(", "NonLibcallCSI", ")", ")", "{", "Register", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CS", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "}", "const", "char", "*", "RestoreLibCall", "=", "getRestoreLibCallName", "(", "*", "MF", ",", "CSI", ")", ";", "if", "(", "RestoreLibCall", ")", "{", "MachineBasicBlock", "::", "iterator", "NewMI", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "RISCV", "::", "PseudoTAIL", ")", ")", ".", "addExternalSymbol", "(", "RestoreLibCall", ",", "RISCVII", "::", "MO_CALL", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "MI", "->", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoRET", ")", "{", "NewMI", "->", "copyImplicitOps", "(", "*", "MF", ",", "*", "MI", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"loadRegFromStackSlot didn't insert any code!\"", "RISCV::PseudoTAIL", "RISCVII::MO_CALL", "RISCV::PseudoRET" ]

[]

[ "<s>", "void", "split_adds_subs", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "rtx", "reg", "=", "operands", "[", "0", "]", ";", "HOST_WIDE_INT", "sign", "=", "1", ";", "HOST_WIDE_INT", "amount", ";", "rtx", "(", "*", "gen_add", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "if", "(", "val", "<", "0", ")", "{", "val", "=", "-", "val", ";", "sign", "=", "-", "1", ";", "}", "switch", "(", "mode", ")", "{", "case", "HImode", ":", "gen_add", "=", "gen_addhi3", ";", "break", ";", "case", "SImode", ":", "gen_add", "=", "gen_addsi3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "for", "(", "amount", "=", "(", "TARGET_H8300H", "||", "TARGET_H8300S", ")", "?", "4", ":", "2", ";", "amount", ">", "0", ";", "amount", "/=", "2", ")", "{", "for", "(", ";", "val", ">=", "amount", ";", "val", "-=", "amount", ")", "emit_insn", "(", "gen_add", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "sign", "*", "amount", ")", ")", ")", ";", "}", "return", ";", "}", "</s>" ]

[ "Split", "an", "add", "of", "a", "small", "constant", "into", "two", "adds/subs", "insns", "." ]

[ "h8300", "1", "0", "1", "0", "1", "4", "2", "0", "2" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "DebugLoc", "dl", "=", "Old", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "\"This eliminateCallFramePseudoInstr does not suppor Thumb1!\"", ")", ";", "bool", "isARM", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", ";", "unsigned", "Opc", "=", "Old", "->", "getOpcode", "(", ")", ";", "ARMCC", "::", "CondCodes", "Pred", "=", "(", "ARMCC", "::", "CondCodes", ")", "Old", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKDOWN", ")", "{", "unsigned", "PredReg", "=", "Old", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "I", ",", "dl", ",", "TII", ",", "-", "Amount", ",", "Pred", ",", "PredReg", ")", ";", "}", "else", "{", "unsigned", "PredReg", "=", "Old", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "assert", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "I", ",", "dl", ",", "TII", ",", "Amount", ",", "Pred", ",", "PredReg", ")", ";", "}", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "0", "1", "ARM", "ARM", "\"This eliminateCallFramePseudoInstr does not suppor Thumb1!\"", "ARM", "ARMCC::CondCodes", "ARMCC::CondCodes", "1", "ARM::ADJCALLSTACKDOWN", "ARM::tADJCALLSTACKDOWN", "2", "ARM", "3", "ARM::ADJCALLSTACKUP", "ARM::tADJCALLSTACKUP", "ARM" ]

[]

[ "<s>", "StringRef", "R600ClauseMergePass", "::", "getPassName", "(", ")", "const", "{", "return", "\"R600 Merge Clause Markers Pass\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "\"R600 Merge Clause Markers Pass\"" ]

[]

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

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

[ "OR1K", "OR1K" ]

[]

[ "<s>", "const", "uint32_t", "*", "PPCRegisterInfo", "::", "getNoPreservedMask", "(", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_NoRegs_Altivec_RegMask", ";", "if", "(", "Subtarget", ".", "isDarwin", "(", ")", ")", "return", "CSR_NoRegs_Darwin_RegMask", ";", "return", "CSR_NoRegs_RegMask", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "BTFTypeFwd", "::", "BTFTypeFwd", "(", "StringRef", "Name", ",", "bool", "IsUnion", ")", ":", "Name", "(", "Name", ")", "{", "Kind", "=", "BTF", "::", "BTF_KIND_FWD", ";", "BTFType", ".", "Info", "=", "IsUnion", "<<", "31", "|", "Kind", "<<", "24", ";", "BTFType", ".", "Type", "=", "0", ";", "}", "</s>" ]

[ "Represent", "a", "struct/union", "forward", "declaration", "." ]

[ "BPF", "BTFTypeFwd::BTFTypeFwd", "BTF::BTF_KIND_FWD", "31", "24", "0" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "useLoadStackGuardNode", "(", ")", "const", "{", "return", "Subtarget", "->", "isTargetMachO", "(", ")", ";", "}", "</s>" ]

[ "If", "this", "function", "returns", "true", ",", "SelectionDAGBuilder", "emits", "a", "LOAD_STACK_GUARD", "node", "when", "it", "is", "lowering", "Intrinsic", ":", ":stackprotector", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "CJG", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_CJG_NONE\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_CJG_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", "." ]

[ "CJG", "CJG::NumTargetFixupKinds", "\"fixup_CJG_NONE\"", "0", "32", "0", "\"fixup_CJG_32\"", "0", "32", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "unsigned", "XCoreInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "int", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "XCore", "::", "LDWFI", ")", "{", "if", "(", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "XCore", "XCore", "XCore::LDWFI", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "bool", "DLXInstrInfo", "::", "analyzeSelect", "(", "const", "MachineInstr", "&", "MI", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "unsigned", "&", "TrueOp", ",", "unsigned", "&", "FalseOp", ",", "bool", "&", "Optimizable", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Analyze", "the", "given", "select", "instruction", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "." ]

[ "DLX", "DLX" ]

[]

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

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

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

[]

[ "<s>", "void", "MBlazeInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "dl", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "MBlaze", "::", "SWI", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze::SWI", "0" ]

[]

[ "<s>", "void", "tilepro_emit_conditional_branch", "(", "rtx", "operands", "[", "]", ",", "machine_mode", "cmp_mode", ")", "{", "rtx", "cmp_rtx", "=", "tilepro_emit_cc_test", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ",", "cmp_mode", ",", "false", ")", ";", "rtx", "branch_rtx", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cmp_rtx", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "operands", "[", "3", "]", ")", ",", "pc_rtx", ")", ")", ";", "emit_jump_insn", "(", "branch_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "the", "comparison", "for", "a", "conditional", "branch", "." ]

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

[]

[ "<s>", "bool", "SITargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Align", ",", "bool", "*", "IsFast", ")", "const", "{", "if", "(", "IsFast", ")", "*", "IsFast", "=", "false", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", "||", "VT", "==", "MVT", "::", "Other", ")", "return", "false", ";", "if", "(", "AddrSpace", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "{", "return", "Align", "%", "4", "==", "0", ";", "}", "if", "(", "VT", ".", "bitsLT", "(", "MVT", "::", "i32", ")", ")", "return", "false", ";", "if", "(", "IsFast", ")", "*", "IsFast", "=", "true", ";", "return", "VT", ".", "bitsGT", "(", "MVT", "::", "i32", ")", "&&", "Align", "%", "4", "==", "0", ";", "}", "</s>" ]

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

[ "R600", "SI", "MVT::Other", "AMDGPUAS::LOCAL_ADDRESS", "4", "0", "MVT::i32", "MVT::i32", "4", "0" ]

[]

[ "<s>", "rtx", "rs6000_force_indexed_or_indirect_mem", "(", "rtx", "x", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", "&&", "!", "indexed_or_indirect_operand", "(", "x", ",", "mode", ")", ")", "{", "rtx", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", ")", "{", "rtx", "reg", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "HOST_WIDE_INT", "size", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ";", "rtx", "size_rtx", "=", "GEN_INT", "(", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", ")", "?", "-", "size", ":", "size", ")", ";", "gcc_assert", "(", "REG_P", "(", "reg", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "reg", ",", "reg", ",", "size_rtx", ")", ")", ";", "addr", "=", "reg", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_MODIFY", ")", "{", "rtx", "reg", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "expr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "REG_P", "(", "reg", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "expr", ")", "==", "PLUS", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "reg", ",", "XEXP", "(", "expr", ",", "0", ")", ",", "XEXP", "(", "expr", ",", "1", ")", ")", ")", ";", "addr", "=", "reg", ";", "}", "x", "=", "replace_equiv_address", "(", "x", ",", "force_reg", "(", "Pmode", ",", "addr", ")", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Given", "a", "memory", "reference", ",", "if", "it", "is", "not", "a", "reg", "or", "reg+reg", "addressing", ",", "convert", "to", "such", "a", "form", "to", "deal", "with", "memory", "reference", "instructions", "like", "STFIWX", "and", "LDBRX", "that", "only", "take", "reg+reg", "addressing", "." ]

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

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "Start", ";", "}", "</s>" ]

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

[ "AVR" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "return", "false", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "bool", "CR2Spilled", "=", "false", ";", "bool", "CR3Spilled", "=", "false", ";", "bool", "CR4Spilled", "=", "false", ";", "unsigned", "CSIIndex", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ",", "BeforeI", "=", "I", ";", "bool", "AtStart", "=", "I", "==", "MBB", ".", "begin", "(", ")", ";", "if", "(", "!", "AtStart", ")", "--", "BeforeI", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "PPC", "::", "VRSAVE", "&&", "!", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "continue", ";", "if", "(", "Reg", "==", "PPC", "::", "CR2", ")", "{", "CR2Spilled", "=", "true", ";", "CSIIndex", "=", "i", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR3", ")", "{", "CR3Spilled", "=", "true", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR4", ")", "{", "CR4Spilled", "=", "true", ";", "continue", ";", "}", "else", "{", "if", "(", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "&&", "!", "(", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", ")", "{", "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "is31", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "CR2Spilled", "=", "CR3Spilled", "=", "CR4Spilled", "=", "false", ";", "}", "if", "(", "CSI", "[", "i", "]", ".", "isSpilledToReg", "(", ")", ")", "{", "DebugLoc", "DL", ";", "NumPEReloadVSR", "++", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "MFVSRD", ")", ",", "Reg", ")", ".", "addReg", "(", "CSI", "[", "i", "]", ".", "getDstReg", "(", ")", ",", "getKillRegState", "(", "true", ")", ")", ";", "}", "else", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "}", "}", "if", "(", "AtStart", ")", "I", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "I", "=", "BeforeI", ";", "++", "I", ";", "}", "}", "if", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "{", "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "is31", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "0", "0", "PPC::VRSAVE", "PPC::CR2", "PPC::CR3", "PPC::CR4", "PPC::CR2", "PPC::CR4", "PPC", "PPC::MFVSRD", "\"loadRegFromStackSlot didn't insert any code!\"", "PPC" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "{", "return", "Kind", "==", "k_Register", "&&", "!", "Reg", ".", "isVector", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "ARM64" ]

[]

[ "<s>", "void", "RISCVRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected non-zero SPAdj value\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "RISCVInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "VSE_V_um", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "VLE_V_um", ")", "{", "Offset", "=", "getFrameLowering", "(", "MF", ")", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ";", "}", "else", "Offset", "=", "getFrameLowering", "(", "MF", ")", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "isInt", "<", "32", ">", "(", "Offset", ")", ")", "{", "report_fatal_error", "(", "\"Frame offsets outside of the signed 32-bit range not supported\"", ")", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "bool", "FrameRegIsKill", "=", "false", ";", "if", "(", "!", "isInt", "<", "12", ">", "(", "Offset", ")", ")", "{", "assert", "(", "isInt", "<", "32", ">", "(", "Offset", ")", "&&", "\"Int32 expected\"", ")", ";", "Register", "ScratchReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "RISCV", "::", "GPRRegClass", ")", ";", "TII", "->", "movImm", "(", "MBB", ",", "II", ",", "DL", ",", "ScratchReg", ",", "Offset", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", "->", "get", "(", "RISCV", "::", "ADD", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Kill", ")", ";", "Offset", "=", "0", ";", "FrameReg", "=", "ScratchReg", ";", "FrameRegIsKill", "=", "true", ";", "}", "if", "(", "(", "Offset", "!=", "0", ")", "&&", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "VSE_V_um", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "VLE_V_um", ")", ")", "{", "unsigned", "ScratchReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "RISCV", "::", "GPRRegClass", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", "->", "get", "(", "RISCV", "::", "ADDI", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "FrameReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Offset", ")", ";", "Offset", "=", "0", ";", "FrameReg", "=", "ScratchReg", ";", "FrameRegIsKill", "=", "true", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "VSE_V_um", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "VLE_V_um", ")", "{", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ",", "false", ",", "FrameRegIsKill", ")", ";", "}", "else", "{", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ",", "false", ",", "FrameRegIsKill", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "\"Unexpected non-zero SPAdj value\"", "RISCV", "RISCV", "RISCV::VSE_V_um", "RISCV::VLE_V_um", "1", "32", "\"Frame offsets outside of the signed 32-bit range not supported\"", "12", "32", "\"Int32 expected\"", "RISCV::GPRRegClass", "RISCV::ADD", "0", "0", "RISCV::VSE_V_um", "RISCV::VLE_V_um", "RISCV::GPRRegClass", "RISCV::ADDI", "0", "RISCV::VSE_V_um", "RISCV::VLE_V_um", "1" ]

[]

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

[ "Return", "the", "value", "of", "the", "return", "address", "for", "the", "frame", "COUNT", "steps", "up", "from", "the", "current", "frame", ",", "after", "the", "prologue", ".", "We", "punt", "for", "everything", "but", "the", "current", "frame", "by", "returning", "const0_rtx", "." ]

[ "c6x", "0" ]

[]

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

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

[ "DLX", "\"DLX Delay Slot Filler\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "MSP430FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "uint64_t", "Amount", "=", "Old", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "nullptr", ";", "if", "(", "Old", ".", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", ".", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "uint64_t", "CalleeAmt", "=", "Old", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "0", "0", "1", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "1", "MSP430::ADD16ri", "MSP430::SP", "MSP430::SP", "3", "1", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "3" ]

[]

[ "<s>", "bool", "PatmosAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "MCInst", "MCI", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "MCI", ")", ";", "PatmosInstPrinter", "PIP", "(", "*", "OutContext", ".", "getAsmInfo", "(", ")", ",", "*", "TM", ".", "getInstrInfo", "(", ")", ",", "*", "TM", ".", "getRegisterInfo", "(", ")", ")", ";", "PIP", ".", "printOperand", "(", "&", "MCI", ",", "OpNo", ",", "O", ",", "ExtraCode", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "0", "Patmos" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "HSAILInstrInfo", "::", "getOpRegClass", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNo", ")", "const", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "nullptr", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Reg", ")", ")", "return", "MRI", ".", "getRegClass", "(", "Reg", ")", ";", "return", "RI", ".", "getPhysRegClass", "(", "Reg", ")", ";", "}", "</s>" ]

[ "Return", "the", "correct", "register", "class", "for", "OpNo", "." ]

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "IsDesirableToPromoteOp", "(", "SDValue", "Op", ",", "EVT", "&", "PVT", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", "!=", "MVT", "::", "i16", ")", "return", "false", ";", "bool", "Promote", "=", "false", ";", "bool", "Commute", "=", "false", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "Promote", "=", "true", ";", "break", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "{", "SDValue", "N0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "if", "(", "MayFoldLoad", "(", "N0", ")", "&&", "MayFoldIntoStore", "(", "Op", ")", ")", "return", "false", ";", "Promote", "=", "true", ";", "break", ";", "}", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "Commute", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "ISD", "::", "SUB", ":", "{", "SDValue", "N0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "Op", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "Commute", "&&", "MayFoldLoad", "(", "N1", ")", ")", "return", "false", ";", "if", "(", "MayFoldLoad", "(", "N0", ")", "&&", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "N1", ")", "||", "MayFoldIntoStore", "(", "Op", ")", ")", ")", "return", "false", ";", "if", "(", "MayFoldLoad", "(", "N1", ")", "&&", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "N0", ")", "||", "MayFoldIntoStore", "(", "Op", ")", ")", ")", "return", "false", ";", "Promote", "=", "true", ";", "}", "}", "PVT", "=", "MVT", "::", "i32", ";", "return", "Promote", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "native", "support", "for", "the", "specified", "value", "type", "and", "it", "is", "'desirable", "'", "to", "use", "the", "type", "." ]

[ "X86", "X86", "MVT::i16", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "ISD::SHL", "ISD::SRL", "0", "ISD::ADD", "ISD::MUL", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::SUB", "0", "1", "MVT::i32" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "if", "(", "!", "mnemonicIsValid", "(", "Name", ",", "0", ")", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "NameLoc", ",", "\"Unknown instruction\"", ")", ";", "}", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "ParseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "\"Unknown instruction\"", "MipsOperand::CreateToken", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "bool", "TL45FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "TL45", "TL45" ]

[]

[ "<s>", "static", "tree", "visium_build_builtin_va_list", "(", "void", ")", "{", "tree", "f_ovfl", ",", "f_gbase", ",", "f_fbase", ",", "f_gbytes", ",", "f_fbytes", ",", "record", ";", "record", "=", "(", "*", "lang_hooks", ".", "types", ".", "make_type", ")", "(", "RECORD_TYPE", ")", ";", "f_ovfl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__overflow_argptr\"", ")", ",", "ptr_type_node", ")", ";", "f_gbase", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__gpr_base\"", ")", ",", "ptr_type_node", ")", ";", "f_fbase", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__fpr_base\"", ")", ",", "ptr_type_node", ")", ";", "f_gbytes", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__gpr_bytes\"", ")", ",", "short_unsigned_type_node", ")", ";", "f_fbytes", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__fpr_bytes\"", ")", ",", "short_unsigned_type_node", ")", ";", "DECL_FIELD_CONTEXT", "(", "f_ovfl", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_gbase", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_fbase", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_gbytes", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_fbytes", ")", "=", "record", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_ovfl", ";", "TREE_CHAIN", "(", "f_ovfl", ")", "=", "f_gbase", ";", "TREE_CHAIN", "(", "f_gbase", ")", "=", "f_fbase", ";", "TREE_CHAIN", "(", "f_fbase", ")", "=", "f_gbytes", ";", "TREE_CHAIN", "(", "f_gbytes", ")", "=", "f_fbytes", ";", "layout_type", "(", "record", ")", ";", "return", "record", ";", "}", "</s>" ]

[ "Define", "the", "`", "__builtin_va_list", "'", "type", "for", "the", "ABI", "." ]

[ "visium", "\"__overflow_argptr\"", "\"__gpr_base\"", "\"__fpr_base\"", "\"__gpr_bytes\"", "\"__fpr_bytes\"" ]

[]

[ "<s>", "bool", "RISCVCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ")", "const", "{", "MachineInstrBuilder", "Ret", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "RISCV", "::", "PseudoRET", ")", ";", "if", "(", "Val", "!=", "nullptr", ")", "{", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::PseudoRET" ]

[]

[ "<s>", "bool", "m32c_illegal_subreg_p", "(", "rtx", "op", ")", "{", "int", "offset", ";", "unsigned", "int", "i", ";", "machine_mode", "src_mode", ",", "dest_mode", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", "&&", "!", "m32c_legitimate_address_p", "(", "Pmode", ",", "XEXP", "(", "op", ",", "0", ")", ",", "false", ")", ")", "{", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "op", ")", "!=", "SUBREG", ")", "return", "false", ";", "dest_mode", "=", "GET_MODE", "(", "op", ")", ";", "offset", "=", "SUBREG_BYTE", "(", "op", ")", ";", "op", "=", "SUBREG_REG", "(", "op", ")", ";", "src_mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "dest_mode", ")", "==", "GET_MODE_SIZE", "(", "src_mode", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "REG", ")", "return", "false", ";", "if", "(", "REGNO", "(", "op", ")", ">=", "MEM0_REGNO", ")", "return", "false", ";", "offset", "=", "(", "1", "<<", "offset", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "legal_subregs", ")", ";", "i", "++", ")", "if", "(", "legal_subregs", "[", "i", "]", ".", "outer_mode_size", "==", "GET_MODE_SIZE", "(", "dest_mode", ")", "&&", "legal_subregs", "[", "i", "]", ".", "regno", "==", "REGNO", "(", "op", ")", "&&", "legal_subregs", "[", "i", "]", ".", "inner_mode_size", "==", "GET_MODE_SIZE", "(", "src_mode", ")", "&&", "legal_subregs", "[", "i", "]", ".", "byte_mask", "&", "offset", ")", "{", "switch", "(", "legal_subregs", "[", "i", "]", ".", "legal_when", ")", "{", "case", "1", ":", "return", "false", ";", "case", "16", ":", "if", "(", "TARGET_A16", ")", "return", "false", ";", "break", ";", "case", "24", ":", "if", "(", "TARGET_A24", ")", "return", "false", ";", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "OP", "is", "a", "subreg", "of", "a", "hard", "reg", "which", "we", "do", "n't", "support", ".", "We", "also", "bail", "on", "MEMs", "with", "illegal", "addresses", "." ]

[ "m32c", "0", "1", "0", "1", "16", "24" ]

[]

[ "<s>", "const", "MCSymbol", "*", "MOSAsmPrinter", "::", "getFunctionFrameSymbol", "(", "int", "FI", ")", "const", "{", "if", "(", "MF", "->", "getFrameInfo", "(", ")", ".", "getStackID", "(", "FI", ")", "==", "TargetStackID", "::", "NoAlloc", ")", "{", "MOSFunctionInfo", "&", "MFI", "=", "*", "MF", "->", "getInfo", "<", "MOSFunctionInfo", ">", "(", ")", ";", "return", "getSymbol", "(", "MFI", ".", "getStaticStackVariable", "(", ")", ")", ";", "}", "return", "AsmPrinter", "::", "getFunctionFrameSymbol", "(", "FI", ")", ";", "}", "</s>" ]

[ "Return", "symbol", "for", "the", "function", "pseudo", "stack", "if", "the", "stack", "frame", "is", "not", "a", "register", "based", "." ]

[ "MOS", "MOS", "MOS", "MOS" ]

[]

[ "<s>", "const", "WebAssemblySubtarget", "*", "WebAssemblyTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "resetTargetOptions", "(", "F", ")", ";", "return", "getSubtargetImpl", "(", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"target-cpu\"", "\"target-features\"" ]

[]

[ "<s>", "static", "rtx", "ix86_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "omode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "machine_mode", "mode", "=", "omode", ";", "HOST_WIDE_INT", "bytes", ",", "words", ";", "rtx", "arg", ";", "if", "(", "(", "type", "&&", "POINTER_BOUNDS_TYPE_P", "(", "type", ")", ")", "||", "POINTER_BOUNDS_MODE_P", "(", "mode", ")", ")", "{", "if", "(", "cum", "->", "bnds_in_bt", ")", "arg", "=", "NULL", ";", "else", "if", "(", "cum", "->", "bnd_regno", "<=", "LAST_BND_REG", ")", "arg", "=", "gen_rtx_REG", "(", "BNDmode", ",", "cum", "->", "bnd_regno", ")", ";", "else", "arg", "=", "GEN_INT", "(", "cum", "->", "bnd_regno", "-", "LAST_BND_REG", "-", "1", ")", ";", "return", "arg", ";", "}", "if", "(", "mode", "==", "BLKmode", ")", "bytes", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "bytes", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "words", "=", "(", "bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "mode", "=", "type_natural_mode", "(", "type", ",", "cum", ",", "false", ")", ";", "if", "(", "TARGET_64BIT", "&&", "(", "cum", "?", "cum", "->", "call_abi", ":", "ix86_abi", ")", "==", "MS_ABI", ")", "arg", "=", "function_arg_ms_64", "(", "cum", ",", "mode", ",", "omode", ",", "named", ",", "bytes", ")", ";", "else", "if", "(", "TARGET_64BIT", ")", "arg", "=", "function_arg_64", "(", "cum", ",", "mode", ",", "omode", ",", "type", ",", "named", ")", ";", "else", "arg", "=", "function_arg_32", "(", "cum", ",", "mode", ",", "omode", ",", "type", ",", "bytes", ",", "words", ")", ";", "return", "arg", ";", "}", "</s>" ]

[ "Return", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Return", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", ".", "It", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "gives", "information", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", "." ]

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

[]

[ "<s>", "static", "X86Operand", "*", "CreateReg", "(", "unsigned", "RegNo", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ")", "{", "X86Operand", "*", "Res", "=", "new", "X86Operand", "(", "Register", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "return", "Res", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "X86InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "assert", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIdx", ")", ">=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "&&", "\"Stack slot too small for store\"", ")", ";", "unsigned", "Alignment", "=", "std", "::", "max", "<", "uint32_t", ">", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ",", "16", ")", ";", "bool", "isAligned", "=", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "isAligned", ",", "Subtarget", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Stack slot too small for store\"", "16" ]

[]

[ "<s>", "void", "SPUTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "char", "ConstraintLetter", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "ConstraintLetter", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "const", "char", "*", "aarch64_output_probe_sve_stack_clash", "(", "rtx", "base", ",", "rtx", "adjustment", ",", "rtx", "min_probe_threshold", ",", "rtx", "guard_size", ")", "{", "gcc_assert", "(", "flag_stack_clash_protection", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "min_probe_threshold", ")", "&&", "CONST_INT_P", "(", "guard_size", ")", ")", ";", "gcc_assert", "(", "INTVAL", "(", "guard_size", ")", ">", "INTVAL", "(", "min_probe_threshold", ")", ")", ";", "HOST_WIDE_INT", "residual_probe_guard", "=", "INTVAL", "(", "min_probe_threshold", ")", ";", "residual_probe_guard", "=", "aarch64_clamp_to_uimm12_shift", "(", "residual_probe_guard", ")", ";", "rtx", "probe_offset_value_rtx", "=", "gen_int_mode", "(", "residual_probe_guard", ",", "Pmode", ")", ";", "gcc_assert", "(", "INTVAL", "(", "min_probe_threshold", ")", ">=", "residual_probe_guard", ")", ";", "gcc_assert", "(", "aarch64_uimm12_shift", "(", "residual_probe_guard", ")", ")", ";", "static", "int", "labelno", "=", "0", ";", "char", "loop_start_lab", "[", "32", "]", ";", "char", "loop_end_lab", "[", "32", "]", ";", "rtx", "xops", "[", "2", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_start_lab", ",", "\"SVLPSPL\"", ",", "labelno", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_end_lab", ",", "\"SVLPEND\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_start_lab", ")", ";", "xops", "[", "0", "]", "=", "adjustment", ";", "xops", "[", "1", "]", "=", "probe_offset_value_rtx", ";", "output_asm_insn", "(", "\"cmp\\t%0, %1\"", ",", "xops", ")", ";", "fputs", "(", "\"\\tb.lt\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_end_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "xops", "[", "0", "]", "=", "base", ";", "xops", "[", "1", "]", "=", "probe_offset_value_rtx", ";", "output_asm_insn", "(", "\"sub\\t%0, %0, %1\"", ",", "xops", ")", ";", "xops", "[", "1", "]", "=", "const0_rtx", ";", "output_asm_insn", "(", "\"str\\txzr, [%0, %1]\"", ",", "xops", ")", ";", "xops", "[", "0", "]", "=", "adjustment", ";", "xops", "[", "1", "]", "=", "probe_offset_value_rtx", ";", "output_asm_insn", "(", "\"sub\\t%0, %0, %1\"", ",", "xops", ")", ";", "fputs", "(", "\"\\tb\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_start_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_end_lab", ")", ";", "xops", "[", "0", "]", "=", "base", ";", "xops", "[", "1", "]", "=", "adjustment", ";", "output_asm_insn", "(", "\"sub\\t%0, %0, %1\"", ",", "xops", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Emit", "the", "probe", "loop", "for", "doing", "stack", "clash", "probes", "and", "stack", "adjustments", "for", "SVE", ".", "This", "emits", "probes", "from", "BASE", "to", "BASE", "-", "ADJUSTMENT", "based", "on", "a", "guard", "size", "of", "GUARD_SIZE", ".", "When", "a", "probe", "is", "emitted", "it", "is", "done", "at", "most", "MIN_PROBE_THRESHOLD", "bytes", "from", "the", "current", "BASE", "at", "an", "interval", "of", "at", "most", "MIN_PROBE_THRESHOLD", ".", "By", "the", "end", "of", "this", "function", "BASE", "=", "BASE", "-", "ADJUSTMENT", "." ]

[ "aarch64", "0", "32", "32", "2", "\"SVLPSPL\"", "\"SVLPEND\"", "0", "1", "\"cmp\\t%0, %1\"", "\"\\tb.lt\\t\"", "0", "1", "\"sub\\t%0, %0, %1\"", "1", "\"str\\txzr, [%0, %1]\"", "0", "1", "\"sub\\t%0, %0, %1\"", "\"\\tb\\t\"", "0", "1", "\"sub\\t%0, %0, %1\"", "\"\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "V_SET0", ":", "case", "X86", "::", "FsFLD0SS", ":", "case", "X86", "::", "FsFLD0SD", ":", "return", "Expand2AddrUndef", "(", "MI", ",", "get", "(", "HasAVX", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ")", ")", ";", "case", "X86", "::", "AVX_SET0", ":", "assert", "(", "HasAVX", "&&", "\"AVX not supported\"", ")", ";", "return", "Expand2AddrUndef", "(", "MI", ",", "get", "(", "X86", "::", "VXORPSYrr", ")", ")", ";", "case", "X86", "::", "V_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MI", ",", "get", "(", "HasAVX", "?", "X86", "::", "VPCMPEQDrr", ":", "X86", "::", "PCMPEQDrr", ")", ")", ";", "case", "X86", "::", "AVX2_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MI", ",", "get", "(", "X86", "::", "VPCMPEQDYrr", ")", ")", ";", "case", "X86", "::", "TEST8ri_NOREX", ":", "MI", "->", "setDesc", "(", "get", "(", "X86", "::", "TEST8ri", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::V_SET0", "X86::FsFLD0SS", "X86::FsFLD0SD", "X86::VXORPSrr", "X86::XORPSrr", "X86::AVX_SET0", "\"AVX not supported\"", "X86::VXORPSYrr", "X86::V_SETALLONES", "X86::VPCMPEQDrr", "X86::PCMPEQDrr", "X86::AVX2_SETALLONES", "X86::VPCMPEQDYrr", "X86::TEST8ri_NOREX", "X86::TEST8ri" ]

[]

[ "<s>", "void", "OutgoingValueHandler", "::", "assignValueToAddress", "(", "unsigned", "ValVReg", ",", "const", "CCValAssign", "&", "VA", ")", "{", "MachineMemOperand", "*", "MMO", ";", "unsigned", "Addr", "=", "getStackAddress", "(", "VA", ",", "MMO", ")", ";", "unsigned", "ExtReg", "=", "extendRegister", "(", "ValVReg", ",", "VA", ")", ";", "MIRBuilder", ".", "buildStore", "(", "ExtReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "Mips" ]

[]

[ "<s>", "StackOffset", "SparcFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "bool", "isFixed", "=", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ";", "bool", "UseFP", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "if", "(", "isFixed", ")", "{", "UseFP", "=", "true", ";", "}", "else", "if", "(", "RegInfo", "->", "hasStackRealignment", "(", "MF", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "{", "UseFP", "=", "true", ";", "}", "int64_t", "FrameOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FI", ")", "+", "Subtarget", ".", "getStackPointerBias", "(", ")", ";", "if", "(", "UseFP", ")", "{", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "StackOffset", "::", "getFixed", "(", "FrameOffset", ")", ";", "}", "else", "{", "FrameReg", "=", "SP", "::", "O6", ";", "return", "StackOffset", "::", "getFixed", "(", "FrameOffset", "+", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::O6" ]

[]

[ "<s>", "void", "J2InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DstReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MI", "!=", "MBB", ".", "end", "(", ")", "?", "MI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "J2", "::", "MOV32mr", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ";", "}", "</s>" ]

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

[ "J2", "J2", "J2::MOV32mr" ]

[]

[ "<s>", "unsigned", "find_next", "(", "unsigned", "Prev", ")", "const", "{", "int", "Next", "=", "BitVector", "::", "find_next", "(", "v2x", "(", "Prev", ")", ")", ";", "if", "(", "Next", "<", "0", ")", "return", "0", ";", "return", "x2v", "(", "Next", ")", ";", "}", "</s>" ]

[ "find_next", "-", "Returns", "the", "index", "of", "the", "next", "set", "bit", "starting", "from", "the", "``", "Curr", "''", "bit", "." ]

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

[]

[ "<s>", "bool", "MVEVPTOptimisations", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "ARMSubtarget", "&", "STI", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "isThumb2", "(", ")", "||", "!", "STI", ".", "hasLOB", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "MachineLoopInfo", "*", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineDominatorTree", "*", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** ARM MVE VPT Optimisations **********\\n\"", "<<", "\"********** Function: \"", "<<", "Fn", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineLoop", "*", "ML", ":", "MLI", "->", "getBase", "(", ")", ".", "getLoopsInPreorder", "(", ")", ")", "{", "Modified", "|=", "MergeLoopEnd", "(", "ML", ")", ";", "Modified", "|=", "ConvertTailPredLoop", "(", "ML", ",", "DT", ")", ";", "}", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "{", "Modified", "|=", "ReplaceConstByVPNOTs", "(", "MBB", ",", "DT", ")", ";", "Modified", "|=", "ReplaceVCMPsByVPNOTs", "(", "MBB", ")", ";", "Modified", "|=", "ReduceOldVCCRValueUses", "(", "MBB", ")", ";", "Modified", "|=", "ConvertVPSEL", "(", "MBB", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"**************************************\\n\"", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"********** ARM MVE VPT Optimisations **********\\n\"", "\"********** Function: \"", "\"**************************************\\n\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "Z80oldFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "unsigned", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "I", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "Amount", "-=", "TII", ".", "getFramePoppedByCallee", "(", "*", "I", ")", ";", "BuildStackAdjustment", "(", "MF", ",", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "Amount", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old" ]

[]

[ "<s>", "bool", "AArch64CondBrTuning", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Conditional Branch Tuning **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "bool", "LocalChange", "=", "false", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstTerminator", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "CBZW", ":", "case", "AArch64", "::", "CBZX", ":", "case", "AArch64", "::", "CBNZW", ":", "case", "AArch64", "::", "CBNZX", ":", "case", "AArch64", "::", "TBZW", ":", "case", "AArch64", "::", "TBZX", ":", "case", "AArch64", "::", "TBNZW", ":", "case", "AArch64", "::", "TBNZX", ":", "MachineInstr", "*", "DefMI", "=", "getOperandDef", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ";", "LocalChange", "=", "(", "DefMI", "&&", "tryToTuneBranch", "(", "MI", ",", "*", "DefMI", ")", ")", ";", "break", ";", "}", "if", "(", "LocalChange", ")", "{", "Changed", "=", "true", ";", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Conditional Branch Tuning **********\\n\"", "\"********** Function: \"", "AArch64", "AArch64::CBZW", "AArch64::CBZX", "AArch64::CBNZW", "AArch64::CBNZX", "AArch64::TBZW", "AArch64::TBZX", "AArch64::TBNZW", "AArch64::TBNZX", "0" ]

[]

[ "<s>", "void", "final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "opvec", "ATTRIBUTE_UNUSED", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_DUMPISIZE", ")", "fprintf", "(", "asm_out_file", ",", "\"\\n! at %04x\\n\"", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "if", "(", "TARGET_RELAX", ")", "{", "if", "(", "rtx", "note", "=", "find_reg_note", "(", "insn", ",", "REG_LABEL_OPERAND", ",", "NULL_RTX", ")", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", "pattern", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "pattern", ")", ")", "{", "case", "SET", ":", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "!=", "CALL", "&&", "get_attr_type", "(", "insn", ")", "!=", "TYPE_SFUNC", ")", "{", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "note", ",", "0", ")", ")", ")", ";", "break", ";", "}", "case", "CALL", ":", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.uses %LL%d\\n\"", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "note", ",", "0", ")", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "statement", "to", "be", "executed", "just", "prior", "to", "the", "output", "of", "assembler", "code", "for", "INSN", ",", "to", "modify", "the", "extracted", "operands", "so", "they", "will", "be", "output", "differently", ".", "Here", "the", "argument", "OPVEC", "is", "the", "vector", "containing", "the", "operands", "extracted", "from", "INSN", ",", "and", "NOPERANDS", "is", "the", "number", "of", "elements", "of", "the", "vector", "which", "contain", "meaningful", "data", "for", "this", "insn", ".", "The", "contents", "of", "this", "vector", "are", "what", "will", "be", "used", "to", "convert", "the", "insn", "template", "into", "assembler", "code", ",", "so", "you", "can", "change", "the", "assembler", "output", "by", "changing", "the", "contents", "of", "the", "vector", ".", "We", "use", "it", "to", "check", "if", "the", "current", "insn", "needs", "a", "nop", "in", "front", "of", "it", "because", "of", "load", "delays", ",", "and", "also", "to", "update", "the", "delay", "slot", "statistics", "." ]

[ "sh", "\"\\n! at %04x\\n\"", "0", "0", "\"L\"", "0", "\"\\t.uses %LL%d\\n\"", "0" ]

[]

[ "<s>", "const", "char", "*", "m68k_output_movem", "(", "rtx", "*", "operands", ",", "rtx", "pattern", ",", "HOST_WIDE_INT", "automod_offset", ",", "bool", "store_p", ")", "{", "unsigned", "int", "mask", ";", "int", "i", ",", "first", ";", "gcc_assert", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", ";", "mask", "=", "0", ";", "first", "=", "(", "automod_offset", "!=", "0", ")", ";", "for", "(", "i", "=", "first", ";", "i", "<", "XVECLEN", "(", "pattern", ",", "0", ")", ";", "i", "++", ")", "{", "unsigned", "int", "regno", ";", "gcc_assert", "(", "MEM_P", "(", "XEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ",", "!", "store_p", ")", ")", ")", ";", "gcc_assert", "(", "REG_P", "(", "XEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ",", "store_p", ")", ")", ")", ";", "regno", "=", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ",", "store_p", ")", ")", ";", "if", "(", "automod_offset", "<", "0", ")", "{", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "mask", "|=", "1", "<<", "(", "regno", "-", "FP0_REG", ")", ";", "else", "mask", "|=", "1", "<<", "(", "15", "-", "(", "regno", "-", "D0_REG", ")", ")", ";", "}", "else", "{", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "mask", "|=", "1", "<<", "(", "7", "-", "(", "regno", "-", "FP0_REG", ")", ")", ";", "else", "mask", "|=", "1", "<<", "(", "regno", "-", "D0_REG", ")", ";", "}", "}", "CC_STATUS_INIT", ";", "if", "(", "automod_offset", "==", "0", ")", "operands", "[", "0", "]", "=", "XEXP", "(", "XEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "first", ")", ",", "!", "store_p", ")", ",", "0", ")", ";", "else", "if", "(", "automod_offset", "<", "0", ")", "operands", "[", "0", "]", "=", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "SET_DEST", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ")", ")", ";", "else", "operands", "[", "0", "]", "=", "gen_rtx_POST_INC", "(", "Pmode", ",", "SET_DEST", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ")", ")", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "mask", ")", ";", "if", "(", "FP_REGNO_P", "(", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "first", ")", ",", "store_p", ")", ")", ")", ")", "{", "if", "(", "store_p", ")", "return", "\"fmovem %1,%a0\"", ";", "else", "return", "\"fmovem %a0,%1\"", ";", "}", "else", "{", "if", "(", "store_p", ")", "return", "\"movem%.l %1,%a0\"", ";", "else", "return", "\"movem%.l %a0,%1\"", ";", "}", "}", "</s>" ]

[ "Return", "the", "assembly", "code", "template", "for", "a", "movem", "or", "fmovem", "instruction", "whose", "pattern", "is", "given", "by", "PATTERN", ".", "Store", "the", "template", "'s", "operands", "in", "OPERANDS", ".", "If", "the", "instruction", "uses", "post-increment", "or", "pre-decrement", "addressing", ",", "AUTOMOD_OFFSET", "is", "the", "total", "adjustment", ",", "otherwise", "it", "is", "0", ".", "STORE_P", "is", "true", "if", "this", "is", "a", "store", "instruction", "." ]

[ "m68k", "0", "0", "0", "0", "0", "0", "0", "1", "1", "15", "1", "7", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "\"fmovem %1,%a0\"", "\"fmovem %a0,%1\"", "\"movem%.l %1,%a0\"", "\"movem%.l %a0,%1\"" ]

[]

[ "<s>", "static", "int", "pa_arg_partial_bytes", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "max_arg_words", "=", "8", ";", "unsigned", "int", "offset", "=", "0", ";", "if", "(", "!", "TARGET_64BIT", ")", "return", "0", ";", "if", "(", "FUNCTION_ARG_SIZE", "(", "mode", ",", "type", ")", ">", "1", "&&", "(", "cum", "->", "words", "&", "1", ")", ")", "offset", "=", "1", ";", "if", "(", "cum", "->", "words", "+", "offset", "+", "FUNCTION_ARG_SIZE", "(", "mode", ",", "type", ")", "<=", "max_arg_words", ")", "return", "0", ";", "else", "if", "(", "cum", "->", "words", "+", "offset", ">=", "max_arg_words", ")", "return", "0", ";", "else", "return", "(", "max_arg_words", "-", "cum", "->", "words", "-", "offset", ")", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "If", "this", "arg", "would", "be", "passed", "totally", "in", "registers", "or", "totally", "on", "the", "stack", ",", "then", "this", "routine", "should", "return", "zero", "." ]

[ "pa", "8", "0", "0", "1", "1", "1", "0", "0" ]

[]

[ "<s>", "bool", "ARM64AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'w'", ":", "case", "'x'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", "&&", "MO", ".", "getImm", "(", ")", "==", "0", ")", "{", "unsigned", "Reg", "=", "ExtraCode", "[", "0", "]", "==", "'w'", "?", "ARM64", "::", "WZR", ":", "ARM64", "::", "XZR", ";", "O", "<<", "ARM64InstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "return", "false", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'s'", ":", "case", "'d'", ":", "case", "'q'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "case", "'b'", ":", "RC", "=", "&", "ARM64", "::", "FPR8RegClass", ";", "break", ";", "case", "'h'", ":", "RC", "=", "&", "ARM64", "::", "FPR16RegClass", ";", "break", ";", "case", "'s'", ":", "RC", "=", "&", "ARM64", "::", "FPR32RegClass", ";", "break", ";", "case", "'d'", ":", "RC", "=", "&", "ARM64", "::", "FPR64RegClass", ";", "break", ";", "case", "'q'", ":", "RC", "=", "&", "ARM64", "::", "FPR128RegClass", ";", "break", ";", "default", ":", "return", "true", ";", "}", "return", "printAsmRegInClass", "(", "MO", ",", "RC", ",", "false", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "}", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "ARM64", "::", "GPR32allRegClass", ".", "contains", "(", "Reg", ")", "||", "ARM64", "::", "GPR64allRegClass", ".", "contains", "(", "Reg", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "'x'", ",", "O", ")", ";", "return", "printAsmRegInClass", "(", "MO", ",", "&", "ARM64", "::", "FPR128RegClass", ",", "true", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "0", "1", "0", "0", "0", "0", "0", "ARM64::WZR", "ARM64::XZR", "ARM64", "0", "ARM64::FPR8RegClass", "ARM64::FPR16RegClass", "ARM64::FPR32RegClass", "ARM64::FPR64RegClass", "ARM64::FPR128RegClass", "ARM64::GPR32allRegClass", "ARM64::GPR64allRegClass", "ARM64::FPR128RegClass" ]

[]

[ "<s>", "const", "VEMCExpr", "*", "VEMCExpr", "::", "create", "(", "VariantKind", "Kind", ",", "const", "MCExpr", "*", "Expr", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "VEMCExpr", "(", "Kind", ",", "Expr", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE", "VE" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "mayBeEmittedAsTailCall", "(", "const", "CallInst", "*", "CI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", "||", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "false", ";", "if", "(", "!", "CI", "->", "isTailCall", "(", ")", ")", "return", "false", ";", "const", "Function", "*", "Caller", "=", "CI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "auto", "Attr", "=", "Caller", "->", "getFnAttribute", "(", "\"disable-tail-calls\"", ")", ";", "if", "(", "Attr", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "return", "false", ";", "auto", "&", "TM", "=", "getTargetMachine", "(", ")", ";", "if", "(", "!", "TM", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "DisableSCO", ")", "return", "false", ";", "const", "Function", "*", "Callee", "=", "CI", "->", "getCalledFunction", "(", ")", ";", "if", "(", "!", "Callee", "||", "Callee", "->", "isVarArg", "(", ")", ")", "return", "false", ";", "if", "(", "!", "areCallingConvEligibleForTCO_64SVR4", "(", "Caller", "->", "getCallingConv", "(", ")", ",", "CI", "->", "getCallingConv", "(", ")", ")", ")", "return", "false", ";", "return", "getTargetMachine", "(", ")", ".", "shouldAssumeDSOLocal", "(", "*", "Caller", "->", "getParent", "(", ")", ",", "Callee", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "PowerPC", "PPC", "PPC", "\"disable-tail-calls\"", "\"true\"" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", ")", "const", "{", "return", "(", "(", "EnablePPC32RS", "&&", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "||", "(", "EnablePPC64RS", "&&", "Subtarget", ".", "isPPC64", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

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

[]

[ "<s>", "AArch64GenInstrInfo", "::", "MachineOutlinerInstrType", "AArch64InstrInfo", "::", "getOutliningType", "(", "MachineInstr", "&", "MI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "AArch64FunctionInfo", "*", "FuncInfo", "=", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "FuncInfo", "->", "getLOHRelated", "(", ")", ".", "count", "(", "&", "MI", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", "||", "MI", ".", "isIndirectDebugValue", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Invisible", ";", "if", "(", "MI", ".", "isTerminator", "(", ")", ")", "{", "if", "(", "MI", ".", "getParent", "(", ")", "->", "succ_empty", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "}", "if", "(", "MI", ".", "isPosition", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "for", "(", "const", "MachineOperand", "&", "MOP", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "MOP", ".", "isCPI", "(", ")", "||", "MOP", ".", "isJTI", "(", ")", "||", "MOP", ".", "isCFIIndex", "(", ")", "||", "MOP", ".", "isFI", "(", ")", "||", "MOP", ".", "isTargetIndex", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "AArch64", "::", "LR", ",", "&", "RI", ")", "||", "MI", ".", "readsRegister", "(", "AArch64", "::", "LR", ",", "&", "RI", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "AArch64", "::", "SP", ",", "&", "RI", ")", "||", "MI", ".", "readsRegister", "(", "AArch64", "::", "SP", ",", "&", "RI", ")", ")", "{", "if", "(", "MI", ".", "mayLoadOrStore", "(", ")", ")", "{", "unsigned", "Base", ";", "int64_t", "Offset", ";", "unsigned", "DummyWidth", ";", "if", "(", "!", "getMemOpBaseRegImmOfsWidth", "(", "MI", ",", "Base", ",", "Offset", ",", "DummyWidth", ",", "&", "RI", ")", "||", "Base", "!=", "AArch64", "::", "SP", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "int64_t", "MinOffset", ",", "MaxOffset", ";", "unsigned", "DummyScale", ";", "getMemOpInfo", "(", "MI", ".", "getOpcode", "(", ")", ",", "DummyScale", ",", "DummyWidth", ",", "MinOffset", ",", "MaxOffset", ")", ";", "if", "(", "Offset", "+", "16", "<", "MinOffset", "||", "Offset", "+", "16", ">", "MaxOffset", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "}", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "}", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "}", "</s>" ]

[ "Returns", "how", "or", "if", "MIT", "should", "be", "outlined", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::LR", "AArch64::LR", "AArch64::SP", "AArch64::SP", "AArch64::SP", "16", "16" ]

[]

[ "<s>", "void", "ix86_expand_vector_logical_operator", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "op1", "=", "NULL_RTX", ",", "op2", "=", "NULL_RTX", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "SUBREG", ")", "{", "op1", "=", "operands", "[", "1", "]", ";", "op2", "=", "operands", "[", "2", "]", ";", "}", "else", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "SUBREG", ")", "{", "op1", "=", "operands", "[", "2", "]", ";", "op2", "=", "operands", "[", "1", "]", ";", "}", "if", "(", "op1", "&&", "!", "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL", "&&", "(", "(", "GET_CODE", "(", "op2", ")", "==", "SUBREG", "||", "GET_CODE", "(", "op2", ")", "==", "CONST_VECTOR", ")", ")", "&&", "GET_MODE_CLASS", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op1", ")", ")", ")", "==", "MODE_VECTOR_FLOAT", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op1", ")", ")", ")", "==", "GET_MODE_SIZE", "(", "mode", ")", "&&", "SUBREG_BYTE", "(", "op1", ")", "==", "0", "&&", "(", "GET_CODE", "(", "op2", ")", "==", "CONST_VECTOR", "||", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op1", ")", ")", "==", "GET_MODE", "(", "SUBREG_REG", "(", "op2", ")", ")", "&&", "SUBREG_BYTE", "(", "op2", ")", "==", "0", ")", ")", "&&", "can_create_pseudo_p", "(", ")", ")", "{", "rtx", "dst", ";", "switch", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op1", ")", ")", ")", "{", "case", "V4SFmode", ":", "case", "V8SFmode", ":", "case", "V16SFmode", ":", "case", "V2DFmode", ":", "case", "V4DFmode", ":", "case", "V8DFmode", ":", "dst", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op1", ")", ")", ")", ";", "if", "(", "GET_CODE", "(", "op2", ")", "==", "CONST_VECTOR", ")", "{", "op2", "=", "gen_lowpart", "(", "GET_MODE", "(", "dst", ")", ",", "op2", ")", ";", "op2", "=", "force_reg", "(", "GET_MODE", "(", "dst", ")", ",", "op2", ")", ";", "}", "else", "{", "op1", "=", "operands", "[", "1", "]", ";", "op2", "=", "SUBREG_REG", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "!", "nonimmediate_operand", "(", "op2", ",", "GET_MODE", "(", "dst", ")", ")", ")", "op2", "=", "force_reg", "(", "GET_MODE", "(", "dst", ")", ",", "op2", ")", ";", "}", "op1", "=", "SUBREG_REG", "(", "op1", ")", ";", "if", "(", "!", "nonimmediate_operand", "(", "op1", ",", "GET_MODE", "(", "dst", ")", ")", ")", "op1", "=", "force_reg", "(", "GET_MODE", "(", "dst", ")", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "dst", ")", ",", "op1", ",", "op2", ")", ")", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "gen_lowpart", "(", "mode", ",", "dst", ")", ")", ";", "return", ";", "default", ":", "break", ";", "}", "}", "if", "(", "!", "nonimmediate_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "!", "nonimmediate_operand", "(", "operands", "[", "2", "]", ",", "mode", ")", ")", "operands", "[", "2", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "2", "]", ")", ";", "ix86_fixup_binary_operands_no_copy", "(", "code", ",", "mode", ",", "operands", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", ")", ";", "}", "</s>" ]

[ "Expand", "vector", "logical", "operation", "CODE", "(", "AND", ",", "IOR", ",", "XOR", ")", "in", "MODE", "with", "the", "given", "OPERANDS", "." ]

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

[]

[ "<s>", "void", "cris_reduce_compare", "(", "rtx", "*", "relp", ",", "rtx", "*", ",", "rtx", "*", "op1p", ")", "{", "rtx", "op1", "=", "*", "op1p", ";", "rtx_code", "code", "=", "GET_CODE", "(", "*", "relp", ")", ";", "switch", "(", "code", ")", "{", "case", "LT", ":", "if", "(", "op1", "==", "const1_rtx", ")", "code", "=", "LE", ";", "break", ";", "case", "LE", ":", "if", "(", "op1", "==", "constm1_rtx", ")", "code", "=", "LT", ";", "break", ";", "case", "GE", ":", "if", "(", "op1", "==", "const1_rtx", ")", "code", "=", "GT", ";", "break", ";", "case", "GT", ":", "if", "(", "op1", "==", "constm1_rtx", ")", "code", "=", "GE", ";", "break", ";", "case", "GEU", ":", "if", "(", "op1", "==", "const1_rtx", ")", "code", "=", "NE", ";", "break", ";", "case", "LTU", ":", "if", "(", "op1", "==", "const1_rtx", ")", "code", "=", "EQ", ";", "break", ";", "case", "GTU", ":", "if", "(", "op1", "==", "const0_rtx", ")", "code", "=", "NE", ";", "break", ";", "case", "LEU", ":", "if", "(", "op1", "==", "const0_rtx", ")", "code", "=", "EQ", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "code", "!=", "GET_CODE", "(", "*", "relp", ")", ")", "{", "*", "op1p", "=", "const0_rtx", ";", "PUT_CODE", "(", "*", "relp", ",", "code", ")", ";", "}", "}", "</s>" ]

[ "Try", "to", "change", "a", "comparison", "against", "a", "constant", "to", "be", "against", "zero", ",", "and", "an", "unsigned", "compare", "against", "zero", "to", "be", "an", "equality", "test", ".", "Beware", ":", "only", "valid", "for", "compares", "of", "integer-type", "operands", ".", "Also", ",", "note", "that", "we", "do", "n't", "use", "operand", "0", "at", "the", "moment", "." ]

[ "cris" ]

[]

[ "<s>", "Relocator", "::", "Result", "abs", "(", "Relocation", "&", "pReloc", ",", "AArch64Relocator", "&", "pParent", ")", "{", "ResolveInfo", "*", "rsym", "=", "pReloc", ".", "symInfo", "(", ")", ";", "Relocator", "::", "DWord", "A", "=", "pReloc", ".", "target", "(", ")", "+", "pReloc", ".", "addend", "(", ")", ";", "Relocator", "::", "DWord", "S", "=", "pReloc", ".", "symValue", "(", ")", ";", "Relocation", "*", "dyn_rel", "=", "pParent", ".", "getRelRelMap", "(", ")", ".", "lookUp", "(", "pReloc", ")", ";", "bool", "has_dyn_rel", "=", "(", "dyn_rel", "!=", "NULL", ")", ";", "LDSection", "&", "target_sect", "=", "pReloc", ".", "targetRef", "(", ")", ".", "frag", "(", ")", "->", "getParent", "(", ")", "->", "getSection", "(", ")", ";", "if", "(", "0x0", "==", "(", "llvm", "::", "ELF", "::", "SHF_ALLOC", "&", "target_sect", ".", "flag", "(", ")", ")", ")", "{", "pReloc", ".", "target", "(", ")", "=", "S", "+", "A", ";", "return", "Relocator", "::", "OK", ";", "}", "if", "(", "rsym", "->", "isLocal", "(", ")", "&&", "has_dyn_rel", ")", "{", "dyn_rel", "->", "setAddend", "(", "S", "+", "A", ")", ";", "}", "if", "(", "!", "rsym", "->", "isLocal", "(", ")", ")", "{", "if", "(", "rsym", "->", "reserved", "(", ")", "&", "AArch64Relocator", "::", "ReservePLT", ")", "{", "S", "=", "helper_get_PLT_address", "(", "*", "rsym", ",", "pParent", ")", ";", "}", "if", "(", "has_dyn_rel", ")", "{", "if", "(", "llvm", "::", "ELF", "::", "R_AARCH64_ABS64", "==", "pReloc", ".", "type", "(", ")", "&&", "llvm", "::", "ELF", "::", "R_AARCH64_RELATIVE", "==", "dyn_rel", "->", "type", "(", ")", ")", "{", "dyn_rel", "->", "setAddend", "(", "S", "+", "A", ")", ";", "}", "else", "{", "dyn_rel", "->", "setAddend", "(", "A", ")", ";", "return", "Relocator", "::", "OK", ";", "}", "}", "}", "pReloc", ".", "target", "(", ")", "=", "S", "+", "A", ";", "return", "Relocator", "::", "OK", ";", "}", "</s>" ]

[ "Compute", "known", "bits", "for", "the", "absolute", "value", "." ]

[ "AArch64", "AArch64", "0x0", "AArch64" ]

[]

[ "<s>", "rtx", "mep_function_value", "(", "const_tree", "type", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_IVC2", "&&", "VECTOR_TYPE_P", "(", "type", ")", ")", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "type", ")", ",", "48", ")", ";", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "type", ")", ",", "RETURN_VALUE_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "FUNCTION_VALUE", ".", "All", "values", "are", "returned", "in", "$", "0", "." ]

[ "mep", "48" ]

[]

[ "<s>", "static", "void", "mips_set_fast_mult_zero_zero_p", "(", "struct", "mips_sim", "*", "state", ")", "{", "if", "(", "TARGET_MIPS16", "||", "!", "ISA_HAS_HILO", ")", "mips_tuning_info", ".", "fast_mult_zero_zero_p", "=", "true", ";", "else", "{", "unsigned", "int", "true_time", "=", "mips_mult_zero_zero_cost", "(", "state", ",", "true", ")", ";", "unsigned", "int", "false_time", "=", "mips_mult_zero_zero_cost", "(", "state", ",", "false", ")", ";", "mips_tuning_info", ".", "fast_mult_zero_zero_p", "=", "(", "true_time", "<=", "false_time", ")", ";", "}", "}", "</s>" ]

[ "Check", "the", "relative", "speeds", "of", "``", "MULT", "$", "0", ",", "$", "0", "''", "and", "``", "MTLO", "$", "0", ";", "MTHI", "$", "0", "''", "and", "set", "up", "mips_tuning_info.fast_mult_zero_zero_p", "accordingly", ".", "Prefer", "MULT", "--", "which", "is", "shorter", "--", "in", "the", "event", "of", "a", "tie", "." ]

[ "mips" ]

[]

[ "<s>", "BitVector", "XtensaRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "reserved", "(", "getNumRegs", "(", ")", ")", ";", "return", "reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "bool", "isUndef", "(", "SDValue", "Op", ")", "const", "{", "if", "(", "Op", ".", "isMachineOpcode", "(", ")", ")", "return", "Op", ".", "getMachineOpcode", "(", ")", "==", "TargetOpcode", "::", "IMPLICIT_DEF", ";", "return", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "result", "of", "this", "operation", "is", "always", "undefined", "." ]

[ "Hexagon", "ISD::UNDEF" ]

[]

[ "<s>", "void", "CAHPInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DstReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "assert", "(", "CAHP", "::", "GPRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", "&&", "\"Impossible reg-to-reg copy\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "CAHP", "::", "MOV", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "CAHP::GPRRegClass", "\"Impossible reg-to-reg copy\"", "CAHP::MOV" ]

[]

[ "<s>", "void", "buildLoad", "(", "Register", "Val", ",", "const", "CCValAssign", "&", "VA", ")", "{", "MachineMemOperand", "*", "MMO", ";", "Register", "Addr", "=", "getStackAddress", "(", "VA", ",", "MMO", ")", ";", "MIRBuilder", ".", "buildLoad", "(", "Val", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "Build", "and", "insert", "a", "G_LOAD", "instruction", ",", "while", "constructing", "the", "MachineMemOperand", "." ]

[ "Mips" ]

[]

[ "<s>", "bool", "MipsFastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "if", "(", "!", "TargetSupported", ")", "return", "false", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "Load", ":", "return", "selectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "selectStore", "(", "I", ")", ";", "case", "Instruction", "::", "SDiv", ":", "if", "(", "!", "selectBinaryOp", "(", "I", ",", "ISD", "::", "SDIV", ")", ")", "return", "selectDivRem", "(", "I", ",", "ISD", "::", "SDIV", ")", ";", "return", "true", ";", "case", "Instruction", "::", "UDiv", ":", "if", "(", "!", "selectBinaryOp", "(", "I", ",", "ISD", "::", "UDIV", ")", ")", "return", "selectDivRem", "(", "I", ",", "ISD", "::", "UDIV", ")", ";", "return", "true", ";", "case", "Instruction", "::", "SRem", ":", "if", "(", "!", "selectBinaryOp", "(", "I", ",", "ISD", "::", "SREM", ")", ")", "return", "selectDivRem", "(", "I", ",", "ISD", "::", "SREM", ")", ";", "return", "true", ";", "case", "Instruction", "::", "URem", ":", "if", "(", "!", "selectBinaryOp", "(", "I", ",", "ISD", "::", "UREM", ")", ")", "return", "selectDivRem", "(", "I", ",", "ISD", "::", "UREM", ")", ";", "return", "true", ";", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "return", "selectShift", "(", "I", ")", ";", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "return", "selectLogicalOp", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "selectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "selectRet", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "return", "selectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "return", "selectIntExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "selectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "selectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPToSI", ":", "return", "selectFPToInt", "(", "I", ",", "true", ")", ";", "case", "Instruction", "::", "FPToUI", ":", "return", "selectFPToInt", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "ICmp", ":", "case", "Instruction", "::", "FCmp", ":", "return", "selectCmp", "(", "I", ")", ";", "case", "Instruction", "::", "Select", ":", "return", "selectSelect", "(", "I", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

[ "Mips", "Mips", "ISD::SDIV", "ISD::SDIV", "ISD::UDIV", "ISD::UDIV", "ISD::SREM", "ISD::SREM", "ISD::UREM", "ISD::UREM" ]

[]

[ "<s>", "void", "TriCoreInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "\"%\"", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ".", "lower", "(", ")", ";", "}", "</s>" ]

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

[ "TriCore", "TriCore", "\"%\"" ]

[]

[ "<s>", "static", "bool", "rx_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "PRE_DEC", ":", "case", "POST_INC", ":", "return", "true", ";", "case", "MINUS", ":", "case", "PLUS", ":", "if", "(", "!", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "return", "true", ";", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "return", "true", ";", "case", "CONST_INT", ":", "if", "(", "(", "(", "INTVAL", "(", "addr", ")", "&", "3", ")", "==", "0", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "addr", ")", ",", "4", ",", "0xfffc", ")", ")", "return", "false", ";", "return", "true", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "true", ";", "case", "MULT", ":", "gcc_assert", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", ";", "return", "true", ";", "default", ":", "return", "true", ";", "}", "case", "CONST_INT", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "REG", ":", "return", "false", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_MODE_DEPENDENT_ADDRESS_P", "." ]

[ "rx", "0", "0", "1", "3", "0", "4", "0xfffc", "0", "1" ]

[]

[ "<s>", "bool", "PadShortFunc", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "optForSize", "(", ")", ")", "{", "return", "false", ";", "}", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "padShortFunctions", "(", ")", ")", "return", "false", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "ReturnBBs", ".", "clear", "(", ")", ";", "VisitedBBs", ".", "clear", "(", ")", ";", "findReturns", "(", "&", "MF", ".", "front", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "MachineBasicBlock", "*", "MBB", ";", "unsigned", "int", "Cycles", "=", "0", ";", "for", "(", "DenseMap", "<", "MachineBasicBlock", "*", ",", "unsigned", "int", ">", "::", "iterator", "I", "=", "ReturnBBs", ".", "begin", "(", ")", ";", "I", "!=", "ReturnBBs", ".", "end", "(", ")", ";", "++", "I", ")", "{", "MBB", "=", "I", "->", "first", ";", "Cycles", "=", "I", "->", "second", ";", "if", "(", "Cycles", "<", "Threshold", ")", "{", "assert", "(", "MBB", "->", "size", "(", ")", ">", "0", "&&", "\"Basic block should contain at least a RET but is empty\"", ")", ";", "MachineBasicBlock", "::", "iterator", "ReturnLoc", "=", "--", "MBB", "->", "end", "(", ")", ";", "while", "(", "ReturnLoc", "->", "isDebugValue", "(", ")", ")", "--", "ReturnLoc", ";", "assert", "(", "ReturnLoc", "->", "isReturn", "(", ")", "&&", "!", "ReturnLoc", "->", "isCall", "(", ")", "&&", "\"Basic block does not end with RET\"", ")", ";", "addPadding", "(", "MBB", ",", "ReturnLoc", ",", "Threshold", "-", "Cycles", ")", ";", "NumBBsPadded", "++", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "0", "\"Basic block should contain at least a RET but is empty\"", "\"Basic block does not end with RET\"" ]

[]

[ "<s>", "static", "unsigned", "rs6000_add_stmt_cost", "(", "class", "vec_info", "*", "vinfo", ",", "void", "*", "data", ",", "int", "count", ",", "enum", "vect_cost_for_stmt", "kind", ",", "struct", "_stmt_vec_info", "*", "stmt_info", ",", "tree", "vectype", ",", "int", "misalign", ",", "enum", "vect_cost_model_location", "where", ")", "{", "rs6000_cost_data", "*", "cost_data", "=", "(", "rs6000_cost_data", "*", ")", "data", ";", "unsigned", "retval", "=", "0", ";", "if", "(", "flag_vect_cost_model", ")", "{", "int", "stmt_cost", "=", "rs6000_builtin_vectorization_cost", "(", "kind", ",", "vectype", ",", "misalign", ")", ";", "stmt_cost", "+=", "rs6000_adjust_vect_cost_per_stmt", "(", "kind", ",", "stmt_info", ")", ";", "if", "(", "where", "==", "vect_body", "&&", "stmt_info", "&&", "stmt_in_inner_loop_p", "(", "vinfo", ",", "stmt_info", ")", ")", "count", "*=", "50", ";", "retval", "=", "(", "unsigned", ")", "(", "count", "*", "stmt_cost", ")", ";", "cost_data", "->", "cost", "[", "where", "]", "+=", "retval", ";", "if", "(", "(", "kind", "==", "vec_to_scalar", "||", "kind", "==", "vec_perm", "||", "kind", "==", "vec_promote_demote", "||", "kind", "==", "vec_construct", "||", "kind", "==", "scalar_to_vec", ")", "||", "(", "where", "==", "vect_body", "&&", "kind", "==", "vector_stmt", ")", ")", "rs6000_vect_nonmem", "=", "true", ";", "}", "return", "retval", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.add_stmt_cost", "." ]

[ "rs6000", "0", "50" ]

[]

[ "<s>", "static", "rtx_insn", "*", "rs6000_frame_related", "(", "rtx_insn", "*", "insn", ",", "rtx", "reg", ",", "HOST_WIDE_INT", "val", ",", "rtx", "reg2", ",", "rtx", "repl2", ")", "{", "rtx", "repl", ";", "if", "(", "REGNO", "(", "reg", ")", "==", "STACK_POINTER_REGNUM", ")", "{", "gcc_checking_assert", "(", "val", "==", "0", ")", ";", "repl", "=", "NULL_RTX", ";", "}", "else", "repl", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ",", "GEN_INT", "(", "val", ")", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "!", "repl", "&&", "!", "reg2", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "for", "(", "int", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", "==", "SET", ")", "{", "rtx", "set", "=", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ";", "if", "(", "!", "REG_P", "(", "SET_SRC", "(", "set", ")", ")", "||", "!", "fixed_reg_p", "(", "REGNO", "(", "SET_SRC", "(", "set", ")", ")", ")", ")", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "}", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", "insn", ";", "}", "set_used_flags", "(", "pat", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "{", "if", "(", "repl", ")", "pat", "=", "simplify_replace_rtx", "(", "pat", ",", "reg", ",", "repl", ")", ";", "if", "(", "reg2", ")", "pat", "=", "simplify_replace_rtx", "(", "pat", ",", "reg2", ",", "repl2", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "pat", "=", "shallow_copy_rtx", "(", "pat", ")", ";", "XVEC", "(", "pat", ",", "0", ")", "=", "shallow_copy_rtvec", "(", "XVEC", "(", "pat", ",", "0", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", "==", "SET", ")", "{", "rtx", "set", "=", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ";", "if", "(", "repl", ")", "set", "=", "simplify_replace_rtx", "(", "set", ",", "reg", ",", "repl", ")", ";", "if", "(", "reg2", ")", "set", "=", "simplify_replace_rtx", "(", "set", ",", "reg2", ",", "repl2", ")", ";", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", "=", "set", ";", "if", "(", "!", "REG_P", "(", "SET_SRC", "(", "set", ")", ")", "||", "!", "fixed_reg_p", "(", "REGNO", "(", "SET_SRC", "(", "set", ")", ")", ")", ")", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "}", "}", "else", "gcc_unreachable", "(", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "copy_rtx_if_shared", "(", "pat", ")", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Add", "to", "'insn", "'", "a", "note", "which", "is", "PATTERN", "(", "INSN", ")", "but", "with", "REG", "replaced", "with", "(", "plus", ":", "P", "(", "reg", "1", ")", "VAL", ")", ",", "and", "with", "REG2", "replaced", "with", "RREG", "if", "REG2", "is", "not", "NULL", ".", "It", "would", "be", "nice", "if", "dwarf2out_frame_debug_expr", "could", "deduce", "these", "equivalences", "by", "itself", "so", "it", "was", "n't", "necessary", "to", "hold", "its", "hand", "so", "much", ".", "Do", "n't", "be", "tempted", "to", "always", "supply", "d2_f_d_e", "with", "the", "actual", "cfa", "register", ",", "ie", ".", "r31", "when", "we", "are", "using", "a", "hard", "frame", "pointer", ".", "That", "fails", "when", "saving", "regs", "off", "r1", ",", "and", "sched", "moves", "the", "r31", "setup", "past", "the", "reg", "saves", "." ]

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

[]

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

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

[ "CJG" ]

[]

[ "<s>", "void", "PPCTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ",", "OptimizationRemarkEmitter", "*", "ORE", ")", "{", "if", "(", "ST", "->", "getCPUDirective", "(", ")", "==", "PPC", "::", "DIR_A2", ")", "{", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "AllowExpensiveTripCount", "=", "true", ";", "}", "BaseT", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ",", "ORE", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::DIR_A2" ]

[]

[ "<s>", "static", "bool", "frv_registers_conflict_p", "(", "rtx", "x", ")", "{", "regstate_t", "flags", ";", "flags", "=", "0", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "COND_EXEC", ")", "{", "if", "(", "for_each_rtx", "(", "&", "XEXP", "(", "x", ",", "0", ")", ",", "frv_registers_conflict_p_1", ",", "&", "flags", ")", ")", "return", "true", ";", "flags", "|=", "frv_cond_flags", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "x", "=", "XEXP", "(", "x", ",", "1", ")", ";", "}", "return", "for_each_rtx", "(", "&", "x", ",", "frv_registers_conflict_p_1", ",", "&", "flags", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "something", "in", "X", "might", "depend", "on", "an", "instruction", "in", "the", "current", "packet", "." ]

[ "frv", "0", "0", "0", "1" ]

[]

[ "<s>", "const", "uint16_t", "*", "XCoreRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "XCore", "::", "R4", ",", "XCore", "::", "R5", ",", "XCore", "::", "R6", ",", "XCore", "::", "R7", ",", "XCore", "::", "R8", ",", "XCore", "::", "R9", ",", "XCore", "::", "R10", ",", "XCore", "::", "LR", ",", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::R4", "XCore::R5", "XCore::R6", "XCore::R7", "XCore::R8", "XCore::R9", "XCore::R10", "XCore::LR", "0" ]

[]