Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "enum", "loongarch_symbol_type", "loongarch_classify_symbol", "(", "const_rtx", "x", ")", "{", "enum", "loongarch_symbol_type", "pcrel", "=", "TARGET_CMODEL_EXTREME", "?", "SYMBOL_PCREL64", ":", "SYMBOL_PCREL", ";", "if", "(", "!", "SYMBOL_REF_P", "(", "x", ")", ")", "return", "pcrel", ";", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "SYMBOL_TLS", ";", "if", "(", "!", "loongarch_symbol_binds_local_p", "(", "x", ")", ")", "return", "SYMBOL_GOT_DISP", ";", "tree", "t", "=", "SYMBOL_REF_DECL", "(", "x", ")", ";", "if", "(", "!", "t", ")", "return", "pcrel", ";", "t", "=", "lookup_attribute", "(", "\"model\"", ",", "DECL_ATTRIBUTES", "(", "t", ")", ")", ";", "if", "(", "!", "t", ")", "return", "pcrel", ";", "t", "=", "TREE_VALUE", "(", "TREE_VALUE", "(", "t", ")", ")", ";", "gcc_assert", "(", "TREE_CODE", "(", "t", ")", "==", "STRING_CST", ")", ";", "const", "char", "*", "model", "=", "TREE_STRING_POINTER", "(", "t", ")", ";", "if", "(", "strcmp", "(", "model", ",", "\"normal\"", ")", "==", "0", ")", "return", "SYMBOL_PCREL", ";", "if", "(", "strcmp", "(", "model", ",", "\"extreme\"", ")", "==", "0", ")", "return", "SYMBOL_PCREL64", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "method", "that", "should", "be", "used", "to", "access", "SYMBOL_REF", "or", "LABEL_REF", "X", "." ]

