Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "TargetLowering", "::", "ConstraintType", "TPCTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "unsigned", "S", "=", "Constraint", ".", "size", "(", ")", ";", "if", "(", "S", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'s'", ":", "case", "'v'", ":", "case", "'S'", ":", "case", "'V'", ":", "return", "C_RegisterClass", ";", "case", "'g'", ":", "case", "'l'", ":", "case", "'L'", ":", "return", "C_Memory", ";", "}", "}", "if", "(", "S", ">", "1", "&&", "Constraint", "[", "0", "]", "==", "'{'", "&&", "Constraint", "[", "S", "-", "1", "]", "==", "'}'", ")", "{", "if", "(", "S", "==", "8", "&&", "Constraint", ".", "substr", "(", "1", ",", "6", ")", "==", "\"memory\"", ")", "return", "C_Memory", ";", "return", "C_Register", ";", "}", "return", "C_Unknown", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "TPC", "TPC", "1", "0", "1", "0", "1", "8", "1", "6", "\"memory\"" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isExtended", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "uint64_t", "F", "=", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ";", "if", "(", "(", "F", ">>", "HexagonII", "::", "ExtendedPos", ")", "&", "HexagonII", "::", "ExtendedMask", ")", "return", "true", ";", "for", "(", "MachineInstr", "::", "const_mop_iterator", "I", "=", "MI", ".", "operands_begin", "(", ")", ",", "E", "=", "MI", ".", "operands_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "getTargetFlags", "(", ")", "&&", "HexagonII", "::", "HMOTF_ConstExtended", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Test", "if", "the", "given", "EVT", "is", "extended", "(", "as", "opposed", "to", "being", "simple", ")", "." ]

[ "Hexagon", "Hexagon", "HexagonII::ExtendedPos", "HexagonII::ExtendedMask", "HexagonII::HMOTF_ConstExtended" ]

[]

[ "<s>", "ArrayRef", "<", "MCPhysReg", ">", "MipsABIInfo", "::", "GetByValArgRegs", "(", ")", "const", "{", "if", "(", "IsO32", "(", ")", ")", "return", "makeArrayRef", "(", "O32IntRegs", ")", ";", "if", "(", "IsN32", "(", ")", "||", "IsN64", "(", ")", ")", "return", "makeArrayRef", "(", "Mips64IntRegs", ")", ";", "llvm_unreachable", "(", "\"Unhandled ABI\"", ")", ";", "}", "</s>" ]

[ "The", "registers", "to", "use", "for", "byval", "arguments", "." ]

[ "Mips", "Mips", "Mips", "\"Unhandled ABI\"" ]

[]

[ "<s>", "bool", "compact_sda_memory_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "bool", "short_p", ")", "{", "rtx", "addr", ";", "int", "size", ";", "int", "align", "=", "0", ";", "int", "mask", "=", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "false", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "!", "legitimate_small_data_address_p", "(", "addr", ")", ")", "return", "false", ";", "if", "(", "!", "short_p", "||", "size", "==", "1", ")", "return", "true", ";", "align", "=", "get_symbol_alignment", "(", "addr", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "mask", "=", "1", ";", "break", ";", "default", ":", "mask", "=", "3", ";", "break", ";", "}", "if", "(", "align", "&&", "(", "(", "align", "&", "mask", ")", "==", "0", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "volatile", "cache", "option", "still", "to", "be", "handled", "." ]

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

[]

[ "<s>", "BitVector", "CJGRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "CJG", "::", "SR", ")", ";", "Reserved", ".", "set", "(", "CJG", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "CJG", "::", "SP", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "CJG", "CJG", "CJG::SR", "CJG::PC", "CJG::SP" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isVectorLoadExtDesirable", "(", "SDValue", "ExtVal", ")", "const", "{", "EVT", "VT", "=", "ExtVal", ".", "getValueType", "(", ")", ";", "if", "(", "!", "isTypeLegal", "(", "VT", ")", ")", "return", "false", ";", "if", "(", "auto", "*", "Ld", "=", "dyn_cast", "<", "MaskedLoadSDNode", ">", "(", "ExtVal", ".", "getOperand", "(", "0", ")", ")", ")", "{", "if", "(", "Ld", "->", "isExpandingLoad", "(", ")", ")", "return", "false", ";", "}", "if", "(", "ExtVal", "->", "use_empty", "(", ")", "||", "!", "ExtVal", "->", "use_begin", "(", ")", "->", "isOnlyUserOf", "(", "ExtVal", ".", "getNode", "(", ")", ")", ")", "return", "true", ";", "SDNode", "*", "U", "=", "*", "ExtVal", "->", "use_begin", "(", ")", ";", "if", "(", "(", "U", "->", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "||", "U", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", "||", "U", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", "||", "U", "->", "getOpcode", "(", ")", "==", "ARMISD", "::", "VSHLIMM", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "vector", "load", "into", "ExtVal", "(", "a", "sign", ",", "zero", ",", "or", "any", "extend", "node", ")", "is", "profitable", "." ]

[ "ARM", "ARM", "0", "ISD::ADD", "ISD::SUB", "ISD::SHL", "ARMISD::VSHLIMM" ]

[]

[ "<s>", "bool", "SIMemoryLegalizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "SIMemOpAccess", "MOA", "(", "MF", ")", ";", "CC", "=", "SICacheControl", "::", "create", "(", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "MI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MI", ")", "{", "if", "(", "MI", "->", "isBundle", "(", ")", "&&", "MI", "->", "mayLoadOrStore", "(", ")", ")", "{", "MachineBasicBlock", "::", "instr_iterator", "II", "(", "MI", "->", "getIterator", "(", ")", ")", ";", "for", "(", "MachineBasicBlock", "::", "instr_iterator", "I", "=", "++", "II", ",", "E", "=", "MBB", ".", "instr_end", "(", ")", ";", "I", "!=", "E", "&&", "I", "->", "isBundledWithPred", "(", ")", ";", "++", "I", ")", "{", "I", "->", "unbundleFromPred", "(", ")", ";", "for", "(", "MachineOperand", "&", "MO", ":", "I", "->", "operands", "(", ")", ")", "if", "(", "MO", ".", "isReg", "(", ")", ")", "MO", ".", "setIsInternalRead", "(", "false", ")", ";", "}", "MI", "->", "eraseFromParent", "(", ")", ";", "MI", "=", "II", "->", "getIterator", "(", ")", ";", "}", "if", "(", "!", "(", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "maybeAtomic", ")", ")", "continue", ";", "if", "(", "const", "auto", "&", "MOI", "=", "MOA", ".", "getLoadInfo", "(", "MI", ")", ")", "Changed", "|=", "expandLoad", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "MOA", ".", "getStoreInfo", "(", "MI", ")", ")", "Changed", "|=", "expandStore", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "MOA", ".", "getAtomicFenceInfo", "(", "MI", ")", ")", "Changed", "|=", "expandAtomicFence", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "MOA", ".", "getAtomicCmpxchgOrRmwInfo", "(", "MI", ")", ")", "Changed", "|=", "expandAtomicCmpxchgOrRmw", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "}", "}", "Changed", "|=", "removeAtomicPseudoMIs", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SIInstrFlags::maybeAtomic" ]

[]

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

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

[ "F2003f", "F2003f", "F2003f" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "unsigned", "Intrinsic", ")", "const", "{", "const", "IntrinsicData", "*", "IntrData", "=", "getIntrinsicWithChain", "(", "Intrinsic", ")", ";", "if", "(", "!", "IntrData", ")", "return", "false", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "readMem", "=", "false", ";", "Info", ".", "writeMem", "=", "false", ";", "Info", ".", "vol", "=", "false", ";", "Info", ".", "offset", "=", "0", ";", "switch", "(", "IntrData", "->", "Type", ")", "{", "case", "EXPAND_FROM_MEM", ":", "{", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getType", "(", ")", ")", ";", "Info", ".", "align", "=", "1", ";", "Info", ".", "readMem", "=", "true", ";", "break", ";", "}", "case", "COMPRESS_TO_MEM", ":", "{", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "1", ")", "->", "getType", "(", ")", ")", ";", "Info", ".", "align", "=", "1", ";", "Info", ".", "writeMem", "=", "true", ";", "break", ";", "}", "case", "TRUNCATE_TO_MEM_VI8", ":", "case", "TRUNCATE_TO_MEM_VI16", ":", "case", "TRUNCATE_TO_MEM_VI32", ":", "{", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "MVT", "VT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "1", ")", "->", "getType", "(", ")", ")", ";", "MVT", "ScalarVT", "=", "MVT", "::", "INVALID_SIMPLE_VALUE_TYPE", ";", "if", "(", "IntrData", "->", "Type", "==", "TRUNCATE_TO_MEM_VI8", ")", "ScalarVT", "=", "MVT", "::", "i8", ";", "else", "if", "(", "IntrData", "->", "Type", "==", "TRUNCATE_TO_MEM_VI16", ")", "ScalarVT", "=", "MVT", "::", "i16", ";", "else", "if", "(", "IntrData", "->", "Type", "==", "TRUNCATE_TO_MEM_VI32", ")", "ScalarVT", "=", "MVT", "::", "i32", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVectorVT", "(", "ScalarVT", ",", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "Info", ".", "align", "=", "1", ";", "Info", ".", "writeMem", "=", "true", ";", "break", ";", "}", "case", "STOREANT", ":", "{", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "1", ")", "->", "getType", "(", ")", ")", ";", "Info", ".", "align", "=", "Info", ".", "memVT", ".", "getSizeInBits", "(", ")", "/", "8", ";", "Info", ".", "writeMem", "=", "true", ";", "break", ";", "}", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "ISD::INTRINSIC_W_CHAIN", "0", "0", "MVT::getVT", "1", "0", "MVT::getVT", "1", "1", "0", "MVT::getVT", "1", "MVT::INVALID_SIMPLE_VALUE_TYPE", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::getVectorVT", "1", "0", "MVT::getVT", "1", "8" ]

[]

[ "<s>", "static", "enum", "sched_fusion_type", "fusion_load_store", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ")", "{", "rtx", "x", ",", "dest", ",", "src", ";", "enum", "sched_fusion_type", "fusion", "=", "SCHED_FUSION_LD", ";", "gcc_assert", "(", "INSN_P", "(", "insn", ")", ")", ";", "x", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SET", ")", "return", "SCHED_FUSION_NONE", ";", "src", "=", "SET_SRC", "(", "x", ")", ";", "dest", "=", "SET_DEST", "(", "x", ")", ";", "machine_mode", "dest_mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "!", "aarch64_mode_valid_for_sched_fusion_p", "(", "dest_mode", ")", ")", "return", "SCHED_FUSION_NONE", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "SIGN_EXTEND", ")", "{", "fusion", "=", "SCHED_FUSION_LD_SIGN_EXTEND", ";", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "if", "(", "!", "MEM_P", "(", "src", ")", "||", "GET_MODE", "(", "src", ")", "!=", "SImode", ")", "return", "SCHED_FUSION_NONE", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "ZERO_EXTEND", ")", "{", "fusion", "=", "SCHED_FUSION_LD_ZERO_EXTEND", ";", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "if", "(", "!", "MEM_P", "(", "src", ")", "||", "GET_MODE", "(", "src", ")", "!=", "SImode", ")", "return", "SCHED_FUSION_NONE", ";", "}", "if", "(", "MEM_P", "(", "src", ")", "&&", "REG_P", "(", "dest", ")", ")", "extract_base_offset_in_addr", "(", "src", ",", "base", ",", "offset", ")", ";", "else", "if", "(", "MEM_P", "(", "dest", ")", "&&", "(", "REG_P", "(", "src", ")", "||", "src", "==", "const0_rtx", ")", ")", "{", "fusion", "=", "SCHED_FUSION_ST", ";", "extract_base_offset_in_addr", "(", "dest", ",", "base", ",", "offset", ")", ";", "}", "else", "return", "SCHED_FUSION_NONE", ";", "if", "(", "*", "base", "==", "NULL_RTX", "||", "*", "offset", "==", "NULL_RTX", ")", "fusion", "=", "SCHED_FUSION_NONE", ";", "return", "fusion", ";", "}", "</s>" ]

[ "If", "INSN", "is", "a", "load", "or", "store", "of", "address", "in", "the", "form", "of", "[", "base+offset", "]", ",", "extract", "the", "two", "parts", "and", "set", "to", "BASE", "and", "OFFSET", ".", "IS_LOAD", "is", "set", "to", "TRUE", "if", "it", "'s", "a", "load", ".", "Return", "TRUE", "if", "INSN", "is", "such", "an", "instruction", ",", "otherwise", "return", "FALSE", "." ]

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

[]

[ "<s>", "int", "h8300_shift_needs_scratch_p", "(", "int", "count", ",", "enum", "machine_mode", "mode", ")", "{", "enum", "h8_cpu", "cpu", ";", "int", "a", ",", "lr", ",", "ar", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<=", "count", ")", "return", "1", ";", "if", "(", "TARGET_H8300", ")", "cpu", "=", "H8_300", ";", "else", "if", "(", "TARGET_H8300H", ")", "cpu", "=", "H8_300H", ";", "else", "cpu", "=", "H8_S", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "a", "=", "shift_alg_qi", "[", "cpu", "]", "[", "SHIFT_ASHIFT", "]", "[", "count", "]", ";", "lr", "=", "shift_alg_qi", "[", "cpu", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "count", "]", ";", "ar", "=", "shift_alg_qi", "[", "cpu", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "count", "]", ";", "break", ";", "case", "HImode", ":", "a", "=", "shift_alg_hi", "[", "cpu", "]", "[", "SHIFT_ASHIFT", "]", "[", "count", "]", ";", "lr", "=", "shift_alg_hi", "[", "cpu", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "count", "]", ";", "ar", "=", "shift_alg_hi", "[", "cpu", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "count", "]", ";", "break", ";", "case", "SImode", ":", "a", "=", "shift_alg_si", "[", "cpu", "]", "[", "SHIFT_ASHIFT", "]", "[", "count", "]", ";", "lr", "=", "shift_alg_si", "[", "cpu", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "count", "]", ";", "ar", "=", "shift_alg_si", "[", "cpu", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "count", "]", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "(", "a", "==", "SHIFT_LOOP", "||", "lr", "==", "SHIFT_LOOP", "||", "ar", "==", "SHIFT_LOOP", "||", "(", "TARGET_H8300H", "&&", "mode", "==", "SImode", "&&", "count", "==", "8", ")", ")", ";", "}", "</s>" ]

[ "Given", "COUNT", "and", "MODE", "of", "a", "shift", ",", "return", "1", "if", "a", "scratch", "reg", "may", "be", "needed", "for", "some", "shift", "with", "COUNT", "and", "MODE", ".", "Return", "0", "otherwise", "." ]

[ "h8300", "1", "8" ]

[]

