Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "}" ]

[ "bool", "AMDGPUMachineCFGStructurizer", "::", "containsDef", "(", "MachineBasicBlock", "*", "MBB", ",", "LinearizedRegion", "*", "InnerRegion", ",", "unsigned", "Register", ")", "{", "return", "getDefInstr", "(", "Register", ")", "->", "getParent", "(", ")", "==", "MBB", "||", "InnerRegion", "->", "contains", "(", "getDefInstr", "(", "Register", ")", "->", "getParent", "(", ")", ")", ";" ]

[ "(", "unspec_volatile", ":", "CC", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPECV_HTM_TTEST", ")", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "CC", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "extend", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "extend", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "LDLARB", ",", "LDLARH", ",", "LDLARW", ",", "LDLARX", ")", ">", ";" ]

[ "def", ":", "InstRW", "<", "[", "A64FXWrite_5Cyc_GI5", ",", "WriteAtomic", "]", ",", "(", "instrs" ]

[ ";" ]

[ "ConstantFoldInstructions", "(", "Func", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "*** IR Dump After Constant folding instructions ***\\n", "<STR_LIT>", ")", ";", "Func", "->", "dump", "(", ")", ";", "HandleGlobalConstants", "(", "Func", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "*** IR Dump After JVM Global Constants Handler ***\\n", "<STR_LIT>", ")", ";", "Func", "->", "dump", "(", ")", ";", "HandleBitCastOperation", "(", "Func", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "*** IR Dump After JVM Casting Handlers ***\\n", "<STR_LIT>", ")", ";", "Func", "->", "dump", "(", ")", ";", "FixupCompositeIndexes", "(", "Func", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "*** IR Dump After JVM Fixup Composite Indexes ***\\n", "<STR_LIT>", ")", ";", "Func", "->", "dump", "(", ")", ";", "LinearizeGEPChains", "(", "Func", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "*** IR Dump After JVM Linearize GEP Chains ***\\n", "<STR_LIT>", ")", ";", "Func", "->", "dump", "(", ")", ";", "UniquifyGEPOperands", "(", "Func", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "*** IR Dump After JVM GEP Uniquification ***\\n", "<STR_LIT>", ")", ";", "Func", "->", "dump", "(", ")" ]

[ "LastPosHighLatencyParentScheduled", "[", "Block", ".", "first", "->", "getID", "(", ")", "]", "=", "NumBlockScheduled", ";" ]

[ "if", "(", "Parent", "->", "isHighLatencyBlock", "(", ")", "&&", "Block", ".", "second", "==", "<STR_LIT>", "::", "<STR_LIT>", ")" ]

[ "false", ";" ]

[ "bool", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "override", "{", "std", "::", "reverse", "(", "CSI", ".", "begin", "(", ")", ",", "CSI", ".", "end", "(", ")", ")", ";", "return" ]

[ "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr" ]

[ "Index", ";" ]

[ "void", "setVarArgsFrameIndex", "(", "int", "Index", ")", "{", "VarArgsFrameIndex", "=" ]