[ "loongarch", "\"model\"", "\"normal\"", "0", "\"extreme\"", "0" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isMBBSafeToOutlineFrom", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "&", "Flags", ")", "const", "{", "assert", "(", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ".", "tracksLiveness", "(", ")", "&&", "\"Suitable Machine Function for outlining must track liveness\"", ")", ";", "LiveRegUnits", "LRU", "(", "getRegisterInfo", "(", ")", ")", ";", "std", "::", "for_each", "(", "MBB", ".", "rbegin", "(", ")", ",", "MBB", ".", "rend", "(", ")", ",", "[", "&", "LRU", "]", "(", "MachineInstr", "&", "MI", ")", "{", "LRU", ".", "accumulate", "(", "MI", ")", ";", "}", ")", ";", "bool", "W16AvailableInBlock", "=", "LRU", ".", "available", "(", "AArch64", "::", "W16", ")", ";", "bool", "W17AvailableInBlock", "=", "LRU", ".", "available", "(", "AArch64", "::", "W17", ")", ";", "bool", "NZCVAvailableInBlock", "=", "LRU", ".", "available", "(", "AArch64", "::", "NZCV", ")", ";", "if", "(", "W16AvailableInBlock", "&&", "W17AvailableInBlock", "&&", "NZCVAvailableInBlock", ")", "Flags", "|=", "MachineOutlinerMBBFlags", "::", "UnsafeRegsDead", ";", "LRU", ".", "addLiveOuts", "(", "MBB", ")", ";", "if", "(", "W16AvailableInBlock", "&&", "!", "LRU", ".", "available", "(", "AArch64", "::", "W16", ")", ")", "return", "false", ";", "if", "(", "W17AvailableInBlock", "&&", "!", "LRU", ".", "available", "(", "AArch64", "::", "W17", ")", ")", "return", "false", ";", "if", "(", "NZCVAvailableInBlock", "&&", "!", "LRU", ".", "available", "(", "AArch64", "::", "NZCV", ")", ")", "return", "false", ";", "if", "(", "any_of", "(", "MBB", ",", "[", "]", "(", "MachineInstr", "&", "MI", ")", "{", "return", "MI", ".", "isCall", "(", ")", ";", "}", ")", ")", "Flags", "|=", "MachineOutlinerMBBFlags", "::", "HasCalls", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "bool", "CanSaveLR", "=", "false", ";", "const", "AArch64RegisterInfo", "*", "ARI", "=", "static_cast", "<", "const", "AArch64RegisterInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "for", "(", "unsigned", "Reg", ":", "AArch64", "::", "GPR64RegClass", ")", "{", "if", "(", "!", "ARI", "->", "isReservedReg", "(", "*", "MF", ",", "Reg", ")", "&&", "Reg", "!=", "AArch64", "::", "LR", "&&", "Reg", "!=", "AArch64", "::", "X16", "&&", "Reg", "!=", "AArch64", "::", "X17", "&&", "LRU", ".", "available", "(", "Reg", ")", ")", "{", "CanSaveLR", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "CanSaveLR", "&&", "!", "LRU", ".", "available", "(", "AArch64", "::", "LR", ")", ")", "Flags", "|=", "MachineOutlinerMBBFlags", "::", "LRUnavailableSomewhere", ";", "return", "true", ";", "}", "</s>" ]

[ "Optional", "target", "hook", "that", "returns", "true", "if", "MBB", "is", "safe", "to", "outline", "from", ",", "and", "returns", "any", "target-specific", "information", "in", "Flags", "." ]

[ "AArch64", "AArch64", "\"Suitable Machine Function for outlining must track liveness\"", "AArch64::W16", "AArch64::W17", "AArch64::NZCV", "AArch64::W16", "AArch64::W17", "AArch64::NZCV", "AArch64", "AArch64", "AArch64::GPR64RegClass", "AArch64::LR", "AArch64::X16", "AArch64::X17", "AArch64::LR" ]

[]

[ "<s>", "const", "MCExpr", "*", "ARMElfTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "unsigned", "Encoding", ",", "Mangler", "&", "Mang", ",", "const", "TargetMachine", "&", "TM", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "TM", ".", "getMCAsmInfo", "(", ")", "->", "getExceptionHandlingType", "(", ")", "!=", "ExceptionHandling", "::", "ARM", ")", "return", "TargetLoweringObjectFileELF", "::", "getTTypeGlobalReference", "(", "GV", ",", "Encoding", ",", "Mang", ",", "TM", ",", "MMI", ",", "Streamer", ")", ";", "assert", "(", "Encoding", "==", "DW_EH_PE_absptr", "&&", "\"Can handle absptr encoding only\"", ")", ";", "return", "MCSymbolRefExpr", "::", "create", "(", "TM", ".", "getSymbol", "(", "GV", ",", "Mang", ")", ",", "MCSymbolRefExpr", "::", "VK_ARM_TARGET2", ",", "getContext", "(", ")", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

[ "ARM", "ARM", "ARM", "\"Can handle absptr encoding only\"", "ARM" ]

[]

[ "<s>", "bool", "Z80oldFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "hasStackObjects", "(", ")", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old" ]

[]

[ "<s>", "static", "void", "arm_adjust_block_mem", "(", "rtx", "mem", ",", "HOST_WIDE_INT", "length", ",", "rtx", "*", "loop_reg", ",", "rtx", "*", "loop_mem", ")", "{", "*", "loop_reg", "=", "copy_addr_to_reg", "(", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "*", "loop_mem", "=", "change_address", "(", "mem", ",", "BLKmode", ",", "*", "loop_reg", ")", ";", "set_mem_align", "(", "*", "loop_mem", ",", "MIN", "(", "MEM_ALIGN", "(", "mem", ")", ",", "length", "*", "BITS_PER_UNIT", ")", ")", ";", "}", "</s>" ]

[ "From", "mips_adjust_block_mem", ":", "Helper", "function", "for", "doing", "a", "loop-based", "block", "operation", "on", "memory", "reference", "MEM", ".", "Each", "iteration", "of", "the", "loop", "will", "operate", "on", "LENGTH", "bytes", "of", "MEM", ".", "Create", "a", "new", "base", "register", "for", "use", "within", "the", "loop", "and", "point", "it", "to", "the", "start", "of", "MEM", ".", "Create", "a", "new", "memory", "reference", "that", "uses", "this", "register", ".", "Store", "them", "in", "*", "LOOP_REG", "and", "*", "LOOP_MEM", "respectively", "." ]

[ "arm", "0" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "aarch64_estimated_poly_value", "(", "poly_int64", "val", ",", "poly_value_estimate_kind", "kind", "=", "POLY_VALUE_LIKELY", ")", "{", "enum", "aarch64_sve_vector_bits_enum", "width_source", "=", "aarch64_tune_params", ".", "sve_width", ";", "if", "(", "width_source", "==", "SVE_SCALABLE", ")", "switch", "(", "kind", ")", "{", "case", "POLY_VALUE_MIN", ":", "case", "POLY_VALUE_LIKELY", ":", "return", "val", ".", "coeffs", "[", "0", "]", ";", "case", "POLY_VALUE_MAX", ":", "return", "val", ".", "coeffs", "[", "0", "]", "+", "val", ".", "coeffs", "[", "1", "]", "*", "15", ";", "}", "HOST_WIDE_INT", "over_128", "=", "width_source", "-", "128", ";", "return", "val", ".", "coeffs", "[", "0", "]", "+", "val", ".", "coeffs", "[", "1", "]", "*", "over_128", "/", "128", ";", "}", "</s>" ]

[ "Implement", "TARGET_ESTIMATED_POLY_VALUE", ".", "Look", "into", "the", "tuning", "structure", "for", "an", "estimate", ".", "KIND", "specifies", "the", "type", "of", "requested", "estimate", ":", "min", ",", "max", "or", "likely", ".", "For", "cores", "with", "a", "known", "SVE", "width", "all", "three", "estimates", "are", "the", "same", ".", "For", "generic", "SVE", "tuning", "we", "want", "to", "distinguish", "the", "maximum", "estimate", "from", "the", "minimum", "and", "likely", "ones", ".", "The", "likely", "estimate", "is", "the", "same", "as", "the", "minimum", "in", "that", "case", "to", "give", "a", "conservative", "behavior", "of", "auto-vectorizing", "with", "SVE", "when", "it", "is", "a", "win", "even", "for", "128-bit", "SVE", ".", "When", "SVE", "width", "information", "is", "available", "VAL.coeffs", "[", "1", "]", "is", "multiplied", "by", "the", "number", "of", "VQ", "chunks", "over", "the", "initial", "Advanced", "SIMD", "128", "bits", "." ]

[ "aarch64", "0", "0", "1", "15", "128", "0", "1", "128" ]

[]

[ "<s>", "static", "rtx", "tilepro_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "cum", "=", "*", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "byte_size", "=", "(", "(", "mode", "==", "BLKmode", ")", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "bool", "doubleword_aligned_p", ";", "if", "(", "cum", ">=", "TILEPRO_NUM_ARG_REGS", ")", "return", "NULL_RTX", ";", "doubleword_aligned_p", "=", "tilepro_function_arg_boundary", "(", "mode", ",", "type", ")", ">", "BITS_PER_WORD", ";", "if", "(", "doubleword_aligned_p", ")", "cum", "+=", "cum", "&", "1", ";", "if", "(", "(", "cum", "+", "(", "byte_size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ">", "TILEPRO_NUM_ARG_REGS", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_REG", "(", "mode", ",", "cum", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG", "." ]

[ "tilepro", "1", "1" ]

[]

[ "<s>", "SDValue", "NVPTXTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "bool", "isABI", "=", "(", "nvptxSubtarget", ".", "getSmVersion", "(", ")", ">=", "20", ")", ";", "unsigned", "sizesofar", "=", "0", ";", "unsigned", "idx", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Outs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "SDValue", "theVal", "=", "OutVals", "[", "i", "]", ";", "EVT", "theValType", "=", "theVal", ".", "getValueType", "(", ")", ";", "unsigned", "numElems", "=", "1", ";", "if", "(", "theValType", ".", "isVector", "(", ")", ")", "numElems", "=", "theValType", ".", "getVectorNumElements", "(", ")", ";", "for", "(", "unsigned", "j", "=", "0", ",", "je", "=", "numElems", ";", "j", "!=", "je", ";", "++", "j", ")", "{", "SDValue", "tmpval", "=", "theVal", ";", "if", "(", "theValType", ".", "isVector", "(", ")", ")", "tmpval", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "dl", ",", "theValType", ".", "getVectorElementType", "(", ")", ",", "tmpval", ",", "DAG", ".", "getIntPtrConstant", "(", "j", ")", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "isABI", "?", "NVPTXISD", "::", "StoreRetval", ":", "NVPTXISD", "::", "MoveToRetval", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "isABI", "?", "sizesofar", ":", "idx", ",", "MVT", "::", "i32", ")", ",", "tmpval", ")", ";", "if", "(", "theValType", ".", "isVector", "(", ")", ")", "sizesofar", "+=", "theValType", ".", "getVectorElementType", "(", ")", ".", "getStoreSize", "(", "8", ")", ";", "else", "sizesofar", "+=", "theValType", ".", "getStoreSize", "(", "8", ")", ";", "++", "idx", ";", "}", "}", "return", "DAG", ".", "getNode", "(", "NVPTXISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "ISD::OutputArg", "20", "0", "0", "0", "1", "0", "ISD::EXTRACT_VECTOR_ELT", "NVPTXISD::StoreRetval", "NVPTXISD::MoveToRetval", "MVT::Other", "MVT::i32", "8", "8", "NVPTXISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "ARMTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'l'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "weight", "=", "CW_SpecificReg", ";", "else", "weight", "=", "CW_Register", ";", "}", "break", ";", "case", "'w'", ":", "if", "(", "type", "->", "isFloatingPointTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

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

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

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

[]

[ "<s>", "static", "rtx", "arc_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "int", "unsignedp", "ATTRIBUTE_UNUSED", ";", "unsignedp", "=", "TYPE_UNSIGNED", "(", "valtype", ")", ";", "if", "(", "INTEGRAL_TYPE_P", "(", "valtype", ")", "||", "TREE_CODE", "(", "valtype", ")", "==", "OFFSET_TYPE", ")", "PROMOTE_MODE", "(", "mode", ",", "unsignedp", ",", "valtype", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "0", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FN_DECL_OR_TYPE", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FN_DECL_OR_TYPE", "is", "its", "type", "." ]

[ "arc", "0" ]

[]

[ "<s>", "virtual", "bool", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "CellSPU" ]

[]

[ "<s>", "static", "void", "aarch64_parse_override_string", "(", "const", "char", "*", "input_string", ",", "struct", "tune_params", "*", "tune", ")", "{", "const", "char", "separator", "=", "':'", ";", "size_t", "string_length", "=", "strlen", "(", "input_string", ")", "+", "1", ";", "char", "*", "string_root", "=", "(", "char", "*", ")", "xmalloc", "(", "sizeof", "(", "*", "string_root", ")", "*", "string_length", ")", ";", "char", "*", "string", "=", "string_root", ";", "strncpy", "(", "string", ",", "input_string", ",", "string_length", ")", ";", "string", "[", "string_length", "-", "1", "]", "=", "'\\0'", ";", "char", "*", "ntoken", "=", "string", ";", "while", "(", "(", "ntoken", "=", "strchr", "(", "string", ",", "separator", ")", ")", ")", "{", "size_t", "token_length", "=", "ntoken", "-", "string", ";", "*", "ntoken", "=", "'\\0'", ";", "aarch64_parse_one_override_token", "(", "string", ",", "token_length", ",", "tune", ")", ";", "string", "=", "++", "ntoken", ";", "}", "aarch64_parse_one_override_token", "(", "string", ",", "strlen", "(", "string", ")", ",", "tune", ")", ";", "free", "(", "string_root", ")", ";", "}", "</s>" ]

[ "Parse", "STRING", "looking", "for", "options", "in", "the", "format", ":", "string", ":", ":", "option", ":", "string", "option", ":", ":", "name=substring", "name", ":", ":", "{", "a-z", "}", "substring", ":", ":", "defined", "by", "option", "." ]

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

[]

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

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

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

[]

[ "<s>", "virtual", "MVT", "getShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i64", ";", "}", "</s>" ]

[ "Returns", "the", "type", "for", "the", "shift", "amount", "of", "a", "shift", "opcode", "." ]

[ "SystemZ", "MVT::i64" ]

[]

[ "<s>", "static", "rtx", "arm_expand_builtin_1", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ",", "arm_builtin_datum", "*", "d", ")", "{", "enum", "insn_code", "icode", "=", "d", "->", "code", ";", "builtin_arg", "args", "[", "SIMD_MAX_BUILTIN_ARGS", "+", "1", "]", ";", "int", "num_args", "=", "insn_data", "[", "d", "->", "code", "]", ".", "n_operands", ";", "int", "is_void", "=", "0", ";", "int", "k", ";", "bool", "neon", "=", "false", ";", "bool", "mve", "=", "false", ";", "if", "(", "IN_RANGE", "(", "fcode", ",", "ARM_BUILTIN_VFP_BASE", ",", "ARM_BUILTIN_ACLE_BASE", "-", "1", ")", ")", "neon", "=", "true", ";", "if", "(", "IN_RANGE", "(", "fcode", ",", "ARM_BUILTIN_MVE_BASE", ",", "ARM_BUILTIN_MAX", "-", "1", ")", ")", "mve", "=", "true", ";", "is_void", "=", "!", "!", "(", "d", "->", "qualifiers", "[", "0", "]", "&", "qualifier_void", ")", ";", "num_args", "+=", "is_void", ";", "for", "(", "k", "=", "1", ";", "k", "<", "num_args", ";", "k", "++", ")", "{", "int", "qualifiers_k", "=", "k", ";", "int", "operands_k", "=", "k", "-", "is_void", ";", "int", "expr_args_k", "=", "k", "-", "1", ";", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_index", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_LANE_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_pair_index", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_LANE_PAIR_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_quadtup_index", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_LANE_QUADTUP_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_struct_load_store_lane_index", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_STRUCT_LOAD_STORE_LANE_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_immediate", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_CONSTANT", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_maybe_immediate", ")", "{", "rtx", "arg", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "(", "expr_args_k", ")", ")", ")", ";", "bool", "op_const_int_p", "=", "(", "CONST_INT_P", "(", "arg", ")", "&&", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "predicate", ")", "(", "arg", ",", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "mode", ")", ")", ";", "args", "[", "k", "]", "=", "op_const_int_p", "?", "ARG_BUILTIN_CONSTANT", ":", "ARG_BUILTIN_COPY_TO_REG", ";", "}", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_pointer", ")", "{", "if", "(", "neon", "||", "mve", ")", "args", "[", "k", "]", "=", "ARG_BUILTIN_NEON_MEMORY", ";", "else", "args", "[", "k", "]", "=", "ARG_BUILTIN_MEMORY", ";", "}", "else", "args", "[", "k", "]", "=", "ARG_BUILTIN_COPY_TO_REG", ";", "}", "args", "[", "k", "]", "=", "ARG_BUILTIN_STOP", ";", "return", "arm_expand_builtin_args", "(", "target", ",", "d", "->", "mode", ",", "fcode", ",", "icode", ",", "!", "is_void", ",", "exp", ",", "&", "args", "[", "1", "]", ")", ";", "}", "</s>" ]

[ "Expand", "a", "builtin", ".", "These", "builtins", "are", "``", "special", "''", "because", "they", "do", "n't", "have", "symbolic", "constants", "defined", "per-instruction", "or", "per", "instruction-variant", ".", "Instead", ",", "the", "required", "info", "is", "looked", "up", "in", "the", "ARM_BUILTIN_DATA", "record", "that", "is", "passed", "into", "the", "function", "." ]

[ "arm", "1", "0", "1", "1", "0", "1", "1", "1" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "getTgtMemIntrinsic", "(", "IntrinsicInst", "*", "Inst", ",", "MemIntrinsicInfo", "&", "Info", ")", "const", "{", "switch", "(", "Inst", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_add", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_swap", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "{", "auto", "*", "Ordering", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Inst", "->", "getArgOperand", "(", "2", ")", ")", ";", "auto", "*", "Volatile", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Inst", "->", "getArgOperand", "(", "4", ")", ")", ";", "if", "(", "!", "Ordering", "||", "!", "Volatile", ")", "return", "false", ";", "unsigned", "OrderingVal", "=", "Ordering", "->", "getZExtValue", "(", ")", ";", "if", "(", "OrderingVal", ">", "static_cast", "<", "unsigned", ">", "(", "AtomicOrdering", "::", "SequentiallyConsistent", ")", ")", "return", "false", ";", "Info", ".", "PtrVal", "=", "Inst", "->", "getArgOperand", "(", "0", ")", ";", "Info", ".", "Ordering", "=", "static_cast", "<", "AtomicOrdering", ">", "(", "OrderingVal", ")", ";", "Info", ".", "ReadMem", "=", "true", ";", "Info", ".", "WriteMem", "=", "true", ";", "Info", ".", "IsVolatile", "=", "!", "Volatile", "->", "isNullValue", "(", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "AMDGPU", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_ds_ordered_add", "Intrinsic::amdgcn_ds_ordered_swap", "Intrinsic::amdgcn_ds_fadd", "Intrinsic::amdgcn_ds_fmin", "Intrinsic::amdgcn_ds_fmax", "2", "4", "0" ]

[]

[ "<s>", "void", "ia64_expand_compare", "(", "rtx", "*", "expr", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "*", "expr", ")", ";", "rtx", "cmp", ";", "if", "(", "GET_MODE", "(", "*", "op0", ")", "==", "BImode", ")", "{", "gcc_assert", "(", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "&&", "*", "op1", "==", "const0_rtx", ")", ";", "cmp", "=", "*", "op0", ";", "}", "else", "if", "(", "TARGET_HPUX", "&&", "GET_MODE", "(", "*", "op0", ")", "==", "TFmode", ")", "{", "enum", "qfcmp_magic", "{", "QCMP_INV", "=", "1", ",", "QCMP_UNORD", "=", "2", ",", "QCMP_EQ", "=", "4", ",", "QCMP_LT", "=", "8", ",", "QCMP_GT", "=", "16", "}", ";", "int", "magic", ";", "enum", "rtx_code", "ncode", ";", "rtx", "ret", ",", "insns", ";", "gcc_assert", "(", "cmptf_libfunc", "&&", "GET_MODE", "(", "*", "op1", ")", "==", "TFmode", ")", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "magic", "=", "QCMP_EQ", ";", "ncode", "=", "NE", ";", "break", ";", "case", "NE", ":", "magic", "=", "QCMP_EQ", ";", "ncode", "=", "EQ", ";", "break", ";", "case", "UNORDERED", ":", "magic", "=", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "ORDERED", ":", "magic", "=", "QCMP_UNORD", ";", "ncode", "=", "EQ", ";", "break", ";", "case", "LT", ":", "magic", "=", "QCMP_LT", "|", "QCMP_INV", ";", "ncode", "=", "NE", ";", "break", ";", "case", "LE", ":", "magic", "=", "QCMP_LT", "|", "QCMP_EQ", "|", "QCMP_INV", ";", "ncode", "=", "NE", ";", "break", ";", "case", "GT", ":", "magic", "=", "QCMP_GT", "|", "QCMP_INV", ";", "ncode", "=", "NE", ";", "break", ";", "case", "GE", ":", "magic", "=", "QCMP_GT", "|", "QCMP_EQ", "|", "QCMP_INV", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNLT", ":", "magic", "=", "QCMP_LT", "|", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNLE", ":", "magic", "=", "QCMP_LT", "|", "QCMP_EQ", "|", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNGT", ":", "magic", "=", "QCMP_GT", "|", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNGE", ":", "magic", "=", "QCMP_GT", "|", "QCMP_EQ", "|", "QCMP_UNORD", ";", "ncode", "=", "NE", ";", "break", ";", "case", "UNEQ", ":", "case", "LTGT", ":", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "start_sequence", "(", ")", ";", "ret", "=", "emit_library_call_value", "(", "cmptf_libfunc", ",", "0", ",", "LCT_CONST", ",", "DImode", ",", "3", ",", "*", "op0", ",", "TFmode", ",", "*", "op1", ",", "TFmode", ",", "GEN_INT", "(", "magic", ")", ",", "DImode", ")", ";", "cmp", "=", "gen_reg_rtx", "(", "BImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cmp", ",", "gen_rtx_fmt_ee", "(", "ncode", ",", "BImode", ",", "ret", ",", "const0_rtx", ")", ")", ")", ";", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_libcall_block", "(", "insns", ",", "cmp", ",", "cmp", ",", "gen_rtx_fmt_ee", "(", "code", ",", "BImode", ",", "*", "op0", ",", "*", "op1", ")", ")", ";", "code", "=", "NE", ";", "}", "else", "{", "cmp", "=", "gen_reg_rtx", "(", "BImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cmp", ",", "gen_rtx_fmt_ee", "(", "code", ",", "BImode", ",", "*", "op0", ",", "*", "op1", ")", ")", ")", ";", "code", "=", "NE", ";", "}", "*", "expr", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "cmp", ",", "const0_rtx", ")", ";", "*", "op0", "=", "cmp", ";", "*", "op1", "=", "const0_rtx", ";", "}", "</s>" ]

[ "Emit", "comparison", "instruction", "if", "necessary", ",", "returning", "the", "expression", "that", "holds", "the", "compare", "result", "in", "the", "proper", "mode", "." ]

[ "ia64", "1", "2", "4", "8", "16", "0", "3" ]

[]

[ "<s>", "unsigned", "MipsFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "GlobalBaseReg", ")", "return", "GlobalBaseReg", ";", "const", "MipsSubtarget", "&", "ST", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", ";", "if", "(", "ST", ".", "inMips16Mode", "(", ")", ")", "RC", "=", "(", "const", "TargetRegisterClass", "*", ")", "&", "Mips", "::", "CPU16RegsRegClass", ";", "else", "RC", "=", "ST", ".", "isABI_N64", "(", ")", "?", "(", "const", "TargetRegisterClass", "*", ")", "&", "Mips", "::", "CPU64RegsRegClass", ":", "(", "const", "TargetRegisterClass", "*", ")", "&", "Mips", "::", "CPURegsRegClass", ";", "return", "GlobalBaseReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::CPU16RegsRegClass", "Mips::CPU64RegsRegClass", "Mips::CPURegsRegClass" ]

[]

[ "<s>", "static", "void", "aarch64_restore_callee_saves", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "start_offset", ",", "unsigned", "start", ",", "unsigned", "limit", ",", "bool", "skip_wb", ",", "rtx", "*", "cfi_ops", ")", "{", "rtx", "base_rtx", "=", "stack_pointer_rtx", ";", "rtx", "(", "*", "gen_mem_ref", ")", "(", "machine_mode", ",", "rtx", ")", "=", "(", "frame_pointer_needed", "?", "gen_frame_mem", ":", "gen_rtx_MEM", ")", ";", "unsigned", "regno", ";", "unsigned", "regno2", ";", "HOST_WIDE_INT", "offset", ";", "for", "(", "regno", "=", "aarch64_next_callee_save", "(", "start", ",", "limit", ")", ";", "regno", "<=", "limit", ";", "regno", "=", "aarch64_next_callee_save", "(", "regno", "+", "1", ",", "limit", ")", ")", "{", "rtx", "reg", ",", "mem", ";", "if", "(", "skip_wb", "&&", "(", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", "||", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", ")", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "mem", "=", "gen_mem_ref", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "base_rtx", ",", "offset", ")", ")", ";", "regno2", "=", "aarch64_next_callee_save", "(", "regno", "+", "1", ",", "limit", ")", ";", "if", "(", "regno2", "<=", "limit", "&&", "(", "(", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", "+", "UNITS_PER_WORD", ")", "==", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ")", ")", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "rtx", "mem2", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ";", "mem2", "=", "gen_mem_ref", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "base_rtx", ",", "offset", ")", ")", ";", "emit_insn", "(", "aarch64_gen_load_pair", "(", "mode", ",", "reg", ",", "mem", ",", "reg2", ",", "mem2", ")", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg2", ",", "*", "cfi_ops", ")", ";", "regno", "=", "regno2", ";", "}", "else", "emit_move_insn", "(", "reg", ",", "mem", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "*", "cfi_ops", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "restore", "the", "callee", "registers", "of", "mode", "MODE", "from", "register", "number", "START", "up", "to", "and", "including", "LIMIT", ".", "Restore", "from", "the", "stack", "offset", "START_OFFSET", ",", "skipping", "any", "write-back", "candidates", "if", "SKIP_WB", "is", "true", ".", "Write", "the", "appropriate", "REG_CFA_RESTORE", "notes", "into", "CFI_OPS", "." ]

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