[ "<s>", "unsigned", "SystemZInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "break", ";", "if", "(", "!", "getBranchInfo", "(", "*", "I", ")", ".", "Target", "->", "isMBB", "(", ")", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"code size not handled\"", "0" ]

[]

[ "<s>", "bool", "ARMGlobalMerge", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "bool", "CallsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "assert", "(", "MF", "&&", "\"MachineFunction required\"", ")", ";", "switch", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_SaveList", ";", "return", "CSR_64_RT_AllRegs_SaveList", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "MF", "->", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_64_CXX_TLS_Darwin_PE_SaveList", ":", "CSR_64_TLS_Darwin_SaveList", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_SaveList", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_SaveList", ";", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_SaveList", ";", "break", ";", "case", "CallingConv", "::", "X86_64_Win64", ":", "return", "CSR_Win64_SaveList", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "else", "return", "CSR_64_AllRegs_SaveList", ";", "}", "else", "{", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_SaveList", ";", "else", "return", "CSR_32_AllRegs_SaveList", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_SaveList", ";", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"MachineFunction required\"", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "void", "Z80DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Z80", "Z80" ]

[]

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

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

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

[]

[ "<s>", "void", "BTFDebug", "::", "beginInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "DebugHandlerBase", "::", "beginInstruction", "(", "MI", ")", ";", "if", "(", "SkipInstruction", "||", "MI", "->", "isMetaInstruction", "(", ")", "||", "MI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "return", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", ")", "{", "unsigned", "NumDefs", "=", "0", ";", "for", "(", ";", "MI", "->", "getOperand", "(", "NumDefs", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "NumDefs", ")", ".", "isDef", "(", ")", ";", "++", "NumDefs", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", "->", "getOperand", "(", "NumDefs", ")", ".", "getSymbolName", "(", ")", ";", "if", "(", "AsmStr", "[", "0", "]", "==", "0", ")", "return", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "LD_imm64", ")", "processLDimm64", "(", "MI", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "DL", "||", "PrevInstLoc", "==", "DL", ")", "{", "if", "(", "LineInfoGenerated", "==", "false", ")", "{", "auto", "*", "S", "=", "MI", "->", "getMF", "(", ")", "->", "getFunction", "(", ")", ".", "getSubprogram", "(", ")", ";", "MCSymbol", "*", "FuncLabel", "=", "Asm", "->", "getFunctionBegin", "(", ")", ";", "constructLineInfo", "(", "S", ",", "FuncLabel", ",", "S", "->", "getLine", "(", ")", ",", "0", ")", ";", "LineInfoGenerated", "=", "true", ";", "}", "return", ";", "}", "MCSymbol", "*", "LineSym", "=", "OS", ".", "getContext", "(", ")", ".", "createTempSymbol", "(", ")", ";", "OS", ".", "EmitLabel", "(", "LineSym", ")", ";", "auto", "SP", "=", "DL", ".", "get", "(", ")", "->", "getScope", "(", ")", "->", "getSubprogram", "(", ")", ";", "constructLineInfo", "(", "SP", ",", "LineSym", ",", "DL", ".", "getLine", "(", ")", ",", "DL", ".", "getCol", "(", ")", ")", ";", "LineInfoGenerated", "=", "true", ";", "PrevInstLoc", "=", "DL", ";", "}", "</s>" ]

[ "Process", "beginning", "of", "an", "instruction", "." ]

[ "BPF", "0", "0", "0", "BPF::LD_imm64", "0" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isFunctionSafeToOutlineFrom", "(", "MachineFunction", "&", "MF", ",", "bool", "OutlineFromLinkOnceODRs", ")", "const", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "OutlineFromLinkOnceODRs", "&&", "F", ".", "hasLinkOnceODRLinkage", "(", ")", ")", "return", "false", ";", "if", "(", "F", ".", "hasSection", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "can", "safely", "be", "outlined", "from", "." ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "SUnit", "*", "ConvergingVLIWScheduler", "::", "pickNodeBidrectional", "(", "bool", "&", "IsTopNode", ")", "{", "if", "(", "SUnit", "*", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Picked only Bottom\\n\"", ")", ";", "IsTopNode", "=", "false", ";", "return", "SU", ";", "}", "if", "(", "SUnit", "*", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Picked only Top\\n\"", ")", ";", "IsTopNode", "=", "true", ";", "return", "SU", ";", "}", "SchedCandidate", "BotCand", ";", "CandResult", "BotResult", "=", "pickNodeFromQueue", "(", "Bot", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "if", "(", "BotResult", "==", "SingleExcess", "||", "BotResult", "==", "SingleCritical", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Prefered Bottom Node\\n\"", ")", ";", "IsTopNode", "=", "false", ";", "return", "BotCand", ".", "SU", ";", "}", "SchedCandidate", "TopCand", ";", "CandResult", "TopResult", "=", "pickNodeFromQueue", "(", "Top", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "if", "(", "TopResult", "==", "SingleExcess", "||", "TopResult", "==", "SingleCritical", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Prefered Top Node\\n\"", ")", ";", "IsTopNode", "=", "true", ";", "return", "TopCand", ".", "SU", ";", "}", "if", "(", "BotResult", "==", "SingleMax", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Prefered Bottom Node SingleMax\\n\"", ")", ";", "IsTopNode", "=", "false", ";", "return", "BotCand", ".", "SU", ";", "}", "if", "(", "TopResult", "==", "SingleMax", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Prefered Top Node SingleMax\\n\"", ")", ";", "IsTopNode", "=", "true", ";", "return", "TopCand", ".", "SU", ";", "}", "if", "(", "TopCand", ".", "SCost", ">", "BotCand", ".", "SCost", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Prefered Top Node Cost\\n\"", ")", ";", "IsTopNode", "=", "true", ";", "return", "TopCand", ".", "SU", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Prefered Bottom in Node order\\n\"", ")", ";", "IsTopNode", "=", "false", ";", "return", "BotCand", ".", "SU", ";", "}", "</s>" ]

[ "Pick", "the", "best", "candidate", "node", "from", "either", "the", "top", "or", "bottom", "queue", "." ]

[ "Hexagon", "\"Picked only Bottom\\n\"", "\"Picked only Top\\n\"", "\"failed to find the first candidate\"", "\"Prefered Bottom Node\\n\"", "\"failed to find the first candidate\"", "\"Prefered Top Node\\n\"", "\"Prefered Bottom Node SingleMax\\n\"", "\"Prefered Top Node SingleMax\\n\"", "\"Prefered Top Node Cost\\n\"", "\"Prefered Bottom in Node order\\n\"" ]

[]

[ "<s>", "bool", "SIRemoveShortExecBranches", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MF", ".", "RenumberBlocks", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "continue", ";", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "S_CBRANCH_EXECZ", ":", "Changed", "=", "removeExeczBranch", "(", "MI", ",", "MBB", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::S_CBRANCH_EXECZ" ]

[]

[ "<s>", "virtual", "llvm", "::", "StringRef", "getPassName", "(", ")", "const", "{", "return", "\"Add implicit SYCL global offset\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"Add implicit SYCL global offset\"" ]

[]

[ "<s>", "bool", "can_be_rotated_to_positive_16bits", "(", "HOST_WIDE_INT", "c", ")", "{", "int", "rot", "=", "0", ";", "bool", "res", "=", "can_be_rotated_to_lowbits", "(", "c", ",", "16", ",", "&", "rot", ")", ";", "return", "res", "&&", "rot", ">", "0", ";", "}", "</s>" ]

[ "Check", "if", "C", "(", "as", "64bit", "integer", ")", "can", "be", "rotated", "to", "a", "positive", "16bits", "constant", "which", "contains", "48bits", "leading", "zeros", "and", "16bits", "of", "any", "value", "." ]

[ "rs6000", "0", "16", "0" ]

[]

[ "<s>", "unsigned", "int", "m32r_compute_frame_size", "(", "int", "size", ")", "{", "unsigned", "int", "regno", ";", "unsigned", "int", "total_size", ",", "var_size", ",", "args_size", ",", "pretend_size", ",", "extra_size", ";", "unsigned", "int", "reg_size", ";", "unsigned", "int", "gmask", ";", "enum", "m32r_function_type", "fn_type", ";", "int", "interrupt_p", ";", "int", "pic_reg_used", "=", "flag_pic", "&&", "(", "crtl", "->", "uses_pic_offset_table", "|", "crtl", "->", "profile", ")", ";", "var_size", "=", "M32R_STACK_ALIGN", "(", "size", ")", ";", "args_size", "=", "M32R_STACK_ALIGN", "(", "crtl", "->", "outgoing_args_size", ")", ";", "pretend_size", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "extra_size", "=", "FIRST_PARM_OFFSET", "(", "0", ")", ";", "total_size", "=", "extra_size", "+", "pretend_size", "+", "args_size", "+", "var_size", ";", "reg_size", "=", "0", ";", "gmask", "=", "0", ";", "fn_type", "=", "m32r_compute_function_type", "(", "current_function_decl", ")", ";", "interrupt_p", "=", "M32R_INTERRUPT_P", "(", "fn_type", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "M32R_MAX_INT_REGS", ";", "regno", "++", ")", "{", "if", "(", "MUST_SAVE_REGISTER", "(", "regno", ",", "interrupt_p", ")", "||", "(", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "&&", "pic_reg_used", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1", "<<", "regno", ";", "}", "}", "current_frame_info", ".", "save_fp", "=", "MUST_SAVE_FRAME_POINTER", ";", "current_frame_info", ".", "save_lr", "=", "MUST_SAVE_RETURN_ADDR", "||", "pic_reg_used", ";", "reg_size", "+=", "(", "(", "current_frame_info", ".", "save_fp", "+", "current_frame_info", ".", "save_lr", ")", "*", "UNITS_PER_WORD", ")", ";", "total_size", "+=", "reg_size", ";", "total_size", "=", "M32R_STACK_ALIGN", "(", "total_size", ")", ";", "current_frame_info", ".", "total_size", "=", "total_size", ";", "current_frame_info", ".", "extra_size", "=", "extra_size", ";", "current_frame_info", ".", "pretend_size", "=", "pretend_size", ";", "current_frame_info", ".", "var_size", "=", "var_size", ";", "current_frame_info", ".", "args_size", "=", "args_size", ";", "current_frame_info", ".", "reg_size", "=", "reg_size", ";", "current_frame_info", ".", "gmask", "=", "gmask", ";", "current_frame_info", ".", "initialized", "=", "reload_completed", ";", "return", "total_size", ";", "}", "</s>" ]

[ "Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", ".", "SIZE", "is", "the", "size", "needed", "for", "local", "variables", "." ]

[ "m32r", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "const", "FunctionType", "*", "FTy", "=", "F", ".", "getFunctionType", "(", ")", ";", "LocalMemAvailable", "=", "ST", ".", "getLocalMemorySize", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "FTy", "->", "getNumParams", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "Type", "*", "ParamTy", "=", "FTy", "->", "getParamType", "(", "i", ")", ";", "if", "(", "ParamTy", "->", "isPointerTy", "(", ")", "&&", "ParamTy", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "{", "LocalMemAvailable", "=", "0", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", ")", ";", "break", ";", "}", "}", "if", "(", "LocalMemAvailable", ">", "0", ")", "{", "for", "(", "Module", "::", "global_iterator", "I", "=", "Mod", "->", "global_begin", "(", ")", ",", "E", "=", "Mod", "->", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "GlobalVariable", "*", "GV", "=", "I", ";", "PointerType", "*", "GVTy", "=", "GV", "->", "getType", "(", ")", ";", "if", "(", "GVTy", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "continue", ";", "for", "(", "Value", "::", "use_iterator", "U", "=", "GV", "->", "use_begin", "(", ")", ",", "UE", "=", "GV", "->", "use_end", "(", ")", ";", "U", "!=", "UE", ";", "++", "U", ")", "{", "Instruction", "*", "Use", "=", "dyn_cast", "<", "Instruction", ">", "(", "*", "U", ")", ";", "if", "(", "!", "Use", ")", "continue", ";", "if", "(", "Use", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "==", "&", "F", ")", "LocalMemAvailable", "-=", "Mod", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "GVTy", "->", "getElementType", "(", ")", ")", ";", "}", "}", "}", "LocalMemAvailable", "=", "std", "::", "max", "(", "0", ",", "LocalMemAvailable", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "LocalMemAvailable", "<<", "\"bytes free in local memory.\\n\"", ")", ";", "visit", "(", "F", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "0", "AMDGPU", "0", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", "0", "AMDGPU", "0", "\"bytes free in local memory.\\n\"" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "AMDGPU", "::", "IsaInfo", "::", "hasCodeObjectV3", "(", "&", "getSTI", "(", ")", ")", ")", "{", "if", "(", "IDVal", "==", "\".amdgcn_target\"", ")", "return", "ParseDirectiveAMDGCNTarget", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdhsa_kernel\"", ")", "return", "ParseDirectiveAMDHSAKernel", "(", ")", ";", "}", "else", "{", "if", "(", "IDVal", "==", "\".hsa_code_object_version\"", ")", "return", "ParseDirectiveHSACodeObjectVersion", "(", ")", ";", "if", "(", "IDVal", "==", "\".hsa_code_object_isa\"", ")", "return", "ParseDirectiveHSACodeObjectISA", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_kernel_code_t\"", ")", "return", "ParseDirectiveAMDKernelCodeT", "(", ")", ";", "if", "(", "IDVal", "==", "\".amdgpu_hsa_kernel\"", ")", "return", "ParseDirectiveAMDGPUHsaKernel", "(", ")", ";", "if", "(", "IDVal", "==", "\".amd_amdgpu_isa\"", ")", "return", "ParseDirectiveISAVersion", "(", ")", ";", "}", "if", "(", "IDVal", "==", "AMDGPU", "::", "HSAMD", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectiveHSAMetadata", "(", ")", ";", "if", "(", "IDVal", "==", "PALMD", "::", "AssemblerDirective", ")", "return", "ParseDirectivePALMetadata", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::IsaInfo", "\".amdgcn_target\"", "\".amdhsa_kernel\"", "\".hsa_code_object_version\"", "\".hsa_code_object_isa\"", "\".amd_kernel_code_t\"", "\".amdgpu_hsa_kernel\"", "AMDGPU", "\".amd_amdgpu_isa\"", "AMDGPU::HSAMD" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "MCS51FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "const", "MCS51Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "MCS51Subtarget", ">", "(", ")", ";", "const", "MCS51InstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "MCS51", "::", "R29R28", ")", ";", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "int", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "MI", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "assert", "(", "getStackAlign", "(", ")", "==", "Align", "(", "1", ")", "&&", "\"Unsupported stack alignment\"", ")", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MCS51", "::", "SPREAD", ")", ",", "MCS51", "::", "R31R30", ")", ".", "addReg", "(", "MCS51", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MCS51", "::", "SUBIWRdK", ")", ",", "MCS51", "::", "R31R30", ")", ".", "addReg", "(", "MCS51", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Amount", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MCS51", "::", "SPWRITE", ")", ",", "MCS51", "::", "SP", ")", ".", "addReg", "(", "MCS51", "::", "R31R30", ")", ";", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "MCS51", "::", "R31R30", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "unsigned", "addOpcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "Amount", ")", ")", "{", "addOpcode", "=", "MCS51", "::", "ADIWRdK", ";", "}", "else", "{", "addOpcode", "=", "MCS51", "::", "SUBIWRdK", ";", "Amount", "=", "-", "Amount", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MCS51", "::", "SPREAD", ")", ",", "MCS51", "::", "R31R30", ")", ".", "addReg", "(", "MCS51", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "addOpcode", ")", ",", "MCS51", "::", "R31R30", ")", ".", "addReg", "(", "MCS51", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Amount", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MCS51", "::", "SPWRITE", ")", ",", "MCS51", "::", "SP", ")", ".", "addReg", "(", "MCS51", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</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", ")", "." ]

[ "MCS51", "MCS51", "MCS51", "MCS51", "MCS51", "MCS51::R29R28", "0", "1", "\"Unsupported stack alignment\"", "MCS51::SPREAD", "MCS51::R31R30", "MCS51::SP", "MCS51::SUBIWRdK", "MCS51::R31R30", "MCS51::R31R30", "3", "MCS51::SPWRITE", "MCS51::SP", "MCS51::R31R30", "MCS51::R31R30", "6", "MCS51::ADIWRdK", "MCS51::SUBIWRdK", "MCS51::SPREAD", "MCS51::R31R30", "MCS51::SP", "MCS51::R31R30", "MCS51::R31R30", "3", "MCS51::SPWRITE", "MCS51::SP", "MCS51::R31R30" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addIRTranslator", "(", ")", "{", "addPass", "(", "new", "IRTranslator", "(", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "an", "IR", "translator", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "with", "possibly", "generic", "opcodes", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "SIFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", "MBB", ".", "erase", "(", "I", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "uint64_t", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "Amount", "=", "alignTo", "(", "Amount", ",", "getStackAlign", "(", ")", ")", ";", "assert", "(", "isUInt", "<", "32", ">", "(", "Amount", ")", "&&", "\"exceeded stack address space size\"", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "SPReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "unsigned", "Op", "=", "IsDestroy", "?", "AMDGPU", "::", "S_SUB_U32", ":", "AMDGPU", "::", "S_ADD_U32", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Op", ")", ",", "SPReg", ")", ".", "addReg", "(", "SPReg", ")", ".", "addImm", "(", "Amount", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ";", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "llvm_unreachable", "(", "\"is this used?\"", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "0", "SI", "1", "0", "32", "\"exceeded stack address space size\"", "SI", "SI", "AMDGPU::S_SUB_U32", "AMDGPU::S_ADD_U32", "0", "\"is this used?\"" ]

[]

[ "<s>", "static", "void", "ready_reorder", "(", "rtx", "*", "ready", ",", "int", "nready", ")", "{", "SCHED_REORDER", "(", "ready", ",", "nready", ")", ";", "}", "</s>" ]

[ "Sort", "the", "ready", "list", "READY", "by", "ascending", "priority", ",", "using", "the", "SCHED_REORDER", "macro", "." ]

[ "sh" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ">", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "if", "(", "IsPICCall", "&&", "!", "InternalLinkage", ")", "{", "unsigned", "GPReg", "=", "Subtarget", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "GP_64", ":", "Mips", "::", "GP", ";", "EVT", "Ty", "=", "Subtarget", ".", "isABI_N64", "(", ")", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPReg", ",", "getGlobalReg", "(", "CLI", ".", "DAG", ",", "Ty", ")", ")", ")", ";", "}", "SDValue", "InFlag", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "CLI", ".", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "CLI", ".", "DL", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegister", "(", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "CLI", ".", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "\"Missing call preserved mask for calling convention\"", ")", ";", "if", "(", "Subtarget", ".", "inMips16HardFloat", "(", ")", ")", "{", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "CLI", ".", "Callee", ")", ")", "{", "llvm", "::", "StringRef", "Sym", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "Function", "*", "F", "=", "G", "->", "getGlobal", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", "Sym", ")", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "\"__Mips16RetHelper\"", ")", ")", "{", "Mask", "=", "MipsRegisterInfo", "::", "getMips16RetHelperMask", "(", ")", ";", "}", "}", "}", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "}", "</s>" ]

[ "This", "function", "fills", "Ops", ",", "which", "is", "the", "list", "of", "operands", "that", "will", "later", "be", "used", "when", "a", "function", "call", "node", "is", "created", "." ]

[ "Mips", "Mips", "Mips::GP_64", "Mips::GP", "MVT::i64", "MVT::i32", "0", "1", "0", "\"Missing call preserved mask for calling convention\"", "Mips", "\"__Mips16RetHelper\"", "Mips", "Mips" ]

[]

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

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "MOS" ]

[]

[ "<s>", "static", "bool", "or1k_pass_by_reference", "(", "cumulative_args_t", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", ")", "{", "HOST_WIDE_INT", "size", ";", "if", "(", "type", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "true", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "}", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "size", "<", "0", "||", "size", ">", "8", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_PASS_BY_REFERENCE", ".", "Returns", "true", "if", "an", "argument", "of", "TYPE", "in", "MODE", "should", "be", "passed", "by", "reference", "as", "required", "by", "the", "OpenRISC", "ABI", ".", "On", "OpenRISC", "structures", ",", "unions", "and", "arguments", "larger", "than", "64-bits", "are", "passed", "by", "reference", "." ]

[ "or1k", "0", "8" ]

[]

[ "<s>", "rtx", "m68k_legitimize_call_address", "(", "rtx", "x", ")", "{", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "if", "(", "call_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "VOIDmode", ")", ")", "return", "x", ";", "return", "replace_equiv_address", "(", "x", ",", "force_reg", "(", "Pmode", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "}", "</s>" ]

[ "Convert", "X", "to", "a", "legitimate", "function", "call", "memory", "reference", "and", "return", "the", "result", "." ]

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

[]

[ "<s>", "int", "arc_verify_short", "(", "rtx_insn", "*", "insn", ",", "int", ",", "int", "check_attr", ")", "{", "enum", "attr_iscompact", "iscompact", ";", "struct", "machine_function", "*", "machine", ";", "if", "(", "check_attr", ">", "0", ")", "{", "iscompact", "=", "get_attr_iscompact", "(", "insn", ")", ";", "if", "(", "iscompact", "==", "ISCOMPACT_FALSE", ")", "return", "0", ";", "}", "machine", "=", "cfun", "->", "machine", ";", "if", "(", "machine", "->", "force_short_suffix", ">=", "0", ")", "return", "machine", "->", "force_short_suffix", ";", "return", "(", "get_attr_length", "(", "insn", ")", "&", "2", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "INSN", "should", "be", "output", "as", "a", "short", "insn", ".", "UNALIGN", "is", "zero", "if", "the", "current", "insn", "is", "aligned", "to", "a", "4-byte-boundary", ",", "two", "otherwise", ".", "If", "CHECK_ATTR", "is", "greater", "than", "0", ",", "check", "the", "iscompact", "attribute", "first", "." ]

[ "arc", "0", "0", "0", "2", "0" ]

[]

[ "<s>", "void", "aarch64_d_target_versions", "(", "void", ")", "{", "d_add_builtin_version", "(", "\"AArch64\"", ")", ";", "d_add_builtin_version", "(", "\"D_HardFloat\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_D_CPU_VERSIONS", "for", "AArch64", "targets", "." ]

[ "aarch64", "\"AArch64\"", "\"D_HardFloat\"" ]

[]

[ "<s>", "void", "m32c_emit_prologue", "(", "void", ")", "{", "int", "frame_size", ",", "extra_frame_size", "=", "0", ",", "reg_save_size", ";", "int", "complex_prologue", "=", "0", ";", "cfun", "->", "machine", "->", "is_leaf", "=", "m32c_leaf_function_p", "(", ")", ";", "if", "(", "interrupt_p", "(", "cfun", "->", "decl", ")", ")", "{", "cfun", "->", "machine", "->", "is_interrupt", "=", "1", ";", "complex_prologue", "=", "1", ";", "}", "else", "if", "(", "bank_switch_p", "(", "cfun", "->", "decl", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"%<bank_switch%> has no effect on non-interrupt functions\"", ")", ";", "reg_save_size", "=", "m32c_pushm_popm", "(", "PP_justcount", ")", ";", "if", "(", "interrupt_p", "(", "cfun", "->", "decl", ")", ")", "{", "if", "(", "bank_switch_p", "(", "cfun", "->", "decl", ")", ")", "emit_insn", "(", "gen_fset_b", "(", ")", ")", ";", "else", "if", "(", "cfun", "->", "machine", "->", "intr_pushm", ")", "emit_insn", "(", "gen_pushm", "(", "GEN_INT", "(", "cfun", "->", "machine", "->", "intr_pushm", ")", ")", ")", ";", "}", "frame_size", "=", "m32c_initial_elimination_offset", "(", "FB_REGNO", ",", "SP_REGNO", ")", "-", "reg_save_size", ";", "if", "(", "frame_size", "==", "0", "&&", "!", "m32c_function_needs_enter", "(", ")", ")", "cfun", "->", "machine", "->", "use_rts", "=", "1", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "frame_size", ";", "if", "(", "frame_size", ">", "254", ")", "{", "extra_frame_size", "=", "frame_size", "-", "254", ";", "frame_size", "=", "254", ";", "}", "if", "(", "cfun", "->", "machine", "->", "use_rts", "==", "0", ")", "F", "(", "emit_insn", "(", "m32c_all_frame_related", "(", "TARGET_A16", "?", "gen_prologue_enter_16", "(", "GEN_INT", "(", "frame_size", "+", "2", ")", ")", ":", "gen_prologue_enter_24", "(", "GEN_INT", "(", "frame_size", "+", "4", ")", ")", ")", ")", ")", ";", "if", "(", "extra_frame_size", ")", "{", "complex_prologue", "=", "1", ";", "if", "(", "TARGET_A16", ")", "F", "(", "emit_insn", "(", "gen_addhi3", "(", "gen_rtx_REG", "(", "HImode", ",", "SP_REGNO", ")", ",", "gen_rtx_REG", "(", "HImode", ",", "SP_REGNO", ")", ",", "GEN_INT", "(", "-", "extra_frame_size", ")", ")", ")", ")", ";", "else", "F", "(", "emit_insn", "(", "gen_addpsi3", "(", "gen_rtx_REG", "(", "PSImode", ",", "SP_REGNO", ")", ",", "gen_rtx_REG", "(", "PSImode", ",", "SP_REGNO", ")", ",", "GEN_INT", "(", "-", "extra_frame_size", ")", ")", ")", ")", ";", "}", "complex_prologue", "+=", "m32c_pushm_popm", "(", "PP_pushm", ")", ";", "if", "(", "complex_prologue", ")", "emit_insn", "(", "gen_prologue_end", "(", ")", ")", ";", "}", "</s>" ]

[ "Emits", "the", "prologue", ".", "See", "the", "frame", "layout", "comment", "earlier", "in", "this", "file", ".", "We", "can", "reserve", "up", "to", "256", "bytes", "with", "the", "ENTER", "opcode", ",", "beyond", "that", "we", "manually", "update", "sp", "." ]

[ "m32c", "0", "0", "1", "1", "\"%<bank_switch%> has no effect on non-interrupt functions\"", "0", "1", "254", "254", "254", "0", "2", "4", "1" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reserveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "||", "Amount", ")", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "RoundUpToAlignment", "(", "Amount", ",", "StackAlign", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "WindowsCFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "bool", "DwarfCFI", "=", "!", "WindowsCFI", "&&", "(", "MMI", ".", "hasDebugInfo", "(", ")", "||", "Fn", "->", "needsUnwindTableEntry", "(", ")", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "WindowsCFI", "&&", "!", "MF", ".", "getMMI", "(", ")", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "isDestroy", "&&", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "isDestroy", "&&", "InternalAmt", "&&", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", "&&", "MMI", ".", "usePreciseUnwindInfo", "(", ")", ")", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "-", "InternalAmt", ")", ")", ";", "if", "(", "Amount", ")", "{", "int", "Offset", "=", "isDestroy", "?", "Amount", ":", "-", "Amount", ";", "if", "(", "!", "(", "Fn", "->", "optForMinSize", "(", ")", "&&", "adjustStackWithPops", "(", "MBB", ",", "I", ",", "DL", ",", "Offset", ")", ")", ")", "BuildStackAdjustment", "(", "MBB", ",", "I", ",", "DL", ",", "Offset", ",", "false", ")", ";", "}", "if", "(", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "{", "int", "CFAOffset", "=", "Amount", ";", "if", "(", "!", "MMI", ".", "usePreciseUnwindInfo", "(", ")", ")", "CFAOffset", "+=", "InternalAmt", ";", "CFAOffset", "=", "isDestroy", "?", "-", "CFAOffset", ":", "CFAOffset", ";", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "CFAOffset", ")", ")", ";", "}", "return", ";", "}", "if", "(", "isDestroy", "&&", "InternalAmt", ")", "{", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "I", "!=", "B", "&&", "!", "std", "::", "prev", "(", "I", ")", "->", "isCall", "(", ")", ")", "--", "I", ";", "BuildStackAdjustment", "(", "MBB", ",", "I", ",", "DL", ",", "-", "InternalAmt", ",", "false", ")", ";", "}", "}", "</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", ")", "." ]

[ "X86", "X86", "0", "0", "1", "0", "X86", "0" ]

[]

[ "<s>", "bool", "M68kAsmParser", "::", "emit", "(", "MCInst", "&", "Inst", ",", "SMLoc", "const", "&", "Loc", ",", "MCStreamer", "&", "Out", ")", "const", "{", "Inst", ".", "setLoc", "(", "Loc", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Output", "the", "remark", "via", "the", "diagnostic", "handler", "and", "to", "the", "optimization", "record", "file", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "bool", "AlphaTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", "!=", "MVT", "::", "f32", "&&", "VT", "!=", "MVT", "::", "f64", ")", "return", "false", ";", "return", "Imm", ".", "isZero", "(", ")", "||", "Imm", ".", "isNegZero", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "Alpha", "Alpha", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "return", "MIRBuilder", ".", "buildFrameIndex", "(", "LLT", "::", "pointer", "(", "0", ",", "DL", ".", "getPointerSizeInBits", "(", "0", ")", ")", ",", "FI", ")", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

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

[]

[ "<s>", "static", "bool", "ea_symbol_ref_p", "(", "const_rtx", "x", ")", "{", "tree", "decl", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", ")", "{", "rtx", "plus", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "op0", "=", "XEXP", "(", "plus", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "plus", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", ")", "x", "=", "op0", ";", "}", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "(", "decl", "=", "SYMBOL_REF_DECL", "(", "x", ")", ")", "!=", "0", "&&", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "decl", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "SYMBOL_REF", "to", "an", "__ea", "qualified", "variable", "." ]

[ "spu", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "Mips", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_Mips_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Mips_REL32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Mips_26\"", ",", "0", ",", "26", ",", "0", "}", ",", "{", "\"fixup_Mips_HI16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_LO16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GPREL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_LITERAL\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_Global\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_Local\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_PC16\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_Mips_CALL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GPREL32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Mips_SHIFT5\"", ",", "6", ",", "5", ",", "0", "}", ",", "{", "\"fixup_Mips_SHIFT6\"", ",", "6", ",", "5", ",", "0", "}", ",", "{", "\"fixup_Mips_64\"", ",", "0", ",", "64", ",", "0", "}", ",", "{", "\"fixup_Mips_TLSGD\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOTTPREL\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_TPREL_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_TPREL_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_TLSLDM\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_DTPREL_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_DTPREL_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_Branch_PCRel\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_Mips_GPOFF_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GPOFF_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_PAGE\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_OFST\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_DISP\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_HIGHER\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_HIGHEST\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_HI16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_GOT_LO16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_CALL_HI16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Mips_CALL_LO16\"", ",", "0", ",", "16", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "Mips", "Mips::NumTargetFixupKinds", "\"fixup_Mips_16\"", "0", "16", "0", "\"fixup_Mips_32\"", "0", "32", "0", "\"fixup_Mips_REL32\"", "0", "32", "0", "\"fixup_Mips_26\"", "0", "26", "0", "\"fixup_Mips_HI16\"", "0", "16", "0", "\"fixup_Mips_LO16\"", "0", "16", "0", "\"fixup_Mips_GPREL16\"", "0", "16", "0", "\"fixup_Mips_LITERAL\"", "0", "16", "0", "\"fixup_Mips_GOT_Global\"", "0", "16", "0", "\"fixup_Mips_GOT_Local\"", "0", "16", "0", "\"fixup_Mips_PC16\"", "0", "16", "\"fixup_Mips_CALL16\"", "0", "16", "0", "\"fixup_Mips_GPREL32\"", "0", "32", "0", "\"fixup_Mips_SHIFT5\"", "6", "5", "0", "\"fixup_Mips_SHIFT6\"", "6", "5", "0", "\"fixup_Mips_64\"", "0", "64", "0", "\"fixup_Mips_TLSGD\"", "0", "16", "0", "\"fixup_Mips_GOTTPREL\"", "0", "16", "0", "\"fixup_Mips_TPREL_HI\"", "0", "16", "0", "\"fixup_Mips_TPREL_LO\"", "0", "16", "0", "\"fixup_Mips_TLSLDM\"", "0", "16", "0", "\"fixup_Mips_DTPREL_HI\"", "0", "16", "0", "\"fixup_Mips_DTPREL_LO\"", "0", "16", "0", "\"fixup_Mips_Branch_PCRel\"", "0", "16", "\"fixup_Mips_GPOFF_HI\"", "0", "16", "0", "\"fixup_Mips_GPOFF_LO\"", "0", "16", "0", "\"fixup_Mips_GOT_PAGE\"", "0", "16", "0", "\"fixup_Mips_GOT_OFST\"", "0", "16", "0", "\"fixup_Mips_GOT_DISP\"", "0", "16", "0", "\"fixup_Mips_HIGHER\"", "0", "16", "0", "\"fixup_Mips_HIGHEST\"", "0", "16", "0", "\"fixup_Mips_GOT_HI16\"", "0", "16", "0", "\"fixup_Mips_GOT_LO16\"", "0", "16", "0", "\"fixup_Mips_CALL_HI16\"", "0", "16", "0", "\"fixup_Mips_CALL_LO16\"", "0", "16", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "rtx", "r10k_simplify_address", "(", "rtx", "x", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "newx", ",", "op0", ",", "op1", ",", "set", ",", "note", ";", "rtx_insn", "*", "def_insn", ";", "df_ref", "use", ",", "def", ";", "struct", "df_link", "*", "defs", ";", "newx", "=", "NULL_RTX", ";", "if", "(", "UNARY_P", "(", "x", ")", ")", "{", "op0", "=", "r10k_simplify_address", "(", "XEXP", "(", "x", ",", "0", ")", ",", "insn", ")", ";", "if", "(", "op0", "!=", "XEXP", "(", "x", ",", "0", ")", ")", "newx", "=", "simplify_gen_unary", "(", "GET_CODE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ",", "op0", ",", "GET_MODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "}", "else", "if", "(", "BINARY_P", "(", "x", ")", ")", "{", "op0", "=", "r10k_simplify_address", "(", "XEXP", "(", "x", ",", "0", ")", ",", "insn", ")", ";", "op1", "=", "r10k_simplify_address", "(", "XEXP", "(", "x", ",", "1", ")", ",", "insn", ")", ";", "if", "(", "op0", "!=", "XEXP", "(", "x", ",", "0", ")", "||", "op1", "!=", "XEXP", "(", "x", ",", "1", ")", ")", "newx", "=", "simplify_gen_binary", "(", "GET_CODE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ",", "op0", ",", "op1", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", ")", "{", "op0", "=", "r10k_simplify_address", "(", "XEXP", "(", "x", ",", "0", ")", ",", "insn", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "HIGH", ")", "newx", "=", "XEXP", "(", "x", ",", "1", ")", ";", "}", "else", "if", "(", "REG_P", "(", "x", ")", ")", "{", "use", "=", "df_find_use", "(", "insn", ",", "regno_reg_rtx", "[", "REGNO", "(", "x", ")", "]", ")", ";", "gcc_assert", "(", "use", ")", ";", "defs", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "if", "(", "defs", "&&", "defs", "->", "next", "==", "NULL", ")", "{", "def", "=", "defs", "->", "ref", ";", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "def", ")", ")", "{", "if", "(", "x", "==", "stack_pointer_rtx", "&&", "DF_REF_BB", "(", "def", ")", "==", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", "newx", "=", "virtual_incoming_args_rtx", ";", "}", "else", "if", "(", "dominated_by_p", "(", "CDI_DOMINATORS", ",", "DF_REF_BB", "(", "use", ")", ",", "DF_REF_BB", "(", "def", ")", ")", ")", "{", "def_insn", "=", "DF_REF_INSN", "(", "def", ")", ";", "if", "(", "NONJUMP_INSN_P", "(", "def_insn", ")", ")", "{", "set", "=", "single_set", "(", "def_insn", ")", ";", "if", "(", "set", "&&", "rtx_equal_p", "(", "SET_DEST", "(", "set", ")", ",", "x", ")", ")", "{", "note", "=", "find_reg_equal_equiv_note", "(", "def_insn", ")", ";", "if", "(", "note", ")", "newx", "=", "XEXP", "(", "note", ",", "0", ")", ";", "else", "newx", "=", "SET_SRC", "(", "set", ")", ";", "newx", "=", "r10k_simplify_address", "(", "newx", ",", "def_insn", ")", ";", "}", "}", "}", "}", "}", "if", "(", "newx", "&&", "r10k_simplified_address_p", "(", "newx", ")", ")", "return", "newx", ";", "return", "x", ";", "}", "</s>" ]