[ "<FIXS>", "if", "(", "!", "ST", ".", "isTrapHandlerEnabled", "(", ")", "||", "ST", ".", "getTrapHandlerAbi", "(", ")", "!=", "GCNSubtarget", "::", "TrapHandlerAbi", "::", "AMDHSA", ")", "return", "legalizeTrapEndpgm", "(", "MI", ",", "MRI", ",", "B", ")", ";", "if", "(", "Optional", "uint8_t", ">", "HsaAbiVer", "=", "AMDGPU", "::", "getHsaAbiVersion", "(", "&", "ST", ")", ")", "{", "switch", "(", "*", "HsaAbiVer", ")", "{", "case", "ELF", "::", "ELFABIVERSION_AMDGPU_HSA_V2", ":", "case", "ELF", "::", "ELFABIVERSION_AMDGPU_HSA_V3", ":", "return", "legalizeTrapHsaQueuePtr", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "ELF", "::", "ELFABIVERSION_AMDGPU_HSA_V4", ":", "return", "ST", ".", "supportsGetDoorbellID", "(", ")", "?", "legalizeTrapHsa", "(", "MI", ",", "MRI", ",", "B", ")", ":", "legalizeTrapHsaQueuePtr", "(", "MI", ",", "MRI", ",", "B", ")", ";", "}", "}", "<FIXE>", "<FIXS>", "llvm_unreachable", "(", "<STR_LIT>", "Unknown trap handler", "<STR_LIT>", ")", ";", "}", "<FIXE>", "<FIXS>", "bool", "AMDGPULegalizerInfo", "::", "legalizeTrapEndpgm", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "B", ")", "const", "{", "B", ".", "buildInstr", "(", "AMDGPU", "::", "S_ENDPGM", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "bool", "AMDGPULegalizerInfo", "::", "legalizeTrapHsaQueuePtr", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "B", ")", "const", "{", "Register", "LiveIn", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "pointer", "(", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "loadInputValue", "(", "LiveIn", ",", "B", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", "false", ";", "Register", "SGPR01", "(", "AMDGPU", "::", "SGPR0_SGPR1", ")", ";", "B", ".", "buildCopy", "(", "SGPR01", ",", "LiveIn", ")", ";", "B", ".", "buildInstr", "(", "AMDGPU", "::", "S_TRAP", ")", ".", "addImm", "(", "static_cast", "unsigned", ">", "(", "GCNSubtarget", "::", "TrapID", "::", "LLVMAMDHSATrap", ")", ")", ".", "addReg", "(", "SGPR01", ",", "RegState", "::", "Implicit", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "bool", "AMDGPULegalizerInfo", "::", "legalizeTrapHsa", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "B", ")", "const", "{", "B", ".", "buildInstr", "(", "AMDGPU", "::", "S_TRAP", ")", ".", "addImm", "(", "static_cast", "unsigned", ">", "(", "GCNSubtarget", "::", "TrapID", "::", "LLVMAMDHSATrap", ")", ")", ";", "<FIXE>" ]

[ "bool", "AMDGPULegalizerInfo", "::", "legalizeTrapIntrinsic", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "B", ")", "const", "{", "<BUGS>", "if", "(", "ST", ".", "getTrapHandlerAbi", "(", ")", "!=", "GCNSubtarget", "::", "TrapHandlerAbiHsa", "||", "!", "ST", ".", "isTrapHandlerEnabled", "(", ")", ")", "{", "B", ".", "buildInstr", "(", "AMDGPU", "::", "S_ENDPGM", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "MachineRegisterInfo", "&", "MRI", "=", "*", "B", ".", "getMRI", "(", ")", ";", "<BUGE>", "<BUGS>", "Register", "LiveIn", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "pointer", "(", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "loadInputValue", "(", "LiveIn", ",", "B", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", "false", ";", "<BUGE>", "<BUGS>", "Register", "SGPR01", "(", "AMDGPU", "::", "SGPR0_SGPR1", ")", ";", "B", ".", "buildCopy", "(", "SGPR01", ",", "LiveIn", ")", ";", "B", ".", "buildInstr", "(", "AMDGPU", "::", "S_TRAP", ")", ".", "addImm", "(", "GCNSubtarget", "::", "TrapIDLLVMTrap", ")", ".", "addReg", "(", "SGPR01", ",", "RegState", "::", "Implicit", ")", ";", "}", "<BUGE>", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}" ]

[ ",", "ZPR64", ">", ";" ]

[ "def", "_S", ":", "sve_int_cmp", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "opc", ",", "asm", ",", "PPR32", ",", "ZPR32" ]

[ "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "UNSPECV_CMPXCHG_1", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec_volatile", ":", "QIHI", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPECV_CMPXCHG_2", ")", ")", "(", "set", "(", "reg", ":", "SI", "T_REG", ")", "(", "unspec_volatile", ":", "SI", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPECV_CMPXCHG_3", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "R0_REG", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "rtx", "i", "=", "gen_atomic_compare_and_swap", "<", "mode", ">", "_hard_1", "(", "operands", "[", "<NUM_LIT>", "]", ",", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "operands" ]

[ "<FIXS>", "memcpy", "(", "&", "u", ",", "&", "CONST_DOUBLE_LOW", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "sizeof", "(", "u", ")", ")", ";", "<FIXE>" ]

[ "long", "l", "[", "<NUM_LIT>", "]", ";", "union", "real_extract", "u", ";", "<BUGS>", "bcopy", "(", "(", "char", "*", ")", "&", "CONST_DOUBLE_LOW", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "(", "char", "*", ")", "&", "u", ",", "sizeof", "(", "u", ")", ")", ";", "<BUGE>", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "u", ".", "d", ",", "l", ")", ";", "otherops", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "l", "[", "<NUM_LIT>", "]", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "l", "[", "<NUM_LIT>", "]", ")", ";" ]

[ ",", "false", ")", ";" ]

[ "return", "LowerGlobalOrExternal", "(", "Op", ",", "DAG" ]

[ "ResourcesModel", "->", "clearResources", "(", ")", ";" ]

[ "Packet", ".", "clear", "(", ")", ";", "OldPacket", ".", "resize", "(", "SchedModel", "->", "getIssueWidth", "(", ")", ")", ";", "OldPacket", ".", "clear", "(", ")", ";" ]

[ "}" ]

[ "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", ";", "SpillList", ".", "push_back", "(", "StackSlotInfo", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ",", "Offset", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "}", "if", "(", "fetchFP", ")", "{", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "XFI", "->", "getFPSpillSlot", "(", ")", ")", ";", "SpillList", ".", "push_back", "(", "StackSlotInfo", "(", "XFI", "->", "getFPSpillSlot", "(", ")", ",", "Offset", ",", "FramePtr", ")", ")", ";", "}", "llvm", "::", "sort", "(", "SpillList", ",", "CompareSSIOffset", ")", ";" ]

[ "(", "match_operand", ":", "VI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "VI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "smin", ":", "VI", "(", "match_operand", ":", "VI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "NewMIs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MBB", ".", "insert", "(", "MI", ",", "NewMIs", "[", "i", "]", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "NewMIs", ".", "back", "(", ")", "->", "addMemOperand", "(", "MF", ",", "MMO", ")", ";" ]

[ "<STR_LIT>" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask8", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_mask_cmpneq_epu8_mask", "(", "_", "_", "mmask8", "_", "_", "M", ",", "_", "_", "m256i", "_", "_", "X", ",", "_", "_", "m256i", "_", "_", "Y", ")", "{", "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_ucmpb256_mask", "(", "(", "_", "_", "v32qi", ")", "_", "_", "X", ",", "(", "_", "_", "v32qi", ")", "_", "_", "Y", ",", "<NUM_LIT>", ",", "(", "_", "_", "mmask8", ")", "_", "_", "M", ")", ";" ]

[ "}", "else", "{" ]

[ "const", "MCSymbol", "&", "Sym", "=", "A", "->", "getSymbol", "(", ")", ";", "if", "(", "Sym", ".", "isDefined", "(", ")", ")", "{", "MCSection", "&", "Section", "=", "Sym", ".", "getSection", "(", ")", ";", "const", "MCSectionELF", "*", "SectionELF", "=", "dyn_cast", "<", "MCSectionELF", ">", "(", "&", "Section", ")", ";", "assert", "(", "SectionELF", "&&", "<STR_LIT>", "Null section for reloc symbol", "<STR_LIT>", ")", ";", "unsigned", "Flags", "=", "SectionELF", "->", "getFlags", "(", ")", ";", "if", "(", "Sym", ".", "isTemporary", "(", ")", ")", "{", "if", "(", "(", "Flags", "&", "ELF", "::", "SHF_ALLOC", ")", "&&", "(", "Flags", "&", "ELF", "::", "SHF_EXECINSTR", ")", ")", "return", "ELF", "::", "R_BPF_NONE", ";" ]

[ "}" ]

[ "move", "=", "mode", "==", "QImode", "?", "gen_movqi", "(", "A", ",", "src", ")", ":", "gen_movhi", "(", "AX", ",", "src", ")", ";", "EM", "(", "move", ")", ";", "emit_insn_before", "(", "move", ",", "before", ")", ";", "record_content", "(", "AX", ",", "NULL_RTX", ")", ";" ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "mult", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "let", "HasImm", "=", "<NUM_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "=", "optype", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "sw", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SystemZISD::PCRelativeWrapper", "<STR_LIT>", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SystemZISD::UCMP", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "SystemZISD::SELECT", "<STR_LIT>", ";" ]

[ "if", "(", "!", "is32Bit", ")", "return", "MCDisassembler", "::", "Fail", ";" ]

[ "unsigned", "off18_3", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "off18", "=", "(", "off18_0", "<<", "<NUM_LIT>", ")", "|", "(", "off18_1", "<<", "<NUM_LIT>", ")", "|", "(", "off18_2", "<<", "<NUM_LIT>", ")", "|", "(", "off18_3", "<<", "<NUM_LIT>", ")", ";", "unsigned", "s1_d", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "is32Bit", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";" ]

[ "}", "else", "Opc", "=", "Subtarget", "->", "hasVSX", "(", ")", "?", "PPC", "::", "XSCMPUDP", ":", "PPC", "::", "FCMPUD", ";" ]

[ "}", "else", "if", "(", "LHS", ".", "getValueType", "(", ")", "==", "MVT", "::", "i64", ")", "{", "uint64_t", "Imm", ";", "if", "(", "CC", "==", "ISD", "::", "SETEQ", "||", "CC", "==", "ISD", "::", "SETNE", ")", "{", "if", "(", "isInt64Immediate", "(", "RHS", ".", "getNode", "(", ")", ",", "Imm", ")", ")", "{", "if", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "Imm", ")", ")", "return", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "CMPLDI", ",", "dl", ",", "MVT", "::", "i64", ",", "LHS", ",", "getI32Imm", "(", "Imm", "&", "<NUM_LIT>", ",", "dl", ")", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "Imm", ")", ")", "return", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "CMPDI", ",", "dl", ",", "MVT", "::", "i64", ",", "LHS", ",", "getI32Imm", "(", "Imm", "&", "<NUM_LIT>", ",", "dl", ")", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "Imm", ")", ")", "{", "SDValue", "Xor", "(", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "XORIS8", ",", "dl", ",", "MVT", "::", "i64", ",", "LHS", ",", "getI64Imm", "(", "Imm", ">>", "<NUM_LIT>", ",", "dl", ")", ")", ",", "<NUM_LIT>", ")", ";", "return", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "CMPLDI", ",", "dl", ",", "MVT", "::", "i64", ",", "Xor", ",", "getI64Imm", "(", "Imm", "&", "<NUM_LIT>", ",", "dl", ")", ")", ",", "<NUM_LIT>", ")", ";", "}", "}", "Opc", "=", "PPC", "::", "CMPLD", ";", "}", "else", "if", "(", "ISD", "::", "isUnsignedIntSetCC", "(", "CC", ")", ")", "{", "if", "(", "isInt64Immediate", "(", "RHS", ".", "getNode", "(", ")", ",", "Imm", ")", "&&", "isUInt", "<", "<NUM_LIT>", ">", "(", "Imm", ")", ")", "return", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "CMPLDI", ",", "dl", ",", "MVT", "::", "i64", ",", "LHS", ",", "getI64Imm", "(", "Imm", "&", "<NUM_LIT>", ",", "dl", ")", ")", ",", "<NUM_LIT>", ")", ";", "Opc", "=", "PPC", "::", "CMPLD", ";", "}", "else", "{", "int16_t", "SImm", ";", "if", "(", "isIntS16Immediate", "(", "RHS", ",", "SImm", ")", ")", "return", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "CMPDI", ",", "dl", ",", "MVT", "::", "i64", ",", "LHS", ",", "getI64Imm", "(", "SImm", "&", "<NUM_LIT>", ",", "dl", ")", ")", ",", "<NUM_LIT>", ")", ";", "Opc", "=", "PPC", "::", "CMPD", ";", "}", "}", "else", "if", "(", "LHS", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "{", "if", "(", "Subtarget", "->", "hasSPE", "(", ")", ")", "{", "switch", "(", "CC", ")", "{", "default", ":", "case", "ISD", "::", "SETEQ", ":", "case", "ISD", "::", "SETNE", ":", "Opc", "=", "PPC", "::", "EFSCMPEQ", ";", "break", ";", "case", "ISD", "::", "SETLT", ":", "case", "ISD", "::", "SETGE", ":", "case", "ISD", "::", "SETOLT", ":", "case", "ISD", "::", "SETOGE", ":", "case", "ISD", "::", "SETULT", ":", "case", "ISD", "::", "SETUGE", ":", "Opc", "=", "PPC", "::", "EFSCMPLT", ";", "break", ";", "case", "ISD", "::", "SETGT", ":", "case", "ISD", "::", "SETLE", ":", "case", "ISD", "::", "SETOGT", ":", "case", "ISD", "::", "SETOLE", ":", "case", "ISD", "::", "SETUGT", ":", "case", "ISD", "::", "SETULE", ":", "Opc", "=", "PPC", "::", "EFSCMPGT", ";", "break", ";", "}", "}", "else", "Opc", "=", "PPC", "::", "FCMPUS", ";", "}", "else", "if", "(", "LHS", ".", "getValueType", "(", ")", "==", "MVT", "::", "f64", ")", "{", "if", "(", "Subtarget", "->", "hasSPE", "(", ")", ")", "{", "switch", "(", "CC", ")", "{", "default", ":", "case", "ISD", "::", "SETEQ", ":", "case", "ISD", "::", "SETNE", ":", "Opc", "=", "PPC", "::", "EFDCMPEQ", ";", "break", ";", "case", "ISD", "::", "SETLT", ":", "case", "ISD", "::", "SETGE", ":", "case", "ISD", "::", "SETOLT", ":", "case", "ISD", "::", "SETOGE", ":", "case", "ISD", "::", "SETULT", ":", "case", "ISD", "::", "SETUGE", ":", "Opc", "=", "PPC", "::", "EFDCMPLT", ";", "break", ";", "case", "ISD", "::", "SETGT", ":", "case", "ISD", "::", "SETLE", ":", "case", "ISD", "::", "SETOGT", ":", "case", "ISD", "::", "SETOLE", ":", "case", "ISD", "::", "SETUGT", ":", "case", "ISD", "::", "SETULE", ":", "Opc", "=", "PPC", "::", "EFDCMPGT", ";", "break", ";", "}" ]

[ ";" ]

[ "int", "RegSize", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VSTMDDB_UPD", ":", "RegSize", "=", "<NUM_LIT>", ";", "break", ";", "case", "ARM", "::", "STMDB_UPD", ":", "case", "ARM", "::", "t2STMDB_UPD", ":", "RegSize", "=", "<NUM_LIT>" ]

[ "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", ",", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ")", ")", ";" ]

[ "case", "AsmToken", "::", "Integer", ":", "case", "AsmToken", "::", "BigNum", ":", "case", "AsmToken", "::", "Identifier", ":", "case", "AsmToken", "::", "Real", ":", "if", "(", "!", "tryParseExpression", "(", "Operands", ")", ")", "return", "false", ";", "default", ":", "break", ";", "}" ]

[ "let", "prefersSlot3", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ";" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>" ]

[ "return", "ResultReg", ";" ]

[ "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "<NUM_LIT>", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DL", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ",", "Op0IsKill", "*", "RegState", "::", "Kill", ")", ".", "addFPImm", "(", "FPImm", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DL", ",", "II", ")", ".", "addReg", "(", "Op0", ",", "Op0IsKill", "*", "RegState", "::", "Kill", ")", ".", "addFPImm", "(", "FPImm", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DL", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "<NUM_LIT>", "]", ")", ")", ";", "}" ]

[ ")", "TIDIGCompCnt", "=", "<NUM_LIT>", ";" ]

[ "ProgInfo", ".", "NumSGPR", "=", "AMDGPU", "::", "IsaInfo", "::", "FIXED_NUM_SGPRS_FOR_INIT_BUG", ";", "ProgInfo", ".", "NumSGPRsForWavesPerEU", "=", "AMDGPU", "::", "IsaInfo", "::", "FIXED_NUM_SGPRS_FOR_INIT_BUG", ";", "}", "if", "(", "MFI", "->", "getNumUserSGPRs", "(", ")", ">", "STM", ".", "getMaxNumUserSGPRs", "(", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "DiagnosticInfoResourceLimit", "Diag", "(", "*", "MF", ".", "getFunction", "(", ")", ",", "<STR_LIT>", "user SGPRs", "<STR_LIT>", ",", "MFI", "->", "getNumUserSGPRs", "(", ")", ",", "DS_Error", ")", ";", "Ctx", ".", "diagnose", "(", "Diag", ")", ";", "}", "if", "(", "MFI", "->", "getLDSSize", "(", ")", ">", "static_cast", "<", "unsigned", ">", "(", "STM", ".", "getLocalMemorySize", "(", ")", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "DiagnosticInfoResourceLimit", "Diag", "(", "*", "MF", ".", "getFunction", "(", ")", ",", "<STR_LIT>", "local memory", "<STR_LIT>", ",", "MFI", "->", "getLDSSize", "(", ")", ",", "DS_Error", ")", ";", "Ctx", ".", "diagnose", "(", "Diag", ")", ";", "}", "ProgInfo", ".", "SGPRBlocks", "=", "alignTo", "(", "ProgInfo", ".", "NumSGPRsForWavesPerEU", ",", "STM", ".", "getSGPREncodingGranule", "(", ")", ")", ";", "ProgInfo", ".", "SGPRBlocks", "=", "ProgInfo", ".", "SGPRBlocks", "/", "STM", ".", "getSGPREncodingGranule", "(", ")", "-", "<NUM_LIT>", ";", "ProgInfo", ".", "VGPRBlocks", "=", "alignTo", "(", "ProgInfo", ".", "NumVGPRsForWavesPerEU", ",", "STM", ".", "getVGPREncodingGranule", "(", ")", ")", ";", "ProgInfo", ".", "VGPRBlocks", "=", "ProgInfo", ".", "VGPRBlocks", "/", "STM", ".", "getVGPREncodingGranule", "(", ")", "-", "<NUM_LIT>", ";", "ProgInfo", ".", "ReservedVGPRFirst", "=", "STM", ".", "debuggerReserveRegs", "(", ")", "?", "ProgInfo", ".", "NumVGPR", ":", "<NUM_LIT>", ";", "ProgInfo", ".", "ReservedVGPRCount", "=", "STM", ".", "getReservedNumVGPRs", "(", "MF", ")", ";", "if", "(", "STM", ".", "debuggerEmitPrologue", "(", ")", ")", "{", "ProgInfo", ".", "DebuggerWavefrontPrivateSegmentOffsetSGPR", "=", "RI", "->", "getHWRegIndex", "(", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ")", ";", "ProgInfo", ".", "DebuggerPrivateSegmentBufferSGPR", "=", "RI", "->", "getHWRegIndex", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ";", "}", "ProgInfo", ".", "FloatMode", "=", "getFPMode", "(", "MF", ")", ";", "ProgInfo", ".", "IEEEMode", "=", "STM", ".", "enableIEEEBit", "(", "MF", ")", ";", "ProgInfo", ".", "DX10Clamp", "=", "STM", ".", "enableDX10Clamp", "(", ")", ";", "unsigned", "LDSAlignShift", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", "<", "SISubtarget", "::", "SEA_ISLANDS", ")", "{", "LDSAlignShift", "=", "<NUM_LIT>", ";", "}", "else", "{", "LDSAlignShift", "=", "<NUM_LIT>", ";", "}", "unsigned", "LDSSpillSize", "=", "MFI", "->", "getLDSWaveSpillSize", "(", ")", "*", "MFI", "->", "getMaxFlatWorkGroupSize", "(", ")", ";", "ProgInfo", ".", "LDSSize", "=", "MFI", "->", "getLDSSize", "(", ")", "+", "LDSSpillSize", ";", "ProgInfo", ".", "LDSBlocks", "=", "alignTo", "(", "ProgInfo", ".", "LDSSize", ",", "<NUM_LIT>", "ULL", "<<", "LDSAlignShift", ")", ">>", "LDSAlignShift", ";", "unsigned", "ScratchAlignShift", "=", "<NUM_LIT>", ";", "ProgInfo", ".", "ScratchBlocks", "=", "alignTo", "(", "ProgInfo", ".", "ScratchSize", "*", "STM", ".", "getWavefrontSize", "(", ")", ",", "<NUM_LIT>", "ULL", "<<", "ScratchAlignShift", ")", ">>", "ScratchAlignShift", ";", "ProgInfo", ".", "ComputePGMRSrc1", "=", "S_00B848_VGPRS", "(", "ProgInfo", ".", "VGPRBlocks", ")", "|", "S_00B848_SGPRS", "(", "ProgInfo", ".", "SGPRBlocks", ")", "|", "S_00B848_PRIORITY", "(", "ProgInfo", ".", "Priority", ")", "|", "S_00B848_FLOAT_MODE", "(", "ProgInfo", ".", "FloatMode", ")", "|", "S_00B848_PRIV", "(", "ProgInfo", ".", "Priv", ")", "|", "S_00B848_DX10_CLAMP", "(", "ProgInfo", ".", "DX10Clamp", ")", "|", "S_00B848_DEBUG_MODE", "(", "ProgInfo", ".", "DebugMode", ")", "|", "S_00B848_IEEE_MODE", "(", "ProgInfo", ".", "IEEEMode", ")", ";", "unsigned", "TIDIGCompCnt", "=", "<NUM_LIT>", ";", "if", "(", "MFI", "->", "hasWorkItemIDZ", "(", ")" ]

[ ".", "getContext", "(", ")", ")", ",", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "MCSym", ".", "getInt", "(", ")", ")", "OutStreamer", ".", "EmitIntValue", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "else", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "create", "(", "MCSym", ".", "getPointer", "(", ")", ",", "OutStreamer" ]

[ "case", "CONST_FIXED", ":" ]

[ "const", "struct", "double_op_cost", "*", "double_op_cost_p", ";", "cost_p", "=", "(", "speed", "?", "&", "cycle_cost_single_op", ":", "&", "size_cost_single_op", ")", ";", "double_op_cost_p", "=", "(", "speed", "?", "&", "cycle_cost_double_op", ":", "&", "size_cost_double_op", ")", ";", "switch", "(", "dst_code", ")", "{", "case", "REG", ":", "return", "cost_p", "->", "reg", ";", "case", "MEM", ":", "if", "(", "msp430_is_mem_indirect", "(", "dst", ")", ")", "return", "cost_p", "->", "ind", ";", "else", "return", "cost_p", "->", "mem", ";", "case", "CONST_INT", ":" ]

[ "(", "V8SF", "<STR_LIT>", ")", "(", "V4DF", "<STR_LIT>", ")" ]

[ "(", "V16QI", "<STR_LIT>", ")", "(", "V8HI", "<STR_LIT>", ")", "(", "V4SI", "<STR_LIT>", ")", "(", "V2DI", "<STR_LIT>", ")", "(", "V16SF", "<STR_LIT>", ")", "(", "V8DF", "<STR_LIT>", ")" ]

[ "match_code", "<STR_LIT>", ")" ]

[ "(", "and", "(" ]

[ "bool", "MVEGatherScatterLowering", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "EnableMaskedGatherScatters", ")", "return", "false", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "auto", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "auto", "*", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "<NUM_LIT>", ">", "Gathers", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "<NUM_LIT>", ">", "Scatters", ";", "bool", "Changed", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "for", "(", "Instruction", "&", "I", ":", "BB", ")", "{", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_gather", ")", "{", "Gathers", ".", "push_back", "(", "II", ")", ";", "if", "(", "isa", "<", "GetElementPtrInst", ">", "(", "II", "->", "getArgOperand", "(", "<NUM_LIT>", ")", ")", ")", "Changed", "|=", "optimiseOffsets", "(", "cast", "<", "Instruction", ">", "(", "II", "->", "getArgOperand", "(", "<NUM_LIT>", ")", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "II", "->", "getParent", "(", ")", ",", "LI", ")", ";", "}", "else", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_scatter", ")", "{", "Scatters", ".", "push_back", "(", "II", ")", ";", "if", "(", "isa", "<", "GetElementPtrInst", ">", "(", "II", "->", "getArgOperand", "(", "<NUM_LIT>", ")", ")", ")", "Changed", "|=", "optimiseOffsets", "(", "cast", "<", "Instruction", ">", "(", "II", "->", "getArgOperand", "(", "<NUM_LIT>", ")", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "II", "->", "getParent", "(", ")", ",", "LI", ")", ";", "}", "}", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Gathers", ".", "size", "(", ")", ";", "i", "++", ")", "{", "IntrinsicInst", "*", "I", "=", "Gathers", "[", "i", "]", ";", "Value", "*", "L", "=", "lowerGather", "(", "I", ")", ";", "if", "(", "L", "==", "nullptr", ")", "continue", ";", "SimplifyInstructionsInBlock", "(", "cast", "<", "Instruction", ">", "(", "L", ")", "->", "getParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Scatters", ".", "size", "(", ")", ";", "i", "++", ")", "{", "IntrinsicInst", "*", "I", "=", "Scatters", "[", "i", "]", ";", "Value", "*", "S", "=", "lowerScatter", "(", "I", ")", ";", "if", "(", "S", "==", "nullptr", ")", "continue", ";", "SimplifyInstructionsInBlock", "(", "cast", "<", "Instruction", ">", "(", "S", ")", "->", "getParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}" ]

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

[ ",", "SDTVFPToIntRound", ">", ";" ]

[ "def", "X86VFpToUintRnd", ":", "SDNode", "<", "<STR_LIT>" ]

[ "<FIXS>", "addr1", "=", "plus_constant", "(", "SImode", ",", "copy_rtx", "(", "addr", ")", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "if", "(", "dst1", ")", "{", "<BUGS>", "addr1", "=", "plus_constant", "(", "copy_rtx", "(", "addr", ")", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "addr1", "=", "gen_rtx_AND", "(", "SImode", ",", "addr1", ",", "GEN_INT", "(", "-", "<NUM_LIT>", ")", ")", ";", "emit_insn", "(", "gen__movti", "(", "dst1", ",", "change_address", "(", "src", ",", "TImode", ",", "addr1", ")", ")", ")", ";", "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "s8", ";" ]

[ "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pu", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "S8", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "S8", "{", "<NUM_LIT>", "}", ";" ]

[ ",", "type", ")", ";" ]

[ "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "last_arg", ";", "i", "++", ")", "if", "(", "!", "require_matching_vector_type", "(", "i", ",", "type", ")", ")", "return", "error_mark_node", ";", "return", "finish_opt_n_resolution", "(", "last_arg", ",", "<NUM_LIT>" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VIlong", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "VIlong", "[", "(", "match_operand", ":", "VIlong", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VIlong", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VIlong", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VRLMI", ")", ")", "]" ]

[ "<FIXS>", "def", ":", "Pat", "(", "int_ppc_vsx_stxvd2x_be", "v2f64", ":", "$", "rS", ",", "ForceXForm", ":", "$", "dst", ")", ",", "(", "STXVD2X", "$", "rS", ",", "ForceXForm", ":", "$", "dst", ")", ">", ";", "def", ":", "Pat", "(", "int_ppc_vsx_stxvw4x_be", "v4i32", ":", "$", "rS", ",", "ForceXForm", ":", "$", "dst", ")", ",", "(", "STXVW4X", "$", "rS", ",", "ForceXForm", ":", "$", "dst", ")", ">", ";", "def", ":", "Pat", "(", "v4i32", "(", "int_ppc_vsx_lxvw4x_be", "ForceXForm", ":", "$", "src", ")", ")", ",", "(", "LXVW4X", "ForceXForm", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "v2f64", "(", "int_ppc_vsx_lxvd2x_be", "ForceXForm", ":", "$", "src", ")", ")", ",", "(", "LXVD2X", "ForceXForm", ":", "$", "src", ")", ">", ";", "<FIXE>" ]

[ "def", ":", "Pat", "(", "f64", "(", "fmaxnum_ieee", "(", "fcanonicalize", "f64", ":", "$", "A", ")", ",", "(", "fcanonicalize", "f64", ":", "$", "B", ")", ")", ")", ",", "(", "f64", "(", "XSMAXDP", "$", "A", ",", "$", "B", ")", ")", ">", ";", "<BUGS>", "def", ":", "Pat", "(", "int_ppc_vsx_stxvd2x_be", "v2f64", ":", "$", "rS", ",", "xoaddr", ":", "$", "dst", ")", ",", "(", "STXVD2X", "$", "rS", ",", "xoaddr", ":", "$", "dst", ")", ">", ";", "def", ":", "Pat", "(", "int_ppc_vsx_stxvw4x_be", "v4i32", ":", "$", "rS", ",", "xoaddr", ":", "$", "dst", ")", ",", "(", "STXVW4X", "$", "rS", ",", "xoaddr", ":", "$", "dst", ")", ">", ";", "def", ":", "Pat", "(", "v4i32", "(", "int_ppc_vsx_lxvw4x_be", "xoaddr", ":", "$", "src", ")", ")", ",", "(", "LXVW4X", "xoaddr", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "v2f64", "(", "int_ppc_vsx_lxvd2x_be", "xoaddr", ":", "$", "src", ")", ")", ",", "(", "LXVD2X", "xoaddr", ":", "$", "src", ")", ">", ";", "<BUGE>", "def", ":", "Pat", "(", "f32", "(", "any_fround", "f32", ":", "$", "S", ")", ")", "," ]

[ "<FIXS>", "(", "SrcVT", ".", "ScalarIntMemFrags", "addr", ":", "$", "src", ")", ")", ")", "]", ">", ",", "<FIXE>" ]

[ "def", "rm_Int", ":", "SI", "opc", ",", "MRMSrcMem", ",", "(", "outs", "DstVT", ".", "RC", ":", "$", "dst", ")", ",", "(", "ins", "SrcVT", ".", "IntScalarMemOp", ":", "$", "src", ")", ",", "!", "strconcat", "(", "asm", ",", "<STR_LIT>", ")", ",", "[", "(", "set", "DstVT", ".", "RC", ":", "$", "dst", ",", "(", "OpNode", "<BUGS>", "(", "SrcVT", ".", "VT", "SrcVT", ".", "ScalarIntMemCPat", ":", "$", "src", ")", ")", ")", "]", ">", ",", "<BUGE>", "EVEX", ",", "VEX_LIG", ",", "Sched", "[", "sched", ".", "Folded", ",", "sched", ".", "ReadAfterFold", "]", ">", ",", "SIMD_EXC", ";", "}" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{" ]

[ "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "<STR_LIT>", "Invalid fixup offset!", "<STR_LIT>", ")", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "InstrItinClass", ";" ]

[ "def", "tc_b8bffe55", ":" ]

[ "USR", "]", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isFP", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[" ]

[ "let", "addrMode", "=", "PostInc", ";" ]

[ "def", "L2_loadrub_pcr", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "ModRegs", ":", "$", "Mu2", ")", ",", "<STR_LIT>", ",", "tc_44d3da28", ",", "TypeLD", ">", ",", "Enc_74d4e5", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>", ";" ]

[ "let", "Name", "=" ]

[ "b", ",", "_", "_", "p", ")", ";" ]

[ "return", "_", "_", "arm_vhaddq_x_u32", "(", "_", "_", "a", ",", "_", "_" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "MVE_2", "[", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "<", "V_elem", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "VQDMLAHQ_N", ")", ")", "]", "<STR_LIT>" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx", "{", "<NUM_LIT>", "}", ";" ]

[ "def", "v8i16_indexed", ":", "BaseSIMDIndexedTied", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "opc", ",", "V128", ",", "V128", ",", "V128_lo", ",", "VectorIndexH", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v8i16", "V128", ":", "$", "dst", ")", ",", "(", "OpNode", "(", "v8i16", "V128", ":", "$", "Rd", ")", ",", "(", "v8i16", "V128", ":", "$", "Rn", ")", ",", "(", "v8i16", "(", "AArch64duplane16", "(", "v8i16", "V128_lo", ":", "$", "Rm", ")", ",", "VectorIndexH", ":", "$", "idx", ")", ")", ")", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "idx", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx", "{", "<NUM_LIT>", "}", ";" ]

[ "}" ]

[ "if", "(", "ARM_Q_BIT_READ", ")", "emit_insn", "(", "gen_arm_smlabb_setq", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mult1", ",", "mult2", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "else", "emit_insn", "(", "gen_maddhisi4", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mult1", ",", "mult2", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "DONE" ]

[ "<NUM_LIT>", ",", "<NUM_LIT>", ">", ",", "SDTCisVT", "<", "<NUM_LIT>", ",", "i32", ">", "]", ">", ";" ]

[ "def", "SDTARMVSHINS", ":", "SDTypeProfile", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisInt", "<", "<NUM_LIT>", ">", ",", "SDTCisSameAs", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ",", "SDTCisSameAs", "<" ]

[ "}", "]", ">", "{", "let", "ParserMatchClass", "=", "Imm0_15Operand", ";" ]

[ "def", "sme_elm_idx0_15", ":", "Operand", "<", "i64", ">", ",", "ImmLeaf", "<", "i64", ",", "[", "{", "return", "(", "(", "uint64_t", ")", "Imm", ")", "<", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "assert", "(", "Size", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "size too big in emit constant", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "void", "EmitConstant", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "unsigned", "&", "CurByte", ",", "raw_ostream", "&", "OS", ")", "const", "{", "<BUGS>", "assert", "(", "Size", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "size too big in emit constant", "<STR_LIT>", ")", ";", "<BUGE>", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "Size", ";", "++", "i", ")", "{", "EmitByte", "(", "Val", "&", "<NUM_LIT>", ",", "CurByte", ",", "OS", ")", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";" ]

[ "static", "bool", "sh_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "<NUM_LIT>", "&&", "(", "!", "TARGET_SHCOMPACT", "||", "crtl", "->", "args", ".", "info", ".", "stack_regs", "==", "<NUM_LIT>", ")", "&&", "!", "sh_cfun_interrupt_handler_p", "(", ")", "&&", "(", "!", "flag_pic", "||", "(", "decl", "&&", "!", "TREE_PUBLIC", "(", "decl", ")", ")", "||", "(", "decl", "&&", "DECL_VISIBILITY", "(", "decl", ")", "!=", "VISIBILITY_DEFAULT", ")", ")", ")", ";", "}" ]

[ "If", "PIC", ",", "we", "can", "not", "make", "sibling", "calls", "to", "global", "functions", "because", "the", "PLT", "requires", "r12", "to", "be", "live", "." ]

[ "::", "DR32RegClass", ";" ]

[ "return", "&", "M680x0" ]

[ "SDValue", "Ext2", "=", "extractSubVector", "(", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "DAG", ",", "DL", ",", "<NUM_LIT>", ")", ";" ]

[ "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "MemIntr", ",", "<NUM_LIT>", ")", ",", "BcastLd", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "return", "BcastLd", ";", "}", "}", "if", "(", "IdxVal", "==", "<NUM_LIT>", "&&", "InVec", ".", "hasOneUse", "(", ")", ")", "{", "unsigned", "InOpcode", "=", "InVec", ".", "getOpcode", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "v2f64", "&&", "InVecVT", "==", "MVT", "::", "v4f64", ")", "{", "if", "(", "InOpcode", "==", "ISD", "::", "SINT_TO_FP", "&&", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "v4i32", ")", "{", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "N", ")", ",", "VT", ",", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "if", "(", "InOpcode", "==", "ISD", "::", "UINT_TO_FP", "&&", "Subtarget", ".", "hasVLX", "(", ")", "&&", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "v4i32", ")", "{", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "N", ")", ",", "VT", ",", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "if", "(", "InOpcode", "==", "ISD", "::", "FP_EXTEND", "&&", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "v4f32", ")", "{", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "N", ")", ",", "VT", ",", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "}", "if", "(", "(", "InOpcode", "==", "ISD", "::", "ANY_EXTEND", "||", "InOpcode", "==", "ISD", "::", "ANY_EXTEND_VECTOR_INREG", "||", "InOpcode", "==", "ISD", "::", "ZERO_EXTEND", "||", "InOpcode", "==", "ISD", "::", "ZERO_EXTEND_VECTOR_INREG", "||", "InOpcode", "==", "ISD", "::", "SIGN_EXTEND", "||", "InOpcode", "==", "ISD", "::", "SIGN_EXTEND_VECTOR_INREG", ")", "&&", "VT", ".", "is128BitVector", "(", ")", "&&", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSimpleValueType", "(", ")", ".", "is128BitVector", "(", ")", ")", "{", "unsigned", "ExtOp", "=", "getOpcode_EXTEND_VECTOR_INREG", "(", "InOpcode", ")", ";", "return", "DAG", ".", "getNode", "(", "ExtOp", ",", "SDLoc", "(", "N", ")", ",", "VT", ",", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "if", "(", "InOpcode", "==", "ISD", "::", "VSELECT", "&&", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "is256BitVector", "(", ")", "&&", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "is256BitVector", "(", ")", "&&", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "is256BitVector", "(", ")", ")", "{", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "Ext0", "=", "extractSubVector", "(", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "DAG", ",", "DL", ",", "<NUM_LIT>", ")", ";", "SDValue", "Ext1", "=", "extractSubVector", "(", "InVec", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "DAG", ",", "DL", ",", "<NUM_LIT>", ")", ";" ]

[ "auto", "AlignVectors", "::", "move", "(", "const", "MoveGroup", "&", "Move", ")", "const", "->", "bool", "{", "assert", "(", "!", "Move", ".", "Main", ".", "empty", "(", ")", "&&", "<STR_LIT>", "Move group should have non-empty Main", "<STR_LIT>", ")", ";", "Instruction", "*", "Where", "=", "Move", ".", "Main", ".", "front", "(", ")", ";", "if", "(", "Move", ".", "IsLoad", ")", "{", "for", "(", "Instruction", "*", "D", ":", "Move", ".", "Deps", ")", "D", "->", "moveBefore", "(", "Where", ")", ";", "ArrayRef", "<", "Instruction", "*", ">", "Main", "(", "Move", ".", "Main", ")", ";", "for", "(", "Instruction", "*", "M", ":", "Main", ".", "drop_front", "(", "<NUM_LIT>", ")", ")", "{", "M", "->", "moveAfter", "(", "Where", ")", ";", "Where", "=", "M", ";", "}", "}", "else", "{", "assert", "(", "Move", ".", "Deps", ".", "empty", "(", ")", ")", ";", "ArrayRef", "<", "Instruction", "*", ">", "Main", "(", "Move", ".", "Main", ")", ";", "for", "(", "Instruction", "*", "M", ":", "Main", ".", "drop_front", "(", "<NUM_LIT>", ")", ")", "{", "M", "->", "moveBefore", "(", "Where", ")", ";", "Where", "=", "M", ";", "}", "}", "return", "Move", ".", "Main", ".", "size", "(", ")", "+", "Move", ".", "Deps", ".", "size", "(", ")", ">", "<NUM_LIT>", ";", "}" ]

[ "Move", "in", "the", "provide", "values", "in", "ValuesToLink", "from", "Src", "." ]

[ "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{" ]

[ "SDValue", "M680x0TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";" ]

[ "=", "<NUM_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "R1", ";", "bits", "<", "<NUM_LIT>", ">", "R3", ";", "bits", "<", "<NUM_LIT>", ">", "I2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R1", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "I2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}" ]

[ ")", ")" ]

[ "(", "eq_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "NumDataVectors", ")", "{" ]

[ "AArch64InstrInfo", "::", "decomposeStackOffsetForFrameOffsets", "(", "Offset", ",", "Bytes", ",", "NumPredicateVectors", ",", "NumDataVectors", ")", ";", "if", "(", "Bytes", "||", "(", "!", "Offset", "&&", "SrcReg", "!=", "DestReg", ")", ")", "{", "assert", "(", "(", "DestReg", "!=", "<STR_LIT>", "::", "<STR_LIT>", "||", "Bytes", "%", "<NUM_LIT>", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "SP increment/decrement not 8-byte aligned", "<STR_LIT>", ")", ";", "unsigned", "Opc", "=", "SetNZCV", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "Bytes", "<", "<NUM_LIT>", ")", "{", "Bytes", "=", "-", "Bytes", ";", "Opc", "=", "SetNZCV", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "emitFrameOffsetAdj", "(", "MBB", ",", "MBBI", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "Bytes", ",", "Opc", ",", "TII", ",", "Flag", ",", "NeedsWinCFI", ",", "HasWinCFI", ",", "EmitCFAOffset", ",", "CFAOffset", ",", "FrameReg", ")", ";", "CFAOffset", "+=", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "?", "StackOffset", "::", "getFixed", "(", "-", "Bytes", ")", ":", "StackOffset", "::", "getFixed", "(", "Bytes", ")", ";", "SrcReg", "=", "DestReg", ";", "FrameReg", "=", "DestReg", ";", "}", "assert", "(", "!", "(", "SetNZCV", "&&", "(", "NumPredicateVectors", "||", "NumDataVectors", ")", ")", "&&", "<STR_LIT>", "SetNZCV not supported with SVE vectors", "<STR_LIT>", ")", ";", "assert", "(", "!", "(", "NeedsWinCFI", "&&", "(", "NumPredicateVectors", "||", "NumDataVectors", ")", ")", "&&", "<STR_LIT>", "WinCFI not supported with SVE vectors", "<STR_LIT>", ")", ";", "if", "(" ]

[ "DONE" ]

[ "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "rs6000_split_vec_extract_var", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "I", "->", "eraseFromParent", "(", ")", ";" ]

[ "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "<NUM_LIT>", ";", "--", "I", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "BOpc", "&&", "I", "->", "getOpcode", "(", ")", "!=", "BccOpc", "&&", "I", "->", "getOpcode", "(", ")", "!=", "BccOpcNot", ")", "return", "<NUM_LIT>", ";" ]

[ "CreateReg", "(", "Register", ")", ")", ";" ]

[ "unsigned", "Register", "=", "DDDDecoderTable", "[", "RegNo", "]", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::" ]

[ "static", "int", "loongarch_issue_rate", "(", "void", ")", "{", "if", "(", "(", "unsigned", "long", ")", "la_target", ".", "cpu_tune", "<", "N_TUNE_TYPES", ")", "return", "loongarch_cpu_issue_rate", "[", "la_target", ".", "cpu_tune", "]", ";", "else", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "the", "number", "of", "instructions", "that", "can", "be", "issued", "per", "cycle", "." ]

[ "<FIXS>", "def", "op_sel0", ":", "ArrayOperand0", "<STR_LIT>", ",", "<STR_LIT>", ">", ";", "def", "op_sel_hi0", ":", "ArrayOperand0", "<STR_LIT>", ",", "<STR_LIT>", ">", ";", "def", "neg_lo0", ":", "ArrayOperand0", "<STR_LIT>", ",", "<STR_LIT>", ">", ";", "def", "neg_hi0", ":", "ArrayOperand0", "<STR_LIT>", ",", "<STR_LIT>", ">", ";", "<FIXE>" ]

[ "def", "src1_sel", ":", "SDWAOperand", "<STR_LIT>", ",", "<STR_LIT>", ">", ";", "def", "dst_unused", ":", "CustomOperand", "i32", ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "<BUGS>", "def", "op_sel0", ":", "NamedOperandU32Default0", "<STR_LIT>", ",", "NamedMatchClass", "<STR_LIT>", ">", ">", ";", "def", "op_sel_hi0", ":", "NamedOperandU32Default0", "<STR_LIT>", ",", "NamedMatchClass", "<STR_LIT>", ">", ">", ";", "def", "neg_lo0", ":", "NamedOperandU32Default0", "<STR_LIT>", ",", "NamedMatchClass", "<STR_LIT>", ">", ">", ";", "def", "neg_hi0", ":", "NamedOperandU32Default0", "<STR_LIT>", ",", "NamedMatchClass", "<STR_LIT>", ">", ">", ";", "<BUGE>", "def", "dpp8", ":", "CustomOperand", "i32", ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "def", "dpp_ctrl", ":", "CustomOperand", "i32", ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";" ]

[ ")", "return", ";" ]

[ "void", "SILowerControlFlowPass", "::", "Skip", "(", "MachineInstr", "&", "From", ",", "MachineOperand", "&", "To", ")", "{", "if", "(", "!", "shouldSkip", "(", "*", "From", ".", "getParent", "(", ")", "->", "succ_begin", "(", ")", ",", "To", ".", "getMBB", "(", ")", ")" ]

[ "mmask8", "_", "_", "U", ",", "_", "_", "m128i", "_", "_", "A", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_cvtepu16_epi32", "(", "_", "_" ]

[ "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "case", "ISD", "::", "SETGE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETLT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETLE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETULT", ":", "return" ]

[ "(", "_", "_", "v2df", ")", "_", "_", "B", ",", "_", "_", "R", ")", ";" ]

[ "return", "(", "_", "_", "m128d", ")", "_", "_", "builtin_ia32_getexpsd128_round", "(", "(", "_", "_", "v2df", ")", "_", "_", "A", "," ]

[ "let", "DiagnosticType", "=", "<STR_LIT>", ";" ]

[ "let", "Name", "=", "<STR_LIT>", ";", "let", "ParserMethod", "=", "<STR_LIT>", ";" ]

[ "==", "MEM", "&&", "!", "c4x_address_conflict", "(", "op1", ",", "op2", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "GET_CODE", "(", "op3", ")", "==", "SUBREG", ")", "op3", "=", "SUBREG_REG", "(", "op3", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "REG", "&&", "(", "(", "GET_CODE", "(", "op2", ")", "==", "MEM", "&&", "reg_mentioned_p", "(", "op0", ",", "XEXP", "(", "op2", ",", "<NUM_LIT>", ")", ")", ")", "||", "(", "GET_CODE", "(", "op3", ")", "==", "MEM", "&&", "reg_mentioned_p", "(", "op0", ",", "XEXP", "(", "op3", ",", "<NUM_LIT>", ")", ")", ")", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "REG", "&&", "GET_CODE", "(", "op2", ")", "==", "REG", ")", "return", "(", "REGNO", "(", "op0", ")", "!=", "REGNO", "(", "op2", ")", ")", "&&", "GET_CODE", "(", "op1", ")", "==", "MEM", "&&", "GET_CODE", "(", "op3", ")", "==", "MEM", "&&", "!", "c4x_address_conflict", "(", "op1", ",", "op3", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "REG", "&&", "GET_CODE", "(", "op3", ")", "==", "REG", ")", "return", "GET_CODE", "(", "op0", ")", "==", "MEM", "&&", "GET_CODE", "(", "op2", ")", "==", "MEM", "&&", "!", "c4x_address_conflict", "(", "op0", ",", "op2", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "REG", "&&", "GET_CODE", "(", "op3", ")", "==", "REG", ")", "return", "GET_CODE", "(", "op1", ")", "==", "MEM", "&&", "GET_CODE", "(", "op2", ")" ]

[ "BLK", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V16QI", "[", "(", "match_operand", ":" ]

[ "(", "v8i8", "V64", ":", "$", "Rd", ")", ",", "(", "OpNode", "(", "v8i8", "V64", ":", "$", "Rn", ")", ")", ")", "]", ">", ";" ]

[ "def", "v8i8", ":", "BaseSIMDTwoSameVector", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "opc", ",", "<NUM_LIT>", ",", "V64", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set" ]

[ "<STR_LIT>", ";" ]

[ "def", "A2_combine_hl", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rt32", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_3op", ">", ",", "Enc_bd6011", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "InputType", "=" ]

[ "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "def", "J4_tstbit0_t_jumpnv_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Ns8", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_8c945be0", ",", "TypeNCJ", ">", ",", "Enc_69d63b", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "emitWordLE", "(", "Binary", ")", ";" ]

[ "Binary", "|=", "getMachineOpValue", "(", "MI", ",", "OpIdx", "++", ")", "<<", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "TID", ".", "getNumOperands", "(", ")", ">", "OpIdx", "&&", "!", "TID", ".", "OpInfo", "[", "OpIdx", "]", ".", "isPredicate", "(", ")", "&&", "!", "TID", ".", "OpInfo", "[", "OpIdx", "]", ".", "isOptionalDef", "(", ")", ")", "Binary", "|=", "getMachineOpValue", "(", "MI", ",", "OpIdx", ")", "<<", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "let", "prefersSlot3", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "(", "match_operand", ":", "VI48_256", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VI48_256", "<NUM_LIT>", "<STR_LIT>", ")", "(", "ashift", ":", "VI48_256", "(", "match_operand", ":", "VI48_256", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ "setIsKill", "(", "false", ")", ";" ]

[ "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "bool", ">", ",", "<NUM_LIT>", ">", "Regs", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "ImpDefs", ";", "for", "(", "unsigned", "i", "=", "memOpsBegin", ";", "i", "<", "memOpsEnd", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "memOps", "[", "i", "]", ".", "Reg", ";", "bool", "isKill", "=", "memOps", "[", "i", "]", ".", "isKill", "||", "KilledRegs", ".", "count", "(", "Reg", ")", ";", "Regs", ".", "push_back", "(", "std", "::", "make_pair", "(", "Reg", ",", "isKill", ")", ")", ";", "for", "(", "MIOperands", "MO", "(", "memOps", "[", "i", "]", ".", "MBBI", ")", ";", "MO", ".", "isValid", "(", ")", ";", "++", "MO", ")", "{", "if", "(", "!", "MO", "->", "isReg", "(", ")", "||", "!", "MO", "->", "isDef", "(", ")", "||", "!", "MO", "->", "isImplicit", "(", ")", "||", "MO", "->", "isDead", "(", ")", ")", "continue", ";", "unsigned", "DefReg", "=", "MO", "->", "getReg", "(", ")", ";", "if", "(", "std", "::", "find", "(", "ImpDefs", ".", "begin", "(", ")", ",", "ImpDefs", ".", "end", "(", ")", ",", "DefReg", ")", "==", "ImpDefs", ".", "end", "(", ")", ")", "ImpDefs", ".", "push_back", "(", "DefReg", ")", ";", "}", "}", "MachineBasicBlock", "::", "iterator", "Loc", "=", "memOps", "[", "insertAfter", "]", ".", "MBBI", ";", "++", "Loc", ";", "if", "(", "!", "MergeOps", "(", "MBB", ",", "Loc", ",", "Offset", ",", "Base", ",", "BaseKill", ",", "Opcode", ",", "Pred", ",", "PredReg", ",", "Scratch", ",", "dl", ",", "Regs", ",", "ImpDefs", ")", ")", "return", ";", "Merges", ".", "push_back", "(", "prior", "(", "Loc", ")", ")", ";", "for", "(", "unsigned", "i", "=", "memOpsBegin", ";", "i", "<", "memOpsEnd", ";", "++", "i", ")", "{", "if", "(", "Regs", "[", "i", "-", "memOpsBegin", "]", ".", "second", ")", "{", "unsigned", "Reg", "=", "Regs", "[", "i", "-", "memOpsBegin", "]", ".", "first", ";", "if", "(", "KilledRegs", ".", "count", "(", "Reg", ")", ")", "{", "unsigned", "j", "=", "Killer", "[", "Reg", "]", ";", "int", "Idx", "=", "memOps", "[", "j", "]", ".", "MBBI", "->", "findRegisterUseOperandIdx", "(", "Reg", ",", "true", ")", ";", "assert", "(", "Idx", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Cannot find killing operand", "<STR_LIT>", ")", ";", "memOps", "[", "j", "]", ".", "MBBI", "->", "getOperand", "(", "Idx", ")", "." ]

[ "}" ]

[ "forest", "=", "root_node", "->", "get_forest", "(", ")", ";", "node", "=", "root_node", ";", "this", "->", "m_fma_forests", ".", "push_back", "(", "forest", ")", ";", "}", "else", "forest", "=", "node", "->", "get_forest", "(", ")", ";", "node", "->", "set_head", "(", "head", ")", ";", "if", "(", "ref_forest", ")", "{", "ref_forest", "->", "merge_forest", "(", "forest", ")", ";", "return", ";", "}", "for", "(", "chain", "=", "head", "->", "first", ";", "chain", ";", "chain", "=", "chain", "->", "next_use", ")", "{", "fma_node", "*", "child_fma", ";", "rtx", "fma_rtx", ",", "*", "accum_rtx_p", ";", "if", "(", "!", "is_fmul_fmac_insn", "(", "chain", "->", "insn", ",", "false", ")", ")", "continue", ";", "fma_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "chain", "->", "insn", ")", ")", ";", "if", "(", "GET_CODE", "(", "fma_rtx", ")", "==", "NEG", ")", "fma_rtx", "=", "XEXP", "(", "fma_rtx", ",", "<NUM_LIT>", ")", ";", "accum_rtx_p", "=", "&", "XEXP", "(", "fma_rtx", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "REG_P", "(", "*", "accum_rtx_p", ")", ")", "accum_rtx_p", "=", "&", "XEXP", "(", "*", "accum_rtx_p", ",", "<NUM_LIT>", ")", ";", "if", "(", "accum_rtx_p", "!=", "chain", "->", "loc", ")", "continue", ";", "if", "(", "this", "->", "get_fma_node", "(", "chain", "->", "insn", ")", ")", "continue", ";", "child_fma", "=", "new", "fma_node", "(", "node", ",", "chain", ")", ";", "node", "->", "add_child", "(", "child_fma", ")", ";", "}" ]

[ "}" ]

[ "def", "am_indexed128simm7", ":", "Operand", "<", "i32", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "MemoryIndexed128SImm7", ";", "let", "MIOperandInfo", "=", "(", "ops", "GPR64sp", ":", "$", "base", ",", "i32imm", ":", "$", "offset", ")", ";" ]

[ "}" ]

[ "void", "aarch64_init_expanders", "(", "void", ")", "{", "init_machine_status", "=", "aarch64_init_machine_status", ";" ]

[ "stream", ")", ";" ]

[ "fputs", "(", "GLOBAL_ASM_OP", ",", "stream", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "stream", ",", "name", ")", ";", "putc", "(", "'", "\\n", "'", "," ]

[ ")", "]", ")" ]

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>" ]

[ "xops", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "DImode", ",", "<NUM_LIT>", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "{", "rtx", "xops", "[", "<NUM_LIT>", "]", "xops", "[", "<NUM_LIT>", "]", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "xops", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "DImode", ",", "<NUM_LIT>", ")", "xops", "[", "<NUM_LIT>", "]", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "_", "_", "v4di", ")", "_", "_", "Y", ")", ";" ]

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_psllv4di", "(", "(", "_", "_", "v4di", ")", "_", "_", "X", ",", "(" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "MB_ABI_ASM_TEMP_REGNUM", ")" ]

[ "(", "if_then_else", "(", "match_operator", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", ")", ")", "(", "pc", ")", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "R_TMP", ")", ")", "]", "<STR_LIT>", "{" ]

[ "}" ]

[ "if", "(", "!", "FoldingImm", "&&", "!", "OpToFold", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "OpToFold", ".", "isReg", "(", ")", "&&", "!", "OpToFold", ".", "getReg", "(", ")", ".", "isVirtual", "(", ")", ")", "continue", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ".", "isVirtual", "(", ")", ")", "continue", ";", "Changed", "|=", "foldInstOperand", "(", "MI", ",", "OpToFold", ")", ";", "auto", "*", "InstToErase", "=", "&", "MI", ";", "while", "(", "MRI", "->", "use_nodbg_empty", "(", "InstToErase", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "{", "auto", "&", "SrcOp", "=", "InstToErase", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "auto", "SrcReg", "=", "SrcOp", ".", "isReg", "(", ")", "?", "SrcOp", ".", "getReg", "(", ")", ":", "Register", "(", ")", ";", "InstToErase", "->", "eraseFromParent", "(", ")", ";", "Changed", "=", "true", ";", "InstToErase", "=", "nullptr", ";", "if", "(", "!", "SrcReg", "||", "SrcReg", ".", "isPhysical", "(", ")", ")", "break", ";", "InstToErase", "=", "MRI", "->", "getVRegDef", "(", "SrcReg", ")", ";", "if", "(", "!", "InstToErase", "||", "!", "TII", "->", "isFoldableCopy", "(", "*", "InstToErase", ")", ")", "break", ";", "}", "if", "(", "InstToErase", "&&", "InstToErase", "->", "isRegSequence", "(", ")", "&&", "MRI", "->", "use_nodbg_empty", "(", "InstToErase", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "{", "InstToErase", "->", "eraseFromParent", "(", ")", ";", "Changed", "=", "true", ";", "}" ]

[ "return", "false", ";" ]

[ "if", "(", "nregs", ">", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "regno", "<", "CSKY_NGPR_REGS", ")", "{", "if", "(", "nregs", "<", "<NUM_LIT>", ")", "return", "true", ";", "else", "if", "(", "TARGET_MINI_REGISTERS", ")", "return", "(", "regno", "<", "CSKY_LAST_MINI_REGNUM", ")", ";", "else", "if", "(", "CSKY_TARGET_ARCH", "(", "CK802", ")", "||", "CSKY_TARGET_ARCH", "(", "CK803", ")", "||", "!", "TARGET_HIGH_REGISTERS", ")", "return", "(", "regno", "<", "(", "CSKY_SP_REGNUM", "-", "<NUM_LIT>", ")", ")", ";", "else", "return", "(", "regno", "<", "(", "CSKY_SP_REGNUM", "-", "<NUM_LIT>", ")", "||", "(", "regno", ">=", "CSKY_LR_REGNUM", "&&", "regno", "<", "CSKY_LAST_HIGH_UNFIXED_REGNUM", ")", ")", ";", "}", "else", "if", "(", "regno", "==", "CSKY_CC_REGNUM", ")", "return", "(", "mode", "==", "CCmode", ")", ";", "else", "if", "(", "regno", "==", "CSKY_HI_REGNUM", "||", "regno", "==", "CSKY_LO_REGNUM", ")", "{", "if", "(", "!", "TARGET_DSP", "||", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", "return", "false", ";", "else", "if", "(", "nregs", "==", "<NUM_LIT>", ")", "return", "(", "regno", "==", "CSKY_HI_REGNUM", ")", ";", "else", "return", "true", ";", "}", "else", "if", "(", "CSKY_VREG_P", "(", "regno", ")", "&&", "TARGET_HARD_FLOAT", ")", "return", "true", ";" ]

[ "bool", "MipsCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "!", "isSupportedArgumentType", "(", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "}", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "<NUM_LIT>", ">", "ArgInfos", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "OrigArgIndices", ";", "unsigned", "i", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "AInfo", "(", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "AInfo", ",", "i", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "ArgInfos", ".", "push_back", "(", "AInfo", ")", ";", "OrigArgIndices", ".", "push_back", "(", "i", ")", ";", "++", "i", ";", "}", "SmallVector", "<", "ISD", "::", "InputArg", ",", "<NUM_LIT>", ">", "Ins", ";", "subTargetRegTypeForCallingConv", "(", "F", ",", "ArgInfos", ",", "OrigArgIndices", ",", "Ins", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "const", "MipsTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "const", "MipsABIInfo", "&", "ABI", "=", "TM", ".", "getABI", "(", ")", ";", "CCInfo", ".", "AllocateStack", "(", "ABI", ".", "GetCalleeAllocdArgSizeInBytes", "(", "F", ".", "getCallingConv", "(", ")", ")", ",", "Align", "(", "<NUM_LIT>", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "TLI", ".", "CCAssignFnForCall", "(", ")", ")", ";", "setLocInfo", "(", "ArgLocs", ",", "Ins", ")", ";", "MipsIncomingValueHandler", "Handler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ")", ";", "if", "(", "!", "Handler", ".", "handle", "(", "ArgLocs", ",", "ArgInfos", ")", ")", "return", "false", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "ArrayRef", "<", "MCPhysReg", ">", "ArgRegs", "=", "ABI", ".", "GetVarArgRegs", "(", ")", ";", "unsigned", "Idx", "=", "CCInfo", ".", "getFirstUnallocated", "(", "ArgRegs", ")", ";", "int", "VaArgOffset", ";", "unsigned", "RegSize", "=", "<NUM_LIT>", ";", "if", "(", "ArgRegs", ".", "size", "(", ")", "==", "Idx", ")", "VaArgOffset", "=", "alignTo", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", ",", "RegSize", ")", ";", "else", "{", "VaArgOffset", "=", "(", "int", ")", "ABI", ".", "GetCalleeAllocdArgSizeInBytes", "(", "CCInfo", ".", "getCallingConv", "(", ")", ")", "-", "(", "int", ")", "(", "RegSize", "*", "(", "ArgRegs", ".", "size", "(", ")", "-", "Idx", ")", ")", ";", "}", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "RegSize", ",", "VaArgOffset", ",", "true", ")", ";", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "setVarArgsFrameIndex", "(", "FI", ")", ";", "for", "(", "unsigned", "I", "=", "Idx", ";", "I", "<", "ArgRegs", ".", "size", "(", ")", ";", "++", "I", ",", "VaArgOffset", "+=", "RegSize", ")", "{", "MIRBuilder", ".", "getMBB", "(", ")", ".", "addLiveIn", "(", "ArgRegs", "[", "I", "]", ")", ";", "MachineInstrBuilder", "Copy", "=", "MIRBuilder", ".", "buildCopy", "(", "LLT", "::", "scalar", "(", "RegSize", "*", "<NUM_LIT>", ")", ",", "Register", "(", "ArgRegs", "[", "I", "]", ")", ")", ";", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "RegSize", ",", "VaArgOffset", ",", "true", ")", ";", "MachinePointerInfo", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ";", "MachineInstrBuilder", "FrameIndex", "=", "MIRBuilder", ".", "buildFrameIndex", "(", "LLT", "::", "pointer", "(", "MPO", ".", "getAddrSpace", "(", ")", ",", "<NUM_LIT>", ")", ",", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOStore", ",", "RegSize", ",", "Align", "(", "RegSize", ")", ")", ";", "MIRBuilder", ".", "buildStore", "(", "Copy", ",", "FrameIndex", ",", "*", "MMO", ")", ";", "}", "}", "return", "true", ";", "}" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "<FIXS>", "class", "EffectiveAddress", "string", "opstr", ",", "RegisterOperand", "RO", ">", ":", "InstSE", "(", "outs", "RO", ":", "$", "rt", ")", ",", "(", "ins", "mem_ea", ":", "$", "addr", ")", ",", "!", "strconcat", "(", "opstr", ",", "<STR_LIT>", ")", ",", "<FIXE>" ]

[ "let", "neverHasSideEffects", "=", "<NUM_LIT>", ";", "}", "<BUGS>", "class", "EffectiveAddress", "string", "opstr", ",", "RegisterOperand", "RO", ",", "Operand", "Mem", ">", ":", "InstSE", "(", "outs", "RO", ":", "$", "rt", ")", ",", "(", "ins", "Mem", ":", "$", "addr", ")", ",", "!", "strconcat", "(", "opstr", ",", "<STR_LIT>", ")", ",", "<BUGE>", "[", "(", "set", "RO", ":", "$", "rt", ",", "addr", ":", "$", "addr", ")", "]", ",", "NoItinerary", ",", "FrmI", ">", "{", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "reg", ":", "CCVFH", "CC_REGNUM", ")", "(", "compare", ":", "CCVFH", "(", "match_operand", ":", "VF_HW", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VF_HW", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "<", "tointvec", ">", "<NUM_LIT>" ]