[]

[ "<s>", "poly_uint64", "riscv_regmode_natural_size", "(", "machine_mode", "mode", ")", "{", "if", "(", "!", "riscv_vector_chunks", ".", "is_constant", "(", ")", "&&", "riscv_v_ext_vector_mode_p", "(", "mode", ")", ")", "return", "BYTES_PER_RISCV_VECTOR", ";", "return", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "REGMODE_NATURAL_SIZE", "." ]

[ "riscv" ]

[]

[ "<s>", "int", "pa_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "length", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "(", "unsigned", "int", ")", "length", ">=", "INT_MAX", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SEQUENCE", ")", "insn", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_MILLI", ":", "length", "=", "pa_attr_length_millicode_call", "(", "insn", ")", ";", "break", ";", "case", "TYPE_CALL", ":", "length", "=", "pa_attr_length_call", "(", "insn", ",", "0", ")", ";", "break", ";", "case", "TYPE_SIBCALL", ":", "length", "=", "pa_attr_length_call", "(", "insn", ",", "1", ")", ";", "break", ";", "case", "TYPE_DYNCALL", ":", "length", "=", "pa_attr_length_indirect_call", "(", "insn", ")", ";", "break", ";", "case", "TYPE_SH_FUNC_ADRS", ":", "length", "=", "pa_attr_length_millicode_call", "(", "insn", ")", "+", "20", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "1", ")", ")", "==", "MEM", "&&", "GET_MODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ")", "==", "BLKmode", "&&", "GET_MODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "1", ")", ")", "==", "BLKmode", ")", "length", "+=", "compute_cpymem_length", "(", "insn", ")", "-", "4", ";", "else", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ")", "==", "MEM", "&&", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "1", ")", "==", "const0_rtx", "&&", "GET_MODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ")", "==", "BLKmode", ")", "length", "+=", "compute_clrmem_length", "(", "insn", ")", "-", "4", ";", "else", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "!", "simplejump_p", "(", "insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", "&&", "length", "==", "4", "&&", "JUMP_LABEL", "(", "insn", ")", "!=", "NULL_RTX", "&&", "!", "forward_branch_p", "(", "insn", ")", ")", "length", "+=", "4", ";", "else", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_PARALLEL_BRANCH", "&&", "length", "==", "4", ")", "length", "+=", "4", ";", "else", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ",", "0", ")", ")", "==", "REG", "&&", "!", "FP_REG_P", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ",", "0", ")", ")", "&&", "length", "==", "4", "&&", "!", "forward_branch_p", "(", "insn", ")", ")", "length", "+=", "4", ";", "}", "return", "length", ";", "}", "</s>" ]

[ "Return", "any", "length", "adjustment", "needed", "by", "INSN", "which", "already", "has", "its", "length", "computed", "as", "LENGTH", ".", "Return", "zero", "if", "no", "adjustment", "is", "necessary", ".", "For", "the", "PA", ":", "function", "calls", ",", "millicode", "calls", ",", "and", "backwards", "short", "conditional", "branches", "with", "unfilled", "delay", "slots", "need", "an", "adjustment", "by", "+1", "(", "to", "account", "for", "the", "NOP", "which", "will", "be", "inserted", "into", "the", "instruction", "stream", ")", ".", "Also", "compute", "the", "length", "of", "an", "inline", "block", "move", "here", "as", "it", "is", "too", "complicated", "to", "express", "as", "a", "length", "attribute", "in", "pa.md", "." ]

[ "pa", "0", "0", "0", "1", "20", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "1", "4", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "4", "4", "4", "4", "4", "0", "1", "0", "1", "0", "0", "1", "0", "4", "4" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "Options", ".", "StackAlignmentOverride", ")", ",", "FrameLowering", "(", "*", "this", ",", "Subtarget", ")", ",", "InstrItins", "(", "Subtarget", ".", "getInstrItineraryData", "(", ")", ")", ",", "DL", "(", "computeDataLayout", "(", "*", "getSubtargetImpl", "(", ")", ")", ")", ",", "InstrInfo", "(", "*", "this", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", ",", "JITInfo", "(", "*", "this", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetCOFF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "Subtarget", ".", "isTargetELF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

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

[]

[ "<s>", "static", "rtx", "mips16_gp_pseudo_reg", "(", "void", ")", "{", "if", "(", "cfun", "->", "machine", "->", "mips16_gp_pseudo_rtx", "==", "NULL_RTX", ")", "{", "rtx_insn", "*", "scan", ";", "cfun", "->", "machine", "->", "mips16_gp_pseudo_rtx", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "push_topmost_sequence", "(", ")", ";", "scan", "=", "get_insns", "(", ")", ";", "while", "(", "NEXT_INSN", "(", "scan", ")", "&&", "!", "INSN_P", "(", "NEXT_INSN", "(", "scan", ")", ")", ")", "scan", "=", "NEXT_INSN", "(", "scan", ")", ";", "rtx", "set", "=", "gen_load_const_gp", "(", "cfun", "->", "machine", "->", "mips16_gp_pseudo_rtx", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn_after", "(", "set", ",", "scan", ")", ";", "INSN_LOCATION", "(", "insn", ")", "=", "0", ";", "pop_topmost_sequence", "(", ")", ";", "}", "return", "cfun", "->", "machine", "->", "mips16_gp_pseudo_rtx", ";", "}", "</s>" ]

[ "If", "we", "can", "access", "small", "data", "directly", "(", "using", "gp-relative", "relocation", "operators", ")", "return", "the", "small", "data", "pointer", ",", "otherwise", "return", "null", ".", "For", "each", "mips16", "function", "which", "refers", "to", "GP", "relative", "symbols", ",", "we", "use", "a", "pseudo", "register", ",", "initialized", "at", "the", "start", "of", "the", "function", ",", "to", "hold", "the", "$", "gp", "value", "." ]

[ "mips", "0" ]

[]

[ "<s>", "bool", "s390_fma_allowed_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_VXE", "&&", "mode", "==", "TFmode", ")", "return", "flag_vx_long_double_fma", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "it", "'s", "OK", "to", "use", "fused", "multiply-add", "for", "MODE", "." ]

[ "s390" ]

[]

[ "<s>", "static", "int", "arm_block_set_max_insns", "(", "void", ")", "{", "if", "(", "optimize_function_for_size_p", "(", "cfun", ")", ")", "return", "4", ";", "else", "return", "current_tune", "->", "max_insns_inline_memset", ";", "}", "</s>" ]

[ "Maximum", "number", "of", "instructions", "to", "set", "block", "of", "memory", "." ]

[ "arm", "4" ]

[]

[ "<s>", "static", "bool", "mips_cfun_has_inflexible_gp_ref_p", "(", "void", ")", "{", "if", "(", "crtl", "->", "has_nonlocal_goto", ")", "return", "true", ";", "if", "(", "TARGET_ABICALLS_PIC2", ")", "{", "if", "(", "!", "TARGET_EXPLICIT_RELOCS", ")", "return", "true", ";", "if", "(", "crtl", "->", "profile", ")", "return", "true", ";", "if", "(", "mips16_cfun_returns_in_fpr_p", "(", ")", ")", "return", "true", ";", "}", "return", "mips_find_gp_ref", "(", "&", "cfun", "->", "machine", "->", "has_inflexible_gp_insn_p", ",", "mips_insn_has_inflexible_gp_ref_p", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "current", "function", "refers", "to", "the", "global", "pointer", "in", "a", "way", "that", "forces", "$", "28", "to", "be", "valid", ".", "This", "means", "that", "we", "ca", "n't", "change", "the", "choice", "of", "global", "pointer", ",", "even", "for", "NewABI", "code", ".", "One", "example", "of", "this", "(", "and", "one", "which", "needs", "several", "checks", ")", "is", "that", "$", "28", "must", "be", "valid", "when", "calling", "traditional", "MIPS", "lazy-binding", "stubs", ".", "(", "This", "restriction", "does", "not", "apply", "to", "PLTs", ".", ")" ]

[ "mips" ]

[]

[ "<s>", "bool", "ix86_cannot_change_mode_class", "(", "enum", "machine_mode", "from", ",", "enum", "machine_mode", "to", ",", "enum", "reg_class", "class", ")", "{", "if", "(", "from", "==", "to", ")", "return", "false", ";", "if", "(", "MAYBE_FLOAT_CLASS_P", "(", "class", ")", ")", "return", "true", ";", "if", "(", "MAYBE_SSE_CLASS_P", "(", "class", ")", "||", "MAYBE_MMX_CLASS_P", "(", "class", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "from", ")", "<", "4", ")", "return", "true", ";", "if", "(", "GET_MODE_SIZE", "(", "to", ")", "<", "GET_MODE_SIZE", "(", "from", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "registers", "in", "CLASS", "can", "not", "represent", "the", "change", "from", "modes", "FROM", "to", "TO", "." ]

[ "i386", "4" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "getMachineCombinerPatterns", "(", "MachineInstr", "&", "Root", ",", "SmallVectorImpl", "<", "MachineCombinerPattern", "::", "MC_PATTERN", ">", "&", "Patterns", ")", "const", "{", "if", "(", "!", "Root", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "Options", ".", "UnsafeFPMath", ")", "return", "false", ";", "bool", "Commute", ";", "if", "(", "isReassocCandidate", "(", "Root", ",", "Commute", ")", ")", "{", "if", "(", "Commute", ")", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MC_REASSOC_AX_YB", ")", ";", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MC_REASSOC_XA_YB", ")", ";", "}", "else", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MC_REASSOC_AX_BY", ")", ";", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MC_REASSOC_XA_BY", ")", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "when", "there", "is", "potentially", "a", "faster", "code", "sequence", "for", "an", "instruction", "chain", "ending", "in", "Root", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "XCoreFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", "->", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "bool", "emitFrameMoves", "=", "XCoreRegisterInfo", "::", "needsFrameMoves", "(", "*", "MF", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugValue", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "unsigned", "Reg", "=", "it", "->", "getReg", "(", ")", ";", "assert", "(", "Reg", "!=", "XCore", "::", "LR", "&&", "!", "(", "Reg", "==", "XCore", "::", "R10", "&&", "hasFP", "(", "*", "MF", ")", ")", "&&", "\"LR & FP are always handled in emitPrologue\"", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "it", "->", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "auto", "Store", "=", "MI", ";", "--", "Store", ";", "XFI", "->", "getSpillLabels", "(", ")", ".", "push_back", "(", "std", "::", "make_pair", "(", "Store", ",", "*", "it", ")", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore", "XCore", "XCore::LR", "XCore::R10", "\"LR & FP are always handled in emitPrologue\"" ]

[]

[ "<s>", "unsigned", "getELFArch", "(", ")", "const", "{", "assert", "(", "ELFArch", "!=", "0", "&&", "\"every device must have an associate ELF architecture\"", ")", ";", "return", "ELFArch", ";", "}", "</s>" ]

[ "Gets", "the", "ELF", "architecture", "for", "the", "e_flags", "field", "of", "an", "ELF", "object", "file", "." ]

[ "AVR", "0", "\"every device must have an associate ELF architecture\"" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "isRegNumber", "(", ")", "&&", "\"Invalid access!\"", ")", ";", "return", "(", "unsigned", ")", "Imm", ".", "Val", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "PowerPC", "\"Invalid access!\"" ]

[]