[ "X", "is", "an", "expression", "that", "appears", "in", "INSN", ".", "Try", "to", "use", "the", "UD", "chains", "to", "simplify", "it", ",", "returning", "the", "simplified", "form", "on", "success", "and", "the", "original", "form", "otherwise", ".", "Replace", "the", "incoming", "value", "of", "$", "sp", "with", "virtual_incoming_args_rtx", "(", "which", "should", "never", "occur", "in", "X", "otherwise", ")", "." ]

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

[]

[ "<s>", "void", "NVPTXAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "if", "(", "nvptxSubtarget", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "CUDA", ")", "emitLineNumberAsDotLoc", "(", "*", "MI", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "128", "NVPTX::CUDA" ]

[]

[ "<s>", "virtual", "const", "LanaiRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RegisterInfo", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai" ]

[]

[ "<s>", "Register", "M88kIncomingValueHandler", "::", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ",", "ISD", "::", "ArgFlagsTy", "Flags", ")", "{", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "const", "bool", "IsImmutable", "=", "!", "Flags", ".", "isByVal", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "IsImmutable", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "llvm", "::", "LLT", "FramePtr", "=", "LLT", "::", "pointer", "(", "0", ",", "32", ")", ";", "MachineInstrBuilder", "AddrReg", "=", "MIRBuilder", ".", "buildFrameIndex", "(", "FramePtr", ",", "FI", ")", ";", "return", "AddrReg", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "M88k", "M88k", "ISD::ArgFlagsTy", "0", "32", "0" ]

[]

[ "<s>", "bool", "enableInterleavedAccessVectorization", "(", ")", "{", "return", "!", "ST", "->", "hasSVE", "(", ")", ";", "}", "</s>" ]

[ "Enable", "matching", "of", "interleaved", "access", "groups", "." ]

[ "AArch64" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "*", "device_malloc", "(", "size_t", "size", ")", "{", "void", "*", "result", ";", "XHSA", "(", "hsa_fns", ".", "hsa_memory_allocate_fn", "(", "kernargs_region", ",", "size", ",", "&", "result", ")", ",", "\"Allocate device memory\"", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Allocate", "some", "device", "memory", "from", "the", "kernargs", "region", ".", "The", "returned", "address", "will", "be", "32-bit", "(", "with", "excess", "zeroed", "on", "64-bit", "host", ")", ",", "and", "accessible", "via", "the", "same", "address", "on", "both", "host", "and", "target", "(", "via", "__flat_scalar", "GCN", "address", "space", ")", "." ]

[ "gcn", "\"Allocate device memory\"" ]

[]

[ "<s>", "explicit", "Entry", "(", "const", "MachineLoop", "*", "L", ")", ":", "Loop", "(", "L", ")", ",", "NumBlocksLeft", "(", "L", "->", "getNumBlocks", "(", ")", ")", "{", "}", "</s>" ]

[ "The", "index", "of", "the", "entry", "block", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "static", "rtx", "rl78_addr_space_convert", "(", "rtx", "op", ",", "tree", "from_type", ",", "tree", "to_type", ")", "{", "addr_space_t", "from_as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "from_type", ")", ")", ";", "addr_space_t", "to_as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "to_type", ")", ")", ";", "rtx", "result", ";", "int", "to_bits", ";", "int", "from_bits", ";", "to_bits", "=", "GET_MODE_BITSIZE", "(", "rl78_addr_space_address_mode", "(", "to_as", ")", ")", ";", "from_bits", "=", "GET_MODE_BITSIZE", "(", "rl78_addr_space_address_mode", "(", "from_as", ")", ")", ";", "if", "(", "to_bits", "<", "from_bits", ")", "{", "rtx", "tmp", ";", "warning", "(", "OPT_Waddress", ",", "\"converting far pointer to near pointer\"", ")", ";", "result", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", "||", "(", "GET_CODE", "(", "op", ")", "==", "REG", "&&", "REGNO", "(", "op", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", ")", "tmp", "=", "gen_rtx_raw_SUBREG", "(", "HImode", ",", "op", ",", "0", ")", ";", "else", "tmp", "=", "simplify_subreg", "(", "HImode", ",", "op", ",", "SImode", ",", "0", ")", ";", "gcc_assert", "(", "tmp", "!=", "NULL_RTX", ")", ";", "emit_move_insn", "(", "result", ",", "tmp", ")", ";", "return", "result", ";", "}", "else", "if", "(", "to_bits", ">", "from_bits", ")", "{", "result", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_move_insn", "(", "rl78_subreg", "(", "HImode", ",", "result", ",", "SImode", ",", "0", ")", ",", "op", ")", ";", "if", "(", "TREE_CODE", "(", "from_type", ")", "==", "POINTER_TYPE", "&&", "TREE_CODE", "(", "TREE_TYPE", "(", "from_type", ")", ")", "==", "FUNCTION_TYPE", ")", "emit_move_insn", "(", "rl78_subreg", "(", "HImode", ",", "result", ",", "SImode", ",", "2", ")", ",", "const0_rtx", ")", ";", "else", "emit_move_insn", "(", "rl78_subreg", "(", "HImode", ",", "result", ",", "SImode", ",", "2", ")", ",", "GEN_INT", "(", "0x0f", ")", ")", ";", "return", "result", ";", "}", "else", "return", "op", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Convert", "from", "one", "address", "space", "to", "another", "." ]

[ "rl78", "\"converting far pointer to near pointer\"", "0", "0", "0", "2", "2", "0x0f" ]

[]

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "bool", "IsEHFuncletEpilogue", "=", "MBBI", "==", "MBB", ".", "end", "(", ")", "?", "false", ":", "isFuncletReturnInstr", "(", "*", "MBBI", ")", ";", "const", "X86FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "int", "FIOffset", ";", "unsigned", "BasePtr", ";", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "{", "assert", "(", "(", "!", "needsStackRealignment", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "isFixedObjectIndex", "(", "FrameIndex", ")", ")", "&&", "\"Return instruction can only reference SP relative frame objects\"", ")", ";", "FIOffset", "=", "TFI", "->", "getFrameIndexReferenceSP", "(", "MF", ",", "FrameIndex", ",", "BasePtr", ",", "0", ")", ";", "}", "else", "if", "(", "TFI", "->", "Is64Bit", "&&", "(", "MBB", ".", "isEHFuncletEntry", "(", ")", "||", "IsEHFuncletEpilogue", ")", ")", "{", "FIOffset", "=", "TFI", "->", "getWin64EHFrameIndexRef", "(", "MF", ",", "FrameIndex", ",", "BasePtr", ")", ";", "}", "else", "{", "FIOffset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "BasePtr", ")", ";", "}", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "LOCAL_ESCAPE", ")", "{", "MachineOperand", "&", "FI", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "FI", ".", "ChangeToImmediate", "(", "FIOffset", ")", ";", "return", ";", "}", "unsigned", "MachineBasePtr", "=", "BasePtr", ";", "if", "(", "Opc", "==", "X86", "::", "LEA64_32r", "&&", "X86", "::", "GR32RegClass", ".", "contains", "(", "BasePtr", ")", ")", "MachineBasePtr", "=", "getX86SubSuperRegister", "(", "BasePtr", ",", "64", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "MachineBasePtr", ",", "false", ")", ";", "if", "(", "BasePtr", "==", "StackPtr", ")", "FIOffset", "+=", "SPAdj", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "STACKMAP", "||", "Opc", "==", "TargetOpcode", "::", "PATCHPOINT", ")", "{", "assert", "(", "BasePtr", "==", "FramePtr", "&&", "\"Expected the FP as base register\"", ")", ";", "int64_t", "Offset", "=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", "+", "FIOffset", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "isImm", "(", ")", ")", "{", "int", "Imm", "=", "(", "int", ")", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getImm", "(", ")", ")", ";", "int", "Offset", "=", "FIOffset", "+", "Imm", ";", "assert", "(", "(", "!", "Is64Bit", "||", "isInt", "<", "32", ">", "(", "(", "long", "long", ")", "FIOffset", "+", "Imm", ")", ")", "&&", "\"Requesting 64-bit offset in 32-bit immediate!\"", ")", ";", "if", "(", "Offset", "!=", "0", "||", "!", "tryOptimizeLEAtoMOV", "(", "II", ")", ")", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "uint64_t", "Offset", "=", "FIOffset", "+", "(", "uint64_t", ")", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getOffset", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "setOffset", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"Return instruction can only reference SP relative frame objects\"", "0", "X86::LEA64_32r", "X86::GR32RegClass", "X86", "64", "\"Expected the FP as base register\"", "1", "1", "3", "3", "32", "\"Requesting 64-bit offset in 32-bit immediate!\"", "0", "3", "3", "3" ]

[]

[ "<s>", "bool", "GBZ80PostISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "const", "GBZ80Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GBZ80Subtarget", ">", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "Modified", "|=", "expandShiftLoop16", "(", ")", ";", "Modified", "|=", "expandPseudos", "(", ")", ";", "Modified", "|=", "expandBranch16", "(", ")", ";", "Modified", "|=", "optimizeCP", "(", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GB", "GB" ]

[]

[ "<s>", "const", "char", "*", "cr16_emit_add_sub_di", "(", "rtx", "*", "operands", ",", "enum", "rtx_code", "code", ")", "{", "rtx", "lo_op", "[", "2", "]", ";", "rtx", "hi0_op", "[", "2", "]", ";", "rtx", "hi1_op", "[", "2", "]", ";", "lo_op", "[", "0", "]", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "0", "]", ")", ";", "hi0_op", "[", "0", "]", "=", "simplify_gen_subreg", "(", "HImode", ",", "operands", "[", "0", "]", ",", "DImode", ",", "4", ")", ";", "hi1_op", "[", "0", "]", "=", "simplify_gen_subreg", "(", "HImode", ",", "operands", "[", "0", "]", ",", "DImode", ",", "6", ")", ";", "lo_op", "[", "1", "]", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "2", "]", ")", ";", "hi0_op", "[", "1", "]", "=", "simplify_gen_subreg", "(", "HImode", ",", "operands", "[", "2", "]", ",", "DImode", ",", "4", ")", ";", "hi1_op", "[", "1", "]", "=", "simplify_gen_subreg", "(", "HImode", ",", "operands", "[", "2", "]", ",", "DImode", ",", "6", ")", ";", "switch", "(", "code", ")", "{", "case", "PLUS", ":", "{", "output_asm_insn", "(", "\"addd\\t%1, %0\"", ",", "lo_op", ")", ";", "output_asm_insn", "(", "\"addcw\\t%1, %0\"", ",", "hi0_op", ")", ";", "output_asm_insn", "(", "\"addcw\\t%1, %0\"", ",", "hi1_op", ")", ";", "break", ";", "}", "case", "MINUS", ":", "{", "output_asm_insn", "(", "\"subd\\t%1, %0\"", ",", "lo_op", ")", ";", "output_asm_insn", "(", "\"subcw\\t%1, %0\"", ",", "hi0_op", ")", ";", "output_asm_insn", "(", "\"subcw\\t%1, %0\"", ",", "hi1_op", ")", ";", "break", ";", "}", "default", ":", "break", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Helper", "function", "for", "md", "file", ".", "This", "function", "is", "used", "to", "emit", "arithmetic", "DI", "instructions", ".", "The", "argument", "``", "num", "''", "decides", "which", "instruction", "to", "be", "printed", "." ]

[ "cr16", "2", "2", "2", "0", "0", "0", "0", "4", "0", "0", "6", "1", "2", "1", "2", "4", "1", "2", "6", "\"addd\\t%1, %0\"", "\"addcw\\t%1, %0\"", "\"addcw\\t%1, %0\"", "\"subd\\t%1, %0\"", "\"subcw\\t%1, %0\"", "\"subcw\\t%1, %0\"", "\"\"" ]

[]

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

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

[ "LEG", "LEG", "LEG::R4", "LEG::R5", "LEG::R6", "LEG::R7", "LEG::R8", "LEG::R9", "0" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "ExpandInlineAsm", "(", "CallInst", "*", "CI", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "hasV6Ops", "(", ")", ")", "return", "false", ";", "InlineAsm", "*", "IA", "=", "cast", "<", "InlineAsm", ">", "(", "CI", "->", "getCalledValue", "(", ")", ")", ";", "std", "::", "string", "AsmStr", "=", "IA", "->", "getAsmString", "(", ")", ";", "SmallVector", "<", "StringRef", ",", "4", ">", "AsmPieces", ";", "SplitString", "(", "AsmStr", ",", "AsmPieces", ",", "\";\\n\"", ")", ";", "switch", "(", "AsmPieces", ".", "size", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "1", ":", "AsmStr", "=", "std", "::", "string", "(", "AsmPieces", "[", "0", "]", ")", ";", "AsmPieces", ".", "clear", "(", ")", ";", "SplitString", "(", "AsmStr", ",", "AsmPieces", ",", "\" \\t,\"", ")", ";", "if", "(", "AsmPieces", ".", "size", "(", ")", "==", "3", "&&", "AsmPieces", "[", "0", "]", "==", "\"rev\"", "&&", "AsmPieces", "[", "1", "]", "==", "\"$0\"", "&&", "AsmPieces", "[", "2", "]", "==", "\"$1\"", "&&", "IA", "->", "getConstraintString", "(", ")", ".", "compare", "(", "0", ",", "4", ",", "\"=l,l\"", ")", "==", "0", ")", "{", "IntegerType", "*", "Ty", "=", "dyn_cast", "<", "IntegerType", ">", "(", "CI", "->", "getType", "(", ")", ")", ";", "if", "(", "Ty", "&&", "Ty", "->", "getBitWidth", "(", ")", "==", "32", ")", "return", "IntrinsicLowering", "::", "LowerToByteSwap", "(", "CI", ")", ";", "}", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "hook", "allows", "the", "target", "to", "expand", "an", "inline", "asm", "call", "to", "be", "explicit", "llvm", "code", "if", "it", "wants", "to", "." ]

[ "ARM", "ARM", "4", "\";\\n\"", "1", "0", "\" \\t,\"", "3", "0", "\"rev\"", "1", "\"$0\"", "2", "\"$1\"", "0", "4", "\"=l,l\"", "0", "32" ]

[]

[ "<s>", "static", "void", "s390_check_type_for_vector_abi", "(", "const_tree", "type", ",", "bool", "arg_p", ",", "bool", "in_struct_p", ")", "{", "static", "hash_set", "<", "const_tree", ">", "visited_types_hash", ";", "if", "(", "s390_vector_abi", ")", "return", ";", "if", "(", "type", "==", "NULL_TREE", "||", "TREE_CODE", "(", "type", ")", "==", "ERROR_MARK", ")", "return", ";", "if", "(", "visited_types_hash", ".", "contains", "(", "type", ")", ")", "return", ";", "visited_types_hash", ".", "add", "(", "type", ")", ";", "if", "(", "VECTOR_TYPE_P", "(", "type", ")", ")", "{", "int", "type_size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "!", "arg_p", "&&", "type_size", "<", "16", ")", "return", ";", "if", "(", "arg_p", "&&", "type_size", ">", "16", "&&", "!", "in_struct_p", ")", "return", ";", "s390_vector_abi", "=", "TARGET_VX_ABI", "?", "2", ":", "1", ";", "}", "else", "if", "(", "POINTER_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "{", "s390_check_type_for_vector_abi", "(", "TREE_TYPE", "(", "type", ")", ",", "arg_p", ",", "in_struct_p", ")", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "METHOD_TYPE", ")", "{", "tree", "arg_chain", ";", "s390_check_type_for_vector_abi", "(", "TREE_TYPE", "(", "type", ")", ",", "true", ",", "false", ")", ";", "for", "(", "arg_chain", "=", "TYPE_ARG_TYPES", "(", "type", ")", ";", "arg_chain", ";", "arg_chain", "=", "TREE_CHAIN", "(", "arg_chain", ")", ")", "s390_check_type_for_vector_abi", "(", "TREE_VALUE", "(", "arg_chain", ")", ",", "true", ",", "false", ")", ";", "}", "else", "if", "(", "RECORD_OR_UNION_TYPE_P", "(", "type", ")", ")", "{", "tree", "field", ";", "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "continue", ";", "s390_check_type_for_vector_abi", "(", "TREE_TYPE", "(", "field", ")", ",", "arg_p", ",", "true", ")", ";", "}", "}", "}", "</s>" ]

[ "Set", "the", "vector", "ABI", "marker", "if", "TYPE", "is", "subject", "to", "the", "vector", "ABI", "switch", ".", "The", "vector", "ABI", "affects", "only", "vector", "data", "types", ".", "There", "are", "two", "aspects", "of", "the", "vector", "ABI", "relevant", "here", ":", "1.", "vectors", ">", "=", "16", "bytes", "have", "an", "alignment", "of", "8", "bytes", "with", "the", "new", "ABI", "and", "natural", "alignment", "with", "the", "old", ".", "2.", "vector", "<", "=", "16", "bytes", "are", "passed", "in", "VRs", "or", "by", "value", "on", "the", "stack", "with", "the", "new", "ABI", "but", "by", "reference", "on", "the", "stack", "with", "the", "old", ".", "If", "ARG_P", "is", "true", "TYPE", "is", "used", "for", "a", "function", "argument", "or", "return", "value", ".", "The", "ABI", "marker", "then", "is", "set", "for", "all", "vector", "data", "types", ".", "If", "ARG_P", "is", "false", "only", "type", "1", "vectors", "are", "being", "checked", "." ]

[ "s390", "16", "16", "2", "1" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "TM", "||", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", ".", "isPromoteAllocaEnabled", "(", ")", ")", "return", "false", ";", "FunctionType", "*", "FTy", "=", "F", ".", "getFunctionType", "(", ")", ";", "for", "(", "Type", "*", "ParamTy", ":", "FTy", "->", "params", "(", ")", ")", "{", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "ParamTy", ")", ";", "if", "(", "PtrTy", "&&", "PtrTy", "->", "getAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "{", "LocalMemLimit", "=", "0", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", ")", ";", "return", "false", ";", "}", "}", "LocalMemLimit", "=", "ST", ".", "getLocalMemorySize", "(", ")", ";", "if", "(", "LocalMemLimit", "==", "0", ")", "return", "false", ";", "const", "DataLayout", "&", "DL", "=", "Mod", "->", "getDataLayout", "(", ")", ";", "CurrentLocalMemUsage", "=", "0", ";", "for", "(", "GlobalVariable", "&", "GV", ":", "Mod", "->", "globals", "(", ")", ")", "{", "if", "(", "GV", ".", "getType", "(", ")", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "continue", ";", "for", "(", "const", "User", "*", "U", ":", "GV", ".", "users", "(", ")", ")", "{", "const", "Instruction", "*", "Use", "=", "dyn_cast", "<", "Instruction", ">", "(", "U", ")", ";", "if", "(", "!", "Use", ")", "continue", ";", "if", "(", "Use", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "==", "&", "F", ")", "{", "unsigned", "Align", "=", "GV", ".", "getAlignment", "(", ")", ";", "if", "(", "Align", "==", "0", ")", "Align", "=", "DL", ".", "getABITypeAlignment", "(", "GV", ".", "getValueType", "(", ")", ")", ";", "uint64_t", "AllocSize", "=", "DL", ".", "getTypeAllocSize", "(", "GV", ".", "getValueType", "(", ")", ")", ";", "CurrentLocalMemUsage", "=", "alignTo", "(", "CurrentLocalMemUsage", ",", "Align", ")", ";", "CurrentLocalMemUsage", "+=", "AllocSize", ";", "break", ";", "}", "}", "}", "unsigned", "MaxOccupancy", "=", "ST", ".", "getOccupancyWithLocalMemSize", "(", "CurrentLocalMemUsage", ",", "F", ")", ";", "unsigned", "OccupancyHint", "=", "ST", ".", "getWavesPerEU", "(", "F", ")", ".", "second", ";", "if", "(", "OccupancyHint", "==", "0", ")", "OccupancyHint", "=", "7", ";", "OccupancyHint", "=", "std", "::", "min", "(", "OccupancyHint", ",", "ST", ".", "getMaxWavesPerEU", "(", ")", ")", ";", "MaxOccupancy", "=", "std", "::", "min", "(", "OccupancyHint", ",", "MaxOccupancy", ")", ";", "unsigned", "MaxSizeWithWaveCount", "=", "ST", ".", "getMaxLocalMemSizeWithWaveCount", "(", "MaxOccupancy", ",", "F", ")", ";", "if", "(", "CurrentLocalMemUsage", ">", "MaxSizeWithWaveCount", ")", "return", "false", ";", "LocalMemLimit", "=", "MaxSizeWithWaveCount", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "F", ".", "getName", "(", ")", "<<", "\" uses \"", "<<", "CurrentLocalMemUsage", "<<", "\" bytes of LDS\\n\"", "<<", "\" Rounding size to \"", "<<", "MaxSizeWithWaveCount", "<<", "\" with a maximum occupancy of \"", "<<", "MaxOccupancy", "<<", "'\\n'", "<<", "\" and \"", "<<", "(", "LocalMemLimit", "-", "CurrentLocalMemUsage", ")", "<<", "\" available for promotion\\n\"", ")", ";", "BasicBlock", "&", "EntryBB", "=", "*", "F", ".", "begin", "(", ")", ";", "for", "(", "auto", "I", "=", "EntryBB", ".", "begin", "(", ")", ",", "E", "=", "EntryBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "I", ")", ";", "++", "I", ";", "if", "(", "AI", ")", "handleAlloca", "(", "*", "AI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "0", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", "0", "0", "AMDGPU", "0", "0", "7", "\" uses \"", "\" bytes of LDS\\n\"", "\" Rounding size to \"", "\" with a maximum occupancy of \"", "\" and \"", "\" available for promotion\\n\"" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "DestBB", ",", "MachineBasicBlock", "&", "RestoreBB", ",", "const", "DebugLoc", "&", "DL", ",", "int64_t", "BrOffset", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "RS", "&&", "\"RegScavenger required for long branching\"", ")", ";", "assert", "(", "MBB", ".", "empty", "(", ")", "&&", "\"new block should be inserted for expanding unconditional branch\"", ")", ";", "assert", "(", "MBB", ".", "pred_size", "(", ")", "==", "1", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "if", "(", "!", "isInt", "<", "32", ">", "(", "BrOffset", ")", ")", "report_fatal_error", "(", "\"Branch offsets outside of the signed 32-bit range not supported\"", ")", ";", "Register", "ScratchReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "RISCV", "::", "GPRRegClass", ")", ";", "auto", "II", "=", "MBB", ".", "end", "(", ")", ";", "MachineInstr", "&", "MI", "=", "*", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "RISCV", "::", "PseudoJump", ")", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ".", "addMBB", "(", "&", "DestBB", ",", "RISCVII", "::", "MO_CALL", ")", ";", "RS", "->", "enterBasicBlockEnd", "(", "MBB", ")", ";", "Register", "Scav", "=", "RS", "->", "scavengeRegisterBackwards", "(", "RISCV", "::", "GPRRegClass", ",", "MI", ".", "getIterator", "(", ")", ",", "false", ",", "0", ")", ";", "assert", "(", "Scav", "!=", "RISCV", "::", "NoRegister", "&&", "\"No register is scavenged!\"", ")", ";", "MRI", ".", "replaceRegWith", "(", "ScratchReg", ",", "Scav", ")", ";", "MRI", ".", "clearVirtRegs", "(", ")", ";", "RS", "->", "setRegUsed", "(", "Scav", ")", ";", "}", "</s>" ]

[ "Insert", "an", "unconditional", "indirect", "branch", "at", "the", "end", "of", "MBB", "to", "NewDestBB", "." ]

[ "RISCV", "RISCV", "\"RegScavenger required for long branching\"", "\"new block should be inserted for expanding unconditional branch\"", "1", "32", "\"Branch offsets outside of the signed 32-bit range not supported\"", "RISCV::GPRRegClass", "RISCV::PseudoJump", "RISCVII::MO_CALL", "RISCV::GPRRegClass", "0", "RISCV::NoRegister", "\"No register is scavenged!\"" ]

[]

[ "<s>", "unsigned", "X86RegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "X86FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "unsigned", "FPDiff", "=", "TFI", "->", "hasFP", "(", "MF", ")", "?", "1", ":", "0", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "X86", "::", "GR32RegClassID", ":", "return", "4", "-", "FPDiff", ";", "case", "X86", "::", "GR64RegClassID", ":", "return", "12", "-", "FPDiff", ";", "case", "X86", "::", "VR128RegClassID", ":", "return", "Is64Bit", "?", "10", ":", "4", ";", "case", "X86", "::", "VR64RegClassID", ":", "return", "4", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "X86", "X86", "X86", "1", "0", "0", "X86::GR32RegClassID", "4", "X86::GR64RegClassID", "12", "X86::VR128RegClassID", "10", "4", "X86::VR64RegClassID", "4" ]