[ "<s>", "int", "scalar_chain", "::", "convert", "(", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "id", ";", "int", "converted_insns", "=", "0", ";", "if", "(", "!", "dbg_cnt", "(", "stv_conversion", ")", ")", "return", "0", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Converting chain #%d...\\n\"", ",", "chain_id", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "defs", ",", "0", ",", "id", ",", "bi", ")", "convert_reg", "(", "id", ")", ";", "EXECUTE_IF_AND_COMPL_IN_BITMAP", "(", "defs_conv", ",", "defs", ",", "0", ",", "id", ",", "bi", ")", "make_vector_copies", "(", "id", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "insns", ",", "0", ",", "id", ",", "bi", ")", "{", "convert_insn", "(", "DF_INSN_UID_GET", "(", "id", ")", "->", "insn", ")", ";", "converted_insns", "++", ";", "}", "return", "converted_insns", ";", "}", "</s>" ]

[ "Convert", "whole", "chain", "creating", "required", "register", "conversions", "and", "copies", "." ]

[ "i386", "0", "0", "\"Converting chain #%d...\\n\"", "0", "0", "0" ]

[]

[ "<s>", "bool", "msp430_use_f5_series_hwmult", "(", "void", ")", "{", "static", "const", "char", "*", "cached_match", "=", "NULL", ";", "static", "bool", "cached_result", ";", "if", "(", "msp430_hwmult_type", "==", "MSP430_HWMULT_F5SERIES", ")", "return", "true", ";", "if", "(", "target_mcu", "==", "NULL", "||", "msp430_hwmult_type", "!=", "MSP430_HWMULT_AUTO", ")", "return", "false", ";", "if", "(", "target_mcu", "==", "cached_match", ")", "return", "cached_result", ";", "cached_match", "=", "target_mcu", ";", "if", "(", "strncasecmp", "(", "target_mcu", ",", "\"msp430f5\"", ",", "8", ")", "==", "0", ")", "return", "cached_result", "=", "true", ";", "if", "(", "strncasecmp", "(", "target_mcu", ",", "\"msp430fr5\"", ",", "9", ")", "==", "0", ")", "return", "cached_result", "=", "true", ";", "if", "(", "strncasecmp", "(", "target_mcu", ",", "\"msp430f6\"", ",", "8", ")", "==", "0", ")", "return", "cached_result", "=", "true", ";", "int", "i", ";", "for", "(", "i", "=", "ARRAY_SIZE", "(", "msp430_mcu_data", ")", ";", "i", "--", ";", ")", "if", "(", "strcasecmp", "(", "target_mcu", ",", "msp430_mcu_data", "[", "i", "]", ".", "name", ")", "==", "0", ")", "return", "cached_result", "=", "msp430_mcu_data", "[", "i", "]", ".", "hwmpy", "==", "8", ";", "return", "cached_result", "=", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "current", "MCU", "supports", "an", "F5xxx", "series", "hardware", "multiper", "." ]

[ "msp430", "\"msp430f5\"", "8", "0", "\"msp430fr5\"", "9", "0", "\"msp430f6\"", "8", "0", "0", "8" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "{", "SDValue", "Result", "=", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "assert", "(", "(", "!", "Result", ".", "getNode", "(", ")", "||", "Result", ".", "getNode", "(", ")", "->", "getNumValues", "(", ")", "==", "2", ")", "&&", "\"Load should return a value and a chain\"", ")", ";", "return", "Result", ";", "}", "case", "ISD", "::", "FSIN", ":", "case", "ISD", "::", "FCOS", ":", "return", "LowerTrig", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerFDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "return", "LowerATOMIC_CMP_SWAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "LowerGlobalAddress", "(", "MFI", ",", "Op", ",", "DAG", ")", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADDRSPACECAST", ":", "return", "lowerADDRSPACECAST", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "lowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "lowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "lowerFP_ROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRAP", ":", "case", "ISD", "::", "DEBUGTRAP", ":", "return", "lowerTRAP", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "ISD::BRCOND", "ISD::LOAD", "2", "\"Load should return a value and a chain\"", "ISD::FSIN", "ISD::FCOS", "ISD::SELECT", "ISD::FDIV", "ISD::ATOMIC_CMP_SWAP", "ISD::STORE", "ISD::GlobalAddress", "SI", "SI", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::INTRINSIC_W_CHAIN", "SI", "ISD::INTRINSIC_VOID", "SI", "ISD::ADDRSPACECAST", "ISD::INSERT_VECTOR_ELT", "ISD::EXTRACT_VECTOR_ELT", "ISD::FP_ROUND", "ISD::TRAP", "ISD::DEBUGTRAP" ]

[]

[ "<s>", "static", "int", "aarch64_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", "misalign", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "elements", ";", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "scalar_stmt_cost", ";", "case", "scalar_load", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "scalar_load_cost", ";", "case", "scalar_store", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "scalar_store_cost", ";", "case", "vector_stmt", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "vec_stmt_cost", ";", "case", "vector_load", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "vec_align_load_cost", ";", "case", "vector_store", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "vec_store_cost", ";", "case", "vec_to_scalar", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "vec_to_scalar_cost", ";", "case", "scalar_to_vec", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "scalar_to_vec_cost", ";", "case", "unaligned_load", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "vec_unalign_load_cost", ";", "case", "unaligned_store", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "vec_unalign_store_cost", ";", "case", "cond_branch_taken", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "cond_taken_branch_cost", ";", "case", "cond_branch_not_taken", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "cond_not_taken_branch_cost", ";", "case", "vec_perm", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "vec_permute_cost", ";", "case", "vec_promote_demote", ":", "return", "aarch64_tune_params", ".", "vec_costs", "->", "vec_stmt_cost", ";", "case", "vec_construct", ":", "elements", "=", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ";", "return", "elements", "/", "2", "+", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "{", "if", "(", "isSpecialLLVMGlobalArrayToSkip", "(", "GV", ")", "||", "isSpecialLLVMGlobalArrayForStaticInit", "(", "GV", ")", ")", "return", ";", "if", "(", "GV", "->", "hasAttribute", "(", "\"toc-data\"", ")", ")", "{", "TOCDataGlobalVars", ".", "push_back", "(", "GV", ")", ";", "return", ";", "}", "emitGlobalVariableHelper", "(", "GV", ")", ";", "}", "</s>" ]

[ "Emit", "the", "specified", "global", "variable", "to", "the", ".s", "file", "." ]

[ "PowerPC", "PPC", "\"toc-data\"" ]

[]

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

[ "Return", "true", "if", "target", "does", "n't", "mind", "addresses", "in", "vectors", "." ]

[ "SystemZ" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "getTargetNode", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flag", ")", "const", "{", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "if", "(", "GlobalAddressSDNode", "*", "N", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetGlobalAddress", "(", "N", "->", "getGlobal", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "Ty", ",", "0", ",", "Flag", ")", ";", "if", "(", "ExternalSymbolSDNode", "*", "N", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetExternalSymbol", "(", "N", "->", "getSymbol", "(", ")", ",", "Ty", ",", "Flag", ")", ";", "if", "(", "BlockAddressSDNode", "*", "N", "=", "dyn_cast", "<", "BlockAddressSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetBlockAddress", "(", "N", "->", "getBlockAddress", "(", ")", ",", "Ty", ",", "0", ",", "Flag", ")", ";", "if", "(", "JumpTableSDNode", "*", "N", "=", "dyn_cast", "<", "JumpTableSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetJumpTable", "(", "N", "->", "getIndex", "(", ")", ",", "Ty", ",", "Flag", ")", ";", "if", "(", "ConstantPoolSDNode", "*", "N", "=", "dyn_cast", "<", "ConstantPoolSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetConstantPool", "(", "N", "->", "getConstVal", "(", ")", ",", "Ty", ",", "N", "->", "getAlignment", "(", ")", ",", "N", "->", "getOffset", "(", ")", ",", "Flag", ")", ";", "llvm_unreachable", "(", "\"Unexpected node type.\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Retrieve", "the", "target", "node", "this", "edge", "connects", "to", "." ]

[ "RISCV", "RISCV", "0", "0", "\"Unexpected node type.\"" ]

[]

[ "<s>", "unsigned", "HexagonRegisterInfo", "::", "getRegPressureSetLimit", "(", "unsigned", "Idx", ")", "const", "{", "static", "const", "int", "RegPressureLimit", "[", "]", "=", "{", "16", ",", "4", ",", "2", ",", "8", "}", ";", "assert", "(", "(", "Idx", "<", "4", ")", "&&", "\"Index out of bounds\"", ")", ";", "return", "RegPressureLimit", "[", "Idx", "]", ";", "}", "</s>" ]

[ "Get", "the", "register", "unit", "pressure", "limit", "for", "this", "dimension", "." ]

[ "Hexagon", "Hexagon", "16", "4", "2", "8", "4", "\"Index out of bounds\"" ]

[]

[ "<s>", "static", "void", "i386_pe_mark_dllimport", "(", "tree", "decl", ")", "{", "const", "char", "*", "oldname", ";", "char", "*", "newname", ";", "tree", "idp", ";", "rtx", "rtlname", ",", "newrtl", ";", "rtx", "symref", ";", "rtlname", "=", "XEXP", "(", "DECL_RTL", "(", "decl", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "rtlname", ")", "==", "MEM", ")", "rtlname", "=", "XEXP", "(", "rtlname", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "rtlname", ")", "==", "SYMBOL_REF", ")", ";", "oldname", "=", "XSTR", "(", "rtlname", ",", "0", ")", ";", "if", "(", "i386_pe_dllexport_name_p", "(", "oldname", ")", ")", "{", "error", "(", "\"%qs declared as both exported to and imported from a DLL\"", ",", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "decl", ")", ")", ")", ";", "return", ";", "}", "else", "if", "(", "i386_pe_dllimport_name_p", "(", "oldname", ")", ")", "{", "gcc_assert", "(", "DECL_EXTERNAL", "(", "decl", ")", "&&", "TREE_PUBLIC", "(", "decl", ")", "&&", "DECL_DLLIMPORT_P", "(", "decl", ")", ")", ";", "return", ";", "}", "newname", "=", "alloca", "(", "strlen", "(", "DLL_IMPORT_PREFIX", ")", "+", "strlen", "(", "oldname", ")", "+", "1", ")", ";", "sprintf", "(", "newname", ",", "\"%s%s\"", ",", "DLL_IMPORT_PREFIX", ",", "oldname", ")", ";", "idp", "=", "get_identifier", "(", "newname", ")", ";", "symref", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "IDENTIFIER_POINTER", "(", "idp", ")", ")", ";", "SYMBOL_REF_DECL", "(", "symref", ")", "=", "decl", ";", "newrtl", "=", "gen_rtx_MEM", "(", "Pmode", ",", "symref", ")", ";", "XEXP", "(", "DECL_RTL", "(", "decl", ")", ",", "0", ")", "=", "newrtl", ";", "DECL_DLLIMPORT_P", "(", "decl", ")", "=", "1", ";", "}", "</s>" ]

[ "Mark", "a", "DECL", "as", "being", "dllimport", "'d", "." ]

[ "i386", "0", "0", "0", "\"%qs declared as both exported to and imported from a DLL\"", "1", "\"%s%s\"", "0", "1" ]

[]

[ "<s>", "static", "bool", "arc_must_save_register", "(", "int", "regno", ",", "struct", "function", "*", "func", ",", "bool", "special_p", ")", "{", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "func", ")", ";", "bool", "irq_auto_save_p", "=", "(", "(", "irq_ctrl_saved", ".", "irq_save_last_reg", ">=", "regno", ")", "&&", "ARC_AUTO_IRQ_P", "(", "fn_type", ")", ")", ";", "bool", "firq_auto_save_p", "=", "ARC_FAST_INTERRUPT_P", "(", "fn_type", ")", ";", "switch", "(", "rgf_banked_register_count", ")", "{", "case", "4", ":", "firq_auto_save_p", "&=", "(", "regno", "<", "4", ")", ";", "break", ";", "case", "8", ":", "firq_auto_save_p", "&=", "(", "(", "regno", "<", "4", ")", "||", "(", "(", "regno", ">", "11", ")", "&&", "(", "regno", "<", "16", ")", ")", ")", ";", "break", ";", "case", "16", ":", "firq_auto_save_p", "&=", "(", "(", "regno", "<", "4", ")", "||", "(", "(", "regno", ">", "9", ")", "&&", "(", "regno", "<", "16", ")", ")", "||", "(", "(", "regno", ">", "25", ")", "&&", "(", "regno", "<", "29", ")", ")", "||", "(", "(", "regno", ">", "29", ")", "&&", "(", "regno", "<", "32", ")", ")", ")", ";", "break", ";", "case", "32", ":", "firq_auto_save_p", "&=", "(", "regno", "!=", "29", ")", "&&", "(", "regno", "<", "32", ")", ";", "break", ";", "default", ":", "firq_auto_save_p", "=", "false", ";", "break", ";", "}", "switch", "(", "regno", ")", "{", "case", "ILINK1_REG", ":", "case", "RETURN_ADDR_REGNUM", ":", "case", "STACK_POINTER_REGNUM", ":", "return", "false", ";", "case", "R30_REG", ":", "if", "(", "!", "TARGET_V2", ")", "return", "false", ";", "break", ";", "case", "R40_REG", ":", "case", "R41_REG", ":", "case", "R42_REG", ":", "case", "R43_REG", ":", "case", "R44_REG", ":", "if", "(", "TARGET_DPFP", "&&", "!", "special_p", ")", "return", "false", ";", "case", "R32_REG", ":", "case", "R33_REG", ":", "case", "R34_REG", ":", "case", "R35_REG", ":", "case", "R36_REG", ":", "case", "R37_REG", ":", "case", "R38_REG", ":", "case", "R39_REG", ":", "case", "R45_REG", ":", "case", "R46_REG", ":", "case", "R47_REG", ":", "case", "R48_REG", ":", "case", "R49_REG", ":", "case", "R50_REG", ":", "case", "R51_REG", ":", "case", "R52_REG", ":", "case", "R53_REG", ":", "case", "R54_REG", ":", "case", "R55_REG", ":", "case", "R56_REG", ":", "case", "R57_REG", ":", "if", "(", "ARC_INTERRUPT_P", "(", "fn_type", ")", "&&", "(", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", "||", "df_regs_ever_live_p", "(", "regno", ")", ")", "&&", "!", "fixed_regs", "[", "regno", "]", ")", "return", "true", ";", "return", "false", ";", "case", "R58_REG", ":", "case", "R59_REG", ":", "if", "(", "ARC_INTERRUPT_P", "(", "fn_type", ")", "&&", "(", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", "||", "df_regs_ever_live_p", "(", "regno", ")", ")", "&&", "(", "(", "!", "fixed_regs", "[", "regno", "]", "&&", "!", "special_p", ")", "||", "(", "TARGET_MUL64_SET", "&&", "special_p", ")", ")", ")", "return", "true", ";", "return", "false", ";", "case", "61", ":", "case", "62", ":", "case", "63", ":", "return", "false", ";", "case", "HARD_FRAME_POINTER_REGNUM", ":", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "return", "false", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "(", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "||", "(", "ARC_INTERRUPT_P", "(", "fn_type", ")", "&&", "(", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", "||", "df_regs_ever_live_p", "(", "regno", ")", ")", ")", ")", "&&", "!", "irq_auto_save_p", "&&", "!", "firq_auto_save_p", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Tell", "prologue", "and", "epilogue", "if", "register", "REGNO", "should", "be", "saved", "/", "restored", ".", "The", "return", "address", ",", "stack", "pointer", "and", "frame", "pointer", "are", "treated", "separately", ".", "Do", "n't", "consider", "them", "here", ".", "Addition", "for", "pic", ":", "The", "gp", "register", "needs", "to", "be", "saved", "if", "the", "current", "function", "changes", "it", "to", "access", "gotoff", "variables", ".", "FIXME", ":", "This", "will", "not", "be", "needed", "if", "we", "used", "some", "arbitrary", "register", "instead", "of", "r26", "." ]

[ "arc", "4", "4", "8", "4", "11", "16", "16", "4", "9", "16", "25", "29", "29", "32", "32", "29", "32", "61", "62", "63" ]

[]

[ "<s>", "void", "initialize", "(", "unsigned", "LHS", ",", "unsigned", "RHS", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "True", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "LHSReg", "=", "LHS", ";", "RHSReg", "=", "RHS", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "LHS", ")", ")", "{", "MachineInstr", "*", "DefI", "=", "MRI", ".", "getVRegDef", "(", "LHS", ")", ";", "if", "(", "DefI", "->", "getOpcode", "(", ")", "==", "GB", "::", "LD_dd_nn", ")", "{", "LHSReg", "=", "0", ";", "LHSImm", "=", "DefI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "}", "}", "if", "(", "!", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "RHSReg", ")", ")", "{", "MachineInstr", "*", "DefI", "=", "MRI", ".", "getVRegDef", "(", "RHSReg", ")", ";", "if", "(", "DefI", "->", "getOpcode", "(", ")", "==", "GB", "::", "LD_dd_nn", ")", "{", "RHSReg", "=", "0", ";", "RHSImm", "=", "DefI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "}", "}", "canonicalize", "(", ")", ";", "}", "</s>" ]

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

[ "GBZ80", "GB::LD_dd_nn", "0", "1", "GB::LD_dd_nn", "0", "1" ]

[]

[ "<s>", "static", "bool", "csky_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "int", "nregs", "=", "CSKY_NUM_REGS", "(", "mode", ")", ";", "if", "(", "nregs", ">", "2", ")", "return", "false", ";", "if", "(", "regno", "<", "CSKY_NGPR_REGS", ")", "{", "if", "(", "nregs", "<", "2", ")", "return", "true", ";", "else", "if", "(", "TARGET_MINI_REGISTERS", ")", "return", "(", "regno", "<", "CSKY_LAST_MINI_REGNUM", ")", ";", "else", "if", "(", "CSKY_TARGET_ARCH", "(", "CK802", ")", "||", "CSKY_TARGET_ARCH", "(", "CK803", ")", "||", "!", "TARGET_HIGH_REGISTERS", ")", "return", "(", "regno", "<", "(", "CSKY_SP_REGNUM", "-", "1", ")", ")", ";", "else", "return", "(", "regno", "<", "(", "CSKY_SP_REGNUM", "-", "1", ")", "||", "(", "regno", ">=", "CSKY_LR_REGNUM", "&&", "regno", "<", "CSKY_LAST_HIGH_UNFIXED_REGNUM", ")", ")", ";", "}", "else", "if", "(", "regno", "==", "CSKY_CC_REGNUM", ")", "return", "(", "mode", "==", "CCmode", ")", ";", "else", "if", "(", "regno", "==", "CSKY_HI_REGNUM", "||", "regno", "==", "CSKY_LO_REGNUM", ")", "{", "if", "(", "!", "TARGET_DSP", "||", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", "return", "false", ";", "else", "if", "(", "nregs", "==", "2", ")", "return", "(", "regno", "==", "CSKY_HI_REGNUM", ")", ";", "else", "return", "true", ";", "}", "else", "if", "(", "CSKY_VREG_P", "(", "regno", ")", "&&", "TARGET_HARD_FLOAT", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", ".", "Return", "true", "if", "REGNO", "is", "a", "valid", "register", "for", "holding", "a", "quantity", "of", "type", "MODE", "." ]

[ "csky", "2", "2", "1", "1", "2" ]

[]

[ "<s>", "static", "bool", "alpha_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", "=", "VOIDmode", ";", "int", "size", ";", "if", "(", "type", ")", "{", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "TARGET_ABI_OPEN_VMS", "&&", "TREE_CODE", "(", "type", ")", "!=", "ARRAY_TYPE", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", "<=", "8", ")", "return", "false", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "true", ";", "}", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_VECTOR_FLOAT", ":", "return", "true", ";", "case", "MODE_COMPLEX_FLOAT", ":", "size", "=", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ";", "break", ";", "case", "MODE_INT", ":", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_INT", ":", "case", "MODE_VECTOR_INT", ":", "break", ";", "default", ":", "return", "true", ";", "}", "return", "size", ">", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Return", "true", "if", "TYPE", "must", "be", "returned", "in", "memory", ",", "instead", "of", "in", "registers", "." ]

[ "alpha", "8" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "reserveIndirectRegisters", "(", "BitVector", "&", "Reserved", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "int", "End", "=", "getIndirectIndexEnd", "(", "MF", ")", ";", "int", "Begin", "=", "getIndirectIndexBegin", "(", "MF", ")", ";", "if", "(", "End", "==", "-", "1", ")", "return", ";", "for", "(", "int", "Index", "=", "Begin", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "1", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_64RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "2", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_96RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "3", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_128RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "7", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_256RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "for", "(", "int", "Index", "=", "std", "::", "max", "(", "0", ",", "Begin", "-", "15", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "Reserved", ".", "set", "(", "AMDGPU", "::", "VReg_512RegClass", ".", "getRegister", "(", "Index", ")", ")", ";", "}", "</s>" ]

[ "Reserve", "the", "registers", "that", "may", "be", "accessed", "using", "indirect", "addressing", "." ]

[ "AMDGPU", "SI", "1", "AMDGPU::VGPR_32RegClass", "0", "1", "AMDGPU::VReg_64RegClass", "0", "2", "AMDGPU::VReg_96RegClass", "0", "3", "AMDGPU::VReg_128RegClass", "0", "7", "AMDGPU::VReg_256RegClass", "0", "15", "AMDGPU::VReg_512RegClass" ]

[]

[ "<s>", "static", "void", "eco32_operand_lossage", "(", "const", "char", "*", "msgid", ",", "rtx", "op", ")", "{", "debug_rtx", "(", "op", ")", ";", "output_operand_lossage", "(", "\"%s\"", ",", "msgid", ")", ";", "}", "</s>" ]

[ "Emit", "an", "error", "message", "when", "we", "'re", "in", "an", "asm", ",", "and", "a", "fatal", "error", "for", "``", "normal", "''", "insns", ".", "Formatted", "output", "is", "n't", "easily", "implemented", ",", "since", "we", "use", "output_operand_lossage", "to", "output", "the", "actual", "message", "and", "handle", "the", "categorization", "of", "the", "error", "." ]

[ "eco32", "\"%s\"" ]

[]

[ "<s>", "static", "void", "bfin_asm_trampoline_template", "(", "FILE", "*", "f", ")", "{", "if", "(", "TARGET_FDPIC", ")", "{", "fprintf", "(", "f", ",", "\"\\t.dd\\t0x00000000\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.dd\\t0x00000000\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.dd\\t0x0000e109\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.dd\\t0x0000e149\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.dd\\t0x0000e10a\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.dd\\t0x0000e14a\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.dw\\t0xac4b\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.dw\\t0x9149\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.dw\\t0x0051\\n\"", ")", ";", "}", "else", "{", "fprintf", "(", "f", ",", "\"\\t.dd\\t0x0000e109\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.dd\\t0x0000e149\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.dd\\t0x0000e10a\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.dd\\t0x0000e14a\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.dw\\t0x0051\\n\"", ")", ";", "}", "}", "</s>" ]

[ "Write", "a", "template", "for", "a", "trampoline", "to", "F", "." ]

[ "bfin", "\"\\t.dd\\t0x00000000\\n\"", "\"\\t.dd\\t0x00000000\\n\"", "\"\\t.dd\\t0x0000e109\\n\"", "\"\\t.dd\\t0x0000e149\\n\"", "\"\\t.dd\\t0x0000e10a\\n\"", "\"\\t.dd\\t0x0000e14a\\n\"", "\"\\t.dw\\t0xac4b\\n\"", "\"\\t.dw\\t0x9149\\n\"", "\"\\t.dw\\t0x0051\\n\"", "\"\\t.dd\\t0x0000e109\\n\"", "\"\\t.dd\\t0x0000e149\\n\"", "\"\\t.dd\\t0x0000e10a\\n\"", "\"\\t.dd\\t0x0000e14a\\n\"", "\"\\t.dw\\t0x0051\\n\"" ]

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "0", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "uint64_t", "CalleeAmt", "=", "Old", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "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", "0", "0", "1", "0", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "1", "MSP430::ADD16ri", "MSP430::SPW", "MSP430::SPW", "3", "1", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "isSimpleMove", "(", "MI", ",", "FrameIndex", ",", "RISCVII", "::", "SimpleStore", ")", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "RISCV", "RISCV", "RISCVII::SimpleStore" ]

[]

[ "<s>", "bool", "PPCLoopDataPrefetch", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ".", "getSE", "(", ")", ";", "DL", "=", "&", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "AC", "=", "&", "getAnalysis", "<", "AssumptionCacheTracker", ">", "(", ")", ".", "getAssumptionCache", "(", "F", ")", ";", "TTI", "=", "&", "getAnalysis", "<", "TargetTransformInfoWrapperPass", ">", "(", ")", ".", "getTTI", "(", "F", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "auto", "I", "=", "LI", "->", "begin", "(", ")", ",", "IE", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "L", "=", "df_begin", "(", "*", "I", ")", ",", "LE", "=", "df_end", "(", "*", "I", ")", ";", "L", "!=", "LE", ";", "++", "L", ")", "MadeChange", "|=", "runOnLoop", "(", "*", "L", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "SDValue", "LM32TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_LM32", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "LM32", "LM32", "ISD::InputArg", "16", "LM32", "0", "1", "2", "0" ]

[]

[ "<s>", "unsigned", "BlackfinIntrinsicInfo", "::", "lookupName", "(", "const", "char", "*", "Name", ",", "unsigned", "Len", ")", "const", "{", "if", "(", "Len", "<", "5", "||", "Name", "[", "4", "]", "!=", "'.'", "||", "Name", "[", "0", "]", "!=", "'l'", "||", "Name", "[", "1", "]", "!=", "'l'", "||", "Name", "[", "2", "]", "!=", "'v'", "||", "Name", "[", "3", "]", "!=", "'m'", ")", "return", "0", ";", "return", "0", ";", "}", "</s>" ]

[ "Look", "up", "target", "intrinsic", "by", "name", "." ]

[ "Blackfin", "5", "4", "0", "1", "2", "3", "0", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "get_some_local_dynamic_name", "(", "void", ")", "{", "rtx", "insn", ";", "if", "(", "cfun", "->", "machine", "->", "some_ld_name", ")", "return", "cfun", "->", "machine", "->", "some_ld_name", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "for_each_rtx", "(", "&", "PATTERN", "(", "insn", ")", ",", "get_some_local_dynamic_name_1", ",", "0", ")", ")", "return", "cfun", "->", "machine", "->", "some_ld_name", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Locate", "some", "local-dynamic", "symbol", "still", "in", "use", "by", "this", "function", "so", "that", "we", "can", "print", "its", "name", "in", "local-dynamic", "base", "patterns", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "riscv_legitimize_move", "(", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "UNITS_PER_WORD", "&&", "can_create_pseudo_p", "(", ")", "&&", "MEM_P", "(", "src", ")", ")", "{", "rtx", "temp_reg", ";", "int", "zero_extend_p", ";", "temp_reg", "=", "gen_reg_rtx", "(", "word_mode", ")", ";", "zero_extend_p", "=", "(", "LOAD_EXTEND_OP", "(", "mode", ")", "==", "ZERO_EXTEND", ")", ";", "emit_insn", "(", "gen_extend_insn", "(", "temp_reg", ",", "src", ",", "word_mode", ",", "mode", ",", "zero_extend_p", ")", ")", ";", "riscv_emit_move", "(", "dest", ",", "gen_lowpart", "(", "mode", ",", "temp_reg", ")", ")", ";", "return", "true", ";", "}", "if", "(", "!", "register_operand", "(", "dest", ",", "mode", ")", "&&", "!", "reg_or_0_operand", "(", "src", ",", "mode", ")", ")", "{", "rtx", "reg", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", ")", "{", "machine_mode", "promoted_mode", "=", "mode", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "UNITS_PER_WORD", ")", "promoted_mode", "=", "word_mode", ";", "if", "(", "splittable_const_int_operand", "(", "src", ",", "mode", ")", ")", "{", "reg", "=", "gen_reg_rtx", "(", "promoted_mode", ")", ";", "riscv_move_integer", "(", "reg", ",", "reg", ",", "INTVAL", "(", "src", ")", ",", "mode", ",", "FALSE", ")", ";", "}", "else", "reg", "=", "force_reg", "(", "promoted_mode", ",", "src", ")", ";", "if", "(", "promoted_mode", "!=", "mode", ")", "reg", "=", "gen_lowpart", "(", "mode", ",", "reg", ")", ";", "}", "else", "reg", "=", "force_reg", "(", "mode", ",", "src", ")", ";", "riscv_emit_move", "(", "dest", ",", "reg", ")", ";", "return", "true", ";", "}", "if", "(", "CONSTANT_P", "(", "src", ")", "&&", "!", "move_operand", "(", "src", ",", "mode", ")", ")", "{", "riscv_legitimize_const_move", "(", "mode", ",", "dest", ",", "src", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "copy_rtx", "(", "src", ")", ")", ";", "return", "true", ";", "}", "if", "(", "MEM_P", "(", "dest", ")", "&&", "!", "riscv_legitimate_address_p", "(", "mode", ",", "XEXP", "(", "dest", ",", "0", ")", ",", "reload_completed", ")", ")", "{", "XEXP", "(", "dest", ",", "0", ")", "=", "riscv_force_address", "(", "XEXP", "(", "dest", ",", "0", ")", ",", "mode", ")", ";", "}", "if", "(", "MEM_P", "(", "src", ")", "&&", "!", "riscv_legitimate_address_p", "(", "mode", ",", "XEXP", "(", "src", ",", "0", ")", ",", "reload_completed", ")", ")", "{", "XEXP", "(", "src", ",", "0", ")", "=", "riscv_force_address", "(", "XEXP", "(", "src", ",", "0", ")", ",", "mode", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "(", "set", "DEST", "SRC", ")", "is", "not", "a", "valid", "move", "instruction", ",", "emit", "an", "equivalent", "sequence", "that", "is", "valid", "." ]

[ "riscv", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "nvptx_vpropagate", "(", "basic_block", "block", ",", "rtx_insn", "*", "insn", ")", "{", "nvptx_propagate", "(", "block", ",", "insn", ",", "PM_read_write", ",", "vprop_gen", ",", "0", ")", ";", "}", "</s>" ]

[ "Propagate", "state", "that", "is", "live", "at", "start", "of", "BLOCK", "across", "the", "vectors", "of", "a", "single", "warp", ".", "Propagation", "is", "inserted", "just", "after", "INSN", ".", "IS_CALL", "and", "return", "as", "for", "nvptx_propagate", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "rtx", "riscv_subword", "(", "rtx", "op", ",", "bool", "high_p", ")", "{", "unsigned", "int", "byte", "=", "high_p", "?", "UNITS_PER_WORD", ":", "0", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "TARGET_64BIT", "?", "TImode", ":", "DImode", ";", "if", "(", "MEM_P", "(", "op", ")", ")", "return", "adjust_address", "(", "op", ",", "word_mode", ",", "byte", ")", ";", "if", "(", "REG_P", "(", "op", ")", ")", "gcc_assert", "(", "!", "FP_REG_RTX_P", "(", "op", ")", ")", ";", "return", "simplify_gen_subreg", "(", "word_mode", ",", "op", ",", "mode", ",", "byte", ")", ";", "}", "</s>" ]

[ "Return", "one", "word", "of", "double-word", "value", "OP", ".", "HIGH_P", "is", "true", "to", "select", "the", "high", "part", "or", "false", "to", "select", "the", "low", "part", "." ]

[ "riscv", "0" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "static", "rtx", "nvptx_expand_bar_red", "(", "tree", "exp", ",", "rtx", "target", ",", "machine_mode", "ARG_UNUSED", "(", "m", ")", ",", "int", "ARG_UNUSED", "(", "ignore", ")", ")", "{", "int", "code", "=", "DECL_MD_FUNCTION_CODE", "(", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ")", ";", "machine_mode", "mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "if", "(", "!", "target", ")", "target", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "pred", ",", "dst", ";", "rtx", "bar", "=", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ",", "NULL_RTX", ",", "SImode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "nthr", "=", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ",", "NULL_RTX", ",", "SImode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "cpl", "=", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ",", "NULL_RTX", ",", "SImode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "redop", "=", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "3", ")", ",", "NULL_RTX", ",", "SImode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "CONST_INT_P", "(", "bar", ")", ")", "{", "if", "(", "INTVAL", "(", "bar", ")", "<", "0", "||", "INTVAL", "(", "bar", ")", ">", "15", ")", "{", "error_at", "(", "EXPR_LOCATION", "(", "exp", ")", ",", "\"barrier value must be within [0,15]\"", ")", ";", "return", "const0_rtx", ";", "}", "}", "else", "if", "(", "!", "REG_P", "(", "bar", ")", ")", "bar", "=", "copy_to_mode_reg", "(", "SImode", ",", "bar", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "nthr", ")", "&&", "!", "REG_P", "(", "nthr", ")", ")", "nthr", "=", "copy_to_mode_reg", "(", "SImode", ",", "nthr", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "cpl", ")", ")", "{", "error_at", "(", "EXPR_LOCATION", "(", "exp", ")", ",", "\"complement argument must be constant\"", ")", ";", "return", "const0_rtx", ";", "}", "pred", "=", "gen_reg_rtx", "(", "BImode", ")", ";", "if", "(", "!", "REG_P", "(", "redop", ")", ")", "redop", "=", "copy_to_mode_reg", "(", "SImode", ",", "redop", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "pred", ",", "gen_rtx_NE", "(", "BImode", ",", "redop", ",", "GEN_INT", "(", "0", ")", ")", ")", ")", ";", "redop", "=", "pred", ";", "rtx", "pat", ";", "switch", "(", "code", ")", "{", "case", "NVPTX_BUILTIN_BAR_RED_AND", ":", "dst", "=", "gen_reg_rtx", "(", "BImode", ")", ";", "pat", "=", "gen_nvptx_barred_and", "(", "dst", ",", "bar", ",", "nthr", ",", "cpl", ",", "redop", ")", ";", "break", ";", "case", "NVPTX_BUILTIN_BAR_RED_OR", ":", "dst", "=", "gen_reg_rtx", "(", "BImode", ")", ";", "pat", "=", "gen_nvptx_barred_or", "(", "dst", ",", "bar", ",", "nthr", ",", "cpl", ",", "redop", ")", ";", "break", ";", "case", "NVPTX_BUILTIN_BAR_RED_POPC", ":", "dst", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "pat", "=", "gen_nvptx_barred_popc", "(", "dst", ",", "bar", ",", "nthr", ",", "cpl", ",", "redop", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "pat", ")", ";", "if", "(", "GET_MODE", "(", "dst", ")", "==", "BImode", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_NE", "(", "mode", ",", "dst", ",", "GEN_INT", "(", "0", ")", ")", ")", ")", ";", "dst", "=", "tmp", ";", "}", "emit_move_insn", "(", "target", ",", "dst", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expander", "for", "'bar.red", "'", "instruction", "builtins", "." ]

[ "nvptx", "0", "0", "1", "2", "3", "0", "15", "\"barrier value must be within [0,15]\"", "\"complement argument must be constant\"", "0", "0" ]

[]

[ "<s>", "static", "void", "mmix_output_octa", "(", "FILE", "*", "stream", ",", "int64_t", "value", ",", "int", "do_begin_end", ")", "{", "if", "(", "do_begin_end", ")", "fprintf", "(", "stream", ",", "\"\\tOCTA \"", ")", ";", "if", "(", "(", "value", "<", "(", "int64_t", ")", "0", "&&", "value", ">", "(", "int64_t", ")", "-", "10000", ")", "||", "(", "value", ">=", "(", "int64_t", ")", "0", "&&", "value", "<=", "(", "int64_t", ")", "16384", ")", ")", "fprintf", "(", "stream", ",", "\"%d\"", ",", "(", "int", ")", "value", ")", ";", "else", "if", "(", "value", ">", "(", "int64_t", ")", "0", "&&", "value", "<", "(", "(", "int64_t", ")", "1", "<<", "31", ")", "*", "2", ")", "fprintf", "(", "stream", ",", "\"#%x\"", ",", "(", "unsigned", "int", ")", "value", ")", ";", "else", "if", "(", "sizeof", "(", "HOST_WIDE_INT", ")", "==", "sizeof", "(", "int64_t", ")", ")", "fprintf", "(", "stream", ",", "\"#\"", "HOST_WIDE_INT_PRINT_HEX_PURE", ",", "(", "HOST_WIDE_INT", ")", "value", ")", ";", "else", "fprintf", "(", "stream", ",", "\"%\"", "PRIu64", ",", "value", ")", ";", "if", "(", "do_begin_end", ")", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "</s>" ]

[ "Print", "a", "64-bit", "value", ",", "optionally", "prefixed", "by", "assembly", "pseudo", "." ]

[ "mmix", "\"\\tOCTA \"", "0", "10000", "0", "16384", "\"%d\"", "0", "1", "31", "2", "\"#%x\"", "\"#\"", "\"%\"", "\"\\n\"" ]

[]

[ "<s>", "static", "bool", "nios2_output_addr_const_extra", "(", "FILE", "*", "file", ",", "rtx", "op", ")", "{", "const", "char", "*", "name", ";", "gcc_assert", "(", "GET_CODE", "(", "op", ")", "==", "UNSPEC", ")", ";", "name", "=", "nios2_unspec_reloc_name", "(", "XINT", "(", "op", ",", "1", ")", ")", ";", "if", "(", "name", ")", "{", "fprintf", "(", "file", ",", "\"%%%s(\"", ",", "name", ")", ";", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA", "." ]

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

[]

[ "<s>", "const", "char", "*", "function_resolver", "::", "get_scalar_type_name", "(", "type_suffix_index", "type", ")", "{", "return", "vector_types", "[", "type_suffixes", "[", "type", "]", ".", "vector_type", "]", ".", "acle_name", "+", "2", ";", "}", "</s>" ]

[ "Return", "the", "<", "stdint.h", ">", "name", "associated", "with", "TYPE", ".", "Using", "the", "<", "stdint.h", ">", "name", "should", "be", "more", "user-friendly", "than", "the", "underlying", "canonical", "type", ",", "since", "it", "makes", "the", "signedness", "and", "bitwidth", "explicit", "." ]

[ "aarch64", "2" ]

[]

[ "<s>", "bool", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "LC2200" ]

[]

[ "<s>", "static", "int", "nios2_compute_frame_layout", "(", "void", ")", "{", "unsigned", "int", "regno", ";", "unsigned", "int", "save_mask", "=", "0", ";", "int", "total_size", ";", "int", "var_size", ";", "int", "out_args_size", ";", "int", "save_reg_size", ";", "if", "(", "cfun", "->", "machine", "->", "initialized", ")", "return", "cfun", "->", "machine", "->", "total_size", ";", "var_size", "=", "NIOS2_STACK_ALIGN", "(", "get_frame_size", "(", ")", ")", ";", "out_args_size", "=", "NIOS2_STACK_ALIGN", "(", "crtl", "->", "outgoing_args_size", ")", ";", "total_size", "=", "var_size", "+", "out_args_size", ";", "save_reg_size", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "LAST_GP_REG", ";", "regno", "++", ")", "if", "(", "prologue_saved_reg_p", "(", "regno", ")", ")", "{", "save_mask", "|=", "1", "<<", "regno", ";", "save_reg_size", "+=", "4", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "i", ";", "unsigned", "r", ";", "for", "(", "i", "=", "0", ";", "(", "r", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ")", "!=", "INVALID_REGNUM", ";", "i", "++", ")", "if", "(", "!", "(", "save_mask", "&", "(", "1", "<<", "r", ")", ")", ")", "{", "save_mask", "|=", "1", "<<", "r", ";", "save_reg_size", "+=", "4", ";", "}", "}", "cfun", "->", "machine", "->", "fp_save_offset", "=", "0", ";", "if", "(", "save_mask", "&", "(", "1", "<<", "HARD_FRAME_POINTER_REGNUM", ")", ")", "{", "int", "fp_save_offset", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "HARD_FRAME_POINTER_REGNUM", ";", "regno", "++", ")", "if", "(", "save_mask", "&", "(", "1", "<<", "regno", ")", ")", "fp_save_offset", "+=", "4", ";", "cfun", "->", "machine", "->", "fp_save_offset", "=", "fp_save_offset", ";", "}", "save_reg_size", "=", "NIOS2_STACK_ALIGN", "(", "save_reg_size", ")", ";", "total_size", "+=", "save_reg_size", ";", "total_size", "+=", "NIOS2_STACK_ALIGN", "(", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "cfun", "->", "machine", "->", "save_mask", "=", "save_mask", ";", "cfun", "->", "machine", "->", "total_size", "=", "total_size", ";", "cfun", "->", "machine", "->", "var_size", "=", "var_size", ";", "cfun", "->", "machine", "->", "args_size", "=", "out_args_size", ";", "cfun", "->", "machine", "->", "save_reg_size", "=", "save_reg_size", ";", "cfun", "->", "machine", "->", "initialized", "=", "reload_completed", ";", "cfun", "->", "machine", "->", "save_regs_offset", "=", "out_args_size", "+", "var_size", ";", "return", "total_size", ";", "}", "</s>" ]

[ "Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", "." ]

[ "nios2", "0", "0", "0", "1", "4", "0", "1", "1", "4", "0", "1", "0", "0", "1", "4" ]

[]

[ "<s>", "static", "rtx_insn", "*", "next_insn_to_bundle", "(", "rtx_insn", "*", "r", ",", "rtx_insn", "*", "end", ")", "{", "for", "(", ";", "r", "!=", "end", ";", "r", "=", "NEXT_INSN", "(", "r", ")", ")", "{", "if", "(", "NONDEBUG_INSN_P", "(", "r", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "r", ")", ")", "!=", "USE", "&&", "GET_CODE", "(", "PATTERN", "(", "r", ")", ")", "!=", "CLOBBER", ")", "return", "r", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Skip", "over", "irrelevant", "NOTEs", "and", "such", "and", "look", "for", "the", "next", "insn", "we", "would", "consider", "bundling", "." ]

[ "tilegx" ]

[]

[ "<s>", "void", "ft32_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"%s,0\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "switch", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "file", ",", "\"%s,%ld\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ",", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "break", ";", "case", "CONST", ":", "{", "rtx", "plus", "=", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "plus", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "plus", ",", "1", ")", ")", ")", "{", "output_addr_const", "(", "file", ",", "XEXP", "(", "plus", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+%ld(%s)\"", ",", "INTVAL", "(", "XEXP", "(", "plus", ",", "1", ")", ")", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "}", "else", "abort", "(", ")", ";", "}", "break", ";", "default", ":", "abort", "(", ")", ";", "}", "break", ";", "default", ":", "output_addr_const", "(", "file", ",", "x", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "ft32", "\"%s,0\"", "1", "\"%s,%ld\"", "0", "1", "1", "\"(%s)\"", "0", "1", "0", "0", "1", "0", "\"+%ld(%s)\"", "1", "0" ]

[]

[ "<s>", "const", "MCExpr", "*", "ARMTargetStreamer", "::", "addConstantPoolEntry", "(", "const", "MCExpr", "*", "Expr", ")", "{", "return", "ConstantPools", "->", "addEntry", "(", "Streamer", ",", "Expr", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "entry", "to", "the", "constant", "pool", "for", "the", "current", "section", "and", "return", "an", "MCExpr", "that", "can", "be", "used", "to", "refer", "to", "the", "constant", "pool", "location", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "Error", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ")", "{", "return", "getParser", "(", ")", ".", "Error", "(", "L", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Return", "an", "error", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "VideocoreOperand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "llvm_unreachable", "(", "\"Not implemented\"", ")", ";", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "Videocore", "Videocore", "\"Not implemented\"" ]

[]

[ "<s>", "static", "bool", "sh_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "SH_OFFSETS_MUST_BE_WITHIN_SECTIONS_P", ")", "{", "rtx", "base", ",", "offset", ";", "split_const", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "SYMBOL_REF", "&&", "!", "offset_within_block_p", "(", "base", ",", "INTVAL", "(", "offset", ")", ")", ")", "return", "false", ";", "}", "if", "(", "TARGET_FDPIC", "&&", "(", "SYMBOLIC_CONST_P", "(", "x", ")", "||", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "SYMBOLIC_CONST_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", ")", ")", ")", "return", "false", ";", "return", "GET_CODE", "(", "x", ")", "!=", "CONST_DOUBLE", "||", "mode", "==", "DFmode", "||", "mode", "==", "SFmode", "||", "mode", "==", "DImode", "||", "GET_MODE", "(", "x", ")", "==", "VOIDmode", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", "can_store_by_pieces", "constructs", "VOIDmode", "CONST_DOUBLEs", "." ]

[ "sh", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "s390_support_vector_misalignment", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "misalignment", "ATTRIBUTE_UNUSED", ",", "bool", "is_packed", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_VX", ")", "return", "true", ";", "return", "default_builtin_support_vector_misalignment", "(", "mode", ",", "type", ",", "misalignment", ",", "is_packed", ")", ";", "}", "</s>" ]

[ "Our", "hardware", "does", "not", "require", "vectors", "to", "be", "strictly", "aligned", "." ]

[ "s390" ]

[]

[ "<s>", "static", "void", "tryAddingPcLoadReferenceComment", "(", "uint64_t", "Address", ",", "uint64_t", "Value", ",", "const", "void", "*", "Decoder", ")", "{", "const", "MCDisassembler", "*", "Dis", "=", "static_cast", "<", "const", "MCDisassembler", "*", ">", "(", "Decoder", ")", ";", "Dis", "->", "tryAddingPcLoadReferenceComment", "(", "Value", ",", "Address", ")", ";", "}", "</s>" ]

[ "Try", "to", "add", "a", "comment", "on", "the", "PC-relative", "load", "." ]

[ "X86" ]

[]

[ "<s>", "static", "void", "aarch64_parse_fuse_string", "(", "const", "char", "*", "fuse_string", ",", "struct", "tune_params", "*", "tune", ")", "{", "tune", "->", "fusible_ops", "=", "aarch64_parse_boolean_options", "(", "fuse_string", ",", "aarch64_fusible_pairs", ",", "tune", "->", "fusible_ops", ",", "\"fuse=\"", ")", ";", "}", "</s>" ]

[ "Support", "for", "overriding", "instruction", "fusion", "." ]

[ "aarch64", "\"fuse=\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "Next", "(", ")", "{", "assert", "(", "HasNext", "(", ")", ")", ";", "return", "successors", "(", ")", "[", "Index", "++", "]", ";", "}", "</s>" ]

[ "Pointer", "to", "the", "next", "DomainValue", "in", "a", "chain", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDRrs", ":", "case", "ARM", "::", "t2LDRs", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "tLDRspi", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "VLDR_P0_off", ":", "case", "ARM", "::", "MVE_VLDRWU32", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLD1q64", ":", "case", "ARM", "::", "VLD1d8TPseudo", ":", "case", "ARM", "::", "VLD1d16TPseudo", ":", "case", "ARM", "::", "VLD1d32TPseudo", ":", "case", "ARM", "::", "VLD1d64TPseudo", ":", "case", "ARM", "::", "VLD1d8QPseudo", ":", "case", "ARM", "::", "VLD1d16QPseudo", ":", "case", "ARM", "::", "VLD1d32QPseudo", ":", "case", "ARM", "::", "VLD1d64QPseudo", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLDMQIA", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "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", "." ]

[ "ARM", "ARM", "ARM::LDRrs", "ARM::t2LDRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::LDRi12", "ARM::t2LDRi12", "ARM::tLDRspi", "ARM::VLDRD", "ARM::VLDRS", "ARM::VLDR_P0_off", "ARM::MVE_VLDRWU32", "1", "2", "2", "0", "1", "0", "ARM::VLD1q64", "ARM::VLD1d8TPseudo", "ARM::VLD1d16TPseudo", "ARM::VLD1d32TPseudo", "ARM::VLD1d64TPseudo", "ARM::VLD1d8QPseudo", "ARM::VLD1d16QPseudo", "ARM::VLD1d32QPseudo", "ARM::VLD1d64QPseudo", "1", "0", "0", "1", "0", "ARM::VLDMQIA", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "void", "arm_option_override_internal", "(", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ")", "{", "arm_override_options_after_change_1", "(", "opts", ")", ";", "if", "(", "TARGET_INTERWORK", "&&", "!", "ARM_FSET_HAS_CPU1", "(", "insn_flags", ",", "FL_THUMB", ")", ")", "{", "opts", "->", "x_target_flags", "&=", "~", "MASK_INTERWORK", ";", "}", "if", "(", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", "&&", "!", "(", "ARM_FSET_HAS_CPU1", "(", "insn_flags", ",", "FL_THUMB", ")", ")", ")", "{", "warning", "(", "0", ",", "\"target CPU does not support THUMB instructions\"", ")", ";", "opts", "->", "x_target_flags", "&=", "~", "MASK_THUMB", ";", "}", "if", "(", "TARGET_APCS_FRAME", "&&", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", ")", "{", "opts", "->", "x_target_flags", "&=", "~", "MASK_APCS_FRAME", ";", "}", "if", "(", "TARGET_THUMB_P", "(", "opts", "->", "x_target_flags", ")", "&&", "TARGET_CALLEE_INTERWORKING", ")", "opts", "->", "x_target_flags", "|=", "MASK_INTERWORK", ";", "cl_optimization", "*", "to", "=", "TREE_OPTIMIZATION", "(", "init_optimize", ")", ";", "if", "(", "!", "opts_set", "->", "x_arm_restrict_it", ")", "opts", "->", "x_arm_restrict_it", "=", "arm_arch8", ";", "if", "(", "!", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_arm_restrict_it", "=", "0", ";", "if", "(", "!", "opts_set", "->", "x_unaligned_access", ")", "{", "opts", "->", "x_unaligned_access", "=", "(", "TARGET_32BIT_P", "(", "opts", "->", "x_target_flags", ")", "&&", "arm_arch6", "&&", "(", "arm_arch_notm", "||", "arm_arch7", ")", ")", ";", "}", "else", "if", "(", "opts", "->", "x_unaligned_access", "==", "1", "&&", "!", "(", "arm_arch6", "&&", "(", "arm_arch_notm", "||", "arm_arch7", ")", ")", ")", "{", "warning", "(", "0", ",", "\"target CPU does not support unaligned accesses\"", ")", ";", "opts", "->", "x_unaligned_access", "=", "0", ";", "}", "if", "(", "TARGET_THUMB1_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_schedule_insns", "=", "0", ";", "else", "opts", "->", "x_flag_schedule_insns", "=", "to", "->", "x_flag_schedule_insns", ";", "if", "(", "optimize_function_for_size_p", "(", "cfun", ")", "&&", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_shrink_wrap", "=", "false", ";", "else", "opts", "->", "x_flag_shrink_wrap", "=", "to", "->", "x_flag_shrink_wrap", ";", "if", "(", "TARGET_THUMB1_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_flag_ipa_ra", "=", "0", ";", "else", "opts", "->", "x_flag_ipa_ra", "=", "to", "->", "x_flag_ipa_ra", ";", "opts", "->", "x_inline_asm_unified", "=", "TARGET_THUMB2_P", "(", "opts", "->", "x_target_flags", ")", ";", "SUBTARGET_OVERRIDE_INTERNAL_OPTIONS", ";", "}", "</s>" ]

[ "Reset", "options", "between", "modes", "that", "the", "user", "has", "specified", "." ]

[ "arm", "0", "\"target CPU does not support THUMB instructions\"", "0", "1", "0", "\"target CPU does not support unaligned accesses\"", "0", "0", "0" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "Cpu0Operand", ">", "CreateReg", "(", "unsigned", "RegNum", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "auto", "Op", "=", "make_unique", "<", "Cpu0Operand", ">", "(", "k_Register", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0" ]

[]

[ "<s>", "void", "ia64_expand_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "old_dst", ",", "rtx", "new_dst", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "old_reg", ",", "new_reg", ",", "cmp_reg", ",", "ar_ccv", ",", "label", ";", "enum", "insn_code", "icode", ";", "if", "(", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", ")", "&&", "(", "code", "==", "PLUS", "||", "code", "==", "MINUS", ")", "&&", "fetchadd_operand", "(", "val", ",", "mode", ")", ")", "{", "if", "(", "code", "==", "MINUS", ")", "val", "=", "GEN_INT", "(", "-", "INTVAL", "(", "val", ")", ")", ";", "if", "(", "!", "old_dst", ")", "old_dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "if", "(", "mode", "==", "SImode", ")", "icode", "=", "CODE_FOR_fetchadd_acq_si", ";", "else", "icode", "=", "CODE_FOR_fetchadd_acq_di", ";", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "old_dst", ",", "mem", ",", "val", ")", ")", ";", "if", "(", "new_dst", ")", "{", "new_reg", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "old_dst", ",", "val", ",", "new_dst", ",", "true", ",", "OPTAB_WIDEN", ")", ";", "if", "(", "new_reg", "!=", "new_dst", ")", "emit_move_insn", "(", "new_dst", ",", "new_reg", ")", ";", "}", "return", ";", "}", "gcc_assert", "(", "MEM_VOLATILE_P", "(", "mem", ")", ")", ";", "old_reg", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "cmp_reg", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "if", "(", "mode", "!=", "DImode", ")", "{", "val", "=", "simplify_gen_subreg", "(", "DImode", ",", "val", ",", "mode", ",", "0", ")", ";", "emit_insn", "(", "gen_extend_insn", "(", "cmp_reg", ",", "mem", ",", "DImode", ",", "mode", ",", "1", ")", ")", ";", "}", "else", "emit_move_insn", "(", "cmp_reg", ",", "mem", ")", ";", "emit_label", "(", "label", ")", ";", "ar_ccv", "=", "gen_rtx_REG", "(", "DImode", ",", "AR_CCV_REGNUM", ")", ";", "emit_move_insn", "(", "old_reg", ",", "cmp_reg", ")", ";", "emit_move_insn", "(", "ar_ccv", ",", "cmp_reg", ")", ";", "if", "(", "old_dst", ")", "emit_move_insn", "(", "old_dst", ",", "gen_lowpart", "(", "mode", ",", "cmp_reg", ")", ")", ";", "new_reg", "=", "cmp_reg", ";", "if", "(", "code", "==", "NOT", ")", "{", "new_reg", "=", "expand_simple_unop", "(", "DImode", ",", "NOT", ",", "new_reg", ",", "NULL_RTX", ",", "true", ")", ";", "code", "=", "AND", ";", "}", "new_reg", "=", "expand_simple_binop", "(", "DImode", ",", "code", ",", "new_reg", ",", "val", ",", "NULL_RTX", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "mode", "!=", "DImode", ")", "new_reg", "=", "gen_lowpart", "(", "mode", ",", "new_reg", ")", ";", "if", "(", "new_dst", ")", "emit_move_insn", "(", "new_dst", ",", "new_reg", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "icode", "=", "CODE_FOR_cmpxchg_rel_qi", ";", "break", ";", "case", "HImode", ":", "icode", "=", "CODE_FOR_cmpxchg_rel_hi", ";", "break", ";", "case", "SImode", ":", "icode", "=", "CODE_FOR_cmpxchg_rel_si", ";", "break", ";", "case", "DImode", ":", "icode", "=", "CODE_FOR_cmpxchg_rel_di", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "cmp_reg", ",", "mem", ",", "ar_ccv", ",", "new_reg", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "cmp_reg", ",", "old_reg", ",", "NE", ",", "NULL", ",", "DImode", ",", "true", ",", "label", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "operation", ".", "We", "want", "to", "perform", "MEM", "<", "CODE", ">", "=", "VAL", "atomically", ".", "This", "differs", "from", "the", "generic", "code", "in", "that", "we", "know", "about", "the", "zero-extending", "properties", "of", "cmpxchg", ",", "and", "the", "zero-extending", "requirements", "of", "ar.ccv", ".", "We", "also", "know", "that", "ld.acq+cmpxchg.rel", "equals", "a", "full", "barrier", ".", "The", "loop", "we", "want", "to", "generate", "looks", "like", "cmp_reg", "=", "mem", ";", "label", ":", "old_reg", "=", "cmp_reg", ";", "new_reg", "=", "cmp_reg", "op", "val", ";", "cmp_reg", "=", "compare-and-swap", "(", "mem", ",", "old_reg", ",", "new_reg", ")", "if", "(", "cmp_reg", "!", "=", "old_reg", ")", "goto", "label", ";", "Note", "that", "we", "only", "do", "the", "plain", "load", "from", "memory", "once", ".", "Subsequent", "iterations", "use", "the", "value", "loaded", "by", "the", "compare-and-swap", "pattern", "." ]

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

[]

[ "<s>", "static", "int", "fr30_arg_partial_bytes", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "if", "(", "named", "==", "0", "||", "*", "cum", ">=", "FR30_NUM_ARG_REGS", ")", "return", "0", ";", "if", "(", "*", "cum", "+", "fr30_num_arg_regs", "(", "mode", ",", "type", ")", "<=", "FR30_NUM_ARG_REGS", ")", "return", "0", ";", "return", "(", "FR30_NUM_ARG_REGS", "-", "*", "cum", ")", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "bytes", "in", "which", "*", "part", "*", "of", "a", "parameter", "of", "machine", "mode", "MODE", "and", "tree", "type", "TYPE", "(", "which", "may", "be", "NULL", "if", "the", "type", "is", "not", "known", ")", ".", "If", "the", "argument", "fits", "entirely", "in", "the", "argument", "registers", ",", "or", "entirely", "on", "the", "stack", ",", "then", "0", "is", "returned", ".", "CUM", "is", "the", "number", "of", "argument", "registers", "already", "used", "by", "earlier", "parameters", "to", "the", "function", "." ]

[ "fr30", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_verify_type_context", "(", "location_t", "loc", ",", "type_context_kind", "context", ",", "const_tree", "type", ",", "bool", "silent_p", ")", "{", "return", "aarch64_sve", "::", "verify_type_context", "(", "loc", ",", "context", ",", "type", ",", "silent_p", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_VERIFY_TYPE_CONTEXT", "." ]

[ "aarch64", "aarch64_sve::verify_type_context" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "Expr", "==", "0", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "FISC", "0", "0" ]

[]

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

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

[ "OR1K", "\"OR1K Assembly Printer\"" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "SplitVectorLoad", "(", "const", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LoadSDNode", "*", "Load", "=", "cast", "<", "LoadSDNode", ">", "(", "Op", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", ")", "return", "scalarizeVectorLoad", "(", "Load", ",", "DAG", ")", ";", "SDValue", "BasePtr", "=", "Load", "->", "getBasePtr", "(", ")", ";", "EVT", "MemVT", "=", "Load", "->", "getMemoryVT", "(", ")", ";", "SDLoc", "SL", "(", "Op", ")", ";", "const", "MachinePointerInfo", "&", "SrcValue", "=", "Load", "->", "getMemOperand", "(", ")", "->", "getPointerInfo", "(", ")", ";", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "LoMemVT", ",", "HiMemVT", ";", "SDValue", "Lo", ",", "Hi", ";", "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "getSplitDestVTs", "(", "VT", ",", "DAG", ")", ";", "std", "::", "tie", "(", "LoMemVT", ",", "HiMemVT", ")", "=", "getSplitDestVTs", "(", "MemVT", ",", "DAG", ")", ";", "std", "::", "tie", "(", "Lo", ",", "Hi", ")", "=", "splitVector", "(", "Op", ",", "SL", ",", "LoVT", ",", "HiVT", ",", "DAG", ")", ";", "unsigned", "Size", "=", "LoMemVT", ".", "getStoreSize", "(", ")", ";", "unsigned", "BaseAlign", "=", "Load", "->", "getAlignment", "(", ")", ";", "unsigned", "HiAlign", "=", "MinAlign", "(", "BaseAlign", ",", "Size", ")", ";", "SDValue", "LoLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "LoVT", ",", "Load", "->", "getChain", "(", ")", ",", "BasePtr", ",", "SrcValue", ",", "LoMemVT", ",", "BaseAlign", ",", "Load", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "SDValue", "HiPtr", "=", "DAG", ".", "getObjectPtrOffset", "(", "SL", ",", "BasePtr", ",", "Size", ")", ";", "SDValue", "HiLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "HiVT", ",", "Load", "->", "getChain", "(", ")", ",", "HiPtr", ",", "SrcValue", ".", "getWithOffset", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ")", ",", "HiMemVT", ",", "HiAlign", ",", "Load", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "auto", "IdxTy", "=", "getVectorIdxTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "Join", ";", "if", "(", "LoVT", "==", "HiVT", ")", "{", "Join", "=", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "SL", ",", "VT", ",", "LoLoad", ",", "HiLoad", ")", ";", "}", "else", "{", "Join", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_SUBVECTOR", ",", "SL", ",", "VT", ",", "DAG", ".", "getUNDEF", "(", "VT", ")", ",", "LoLoad", ",", "DAG", ".", "getConstant", "(", "0", ",", "SL", ",", "IdxTy", ")", ")", ";", "Join", "=", "DAG", ".", "getNode", "(", "HiVT", ".", "isVector", "(", ")", "?", "ISD", "::", "INSERT_SUBVECTOR", ":", "ISD", "::", "INSERT_VECTOR_ELT", ",", "SL", ",", "VT", ",", "Join", ",", "HiLoad", ",", "DAG", ".", "getConstant", "(", "LoVT", ".", "getVectorNumElements", "(", ")", ",", "SL", ",", "IdxTy", ")", ")", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "Join", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "SL", ",", "MVT", "::", "Other", ",", "LoLoad", ".", "getValue", "(", "1", ")", ",", "HiLoad", ".", "getValue", "(", "1", ")", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "load", "into", "2", "loads", "of", "half", "the", "vector", "." ]

[ "AMDGPU", "AMDGPU", "2", "ISD::CONCAT_VECTORS", "ISD::INSERT_SUBVECTOR", "0", "ISD::INSERT_SUBVECTOR", "ISD::INSERT_VECTOR_ELT", "ISD::TokenFactor", "MVT::Other", "1", "1" ]

[]

[ "<s>", "static", "void", "mips_swap_registers", "(", "unsigned", "int", "i", ")", "{", "int", "tmpi", ";", "const", "char", "*", "tmps", ";", "SWAP_INT", "(", "fixed_regs", "[", "i", "]", ",", "fixed_regs", "[", "i", "+", "1", "]", ")", ";", "SWAP_INT", "(", "call_used_regs", "[", "i", "]", ",", "call_used_regs", "[", "i", "+", "1", "]", ")", ";", "SWAP_STRING", "(", "reg_names", "[", "i", "]", ",", "reg_names", "[", "i", "+", "1", "]", ")", ";", "}", "</s>" ]

[ "Swap", "the", "register", "information", "for", "registers", "I", "and", "I", "+", "1", ",", "which", "currently", "have", "the", "wrong", "endianness", ".", "Note", "that", "the", "registers", "'", "fixedness", "and", "call-clobberedness", "might", "have", "been", "set", "on", "the", "command", "line", "." ]

[ "mips", "1", "1", "1" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "void", "LanaiFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "LanaiInstrInfo", "&", "LII", "=", "*", "static_cast", "<", "const", "LanaiInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "determineFrameLayout", "(", "MF", ")", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "LII", ".", "get", "(", "Lanai", "::", "SW_RI", ")", ")", ".", "addReg", "(", "Lanai", "::", "FP", ")", ".", "addReg", "(", "Lanai", "::", "SP", ")", ".", "addImm", "(", "-", "4", ")", ".", "addImm", "(", "LPAC", "::", "makePreOp", "(", "LPAC", "::", "ADD", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "LII", ".", "get", "(", "Lanai", "::", "ADD_I_LO", ")", ",", "Lanai", "::", "FP", ")", ".", "addReg", "(", "Lanai", "::", "SP", ")", ".", "addImm", "(", "8", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "if", "(", "StackSize", "!=", "0", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "LII", ".", "get", "(", "Lanai", "::", "SUB_I_LO", ")", ",", "Lanai", "::", "SP", ")", ".", "addReg", "(", "Lanai", "::", "SP", ")", ".", "addImm", "(", "StackSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "replaceAdjDynAllocPseudo", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "\"Shrink-wrapping not yet supported\"", "Lanai", "Lanai", "Lanai::SW_RI", "Lanai::FP", "Lanai::SP", "4", "Lanai::ADD_I_LO", "Lanai::FP", "Lanai::SP", "8", "0", "Lanai::SUB_I_LO", "Lanai::SP", "Lanai::SP" ]

[]

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

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

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

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "auto", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "auto", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "if", "(", "!", "DstSubReg", ")", "return", "true", ";", "if", "(", "getRegSizeInBits", "(", "*", "NewRC", ")", "<", "256", "&&", "getRegSizeInBits", "(", "*", "DstRC", ")", "<", "256", "&&", "getRegSizeInBits", "(", "*", "SrcRC", ")", "<", "256", ")", "return", "true", ";", "auto", "NewRCWeight", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getRegClassWeight", "(", "NewRC", ")", ";", "auto", "SrcRCWeight", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getRegClassWeight", "(", "SrcRC", ")", ";", "auto", "DstRCWeight", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getRegClassWeight", "(", "DstRC", ")", ";", "if", "(", "SrcRCWeight", ".", "RegWeight", ">", "NewRCWeight", ".", "RegWeight", ")", "return", "true", ";", "if", "(", "DstRCWeight", ".", "RegWeight", ">", "NewRCWeight", ".", "RegWeight", ")", "return", "true", ";", "auto", "AFI", "=", "MF", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "auto", "It", "=", "AFI", "->", "getCoalescedWeight", "(", "MBB", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\tARM::shouldCoalesce - Coalesced Weight: \"", "<<", "It", "->", "second", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\tARM::shouldCoalesce - Reg Weight: \"", "<<", "NewRCWeight", ".", "RegWeight", "<<", "\"\\n\"", ")", ";", "unsigned", "SizeMultiplier", "=", "MBB", "->", "size", "(", ")", "/", "100", ";", "SizeMultiplier", "=", "SizeMultiplier", "?", "SizeMultiplier", ":", "1", ";", "if", "(", "It", "->", "second", "<", "NewRCWeight", ".", "WeightLimit", "*", "SizeMultiplier", ")", "{", "It", "->", "second", "+=", "NewRCWeight", ".", "RegWeight", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "256", "256", "256", "ARM", "\"\\tARM::shouldCoalesce - Coalesced Weight: \"", "\"\\n\"", "\"\\tARM::shouldCoalesce - Reg Weight: \"", "\"\\n\"", "100", "1" ]

[]

[ "<s>", "bool", "SICInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "switch", "(", "MI", ".", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "SIC", "::", "RetLR", ":", "expandRetLR", "(", "MBB", ",", "MI", ")", ";", "break", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "SIC::RetLR" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "bool", "SILowerControlFlow", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MachineFunction", "::", "iterator", "NextBB", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "BI", "=", "NextBB", ")", "{", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ",", "Last", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ",", "Last", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_IF", ":", "emitIf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "emitElse", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_BREAK", ":", "emitBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "emitIfBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE_BREAK", ":", "emitElseBreak", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_LOOP", ":", "emitLoop", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_END_CF", ":", "emitEndCf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_AND_B64", ":", "case", "AMDGPU", "::", "S_OR_B64", ":", "combineMasks", "(", "MI", ")", ";", "Last", "=", "I", ";", "continue", ";", "default", ":", "Last", "=", "I", ";", "continue", ";", "}", "Next", "=", "(", "Last", "==", "MBB", ".", "end", "(", ")", ")", "?", "MBB", ".", "begin", "(", ")", ":", "Last", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_BREAK", "AMDGPU::SI_IF_BREAK", "AMDGPU::SI_ELSE_BREAK", "AMDGPU::SI_LOOP", "AMDGPU::SI_END_CF", "AMDGPU::S_AND_B64", "AMDGPU::S_OR_B64" ]

[]

[ "<s>", "bool", "arc_split_move_p", "(", "rtx", "*", "operands", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "TARGET_LL64", "&&", "(", "(", "memory_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", "&&", "(", "even_register_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", "||", "satisfies_constraint_Cm3", "(", "operands", "[", "1", "]", ")", ")", ")", "||", "(", "memory_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", "&&", "even_register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", ")", ")", "return", "false", ";", "if", "(", "TARGET_PLUS_QMACW", "&&", "even_register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", "&&", "even_register_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Check", "if", "we", "need", "to", "split", "a", "64bit", "move", ".", "We", "do", "not", "need", "to", "split", "it", "if", "we", "can", "use", "vadd2", "or", "ldd/std", "instructions", "." ]

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

[]

[ "<s>", "void", "rl78_split_movsi", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "omode", ")", "{", "rtx", "op00", ",", "op02", ",", "op10", ",", "op12", ";", "op00", "=", "rl78_subreg", "(", "HImode", ",", "operands", "[", "0", "]", ",", "omode", ",", "0", ")", ";", "op02", "=", "rl78_subreg", "(", "HImode", ",", "operands", "[", "0", "]", ",", "omode", ",", "2", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST", "||", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "SYMBOL_REF", ")", "{", "op10", "=", "gen_rtx_ZERO_EXTRACT", "(", "HImode", ",", "operands", "[", "1", "]", ",", "GEN_INT", "(", "16", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "op10", "=", "gen_rtx_CONST", "(", "HImode", ",", "op10", ")", ";", "op12", "=", "gen_rtx_ZERO_EXTRACT", "(", "HImode", ",", "operands", "[", "1", "]", ",", "GEN_INT", "(", "16", ")", ",", "GEN_INT", "(", "16", ")", ")", ";", "op12", "=", "gen_rtx_CONST", "(", "HImode", ",", "op12", ")", ";", "}", "else", "{", "op10", "=", "rl78_subreg", "(", "HImode", ",", "operands", "[", "1", "]", ",", "omode", ",", "0", ")", ";", "op12", "=", "rl78_subreg", "(", "HImode", ",", "operands", "[", "1", "]", ",", "omode", ",", "2", ")", ";", "}", "if", "(", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "else", "if", "(", "rtx_equal_p", "(", "op00", ",", "op12", ")", ")", "{", "operands", "[", "2", "]", "=", "op02", ";", "operands", "[", "4", "]", "=", "op12", ";", "operands", "[", "3", "]", "=", "op00", ";", "operands", "[", "5", "]", "=", "op10", ";", "}", "else", "{", "operands", "[", "2", "]", "=", "op00", ";", "operands", "[", "4", "]", "=", "op10", ";", "operands", "[", "3", "]", "=", "op02", ";", "operands", "[", "5", "]", "=", "op12", ";", "}", "}", "</s>" ]

[ "Generate", "code", "to", "move", "an", "SImode", "value", "." ]

[ "rl78", "0", "0", "0", "2", "1", "1", "1", "16", "0", "1", "16", "16", "1", "0", "1", "2", "0", "1", "2", "4", "3", "5", "2", "4", "3", "5" ]

[]

[ "<s>", "void", "M68kPassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createM68kExpandPseudoPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "M68k", "M68k", "M68k" ]

[]

[ "<s>", "void", "aarch64_expand_sve_vec_cmp_int", "(", "rtx", "target", ",", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "pred_mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "data_mode", "=", "GET_MODE", "(", "op0", ")", ";", "rtx", "res", "=", "aarch64_sve_emit_int_cmp", "(", "target", ",", "pred_mode", ",", "code", ",", "data_mode", ",", "op0", ",", "op1", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "target", ",", "res", ")", ")", "emit_move_insn", "(", "target", ",", "res", ")", ";", "}", "</s>" ]

[ "Expand", "an", "SVE", "integer", "comparison", ":", "TARGET", "=", "CODE", "(", "OP0", ",", "OP1", ")", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "WebAssemblySetP2AlignOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Set p2align Operands **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "int16_t", "P2AlignOpNum", "=", "WebAssembly", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "WebAssembly", "::", "OpName", "::", "p2align", ")", ";", "if", "(", "P2AlignOpNum", "!=", "-", "1", ")", "{", "rewriteP2Align", "(", "MI", ",", "P2AlignOpNum", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Set p2align Operands **********\\n\"", "\"********** Function: \"", "WebAssembly::getNamedOperandIdx", "WebAssembly::OpName", "1" ]

[]

[ "<s>", "static", "void", "mips_macc_chains_reorder", "(", "rtx", "*", "ready", ",", "int", "nready", ")", "{", "int", "i", ",", "j", ";", "if", "(", "mips_macc_chains_last_hilo", "!=", "0", ")", "for", "(", "i", "=", "nready", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "if", "(", "mips_linked_madd_p", "(", "mips_macc_chains_last_hilo", ",", "ready", "[", "i", "]", ")", ")", "{", "for", "(", "j", "=", "nready", "-", "1", ";", "j", ">", "i", ";", "j", "--", ")", "if", "(", "recog_memoized", "(", "ready", "[", "j", "]", ")", ">=", "0", "&&", "get_attr_may_clobber_hilo", "(", "ready", "[", "j", "]", ")", ")", "{", "mips_promote_ready", "(", "ready", ",", "i", ",", "j", ")", ";", "break", ";", "}", "break", ";", "}", "}", "</s>" ]

[ "A", "TUNE_MACC_CHAINS", "helper", "function", ".", "Search", "ready", "queue", "READY", ",", "which", "has", "NREADY", "elements", ",", "looking", "for", "a", "multiply-add", "or", "multiply-subtract", "instruction", "that", "is", "cumulative", "with", "mips_macc_chains_last_hilo", ".", "If", "there", "is", "one", ",", "promote", "it", "ahead", "of", "anything", "else", "that", "might", "clobber", "hi", "or", "lo", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "bool", "rs6000_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_32BIT", "&&", "mode", "==", "TImode", ")", "return", "false", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "default_decimal_float_supported_p", "(", ")", ";", "else", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "scalar_mode_supported_p", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "LoongArchFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "LoongArch", "LoongArch" ]

[]