[]

[ "<s>", "static", "void", "csky_setup_incoming_varargs", "(", "cumulative_args_t", "pcum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "CUMULATIVE_ARGS", "local_cum", ";", "cumulative_args_t", "local_cum_v", "=", "pack_cumulative_args", "(", "&", "local_cum", ")", ";", "int", "regs_to_push", ";", "cfun", "->", "machine", "->", "uses_anonymous_args", "=", "1", ";", "local_cum", "=", "*", "pcum", ";", "csky_function_arg_advance", "(", "local_cum_v", ",", "mode", ",", "type", ",", "true", ")", ";", "regs_to_push", "=", "CSKY_NPARM_REGS", "-", "local_cum", ";", "if", "(", "regs_to_push", ")", "*", "pretend_size", "=", "regs_to_push", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "TARGET_SETUP_INCOMING_VARARGS", ".", "On", "C-Sky", "the", "copy", "from", "the", "argument", "registers", "to", "the", "stack", "is", "emitted", "by", "the", "prologue", "hooks", ",", "so", "here", "we", "just", "have", "to", "note", "how", "much", "stack", "space", "to", "save", "." ]

[ "csky", "1" ]

[]

[ "<s>", "void", "VEInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "VE", "::", "I64RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "STrii", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "VE", "::", "I32RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "STLrii", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "VE", "::", "F32RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "STUrii", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "report_fatal_error", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE::I64RegClass", "VE::STrii", "0", "0", "VE::I32RegClass", "VE::STLrii", "0", "0", "VE::F32RegClass", "VE::STUrii", "0", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "static", "void", "alpha_emit_xfloating_libcall", "(", "rtx", "func", ",", "rtx", "target", ",", "rtx", "operands", "[", "]", ",", "int", "noperands", ",", "rtx", "equiv", ")", "{", "rtx", "usage", "=", "NULL_RTX", ",", "reg", ";", "int", "regno", "=", "16", ",", "i", ";", "start_sequence", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "noperands", ";", "++", "i", ")", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "i", "]", ")", ")", "{", "case", "E_TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "regno", ")", ";", "regno", "+=", "2", ";", "break", ";", "case", "E_DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", "+", "32", ")", ";", "regno", "+=", "1", ";", "break", ";", "case", "E_VOIDmode", ":", "gcc_assert", "(", "CONST_INT_P", "(", "operands", "[", "i", "]", ")", ")", ";", "case", "E_DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "regno", "+=", "1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_move_insn", "(", "reg", ",", "operands", "[", "i", "]", ")", ";", "use_reg", "(", "&", "usage", ",", "reg", ")", ";", "}", "switch", "(", "GET_MODE", "(", "target", ")", ")", "{", "case", "E_TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "16", ")", ";", "break", ";", "case", "E_DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "32", ")", ";", "break", ";", "case", "E_DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "rtx", "mem", "=", "gen_rtx_MEM", "(", "QImode", ",", "func", ")", ";", "rtx_insn", "*", "tmp", "=", "emit_call_insn", "(", "gen_call_value", "(", "reg", ",", "mem", ",", "const0_rtx", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "CALL_INSN_FUNCTION_USAGE", "(", "tmp", ")", "=", "usage", ";", "RTL_CONST_CALL_P", "(", "tmp", ")", "=", "1", ";", "tmp", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_libcall_block", "(", "tmp", ",", "target", ",", "reg", ",", "equiv", ")", ";", "}", "</s>" ]

[ "Emit", "an", "X_floating", "library", "function", "call", ".", "Note", "that", "these", "functions", "do", "not", "follow", "normal", "calling", "conventions", ":", "TFmode", "arguments", "are", "passed", "in", "two", "integer", "registers", "(", "as", "opposed", "to", "indirect", ")", ";", "TFmode", "return", "values", "appear", "in", "R16+R17", ".", "FUNC", "is", "the", "function", "name", "to", "call", ".", "TARGET", "is", "where", "the", "output", "belongs", ".", "OPERANDS", "are", "the", "inputs", ".", "NOPERANDS", "is", "the", "count", "of", "inputs", ".", "EQUIV", "is", "the", "expression", "equivalent", "for", "the", "function", "." ]

[ "alpha", "16", "0", "2", "32", "1", "1", "16", "32", "0", "1" ]

[]

[ "<s>", "void", "ARMTargetELFStreamer", "::", "emitInst", "(", "uint32_t", "Inst", ",", "char", "Suffix", ")", "{", "getStreamer", "(", ")", ".", "emitInst", "(", "Inst", ",", "Suffix", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "AnalyzeArguments", "(", "CCState", "&", "State", ",", "SmallVectorImpl", "<", "CCValAssign", ">", "&", "ArgLocs", ",", "const", "SmallVectorImpl", "<", "ArgT", ">", "&", "Args", ")", "{", "static", "const", "MCPhysReg", "RegList", "[", "]", "=", "{", "MSP430", "::", "R15", ",", "MSP430", "::", "R14", ",", "MSP430", "::", "R13", ",", "MSP430", "::", "R12", "}", ";", "static", "const", "unsigned", "NbRegs", "=", "array_lengthof", "(", "RegList", ")", ";", "if", "(", "State", ".", "isVarArg", "(", ")", ")", "{", "AnalyzeVarArgs", "(", "State", ",", "Args", ")", ";", "return", ";", "}", "SmallVector", "<", "unsigned", ",", "4", ">", "ArgsParts", ";", "ParseFunctionArgs", "(", "Args", ",", "ArgsParts", ")", ";", "unsigned", "RegsLeft", "=", "NbRegs", ";", "bool", "UseStack", "=", "false", ";", "unsigned", "ValNo", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgsParts", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "MVT", "ArgVT", "=", "Args", "[", "ValNo", "]", ".", "VT", ";", "ISD", "::", "ArgFlagsTy", "ArgFlags", "=", "Args", "[", "ValNo", "]", ".", "Flags", ";", "MVT", "LocVT", "=", "ArgVT", ";", "CCValAssign", "::", "LocInfo", "LocInfo", "=", "CCValAssign", "::", "Full", ";", "if", "(", "LocVT", "==", "MVT", "::", "i8", ")", "{", "LocVT", "=", "MVT", "::", "i16", ";", "if", "(", "ArgFlags", ".", "isSExt", "(", ")", ")", "LocInfo", "=", "CCValAssign", "::", "SExt", ";", "else", "if", "(", "ArgFlags", ".", "isZExt", "(", ")", ")", "LocInfo", "=", "CCValAssign", "::", "ZExt", ";", "else", "LocInfo", "=", "CCValAssign", "::", "AExt", ";", "}", "if", "(", "ArgFlags", ".", "isByVal", "(", ")", ")", "{", "State", ".", "HandleByVal", "(", "ValNo", "++", ",", "ArgVT", ",", "LocVT", ",", "LocInfo", ",", "2", ",", "2", ",", "ArgFlags", ")", ";", "continue", ";", "}", "unsigned", "Parts", "=", "ArgsParts", "[", "i", "]", ";", "if", "(", "!", "UseStack", "&&", "Parts", "<=", "RegsLeft", ")", "{", "unsigned", "FirstVal", "=", "ValNo", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "Parts", ";", "j", "++", ")", "{", "unsigned", "Reg", "=", "State", ".", "AllocateReg", "(", "RegList", ")", ";", "State", ".", "addLoc", "(", "CCValAssign", "::", "getReg", "(", "ValNo", "++", ",", "ArgVT", ",", "Reg", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "RegsLeft", "--", ";", "}", "SmallVectorImpl", "<", "CCValAssign", ">", "::", "iterator", "B", "=", "ArgLocs", ".", "begin", "(", ")", "+", "FirstVal", ";", "std", "::", "reverse", "(", "B", ",", "B", "+", "Parts", ")", ";", "}", "else", "{", "UseStack", "=", "true", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "Parts", ";", "j", "++", ")", "CC_MSP430_AssignStack", "(", "ValNo", "++", ",", "ArgVT", ",", "LocVT", ",", "LocInfo", ",", "ArgFlags", ",", "State", ")", ";", "}", "}", "}", "</s>" ]

[ "The", "function", "will", "invoke", "AnalyzeCallOperands", "." ]

[ "MSP430", "MSP430::R15", "MSP430::R14", "MSP430::R13", "MSP430::R12", "4", "0", "0", "ISD::ArgFlagsTy", "MVT::i8", "MVT::i16", "2", "2", "0", "0", "MSP430" ]

[]

[ "<s>", "void", "PPCTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "char", "Letter", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Result", "(", "0", ",", "0", ")", ";", "switch", "(", "Letter", ")", "{", "default", ":", "break", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'O'", ":", "case", "'P'", ":", "{", "ConstantSDNode", "*", "CST", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ";", "if", "(", "!", "CST", ")", "return", ";", "unsigned", "Value", "=", "CST", "->", "getZExtValue", "(", ")", ";", "switch", "(", "Letter", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown constraint letter!\"", ")", ";", "case", "'I'", ":", "if", "(", "(", "short", ")", "Value", "==", "(", "int", ")", "Value", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "case", "'J'", ":", "case", "'L'", ":", "if", "(", "(", "short", ")", "Value", "==", "0", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "case", "'K'", ":", "if", "(", "(", "Value", ">>", "16", ")", "==", "0", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "case", "'M'", ":", "if", "(", "Value", ">", "31", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "case", "'N'", ":", "if", "(", "(", "int", ")", "Value", ">", "0", "&&", "isPowerOf2_32", "(", "Value", ")", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "case", "'O'", ":", "if", "(", "Value", "==", "0", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "case", "'P'", ":", "if", "(", "(", "short", ")", "-", "Value", "==", "(", "int", ")", "-", "Value", ")", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Value", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "break", ";", "}", "}", "if", "(", "Result", ".", "getNode", "(", ")", ")", "{", "Ops", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Letter", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "0", "\"Unknown constraint letter!\"", "0", "16", "0", "31", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "som_text_section_asm_op", "(", "void", ")", "{", "if", "(", "!", "TARGET_SOM", ")", "return", "\"\"", ";", "if", "(", "TARGET_GAS", ")", "{", "if", "(", "cfun", "&&", "!", "cfun", "->", "machine", "->", "in_nsubspa", ")", "{", "cfun", "->", "machine", "->", "in_nsubspa", "=", "1", ";", "if", "(", "cfun", "->", "decl", "&&", "DECL_ONE_ONLY", "(", "cfun", "->", "decl", ")", "&&", "!", "DECL_WEAK", "(", "cfun", "->", "decl", ")", ")", "return", "\"\\t.SPACE $TEXT$\\n\\t.NSUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,SORT=24,COMDAT\"", ";", "}", "else", "{", "forget_section", "(", ")", ";", "}", "return", "\"\\t.SPACE $TEXT$\\n\\t.NSUBSPA $CODE$\"", ";", "}", "return", "\"\\t.SPACE $TEXT$\\n\\t.SUBSPA $CODE$\"", ";", "}", "</s>" ]

[ "Return", "a", "string", "to", "output", "before", "text", "in", "the", "current", "function", ".", "This", "function", "is", "only", "used", "with", "SOM", ".", "Because", "we", "do", "n't", "support", "named", "subspaces", ",", "we", "can", "only", "create", "a", "new", "subspace", "or", "switch", "back", "to", "the", "default", "text", "subspace", "." ]

[ "pa", "\"\"", "1", "\"\\t.SPACE $TEXT$\\n\\t.NSUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,SORT=24,COMDAT\"", "\"\\t.SPACE $TEXT$\\n\\t.NSUBSPA $CODE$\"", "\"\\t.SPACE $TEXT$\\n\\t.SUBSPA $CODE$\"" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "const", "MachineMemOperand", "*", "Dummy", ";", "return", "MI", "->", "mayLoad", "(", ")", "&&", "hasLoadFromStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "}", "</s>" ]

[ "isLoadFromStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "mmix_asm_output_source_filename", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ")", "{", "fprintf", "(", "stream", ",", "\"# 1 \"", ")", ";", "OUTPUT_QUOTED_STRING", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "</s>" ]

[ "ASM_OUTPUT_SOURCE_FILENAME", "." ]

[ "mmix", "\"# 1 \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "areJTsAllowed", "(", "const", "Function", "*", "Fn", ")", "const", "{", "if", "(", "Subtarget", ".", "useIndirectThunkBranches", "(", ")", ")", "return", "false", ";", "return", "TargetLowering", "::", "areJTsAllowed", "(", "Fn", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "lowering", "to", "a", "jump", "table", "is", "allowed", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "llvm", "::", "getAlign", "(", "const", "CallInst", "&", "I", ",", "unsigned", "index", ",", "unsigned", "&", "align", ")", "{", "if", "(", "MDNode", "*", "alignNode", "=", "I", ".", "getMetadata", "(", "\"callalign\"", ")", ")", "{", "for", "(", "int", "i", "=", "0", ",", "n", "=", "alignNode", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "i", "++", ")", "{", "if", "(", "const", "ConstantInt", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "alignNode", "->", "getOperand", "(", "i", ")", ")", ")", "{", "unsigned", "v", "=", "CI", "->", "getZExtValue", "(", ")", ";", "if", "(", "(", "v", ">>", "16", ")", "==", "index", ")", "{", "align", "=", "v", "&", "0xFFFF", ";", "return", "true", ";", "}", "if", "(", "(", "v", ">>", "16", ")", ">", "index", ")", "{", "return", "false", ";", "}", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "the", "minimum", "known", "alignment", "in", "bytes", "of", "the", "actual", "memory", "reference", "." ]

[ "NVPTX", "\"callalign\"", "0", "16", "0xFFFF", "16" ]

[]

[ "<s>", "void", "R600TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "Results", ".", "push_back", "(", "LowerFPTOUINT", "(", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ")", ")", ";", "return", ";", "case", "ISD", "::", "LOAD", ":", "{", "SDNode", "*", "Node", "=", "LowerLOAD", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ".", "getNode", "(", ")", ";", "Results", ".", "push_back", "(", "SDValue", "(", "Node", ",", "0", ")", ")", ";", "Results", ".", "push_back", "(", "SDValue", "(", "Node", ",", "1", ")", ")", ";", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "1", ")", ",", "SDValue", "(", "Node", ",", "1", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "STORE", ":", "SDNode", "*", "Node", "=", "LowerSTORE", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ".", "getNode", "(", ")", ";", "Results", ".", "push_back", "(", "SDValue", "(", "Node", ",", "0", ")", ")", ";", "return", ";", "}", "}", "</s>" ]

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

[ "R600", "ISD::FP_TO_UINT", "0", "ISD::LOAD", "0", "0", "1", "1", "1", "ISD::STORE", "0", "0" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AS", ")", "{", "case", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ":", "{", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "return", "isLegalFlatAddressingMode", "(", "AM", ")", ";", "}", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "}", "case", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ":", "{", "if", "(", "AM", ".", "BaseOffs", "%", "4", "!=", "0", ")", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "if", "(", "DL", ".", "getTypeStoreSize", "(", "Ty", ")", "<", "4", ")", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "8", ">", "(", "AM", ".", "BaseOffs", "/", "4", ")", ")", "return", "false", ";", "}", "else", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "SEA_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "32", ">", "(", "AM", ".", "BaseOffs", "/", "4", ")", ")", "return", "false", ";", "}", "else", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "20", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "}", "else", "llvm_unreachable", "(", "\"unhandled generation\"", ")", ";", "if", "(", "AM", ".", "Scale", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "case", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ":", "case", "AMDGPUAS", "::", "UNKNOWN_ADDRESS_SPACE", ":", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "case", "AMDGPUAS", "::", "LOCAL_ADDRESS", ":", "case", "AMDGPUAS", "::", "REGION_ADDRESS", ":", "{", "if", "(", "!", "isUInt", "<", "16", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "Scale", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "case", "AMDGPUAS", "::", "FLAT_ADDRESS", ":", "return", "isLegalFlatAddressingMode", "(", "AM", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unhandled address space\"", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "AMDGPU", "4", "0", "4", "AMDGPU", "8", "4", "AMDGPU", "32", "4", "AMDGPU", "20", "\"unhandled generation\"", "0", "1", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "16", "0", "1", "AMDGPU", "\"unhandled address space\"" ]

[]

[ "<s>", "inline", "units_index", "function_instance", "::", "displacement_units", "(", ")", "const", "{", "return", "mode_suffix", "(", ")", ".", "displacement_units", ";", "}", "</s>" ]

[ "If", "the", "function", "takes", "a", "vector", "or", "scalar", "displacement", ",", "return", "the", "units", "in", "which", "the", "displacement", "is", "measured", ",", "otherwise", "return", "UNITS_none", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "int", "need_to_save_reg", "(", "int", "regno", ",", "int", "saving", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "return", "1", ";", "if", "(", "flag_pic", "&&", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "&&", "(", "!", "saving", "||", "cfun", "->", "machine", "->", "pic_reg", "==", "pic_offset_table_rtx", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "whether", "REGNO", "needs", "to", "be", "saved", "in", "the", "stack", "frame", "." ]

[ "spu", "1", "1", "0" ]

[]

[ "<s>", "inline", "const", "MatchEntry", "*", "end", "(", "const", "MatchEntry", "array", "[", "]", ")", "{", "return", "array", ";", "}", "</s>" ]

[ "Get", "a", "const_iterator", "to", "the", "end", "of", "the", "symbol", "table", "." ]

[ "Z80" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isSafeToMoveRegClassDefs", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "return", "!", "(", "RC", "==", "&", "X86", "::", "CCRRegClass", "||", "RC", "==", "&", "X86", "::", "RFP32RegClass", "||", "RC", "==", "&", "X86", "::", "RFP64RegClass", "||", "RC", "==", "&", "X86", "::", "RFP80RegClass", ")", ";", "}", "</s>" ]

[ "isSafeToMoveRegClassDefs", "-", "Return", "true", "if", "it", "'s", "safe", "to", "move", "a", "machine", "instruction", "that", "defines", "the", "specified", "register", "class", "." ]

[ "X86", "X86", "X86::CCRRegClass", "X86::RFP32RegClass", "X86::RFP64RegClass", "X86::RFP80RegClass" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "assert", "(", "Offset", "<", "0", "&&", "\"Local offset must be negative\"", ")", ";", "unsigned", "OpC", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "!", "ImmToIdxMap", ".", "count", "(", "OpC", ")", ")", "return", "false", ";", "if", "(", "(", "OpC", "==", "PPC", "::", "ADDI", "||", "OpC", "==", "PPC", "::", "ADDI8", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "return", "false", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "PPCFrameLowering", "*", "PPCFI", "=", "static_cast", "<", "const", "PPCFrameLowering", "*", ">", "(", "Subtarget", ".", "getFrameLowering", "(", ")", ")", ";", "unsigned", "StackEst", "=", "PPCFI", "->", "determineFrameLayout", "(", "MF", ",", "false", ",", "true", ")", ";", "if", "(", "!", "StackEst", ")", "return", "false", ";", "Offset", "+=", "StackEst", ";", "return", "!", "isFrameOffsetLegal", "(", "MI", ",", "getBaseRegister", "(", "MF", ")", ",", "Offset", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "PowerPC", "PPC", "0", "\"Local offset must be negative\"", "PPC::ADDI", "PPC::ADDI8", "2", "0", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "static", "void", "emit_frame_store_1", "(", "rtx", "value", ",", "rtx", "base_reg", ",", "HOST_WIDE_INT", "frame_bias", ",", "HOST_WIDE_INT", "base_ofs", ",", "rtx", "frame_reg", ")", "{", "rtx", "addr", ",", "mem", ",", "insn", ";", "addr", "=", "plus_constant", "(", "base_reg", ",", "base_ofs", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "DImode", ",", "addr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "alpha_sr_alias_set", ")", ";", "insn", "=", "emit_move_insn", "(", "mem", ",", "value", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "frame_bias", "||", "value", "!=", "frame_reg", ")", "{", "if", "(", "frame_bias", ")", "{", "addr", "=", "plus_constant", "(", "stack_pointer_rtx", ",", "frame_bias", "+", "base_ofs", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "DImode", ",", "addr", ")", ";", "}", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "frame_reg", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "}", "</s>" ]

[ "Generates", "a", "store", "with", "the", "proper", "unwind", "info", "attached", ".", "VALUE", "is", "stored", "at", "BASE_REG+BASE_OFS", ".", "If", "FRAME_BIAS", "is", "nonzero", ",", "then", "BASE_REG", "contains", "SP+FRAME_BIAS", ",", "and", "that", "is", "the", "unwind", "info", "that", "should", "be", "generated", ".", "If", "FRAME_REG", "!", "=", "VALUE", ",", "then", "VALUE", "is", "being", "stored", "on", "behalf", "of", "FRAME_REG", ",", "and", "FRAME_REG", "should", "be", "present", "in", "the", "unwind", "." ]

[ "alpha", "1" ]

[]

[ "<s>", "void", "SystemZAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SystemZMCInstLower", "Lower", "(", "Mang", ",", "MF", "->", "getContext", "(", ")", ",", "*", "this", ")", ";", "MCInst", "LoweredMI", ";", "Lower", ".", "lower", "(", "MI", ",", "LoweredMI", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "LoweredMI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "frv_io_handle_set", "(", "rtx", "x", ",", "const_rtx", "pat", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", ")", "{", "HARD_REG_SET", "*", "set", "=", "(", "HARD_REG_SET", "*", ")", "data", ";", "unsigned", "int", "regno", ";", "if", "(", "REG_P", "(", "x", ")", ")", "FOR_EACH_REGNO", "(", "regno", ",", "x", ")", "CLEAR_HARD_REG_BIT", "(", "*", "set", ",", "regno", ")", ";", "}", "</s>" ]

[ "A", "note_stores", "callback", "for", "which", "DATA", "points", "to", "a", "HARD_REG_SET", ".", "Remove", "every", "modified", "register", "from", "the", "set", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "override", "{", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "OW", "->", "Write32", "(", "0x60000000", ")", ";", "OW", "->", "WriteZeros", "(", "Count", "%", "4", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "4", "0", "0x60000000", "4" ]

[]

[ "<s>", "static", "poly_int64", "ix86_return_pops_args", "(", "tree", "fundecl", ",", "tree", "funtype", ",", "poly_int64", "size", ")", "{", "unsigned", "int", "ccvt", ";", "if", "(", "TARGET_64BIT", ")", "return", "0", ";", "ccvt", "=", "ix86_get_callcvt", "(", "funtype", ")", ";", "if", "(", "(", "ccvt", "&", "(", "IX86_CALLCVT_STDCALL", "|", "IX86_CALLCVT_FASTCALL", "|", "IX86_CALLCVT_THISCALL", ")", ")", "!=", "0", "&&", "!", "stdarg_p", "(", "funtype", ")", ")", "return", "size", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "funtype", ")", ",", "fundecl", ")", "&&", "!", "ix86_keep_aggregate_return_pointer", "(", "funtype", ")", ")", "{", "int", "nregs", "=", "ix86_function_regparm", "(", "funtype", ",", "fundecl", ")", ";", "if", "(", "nregs", "==", "0", ")", "return", "GET_MODE_SIZE", "(", "Pmode", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Value", "is", "the", "number", "of", "bytes", "of", "arguments", "automatically", "popped", "when", "returning", "from", "a", "subroutine", "call", ".", "FUNDECL", "is", "the", "declaration", "node", "of", "the", "function", "(", "as", "a", "tree", ")", ",", "FUNTYPE", "is", "the", "data", "type", "of", "the", "function", "(", "as", "a", "tree", ")", ",", "or", "for", "a", "library", "call", "it", "is", "an", "identifier", "node", "for", "the", "subroutine", "name", ".", "SIZE", "is", "the", "number", "of", "bytes", "of", "arguments", "passed", "on", "the", "stack", ".", "On", "the", "80386", ",", "the", "RTD", "insn", "may", "be", "used", "to", "pop", "them", "if", "the", "number", "of", "args", "is", "fixed", ",", "but", "if", "the", "number", "is", "variable", "then", "the", "caller", "must", "pop", "them", "all", ".", "RTD", "ca", "n't", "be", "used", "for", "library", "calls", "now", "because", "the", "library", "is", "compiled", "with", "the", "Unix", "compiler", ".", "Use", "of", "RTD", "is", "a", "selectable", "option", ",", "since", "it", "is", "incompatible", "with", "standard", "Unix", "calling", "sequences", ".", "If", "the", "option", "is", "not", "selected", ",", "the", "caller", "must", "always", "pop", "the", "args", ".", "The", "attribute", "stdcall", "is", "equivalent", "to", "RTD", "on", "a", "per", "module", "basis", "." ]

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

[]

[ "<s>", "unsigned", "ARMBaseRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "ARM", "::", "tGPRRegClassID", ":", "{", "bool", "HasFP", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "isMaxCallFrameSizeComputed", "(", ")", "?", "TFI", "->", "hasFP", "(", "MF", ")", ":", "true", ";", "return", "5", "-", "HasFP", ";", "}", "case", "ARM", "::", "GPRRegClassID", ":", "{", "bool", "HasFP", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "isMaxCallFrameSizeComputed", "(", ")", "?", "TFI", "->", "hasFP", "(", "MF", ")", ":", "true", ";", "return", "10", "-", "HasFP", "-", "(", "STI", ".", "isR9Reserved", "(", ")", "?", "1", ":", "0", ")", ";", "}", "case", "ARM", "::", "SPRRegClassID", ":", "case", "ARM", "::", "DPRRegClassID", ":", "return", "32", "-", "10", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "0", "ARM::tGPRRegClassID", "5", "ARM::GPRRegClassID", "10", "1", "0", "ARM::SPRRegClassID", "ARM::DPRRegClassID", "32", "10" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "Result", "=", "Match_Success", ";", "for", "(", "auto", "Variant", ":", "getMatchedVariants", "(", ")", ")", "{", "uint64_t", "EI", ";", "auto", "R", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "EI", ",", "MatchingInlineAsm", ",", "Variant", ")", ";", "if", "(", "(", "R", "==", "Match_Success", ")", "||", "(", "R", "==", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_InvalidOperand", "&&", "Result", "!=", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_MnemonicFail", "&&", "Result", "!=", "Match_InvalidOperand", "&&", "Result", "!=", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", ")", "{", "Result", "=", "R", ";", "ErrorInfo", "=", "EI", ";", "}", "if", "(", "R", "==", "Match_Success", ")", "break", ";", "}", "if", "(", "Result", "==", "Match_Success", ")", "{", "if", "(", "!", "validateInstruction", "(", "Inst", ",", "IDLoc", ",", "Operands", ")", ")", "{", "return", "true", ";", "}", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "}", "StringRef", "Mnemo", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ";", "if", "(", "checkUnsupportedInstruction", "(", "Mnemo", ",", "IDLoc", ")", ")", "{", "return", "true", ";", "}", "switch", "(", "Result", ")", "{", "default", ":", "break", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"operands are not valid for this GPU or mode\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "{", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "}", "ErrorLoc", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_PreferE32", ":", "return", "Error", "(", "IDLoc", ",", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", ")", ";", "case", "Match_MnemonicFail", ":", "llvm_unreachable", "(", "\"Invalid instructions should have been handled already\"", ")", ";", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "0", "\"operands are not valid for this GPU or mode\"", "0ULL", "\"too few operands for instruction\"", "AMDGPU", "\"invalid operand for instruction\"", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", "\"Invalid instructions should have been handled already\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "SavedRegs", ".", "resize", "(", "HRI", ".", "getNumRegs", "(", ")", ")", ";", "if", "(", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ")", "for", "(", "const", "MCPhysReg", "*", "R", "=", "HRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "R", ";", "++", "R", ")", "SavedRegs", ".", "set", "(", "*", "R", ")", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "NewRegs", ";", "expandSpillMacros", "(", "MF", ",", "NewRegs", ")", ";", "if", "(", "OptimizeSpillSlots", ")", "optimizeSpillSlots", "(", "MF", ",", "NewRegs", ")", ";", "if", "(", "!", "NewRegs", ".", "empty", "(", ")", "&&", "needToReserveScavengingSpillSlots", "(", "MF", ",", "HRI", ")", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SetVector", "<", "const", "TargetRegisterClass", "*", ">", "SpillRCs", ";", "for", "(", "unsigned", "VR", ":", "NewRegs", ")", "SpillRCs", ".", "insert", "(", "MRI", ".", "getRegClass", "(", "VR", ")", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterClass", "&", "IntRC", "=", "Hexagon", "::", "IntRegsRegClass", ";", "if", "(", "SpillRCs", ".", "count", "(", "&", "IntRC", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "NumberScavengerSlots", ";", "i", "++", ")", "{", "int", "NewFI", "=", "MFI", ".", "CreateSpillStackObject", "(", "IntRC", ".", "getSize", "(", ")", ",", "IntRC", ".", "getAlignment", "(", ")", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "NewFI", ")", ";", "}", "}", "for", "(", "auto", "*", "RC", ":", "SpillRCs", ")", "{", "if", "(", "RC", "==", "&", "IntRC", ")", "continue", ";", "int", "NewFI", "=", "MFI", ".", "CreateSpillStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "RC", "->", "getAlignment", "(", ")", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "NewFI", ")", ";", "}", "}", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "8", "Hexagon::IntRegsRegClass", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_print_ldpstp_address", "(", "FILE", "*", "f", ",", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "return", "aarch64_print_address_internal", "(", "f", ",", "mode", ",", "x", ",", "ADDR_QUERY_LDP_STP", ")", ";", "}", "</s>" ]

[ "Print", "address", "'", "x", "'", "of", "a", "LDP/STP", "with", "mode", "'mode", "'", "." ]

[ "aarch64" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SITargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "*", "MI", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "case", "AMDGPU", "::", "BRANCH", ":", "return", "BB", ";", "case", "AMDGPU", "::", "SI_RegisterStorePseudo", ":", "{", "MachineRegisterInfo", "&", "MRI", "=", "BB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "BB", ",", "I", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "SI_RegisterStore", ")", ",", "Reg", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MIB", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "i", ")", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "}", "return", "BB", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU", "AMDGPU::BRANCH", "AMDGPU::SI_RegisterStorePseudo", "AMDGPU::SReg_64RegClass", "AMDGPU::SI_RegisterStore", "0" ]

[]

[ "<s>", "static", "bool", "r10k_needs_protection_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", "r10k_needs_protection_p_call", "(", "PATTERN", "(", "insn", ")", ")", ";", "if", "(", "mips_r10k_cache_barrier", "==", "R10K_CACHE_BARRIER_STORE", ")", "{", "note_stores", "(", "insn", ",", "r10k_needs_protection_p_store", ",", "&", "insn", ")", ";", "return", "insn", "==", "NULL_RTX", ";", "}", "return", "r10k_needs_protection_p_1", "(", "PATTERN", "(", "insn", ")", ",", "insn", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "instruction", "INSN", "needs", "to", "be", "protected", "by", "an", "R10K", "cache", "barrier", "." ]

[ "mips" ]

[]

[ "<s>", "static", "int", "h8300_stack_offset_p", "(", "rtx", "x", ",", "int", "offset", ")", "{", "if", "(", "offset", "==", "0", ")", "return", "x", "==", "stack_pointer_rtx", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "XEXP", "(", "x", ",", "0", ")", "==", "stack_pointer_rtx", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "offset", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "has", "the", "value", "sp", "+", "OFFSET", "." ]

[ "h8300", "0", "0", "1", "1" ]

[]

[ "<s>", "bool", "ARM64ExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "ARM64InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "expandMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ARM64" ]

[]

[ "<s>", "ARCSubtarget", "::", "ARCSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "ARCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "InstrInfo", "(", "*", "this", ")", ",", "FrameLowering", "(", "*", "this", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

[ "ARC", "ARC", "ARC", "ARC" ]

[]

[ "<s>", "static", "rtx", "frv_expand_binop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "target", "=", "frv_legitimize_target", "(", "icode", ",", "target", ")", ";", "op0", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op0", ")", ";", "op1", "=", "frv_legitimize_argument", "(", "icode", ",", "2", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "take", "two", "operands", "." ]

[ "frv", "1", "2" ]

[]

[ "<s>", "SDValue", "PTXTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isVarArg", ")", "llvm_unreachable", "(", "\"PTX does not support varargs\"", ")", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention.\"", ")", ";", "case", "CallingConv", "::", "PTX_Kernel", ":", "assert", "(", "Outs", ".", "size", "(", ")", "==", "0", "&&", "\"Kernel must return void.\"", ")", ";", "return", "DAG", ".", "getNode", "(", "PTXISD", "::", "EXIT", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "case", "CallingConv", "::", "PTX_Device", ":", "assert", "(", "Outs", ".", "size", "(", ")", "<=", "1", "&&", "\"Can at most return one value.\"", ")", ";", "break", ";", "}", "if", "(", "Outs", ".", "size", "(", ")", "==", "0", ")", "return", "DAG", ".", "getNode", "(", "PTXISD", "::", "RET", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "SDValue", "Flag", ";", "unsigned", "reg", ";", "if", "(", "Outs", "[", "0", "]", ".", "VT", "==", "MVT", "::", "i16", ")", "{", "reg", "=", "PTX", "::", "RH0", ";", "}", "else", "if", "(", "Outs", "[", "0", "]", ".", "VT", "==", "MVT", "::", "i32", ")", "{", "reg", "=", "PTX", "::", "R0", ";", "}", "else", "if", "(", "Outs", "[", "0", "]", ".", "VT", "==", "MVT", "::", "i64", ")", "{", "reg", "=", "PTX", "::", "RD0", ";", "}", "else", "if", "(", "Outs", "[", "0", "]", ".", "VT", "==", "MVT", "::", "f32", ")", "{", "reg", "=", "PTX", "::", "F0", ";", "}", "else", "{", "assert", "(", "Outs", "[", "0", "]", ".", "VT", "==", "MVT", "::", "f64", "&&", "\"Can return only basic types\"", ")", ";", "reg", "=", "PTX", "::", "FD0", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "PTXMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "PTXMachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setRetReg", "(", "reg", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "reg", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "reg", ",", "OutVals", "[", "0", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "return", "DAG", ".", "getNode", "(", "PTXISD", "::", "RET", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "ISD::OutputArg", "\"PTX does not support varargs\"", "\"Unsupported calling convention.\"", "PTX", "0", "\"Kernel must return void.\"", "PTXISD::EXIT", "MVT::Other", "PTX", "1", "\"Can at most return one value.\"", "0", "PTXISD::RET", "MVT::Other", "0", "MVT::i16", "PTX::RH0", "0", "MVT::i32", "PTX::R0", "0", "MVT::i64", "PTX::RD0", "0", "MVT::f32", "PTX::F0", "0", "MVT::f64", "\"Can return only basic types\"", "PTX::FD0", "PTX", "PTX", "0", "1", "PTXISD::RET", "MVT::Other" ]

[]

[ "<s>", "bool", "TeakPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createTeakISelDag", "(", "getTeakTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Teak", "Teak", "Teak", "Teak" ]

[]

[ "<s>", "bool", "pure_scalable_type_info", "::", "analyze_registers", "(", "const_tree", "type", ")", "{", "analysis_result", "result", "=", "analyze", "(", "type", ")", ";", "gcc_assert", "(", "result", "!=", "DOESNT_MATTER", ")", ";", "return", "result", "==", "IS_PST", ";", "}", "</s>" ]

[ "Analyze", "a", "type", "that", "is", "known", "not", "to", "be", "passed", "or", "returned", "in", "memory", ".", "Return", "true", "if", "it", "has", "an", "ABI", "identity", "and", "is", "a", "Pure", "Scalable", "Type", "." ]

[ "aarch64" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "ClassifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "if", "(", "GV", "->", "hasDLLImportLinkage", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "bool", "isDecl", "=", "GV", "->", "isDeclaration", "(", ")", "&&", "!", "GV", "->", "hasNotBeenReadFromBitcode", "(", ")", ";", "if", "(", "isPICStyleRIPRel", "(", ")", ")", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "GV", "->", "hasDefaultVisibility", "(", ")", "&&", "(", "isDecl", "||", "GV", "->", "isWeakForLinker", "(", ")", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "}", "else", "{", "assert", "(", "isTargetELF", "(", ")", "&&", "\"Unknown rip-relative target\"", ")", ";", "if", "(", "!", "GV", "->", "hasLocalLinkage", "(", ")", "&&", "GV", "->", "hasDefaultVisibility", "(", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "if", "(", "isPICStyleGOT", "(", ")", ")", "{", "if", "(", "GV", "->", "hasLocalLinkage", "(", ")", "||", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "X86II", "::", "MO_GOTOFF", ";", "return", "X86II", "::", "MO_GOT", ";", "}", "if", "(", "isPICStyleStubPIC", "(", ")", ")", "{", "if", "(", "!", "isDecl", "&&", "!", "GV", "->", "isWeakForLinker", "(", ")", ")", "return", "X86II", "::", "MO_PIC_BASE_OFFSET", ";", "if", "(", "!", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "if", "(", "isDecl", "||", "GV", "->", "hasCommonLinkage", "(", ")", ")", "{", "return", "X86II", "::", "MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE", ";", "}", "return", "X86II", "::", "MO_PIC_BASE_OFFSET", ";", "}", "if", "(", "isPICStyleStubNoDynamic", "(", ")", ")", "{", "if", "(", "!", "isDecl", "&&", "!", "GV", "->", "isWeakForLinker", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "!", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY", ";", "if", "(", "isDecl", "||", "GV", "->", "hasCommonLinkage", "(", ")", ")", "{", "return", "X86II", "::", "MO_DARWIN_HIDDEN_NONLAZY", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "ClassifyGlobalReference", "-", "Find", "the", "target", "operand", "flags", "that", "describe", "how", "a", "global", "value", "should", "be", "referenced", "for", "the", "current", "subtarget", "." ]

[ "X86", "X86", "X86II::MO_DLLIMPORT", "X86II::MO_NO_FLAG", "X86II::MO_GOTPCREL", "\"Unknown rip-relative target\"", "X86II::MO_GOTPCREL", "X86II::MO_NO_FLAG", "X86II::MO_GOTOFF", "X86II::MO_GOT", "X86II::MO_PIC_BASE_OFFSET", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE", "X86II::MO_PIC_BASE_OFFSET", "X86II::MO_NO_FLAG", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_HIDDEN_NONLAZY", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "GlobalBaseReg", "=", "0", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "PPCLowering", "=", "Subtarget", "->", "getTargetLowering", "(", ")", ";", "if", "(", "Subtarget", "->", "hasROPProtect", "(", ")", ")", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "const", "int", "Result", "=", "MFI", ".", "CreateStackObject", "(", "8", ",", "Align", "(", "8", ")", ",", "false", ")", ";", "FI", "->", "setROPProtectionHashSaveIndex", "(", "Result", ")", ";", "}", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "0", "PPC", "PPC", "PPC", "PPC", "8", "8" ]

[]

[ "<s>", "void", "LC2200FrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "LC2200RegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "unsigned", "MaxStackAlign", "=", "std", "::", "max", "(", "StackAlign", ",", "MFI", ".", "getMaxAlignment", "(", ")", ")", ";", "FrameSize", "+=", "(", "MaxStackAlign", "-", "StackAlign", ")", ";", "StackAlign", "=", "MaxStackAlign", ";", "}", "uint64_t", "MaxCallSize", "=", "alignTo", "(", "MFI", ".", "getMaxCallFrameSize", "(", ")", ",", "StackAlign", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "MaxCallSize", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "LC2200", "LC2200", "LC2200" ]

[]

[ "<s>", "static", "void", "arm_unwind_emit_set", "(", "FILE", "*", "asm_out_file", ",", "rtx", "p", ")", "{", "rtx", "e0", ";", "rtx", "e1", ";", "e0", "=", "XEXP", "(", "p", ",", "0", ")", ";", "e1", "=", "XEXP", "(", "p", ",", "1", ")", ";", "switch", "(", "GET_CODE", "(", "e0", ")", ")", "{", "case", "MEM", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "e0", ",", "0", ")", ")", "!=", "PRE_DEC", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "e0", ",", "0", ")", ",", "0", ")", ")", "!=", "REG", "||", "REGNO", "(", "XEXP", "(", "XEXP", "(", "e0", ",", "0", ")", ",", "0", ")", ")", "!=", "SP_REGNUM", ")", "abort", "(", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.save \"", ")", ";", "if", "(", "IS_VFP_REGNUM", "(", "REGNO", "(", "e1", ")", ")", ")", "asm_fprintf", "(", "asm_out_file", ",", "\"{d%d}\\n\"", ",", "(", "REGNO", "(", "e1", ")", "-", "FIRST_VFP_REGNUM", ")", "/", "2", ")", ";", "else", "asm_fprintf", "(", "asm_out_file", ",", "\"{%r}\\n\"", ",", "REGNO", "(", "e1", ")", ")", ";", "break", ";", "case", "REG", ":", "if", "(", "REGNO", "(", "e0", ")", "==", "SP_REGNUM", ")", "{", "if", "(", "GET_CODE", "(", "e1", ")", "!=", "PLUS", "||", "GET_CODE", "(", "XEXP", "(", "e1", ",", "0", ")", ")", "!=", "REG", "||", "REGNO", "(", "XEXP", "(", "e1", ",", "0", ")", ")", "!=", "SP_REGNUM", "||", "GET_CODE", "(", "XEXP", "(", "e1", ",", "1", ")", ")", "!=", "CONST_INT", ")", "abort", "(", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.pad #%wd\\n\"", ",", "-", "INTVAL", "(", "XEXP", "(", "e1", ",", "1", ")", ")", ")", ";", "}", "else", "if", "(", "REGNO", "(", "e0", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "{", "HOST_WIDE_INT", "offset", ";", "unsigned", "reg", ";", "if", "(", "GET_CODE", "(", "e1", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "e1", ",", "0", ")", ")", "!=", "REG", "||", "GET_CODE", "(", "XEXP", "(", "e1", ",", "1", ")", ")", "!=", "CONST_INT", ")", "abort", "(", ")", ";", "reg", "=", "REGNO", "(", "XEXP", "(", "e1", ",", "0", ")", ")", ";", "offset", "=", "INTVAL", "(", "XEXP", "(", "e1", ",", "1", ")", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.setfp %r, %r, #%wd\\n\"", ",", "HARD_FRAME_POINTER_REGNUM", ",", "reg", ",", "INTVAL", "(", "XEXP", "(", "e1", ",", "1", ")", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "e1", ")", "==", "REG", ")", "{", "reg", "=", "REGNO", "(", "e1", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.setfp %r, %r\\n\"", ",", "HARD_FRAME_POINTER_REGNUM", ",", "reg", ")", ";", "}", "else", "abort", "(", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "e1", ")", "==", "REG", "&&", "REGNO", "(", "e1", ")", "==", "SP_REGNUM", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.movsp %r\\n\"", ",", "REGNO", "(", "e0", ")", ")", ";", "}", "else", "abort", "(", ")", ";", "break", ";", "default", ":", "abort", "(", ")", ";", "}", "}", "</s>" ]

[ "Emit", "unwind", "directives", "for", "a", "SET", "." ]

[ "arm", "0", "1", "0", "0", "0", "0", "0", "\"\\t.save \"", "\"{d%d}\\n\"", "2", "\"{%r}\\n\"", "0", "0", "1", "\"\\t.pad #%wd\\n\"", "1", "0", "1", "0", "1", "\"\\t.setfp %r, %r, #%wd\\n\"", "1", "\"\\t.setfp %r, %r\\n\"", "\"\\t.movsp %r\\n\"" ]

[]