Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "<FIXE>", "<FIXS>", "if", "(", "Pred", "!=", "CmpInst", "::", "Predicate", "::", "ICMP_EQ", "&&", "Pred", "!=", "CmpInst", "::", "Predicate", "::", "ICMP_NE", ")", "<FIXE>" ]

[ "return", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "*", "MIB", ".", "getMRI", "(", ")", ";", "<BUGS>", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "<BUGE>", "Register", "TestReg", "=", "AndInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<BUGS>", "unsigned", "TestSize", "=", "MRI", ".", "getType", "(", "TestReg", ")", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Pred", "==", "CmpInst", "::", "Predicate", "::", "ICMP_EQ", ")", "Opc", "=", "TestSize", "==", "<NUM_LIT>", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "Pred", "==", "CmpInst", "::", "Predicate", "::", "ICMP_NE", ")", "Opc", "=", "TestSize", "==", "<NUM_LIT>", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "<BUGE>", "return", "false", ";" ]

[ "}" ]

[ "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", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]

[ "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isBarrier", "=", "<NUM_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=" ]

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

[ "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

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

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

[ "if", "(", "sort", "[", "i", "]", ".", "rewrite", ")", "{" ]

[ "sort", "[", "i", "]", ".", "offset", "=", "o", ";", "sort", "[", "i", "]", ".", "reg", "=", "reg", ";", "sort", "[", "i", "]", ".", "mem", "=", "mem", ";", "}", "if", "(", "load_p", "&&", "(", "regmask", "&", "usemask", ")", ")", "return", "false", ";", "qsort", "(", "sort", ",", "n", ",", "sizeof", "(", "struct", "ldstwm_operand", ")", ",", "compare_ldstwm_operands", ")", ";", "baseoffset", "=", "sort", "[", "<NUM_LIT>", "]", ".", "offset", ";", "needscratch", "=", "baseoffset", "!=", "<NUM_LIT>", ";", "if", "(", "needscratch", "&&", "!", "scratch", ")", "return", "false", ";", "lastreg", "=", "regmask", "=", "regset", "=", "<NUM_LIT>", ";", "lastoffset", "=", "baseoffset", ";", "for", "(", "m", "=", "<NUM_LIT>", ";", "m", "<", "n", "&&", "!", "sort", "[", "m", "]", ".", "bad", ";", "m", "++", ")", "{", "int", "thisreg", "=", "REGNO", "(", "sort", "[", "m", "]", ".", "reg", ")", ";", "if", "(", "sort", "[", "m", "]", ".", "offset", "!=", "lastoffset", "||", "(", "m", ">", "<NUM_LIT>", "&&", "lastreg", ">=", "thisreg", ")", "||", "!", "nios2_ldstwm_regset_p", "(", "thisreg", ",", "&", "regset", ")", ")", "break", ";", "lastoffset", "+=", "<NUM_LIT>", ";", "lastreg", "=", "thisreg", ";", "regmask", "|=", "(", "<NUM_LIT>", "<<", "thisreg", ")", ";", "}", "if", "(", "load_p", "&&", "needscratch", "&&", "(", "(", "<NUM_LIT>", "<<", "REGNO", "(", "scratch", ")", ")", "&", "regmask", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "new", "basereg", "=", "needscratch", "?", "(", "int", ")", "REGNO", "(", "scratch", ")", ":", "basereg", ";", "if", "(", "m", "<", "<NUM_LIT>", ")", "{", "if", "(", "!", "needscratch", ")", "return", "false", ";", "m", "=", "<NUM_LIT>", ";", "nbytes", "=", "<NUM_LIT>", ";", "}", "else", "nbytes", "=", "-", "<NUM_LIT>", ";", "if", "(", "needscratch", ")", "{", "int", "bo", "=", "baseoffset", ">", "<NUM_LIT>", "?", "baseoffset", ":", "-", "baseoffset", ";", "if", "(", "CDX_REG_P", "(", "new", "basereg", ")", "&&", "CDX_REG_P", "(", "basereg", ")", "&&", "bo", "<=", "<NUM_LIT>", "&&", "bo", ">", "<NUM_LIT>", "&&", "(", "bo", "&", "(", "bo", "-", "<NUM_LIT>", ")", ")", "==", "<NUM_LIT>", ")", "nbytes", "-=", "<NUM_LIT>", ";", "else", "nbytes", "-=", "<NUM_LIT>", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "m", ";", "i", "++", ")", "if", "(", "can_use_cdx_ldstw", "(", "REGNO", "(", "sort", "[", "i", "]", ".", "reg", ")", ",", "basereg", ",", "sort", "[", "i", "]", ".", "offset", ")", ")", "nbytes", "+=", "<NUM_LIT>", ";", "else", "nbytes", "+=", "<NUM_LIT>", ";", "if", "(", "needscratch", "&&", "CDX_REG_P", "(", "new", "basereg", ")", ")", "for", "(", "i", "=", "m", ";", "i", "<", "n", "&&", "!", "sort", "[", "i", "]", ".", "bad", ";", "i", "++", ")", "if", "(", "!", "can_use_cdx_ldstw", "(", "REGNO", "(", "sort", "[", "i", "]", ".", "reg", ")", ",", "basereg", ",", "sort", "[", "i", "]", ".", "offset", ")", "&&", "can_use_cdx_ldstw", "(", "REGNO", "(", "sort", "[", "i", "]", ".", "reg", ")", ",", "new", "basereg", ",", "sort", "[", "i", "]", ".", "offset", "-", "baseoffset", ")", ")", "{", "sort", "[", "i", "]", ".", "rewrite", "=", "true", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "if", "(", "nbytes", "<=", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "needscratch", ")", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "XEXP", "(", "sort", "[", "<NUM_LIT>", "]", ".", "mem", ",", "<NUM_LIT>", ")", ")", ")", ";", "if", "(", "m", ">", "<NUM_LIT>", ")", "{", "rtvec", "p", "=", "rtvec_alloc", "(", "m", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "m", ";", "i", "++", ")", "{", "int", "offset", "=", "sort", "[", "i", "]", ".", "offset", ";", "rtx", "mem", ",", "reg", "=", "sort", "[", "i", "]", ".", "reg", ";", "rtx", "base_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "new", "basereg", ")", ";", "if", "(", "needscratch", ")", "offset", "-=", "baseoffset", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "base_reg", ",", "offset", ")", ")", ";", "if", "(", "load_p", ")", "RTVEC_ELT", "(", "p", ",", "i", ")", "=", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "else", "RTVEC_ELT", "(", "p", ",", "i", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "}", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ")", ";", "}", "for", "(", "i", "=", "m", ";", "i", "<", "n", ";", "i", "++", ")", "{", "rtx", "reg", "=", "sort", "[", "i", "]", ".", "reg", ";", "rtx", "mem", "=", "sort", "[", "i", "]", ".", "mem", ";" ]

[ "false", ";" ]

[ "AMDGPUMCAsmInfo", "::", "AMDGPUMCAsmInfo", "(", "StringRef", "&", "TT", ")", ":", "MCAsmInfo", "(", ")", "{", "HasSingleParameterDotFile", "=", "false", ";", "WeakDefDirective", "=", "<NUM_LIT>", ";", "HasSubsectionsViaSymbols", "=", "true", ";", "HasMachoZeroFillDirective", "=", "false", ";", "HasMachoTBSSDirective", "=", "false", ";", "HasStaticCtorDtorReferenceInStaticMode", "=", "false", ";", "LinkerRequiresNonEmptyDwarfLines", "=", "true", ";", "MaxInstLength", "=", "<NUM_LIT>", ";", "SeparatorString", "=", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "CommentColumn", "=", "<NUM_LIT>", ";", "CommentString", "=", "<STR_LIT>", ";", "<STR_LIT>", ";", "LabelSuffix", "=", "<STR_LIT>", ":", "<STR_LIT>", ";", "GlobalPrefix", "=", "<STR_LIT>", "@", "<STR_LIT>", ";", "PrivateGlobalPrefix", "=", "<STR_LIT>", ";.", "<STR_LIT>", ";", "LinkerPrivateGlobalPrefix", "=", "<STR_LIT>", "!", "<STR_LIT>", ";", "InlineAsmStart", "=", "<STR_LIT>", ";#ASMSTART", "<STR_LIT>", ";", "InlineAsmEnd", "=", "<STR_LIT>", ";#ASMEND", "<STR_LIT>", ";", "AssemblerDialect", "=", "<NUM_LIT>", ";", "AllowQuotesInName", "=", "false", ";", "AllowNameToStartWithDigit", "=", "false", ";", "AllowPeriodsInName", "=", "false", ";", "ZeroDirective", "=", "<STR_LIT>", ".zero", "<STR_LIT>", ";", "AsciiDirective", "=", "<STR_LIT>", ".ascii\\t", "<STR_LIT>", ";", "AscizDirective", "=", "<STR_LIT>", ".asciz\\t", "<STR_LIT>", ";", "Data8bitsDirective", "=", "<STR_LIT>", ".byte\\t", "<STR_LIT>", ";", "Data16bitsDirective", "=", "<STR_LIT>", ".short\\t", "<STR_LIT>", ";", "Data32bitsDirective", "=", "<STR_LIT>", ".long\\t", "<STR_LIT>", ";", "Data64bitsDirective", "=", "<STR_LIT>", ".quad\\t", "<STR_LIT>", ";", "GPRel32Directive", "=", "<NUM_LIT>", ";", "SunStyleELFSectionSwitchSyntax", "=", "true", ";", "UsesELFSectionDirectiveForBSS", "=", "true", ";", "HasMicrosoftFastStdCallMangling", "=" ]

[ ")", "]" ]

[ "(", "unspec", ":", "DI", "[", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_INSN_FDOUBLE_ADD_FLAGS", ")" ]

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

[ "(", "ior", "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")", ")" ]

[ "auto", "&", "CPEs", "=", "CPEntries", "[", "CPEntryIdx", "]", ";" ]

[ "MachineBasicBlock", "*", "MBB", "=", "JTBBs", "[", "j", "]", ";", "unsigned", "DstOffset", "=", "BBInfo", "[", "MBB", "->", "getNumber", "(", ")", "]", ".", "Offset", ";", "if", "(", "ByteOk", "&&", "(", "DstOffset", "-", "JTOffset", ")", ">", "(", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ")", "ByteOk", "=", "false", ";", "unsigned", "TBHLimit", "=", "(", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ";", "if", "(", "HalfWordOk", "&&", "(", "DstOffset", "-", "JTOffset", ")", ">", "TBHLimit", ")", "HalfWordOk", "=", "false", ";", "if", "(", "!", "ByteOk", "&&", "!", "HalfWordOk", ")", "break", ";", "}", "if", "(", "!", "ByteOk", "&&", "!", "HalfWordOk", ")", "continue", ";", "CPUser", "&", "User", "=", "CPUsers", "[", "JumpTableUserIndices", "[", "JTI", "]", "]", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "if", "(", "!", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ")", "continue", ";", "unsigned", "DeadSize", "=", "<NUM_LIT>", ";", "bool", "CanDeleteLEA", "=", "false", ";", "bool", "BaseRegKill", "=", "false", ";", "unsigned", "IdxReg", "=", "~", "<NUM_LIT>", "U", ";", "bool", "IdxRegKill", "=", "true", ";", "if", "(", "isThumb2", ")", "{", "IdxReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "IdxRegKill", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ";", "bool", "PreservedBaseReg", "=", "preserveBaseRegister", "(", "MI", ",", "User", ".", "MI", ",", "DeadSize", ",", "CanDeleteLEA", ",", "BaseRegKill", ")", ";", "if", "(", "!", "jumpTableFollowsTB", "(", "MI", ",", "User", ".", "CPEMI", ")", "&&", "!", "PreservedBaseReg", ")", "continue", ";", "}", "else", "{", "unsigned", "BaseReg", "=", "User", ".", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "User", ".", "MI", "->", "getIterator", "(", ")", "==", "User", ".", "MI", "->", "getParent", "(", ")", "->", "begin", "(", ")", ")", "continue", ";", "MachineInstr", "*", "Shift", "=", "User", ".", "MI", "->", "getPrevNode", "(", ")", ";", "if", "(", "Shift", "->", "getOpcode", "(", ")", "!=", "ARM", "::", "tLSLri", "||", "Shift", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "!=", "<NUM_LIT>", "||", "!", "Shift", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ")", "continue", ";", "IdxReg", "=", "Shift", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "ShiftedIdxReg", "=", "Shift", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "BaseReg", "==", "IdxReg", "&&", "!", "jumpTableFollowsTB", "(", "MI", ",", "User", ".", "CPEMI", ")", ")", "continue", ";", "MachineInstr", "*", "Load", "=", "User", ".", "MI", "->", "getNextNode", "(", ")", ";", "if", "(", "Load", "->", "getOpcode", "(", ")", "!=", "ARM", "::", "tLDRr", ")", "continue", ";", "if", "(", "Load", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "!=", "BaseReg", "||", "Load", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "!=", "ShiftedIdxReg", "||", "!", "Load", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ")", "continue", ";", "auto", "*", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "if", "(", "registerDefinedBetween", "(", "BaseReg", ",", "Load", "->", "getNextNode", "(", ")", ",", "MBB", "->", "end", "(", ")", ",", "TRI", ")", ")", "continue", ";", "if", "(", "isPositionIndependentOrROPI", ")", "{", "MachineInstr", "*", "Add", "=", "Load", "->", "getNextNode", "(", ")", ";", "if", "(", "Add", "->", "getOpcode", "(", ")", "!=", "ARM", "::", "tADDrr", "||", "Add", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "!=", "BaseReg", "||", "Add", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "!=", "Load", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "||", "!", "Add", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ")", "continue", ";", "if", "(", "Add", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "!=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "continue", ";", "if", "(", "registerDefinedBetween", "(", "IdxReg", ",", "Add", "->", "getNextNode", "(", ")", ",", "MI", ",", "TRI", ")", ")", "continue", ";", "Add", "->", "eraseFromParent", "(", ")", ";", "DeadSize", "+=", "<NUM_LIT>", ";", "}", "else", "{", "if", "(", "Load", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "!=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "continue", ";", "if", "(", "registerDefinedBetween", "(", "IdxReg", ",", "Load", "->", "getNextNode", "(", ")", ",", "MI", ",", "TRI", ")", ")", "continue", ";", "}", "CanDeleteLEA", "=", "true", ";", "Shift", "->", "eraseFromParent", "(", ")", ";", "Load", "->", "eraseFromParent", "(", ")", ";", "DeadSize", "+=", "<NUM_LIT>", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Shrink JT: ", "<STR_LIT>", "<<", "*", "MI", ")", ";", "MachineInstr", "*", "CPEMI", "=", "User", ".", "CPEMI", ";", "unsigned", "Opc", "=", "ByteOk", "?", "ARM", "::", "t2TBB_JT", ":", "ARM", "::", "t2TBH_JT", ";", "if", "(", "!", "isThumb2", ")", "Opc", "=", "ByteOk", "?", "ARM", "::", "tTBB_JT", ":", "ARM", "::", "tTBH_JT", ";", "MachineBasicBlock", "::", "iterator", "MI_JT", "=", "MI", ";", "MachineInstr", "*", "NewJTMI", "=", "BuildMI", "(", "*", "MBB", ",", "MI_JT", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "User", ".", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "getKillRegState", "(", "BaseRegKill", ")", ")", ".", "addReg", "(", "IdxReg", ",", "getKillRegState", "(", "IdxRegKill", ")", ")", ".", "addJumpTableIndex", "(", "JTI", ",", "JTOP", ".", "getTargetFlags", "(", ")", ")", ".", "addImm", "(", "CPEMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "printMBBReference", "(", "*", "MBB", ")", "<<", "<STR_LIT>", ": ", "<STR_LIT>", "<<", "*", "NewJTMI", ")", ";", "unsigned", "JTOpc", "=", "ByteOk", "?", "ARM", "::", "JUMPTABLE_TBB", ":", "ARM", "::", "JUMPTABLE_TBH", ";", "CPEMI", "->", "setDesc", "(", "TII", "->", "get", "(", "JTOpc", ")", ")", ";", "if", "(", "jumpTableFollowsTB", "(", "MI", ",", "User", ".", "CPEMI", ")", ")", "{", "NewJTMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "ARM", "::", "PC", ")", ";", "NewJTMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsKill", "(", "false", ")", ";", "if", "(", "CanDeleteLEA", ")", "{", "if", "(", "isThumb2", ")", "RemoveDeadAddBetweenLEAAndJT", "(", "User", ".", "MI", ",", "MI", ",", "DeadSize", ")", ";", "User", ".", "MI", "->", "eraseFromParent", "(", ")", ";", "DeadSize", "+=", "isThumb2", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "User", ".", "MI", "=", "NewJTMI", ";", "User", ".", "MaxDisp", "=", "<NUM_LIT>", ";", "User", ".", "NegOk", "=", "false", ";", "User", ".", "IsSoImm", "=", "false", ";", "User", ".", "KnownAlignment", "=", "false", ";", "}", "else", "{", "int", "CPEntryIdx", "=", "JumpTableEntryIndices", "[", "JTI", "]", ";" ]

[ "SDLoc", "DL", "(", "Extract", ")", ";" ]

[ "unsigned", "RegSize", "=", "<NUM_LIT>", ";", "if", "(", "Subtarget", ".", "useBWIRegs", "(", ")", ")", "RegSize", "=", "<NUM_LIT>", ";", "else", "if", "(", "Subtarget", ".", "hasAVX", "(", ")", ")", "RegSize", "=", "<NUM_LIT>", ";", "if", "(", "RegSize", "/", "VT", ".", "getVectorNumElements", "(", ")", "<", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "ISD", "::", "NodeType", "BinOp", ";", "SDValue", "Root", "=", "DAG", ".", "matchBinOpReduction", "(", "Extract", ",", "BinOp", ",", "{", "ISD", "::", "ADD", "}", ")", ";", "if", "(", "Root", "&&", "(", "Root", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND", "||", "Root", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ZERO_EXTEND", "||", "Root", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ANY_EXTEND", ")", ")", "Root", "=", "Root", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "Root", "||", "Root", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "ABS", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Zext0", ",", "Zext1", ";", "if", "(", "!", "detectZextAbsDiff", "(", "Root", ",", "Zext0", ",", "Zext1", ")", ")", "return", "SDValue", "(", ")", ";" ]

[ "if", "(", "StoreNode", "->", "isIndexed", "(", ")", ")", "{" ]

[ "EVT", "MemVT", "=", "StoreNode", "->", "getMemoryVT", "(", ")", ";", "EVT", "PtrVT", "=", "Ptr", ".", "getValueType", "(", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "const", "bool", "TruncatingStore", "=", "StoreNode", "->", "isTruncatingStore", "(", ")", ";", "if", "(", "(", "AS", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", "||", "TruncatingStore", ")", "&&", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "(", "AS", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", "&&", "TruncatingStore", ")", "{", "SDValue", "NewChain", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "SDValue", "NewStore", "=", "DAG", ".", "getTruncStore", "(", "NewChain", ",", "DL", ",", "Value", ",", "Ptr", ",", "StoreNode", "->", "getPointerInfo", "(", ")", ",", "MemVT", ",", "StoreNode", "->", "getAlignment", "(", ")", ",", "StoreNode", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ",", "StoreNode", "->", "getAAInfo", "(", ")", ")", ";", "StoreNode", "=", "cast", "<", "StoreSDNode", ">", "(", "NewStore", ")", ";", "}", "return", "scalarizeVectorStore", "(", "StoreNode", ",", "DAG", ")", ";", "}", "Align", "Alignment", "=", "StoreNode", "->", "getAlign", "(", ")", ";", "if", "(", "Alignment", "<", "MemVT", ".", "getStoreSize", "(", ")", "&&", "!", "allowsMisalignedMemoryAccesses", "(", "MemVT", ",", "AS", ",", "Alignment", ".", "value", "(", ")", ",", "StoreNode", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ",", "nullptr", ")", ")", "{", "return", "expandUnalignedStore", "(", "StoreNode", ",", "DAG", ")", ";", "}", "SDValue", "DWordAddr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "PtrVT", ",", "Ptr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "PtrVT", ")", ")", ";", "if", "(", "AS", "==", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ")", "{", "if", "(", "TruncatingStore", ")", "{", "assert", "(", "VT", ".", "bitsLE", "(", "MVT", "::", "i32", ")", ")", ";", "SDValue", "MaskConstant", ";", "if", "(", "MemVT", "==", "MVT", "::", "i8", ")", "{", "MaskConstant", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "}", "else", "{", "assert", "(", "MemVT", "==", "MVT", "::", "i16", ")", ";", "assert", "(", "StoreNode", "->", "getAlignment", "(", ")", ">=", "<NUM_LIT>", ")", ";", "MaskConstant", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "}", "SDValue", "ByteIndex", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "PtrVT", ",", "Ptr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "PtrVT", ")", ")", ";", "SDValue", "BitShift", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "VT", ",", "ByteIndex", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "VT", ")", ")", ";", "SDValue", "Mask", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "VT", ",", "MaskConstant", ",", "BitShift", ")", ";", "SDValue", "TruncValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "VT", ",", "Value", ",", "MaskConstant", ")", ";", "SDValue", "ShiftedValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "VT", ",", "TruncValue", ",", "BitShift", ")", ";", "SDValue", "Src", "[", "<NUM_LIT>", "]", "=", "{", "ShiftedValue", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "Mask", "}", ";", "SDValue", "Input", "=", "DAG", ".", "getBuildVector", "(", "MVT", "::", "v4i32", ",", "DL", ",", "Src", ")", ";", "SDValue", "Args", "[", "<NUM_LIT>", "]", "=", "{", "Chain", ",", "Input", ",", "DWordAddr", "}", ";", "return", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Op", "->", "getVTList", "(", ")", ",", "Args", ",", "MemVT", ",", "StoreNode", "->", "getMemOperand", "(", ")", ")", ";", "}", "else", "if", "(", "Ptr", "->", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", "&&", "VT", ".", "bitsGE", "(", "MVT", "::", "i32", ")", ")", "{", "Ptr", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "PtrVT", ",", "DWordAddr", ")", ";" ]

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

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

[ "}" ]

[ "assert", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected vector size for 128bit shuffle.", "<STR_LIT>", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "WidenedMask", ";", "if", "(", "!", "canWidenShuffleElements", "(", "Mask", ",", "WidenedMask", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "PermMask", "=", "<NUM_LIT>", ",", "Imm", "=", "<NUM_LIT>", ";", "unsigned", "ControlBitsNum", "=", "WidenedMask", ".", "size", "(", ")", "/", "<NUM_LIT>", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "Size", "=", "WidenedMask", ".", "size", "(", ")", ";", "i", "<", "Size", ";", "++", "i", ")", "{", "if", "(", "WidenedMask", "[", "i", "]", "==", "SM_SentinelZero", ")", "return", "SDValue", "(", ")", ";", "Imm", "=", "(", "WidenedMask", "[", "i", "]", "==", "SM_SentinelUndef", ")", "?", "<NUM_LIT>", ":", "WidenedMask", "[", "i", "]", ";", "PermMask", "|=", "(", "Imm", "%", "WidenedMask", ".", "size", "(", ")", ")", "<<", "(", "i", "*", "ControlBitsNum", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "V1", ",", "V2", ",", "DAG", ".", "getConstant", "(", "PermMask", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";" ]

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

[ "def", "C4_or_orn", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps4", ",", "PredRegs", ":", "$", "Pt4", ",", "PredRegs", ":", "$", "Pu4", ")", ",", "<STR_LIT>", ",", "tc_b31c2e97", ",", "TypeCR", ">", ",", "Enc_9ac432", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "if", "(", "CONSTANT_P", "(", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "(", "set", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "GPR", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", ")", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "ne", "(", "reg", ":", "CCO", "CC_REGNUM", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", ")", ")", "(", "pc", ")", ")", ")", "]", "<STR_LIT>", "{" ]

[ "}" ]

[ "const", "TargetRegisterClass", "*", "SIRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "AMDGPU", "::", "VGPR_32RegClass", ";" ]

[ ";" ]

[ "machine_mode", "mode", ",", "part_mode", ";", "int", "def", ";", "int", "part", ",", "part_goal", ";", "if", "(", "str", "[", "<NUM_LIT>", "]", "==", "'", "x", "'", ")", "part_goal", "=", "-", "<NUM_LIT>", ";", "else", "part_goal", "=", "str", "[", "<NUM_LIT>", "]", "-", "'", "<NUM_LIT>", "'", ";", "switch", "(", "str", "[", "<NUM_LIT>", "]", ")", "{", "case", "'", "Q", "'", ":", "part_mode", "=", "QImode", ";", "break", ";", "case", "'", "H", "'", ":", "part_mode", "=", "HImode", ";", "break", ";", "case", "'", "S", "'", ":", "part_mode", "=", "SImode", ";", "break", ";", "default", ":", "return", "<NUM_LIT>", ";", "}", "switch", "(", "str", "[", "<NUM_LIT>", "]", ")", "{", "case", "'", "H", "'", ":", "mode", "=", "HImode", ";", "break", ";", "case", "'", "S", "'", ":", "mode", "=", "SImode", ";", "break", ";", "case", "'", "D", "'", ":", "mode", "=", "DImode", ";", "break", ";", "default", ":", "return", "<NUM_LIT>", ";", "}", "switch", "(", "str", "[", "<NUM_LIT>", "]", ")", "{", "case", "'", "<NUM_LIT>", "'", ":", "def", "=", "<NUM_LIT>", ";", "break", ";", "case", "'", "F", "'", ":", "def", "=", "-", "<NUM_LIT>", ";", "break", ";", "default", ":", "return", "<NUM_LIT>" ]

[ "<FIXS>", "(", "neg", ":", "SI", "(", "plus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CCC", "CC_REG", ")", "(", "compare", ":", "CCC", "(", "zero_extend", ":", "DI", "<BUGS>", "(", "neg", ":", "SI", "(", "plus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "ltu", ":", "SI", "(", "reg", ":", "CCC", "CC_REG", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", ")", "(", "neg", ":", "DI", "(", "plus", ":", "DI", "(", "zero_extend", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", ")" ]

[ "<FIXS>", "negated_const", "=", "gen_rtx_CONST_DOUBLE", "(", "DImode", ",", "const0_rtx", ",", "<FIXE>", "<FIXS>", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "<FIXE>", "<FIXS>", "gen_safe_XOR64", "(", "temp", ",", "(", "-", "<NUM_LIT>", "|", "trailing_bits", ")", ")", ")", ")", ";", "<FIXE>" ]

[ "negated_const", "=", "GEN_INT", "(", "(", "(", "~", "low_bits", ")", "&", "<NUM_LIT>", ")", "|", "(", "(", "(", "HOST_WIDE_INT", ")", "(", "(", "~", "high_bits", ")", "&", "<NUM_LIT>", ")", ")", "<<", "<NUM_LIT>", ")", ")", ";", "#", "else", "<BUGS>", "negated_const", "=", "gen_rtx_CONST_DOUBLE", "(", "DImode", ",", "NULL_RTX", ",", "<BUGE>", "(", "~", "low_bits", ")", "&", "<NUM_LIT>", ",", "(", "~", "high_bits", ")", "&", "<NUM_LIT>", ")", ";", "#", "endifsparc_emit_set_const64", "(", "temp", ",", "negated_const", ")", ";", "}", "<BUGS>", "emit_insn", "(", "gen_rtx_SET", "(", "DImode", ",", "<BUGE>", "op0", ",", "<BUGS>", "gen_rtx_XOR", "(", "DImode", ",", "temp", ",", "safe_constDI", "(", "-", "<NUM_LIT>", "|", "trailing_bits", ")", ")", ")", ")", ";", "<BUGE>", "return", ";", "}" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "mem", ":", "BLK", "(", "scratch", ")", ")", "(", "unspec", ":", "BLK", "[", "(", "match_operand", ":", "<", "VPRED", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "<", "V_INT_EQUIV", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SVE_D", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_ST1_SCATTER", ")", ")", "]" ]

[ "<FIXS>", "MCContext", "&", "Ctx", ",", "const", "Triple", "&", "TheTriple", ",", "bool", "IsResolved", ")", "{", "<FIXE>" ]

[ "}", "static", "uint64_t", "adjustFixupValue", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "<BUGS>", "MCContext", "&", "Ctx", ")", "{", "<BUGE>", "unsigned", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "int64_t", "SignedValue", "=", "static_cast", "int64_t", ">", "(", "Value", ")", ";", "switch", "(", "Kind", ")", "{" ]

[ "let", "opExtentBits", "=", "<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", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicateLate", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "LC0", ",", "P3", ",", "SA0", ",", "USR", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "match_operand", ":", "VF_HW", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "<", "tointvec", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ge", ":", "<", "tointvec", ">", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "reg", ":", "CCVFHE", "CC_REGNUM", ")", "]", "UNSPEC_CC_TO_INT", ")", ")", "]" ]

[ "SD", ")", ";" ]

[ "static", "SDValue", "createStoreLR", "(", "unsigned", "Opc", ",", "SelectionDAG", "&", "DAG", ",", "StoreSDNode", "*", "SD", ",", "SDValue", "Chain", ",", "unsigned", "Offset", ")", "{", "SDValue", "Ptr", "=", "SD", "->", "getBasePtr", "(", ")", ",", "Value", "=", "SD", "->", "getValue", "(", ")", ";", "EVT", "MemVT", "=", "SD", "->", "getMemoryVT", "(", ")", ",", "BasePtrVT", "=", "Ptr", ".", "getValueType", "(", ")", ";", "SDLoc", "DL", "(" ]

[ "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".word", "<STR_LIT>", ")", "return", "ParseDirectiveWord", "(", "<NUM_LIT>", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "<STR_LIT>", ".code", "<STR_LIT>", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "<STR_LIT>", ".intel_syntax", "<STR_LIT>", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "<NUM_LIT>", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "<STR_LIT>", "noprefix", "<STR_LIT>", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "else", "return", "true", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}" ]

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

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

[ "class", "BaseIntegerToFP", "<", "bit", "isUnsigned", ",", "RegisterClass", "srcType", ",", "RegisterClass", "dstType", ",", "Operand", "immType", ",", "string", "asm", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "(", "outs", "dstType", ":", "$", "Rd", ")", ",", "(", "ins", "srcType", ":", "$", "Rn", ",", "immType", ":", "$", "scale", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", ",", "Sched", "<", "[", "WriteFCvt", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "scale", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isUnsigned", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "scale", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "emit_insn", "(", "gen_tstsi_t", "(", "eop0", ".", "use_as_extended_reg", "(", "curr_insn", ")", ",", "eop1", ".", "use_as_extended_reg", "(", "curr_insn", ")", ")", ")", ";" ]

[ "gcc_assert", "(", "subreg_mode", "==", "QImode", "||", "subreg_mode", "==", "HImode", ")", ";", "sh_extending_set_of_reg", "eop0", "=", "sh_find_extending_set_of_reg", "(", "operands", "[", "<NUM_LIT>", "]", ",", "curr_insn", ")", ";", "sh_extending_set_of_reg", "eop1", "=", "sh_find_extending_set_of_reg", "(", "operands", "[", "<NUM_LIT>", "]", ",", "curr_insn", ")", ";", "if", "(", "eop0", ".", "ext_code", "==", "ZERO_EXTEND", "&&", "eop0", ".", "from_mode", "==", "subreg_mode", ")", "{", "emit_insn", "(", "gen_tstsi_t", "(", "eop0", ".", "use_as_extended_reg", "(", "curr_insn", ")", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "return", ";", "}", "if", "(", "eop1", ".", "ext_code", "==", "ZERO_EXTEND", "&&", "eop1", ".", "from_mode", "==", "subreg_mode", ")", "{", "emit_insn", "(", "gen_tstsi_t", "(", "operands", "[", "<NUM_LIT>", "]", ",", "eop1", ".", "use_as_extended_reg", "(", "curr_insn", ")", ")", ")", ";", "return", ";", "}", "if", "(", "eop0", ".", "ext_code", "==", "SIGN_EXTEND", "&&", "eop1", ".", "ext_code", "==", "SIGN_EXTEND", "&&", "eop0", ".", "from_mode", "==", "subreg_mode", "&&", "eop1", ".", "from_mode", "==", "subreg_mode", ")", "{" ]

[ "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", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "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", ";", "}" ]

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

[ "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", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "def", "ICXWriteResGroup184", ":", "SchedWriteRes", "<", "[", "ICXPort0", ",", "ICXFPDivider", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";" ]

[ "x", ")", ";" ]

[ "if", "(", "!", "loongarch_legitimate_address_p", "(", "mode", ",", "x", ",", "false", ")", ")", "x", "=", "force_reg", "(", "Pmode", "," ]

[ "v2f32", "DPR", ":", "$", "src", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v2f32", "(", "bitconvert", "(", "v8i8", "DPR", ":", "$", "src", ")", ")", ")", ",", "(" ]

[ "<STR_LIT>" ]

[ "(", "define_register_constraint" ]

[ "}" ]

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

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

[ "TFOps", "[", "i", "]", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Loads", "[", "i", "]", ",", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "Dst", ",", "DAG", ".", "getConstant", "(", "DstOff", ",", "MVT", "::", "i32", ")", ")", ",", "DstSV", ",", "DstSVOff", "+", "DstOff", ")", ";", "DstOff", "+=", "VTSize", ";", "}", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "TFOps", "[", "<NUM_LIT>", "]", ",", "i", ")", ";", "EmittedNumMemOps", "+=", "i", ";", "}", "if", "(", "BytesLeft", "==", "<NUM_LIT>", ")", "return", "Chain", ";", "unsigned", "BytesLeftSave", "=", "BytesLeft", ";", "i", "=", "<NUM_LIT>", ";", "while", "(", "BytesLeft", ")", "{", "if", "(", "BytesLeft", ">=", "<NUM_LIT>", ")", "{", "VT", "=", "MVT", "::", "i16", ";", "VTSize", "=", "<NUM_LIT>", ";", "}", "else", "{", "VT", "=", "MVT", "::", "i8", ";", "VTSize", "=", "<NUM_LIT>", ";", "}", "Loads", "[", "i", "]", "=", "DAG", ".", "getLoad", "(", "VT", ",", "dl", ",", "Chain", ",", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ",", "DAG", ".", "getConstant", "(", "SrcOff", ",", "MVT", "::", "i32", ")", ")", ",", "SrcSV", ",", "SrcSVOff", "+", "SrcOff", ")", ";", "TFOps", "[", "i", "]", "=", "Loads", "[", "i", "]", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "++", "i", ";", "SrcOff", "+=", "VTSize", ";", "BytesLeft", "-=", "VTSize", ";", "}", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "TFOps", "[", "<NUM_LIT>", "]", ",", "i", ")", ";", "i", "=", "<NUM_LIT>", ";", "BytesLeft", "=", "BytesLeftSave", ";", "while", "(", "BytesLeft", ")", "{", "if", "(", "BytesLeft", ">=", "<NUM_LIT>", ")", "{", "VT", "=", "MVT", "::", "i16", ";" ]

[ "SDValue", "ARMTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADDC", ":", "return", "PerformADDCCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSUBCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMULCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "PerformXORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformBFICombine", "(", "N", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformVMOVRRDCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformVMOVDRRCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "PerformBUILD_VECTORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "PerformInsertEltCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformVECTOR_SHUFFLECombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformVDUPLANECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "PerformVCVTCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "PerformVDIVCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "PerformIntrinsicCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "return", "PerformExtendCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "PerformSELECT_CCCombine", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "CombineBaseUpdate", "(", "N", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformARMBUILD_VECTORCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "Intrinsic", "::", "arm_neon_vld1", ":", "case", "Intrinsic", "::", "arm_neon_vld2", ":", "case", "Intrinsic", "::", "arm_neon_vld3", ":", "case", "Intrinsic", "::", "arm_neon_vld4", ":", "case", "Intrinsic", "::", "arm_neon_vld2lane", ":", "case", "Intrinsic", "::", "arm_neon_vld3lane", ":", "case", "Intrinsic", "::", "arm_neon_vld4lane", ":", "case", "Intrinsic", "::", "arm_neon_vst1", ":", "case", "Intrinsic", "::", "arm_neon_vst2", ":", "case", "Intrinsic", "::", "arm_neon_vst3", ":", "case", "Intrinsic", "::", "arm_neon_vst4", ":", "case", "Intrinsic", "::", "arm_neon_vst2lane", ":", "case", "Intrinsic", "::", "arm_neon_vst3lane", ":", "case", "Intrinsic", "::", "arm_neon_vst4lane", ":", "return", "CombineBaseUpdate", "(", "N", ",", "DCI", ")", ";", "default", ":", "break", ";", "}", "break", ";", "}", "return", "SDValue", "(", ")", ";", "}" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "<FIXS>", "if", "(", "(", "unsigned", "long", ")", "la_target", ".", "cpu_tune", "N_TUNE_TYPES", ")", "return", "loongarch_cpu_issue_rate", "[", "la_target", ".", "cpu_tune", "]", ";", "<FIXE>" ]

[ "static", "intloongarch_issue_rate", "(", "void", ")", "{", "<BUGS>", "if", "(", "(", "unsigned", "long", ")", "LARCH_ACTUAL_TUNE", "N_TUNE_TYPES", ")", "return", "loongarch_cpu_issue_rate", "[", "LARCH_ACTUAL_TUNE", "]", ";", "<BUGE>", "elsereturn", "<NUM_LIT>", ";", "}" ]

[ ";" ]

[ "bool", "MipsAsmParser", "::", "ParseInstruction", "(", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "return", "true" ]

[ "<STR_LIT>", ")" ]

[ "(", "ior", "(", "and", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "and", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", ")", ")" ]

[ "}" ]

[ "if", "(", "SCALAR_FLOAT_TYPE_P", "(", "t", ")", "&&", "TYPE_PRECISION", "(", "t", ")", "==", "<NUM_LIT>", "&&", "TYPE_MAIN_VARIANT", "(", "t", ")", "==", "arm_fp16_type_node", ")", "return", "float_type_node", ";", "return", "NULL_TREE", ";" ]

[ "&", "offset", ")", ";" ]

[ "rtx", "loongarch_unspec_address", "(", "rtx", "address", ",", "enum", "loongarch_symbol_type", "symbol_type", ")", "{", "rtx", "base", ",", "offset", ";", "split_const", "(", "address", ",", "&", "base", "," ]

[ "<FIXS>", "if", "(", "FrameIndexVirtualScavenging", ")", "{", "unsigned", "TmpReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "ARM", "::", "tGPRRegisterClass", ")", ";", "bool", "UseRR", "=", "false", ";", "if", "(", "Opcode", "==", "ARM", "::", "tSpill", ")", "{", "if", "(", "FrameReg", "==", "ARM", "::", "SP", ")", "emitThumbRegPlusImmInReg", "(", "MBB", ",", "II", ",", "TmpReg", ",", "FrameReg", ",", "Offset", ",", "false", ",", "TII", ",", "*", "this", ",", "dl", ")", ";", "else", "{", "emitLoadConstPool", "(", "MBB", ",", "II", ",", "dl", ",", "TmpReg", ",", "<NUM_LIT>", ",", "Offset", ")", ";", "UseRR", "=", "true", ";", "}", "}", "elseemitThumbRegPlusImmediate", "(", "MBB", ",", "II", ",", "TmpReg", ",", "FrameReg", ",", "Offset", ",", "TII", ",", "*", "this", ",", "dl", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "ARM", "::", "tSTR", ")", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "TmpReg", ",", "false", ",", "false", ",", "true", ")", ";", "if", "(", "UseRR", ")", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "FrameReg", ",", "false", ")", ")", ";", "else", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "<NUM_LIT>", ",", "false", ")", ")", ";", "}", "else", "{", "unsigned", "ValReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "TmpReg", "=", "ARM", "::", "R3", ";", "bool", "UseRR", "=", "false", ";", "if", "(", "ValReg", "==", "ARM", "::", "R3", ")", "{", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVtgpr2gpr", ")", ",", "ARM", "::", "R12", ")", ".", "addReg", "(", "ARM", "::", "R2", ",", "RegState", "::", "Kill", ")", ";", "TmpReg", "=", "ARM", "::", "R2", ";", "<FIXE>", "<FIXS>", "if", "(", "TmpReg", "==", "ARM", "::", "R3", "&&", "AFI", "->", "isR3LiveIn", "(", ")", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVtgpr2gpr", ")", ",", "ARM", "::", "R12", ")", ".", "addReg", "(", "ARM", "::", "R3", ",", "RegState", "::", "Kill", ")", ";", "if", "(", "Opcode", "==", "ARM", "::", "tSpill", ")", "{", "if", "(", "FrameReg", "==", "ARM", "::", "SP", ")", "emitThumbRegPlusImmInReg", "(", "MBB", ",", "II", ",", "TmpReg", ",", "FrameReg", ",", "Offset", ",", "false", ",", "TII", ",", "*", "this", ",", "dl", ")", ";", "else", "{", "emitLoadConstPool", "(", "MBB", ",", "II", ",", "dl", ",", "TmpReg", ",", "<NUM_LIT>", ",", "Offset", ")", ";", "UseRR", "=", "true", ";", "}", "}", "elseemitThumbRegPlusImmediate", "(", "MBB", ",", "II", ",", "TmpReg", ",", "FrameReg", ",", "Offset", ",", "TII", ",", "*", "this", ",", "dl", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "ARM", "::", "tSTR", ")", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "TmpReg", ",", "false", ",", "false", ",", "true", ")", ";", "if", "(", "UseRR", ")", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "FrameReg", ",", "false", ")", ")", ";", "else", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "<NUM_LIT>", ",", "false", ")", ")", ";", "<FIXE>", "<FIXS>", "MachineBasicBlock", "::", "iterator", "NII", "=", "next", "(", "II", ")", ";", "if", "(", "ValReg", "==", "ARM", "::", "R3", ")", "BuildMI", "(", "MBB", ",", "NII", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVgpr2tgpr", ")", ",", "ARM", "::", "R2", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Kill", ")", ";", "if", "(", "TmpReg", "==", "ARM", "::", "R3", "&&", "AFI", "->", "isR3LiveIn", "(", ")", ")", "BuildMI", "(", "MBB", ",", "NII", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVgpr2tgpr", ")", ",", "ARM", "::", "R3", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Kill", ")", ";", "}", "<FIXE>" ]

[ "else", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "<NUM_LIT>", ",", "false", ")", ")", ";", "}", "else", "if", "(", "Desc", ".", "mayStore", "(", ")", ")", "{", "<BUGS>", "unsigned", "ValReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "TmpReg", "=", "ARM", "::", "R3", ";", "bool", "UseRR", "=", "false", ";", "if", "(", "ValReg", "==", "ARM", "::", "R3", ")", "{", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVtgpr2gpr", ")", ",", "ARM", "::", "R12", ")", ".", "addReg", "(", "ARM", "::", "R2", ",", "RegState", "::", "Kill", ")", ";", "TmpReg", "=", "ARM", "::", "R2", ";", "}", "if", "(", "TmpReg", "==", "ARM", "::", "R3", "&&", "AFI", "->", "isR3LiveIn", "(", ")", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVtgpr2gpr", ")", ",", "ARM", "::", "R12", ")", ".", "addReg", "(", "ARM", "::", "R3", ",", "RegState", "::", "Kill", ")", ";", "if", "(", "Opcode", "==", "ARM", "::", "tSpill", ")", "{", "if", "(", "FrameReg", "==", "ARM", "::", "SP", ")", "emitThumbRegPlusImmInReg", "(", "MBB", ",", "II", ",", "TmpReg", ",", "FrameReg", ",", "Offset", ",", "false", ",", "TII", ",", "*", "this", ",", "dl", ")", ";", "else", "{", "emitLoadConstPool", "(", "MBB", ",", "II", ",", "dl", ",", "TmpReg", ",", "<NUM_LIT>", ",", "Offset", ")", ";", "UseRR", "=", "true", ";", "<BUGE>", "}", "<BUGS>", "}", "elseemitThumbRegPlusImmediate", "(", "MBB", ",", "II", ",", "TmpReg", ",", "FrameReg", ",", "Offset", ",", "TII", ",", "*", "this", ",", "dl", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "ARM", "::", "tSTR", ")", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "TmpReg", ",", "false", ",", "false", ",", "true", ")", ";", "if", "(", "UseRR", ")", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "FrameReg", ",", "false", ")", ")", ";", "else", "MI", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "<NUM_LIT>", ",", "false", ")", ")", ";", "<BUGE>", "<BUGS>", "MachineBasicBlock", "::", "iterator", "NII", "=", "next", "(", "II", ")", ";", "if", "(", "ValReg", "==", "ARM", "::", "R3", ")", "BuildMI", "(", "MBB", ",", "NII", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVgpr2tgpr", ")", ",", "ARM", "::", "R2", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Kill", ")", ";", "if", "(", "TmpReg", "==", "ARM", "::", "R3", "&&", "AFI", "->", "isR3LiveIn", "(", ")", ")", "BuildMI", "(", "MBB", ",", "NII", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVgpr2tgpr", ")", ",", "ARM", "::", "R3", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Kill", ")", ";", "<BUGE>", "}", "elseassert", "(", "false", "&&", "<STR_LIT>", "Unexpected opcode!", "<STR_LIT>", ")", ";" ]

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

[ "(", "define_cpu_unit" ]

[ "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "Constraints", "=" ]

[ "unsigned", "Idx", "=", "(", "FullSize", "-", "<NUM_LIT>", "-", "i", ")", ";" ]

[ "uint64_t", "CurVal", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "<NUM_LIT>", "-", "i", ")", ";", "CurVal", "|=", "static_cast", "<", "uint64_t", ">", "(", "static_cast", "<", "uint8_t", ">", "(", "Data", "[", "Offset", "+", "Idx", "]", ")", ")", "<<", "(", "i", "*", "<NUM_LIT>", ")", ";", "}", "uint64_t", "Mask", "=", "(", "static_cast", "<", "uint64_t", ">", "(", "-", "<NUM_LIT>", ")", ">>", "(", "<NUM_LIT>", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{" ]

[ "avr_asm_len", "(", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "<NUM_LIT>", ")", ",", "op", ",", "plen", ",", "<NUM_LIT>", ")", ";" ]

[ "else", "{", "return", "avr_asm_len", "(", "<STR_LIT>", "ld %A0,%1+", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "ld %B0,%1+", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "ld %C0,%1", "<STR_LIT>", ",", "op", ",", "plen", ",", "-", "<NUM_LIT>", ")", ";", "if", "(", "reg_dest", "!=", "reg_base", "-", "<NUM_LIT>", "&&", "!", "reg_unused_after", "(", "insn", ",", "base", ")", ")", "{" ]

[ "<STR_LIT>", ")" ]

[ "(", "float", ":", "SF", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set", "(", "attr" ]

[ ">", ";" ]

[ "def", "A64FXIPPR", ":", "ProcResource", "<", "<NUM_LIT>" ]

[ "(", "_", "_", "v8df", ")", "_", "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_cvtepi32_pd", "(", "_", "_", "m512d", "_", "_", "W", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_cvtdq2pd512_mask", "(", "(", "_", "_", "v8si", ")", "_", "_", "A", "," ]

[ "LastOp", ";" ]

[ "MachineInstr", "*", "Op", "=", "Ops", "[", "i", "]", ";", "unsigned", "Loc", "=", "MI2LocMap", "[", "Op", "]", ";", "if", "(", "Loc", "<=", "FirstLoc", ")", "{", "FirstLoc", "=", "Loc", ";", "FirstOp", "=", "Op", ";", "}", "if", "(", "Loc", ">=", "LastLoc", ")", "{", "LastLoc", "=", "Loc", ";", "LastOp", "=", "Op", ";", "}", "unsigned", "Opcode", "=", "Op", "->", "getOpcode", "(", ")", ";", "if", "(", "LastOpcode", "&&", "Opcode", "!=", "LastOpcode", ")", "break", ";", "int", "Offset", "=", "getMemoryOpOffset", "(", "Op", ")", ";", "unsigned", "Bytes", "=", "getLSMultipleTransferSize", "(", "Op", ")", ";", "if", "(", "LastBytes", ")", "{", "if", "(", "Bytes", "!=", "LastBytes", "||", "Offset", "!=", "(", "LastOffset", "+", "(", "int", ")", "Bytes", ")", ")", "break", ";", "}", "LastOffset", "=", "Offset", ";", "LastBytes", "=", "Bytes", ";", "LastOpcode", "=", "Opcode", ";", "if", "(", "++", "NumMove", "==", "<NUM_LIT>", ")", "break", ";", "}", "if", "(", "NumMove", "<=", "<NUM_LIT>", ")", "Ops", ".", "pop_back", "(", ")", ";", "else", "{", "SmallPtrSet", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "MemOps", ";", "SmallSet", "<", "unsigned", ",", "<NUM_LIT>", ">", "MemRegs", ";", "for", "(", "int", "i", "=", "NumMove", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "--", "i", ")", "{", "MemOps", ".", "insert", "(", "Ops", "[", "i", "]", ")", ";", "MemRegs", ".", "insert", "(", "Ops", "[", "i", "]", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "}", "bool", "DoMove", "=", "(", "LastLoc", "-", "FirstLoc", ")", "<=", "NumMove", "*", "<NUM_LIT>", ";", "if", "(", "DoMove", ")", "DoMove", "=", "IsSafeAndProfitableToMove", "(", "isLd", ",", "Base", ",", "FirstOp", ",", "LastOp", ",", "MemOps", ",", "MemRegs", ",", "TRI", ")", ";", "if", "(", "!", "DoMove", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumMove", ";", "++", "i", ")", "Ops", ".", "pop_back", "(", ")", ";", "}", "else", "{", "MachineBasicBlock", "::", "iterator", "InsertPos", "=", "isLd", "?", "FirstOp", ":" ]

[ "}" ]

[ "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "BasicBlock", "::", "iterator", "SectionEnd", ";", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "BB", ".", "begin", "(", ")", ",", "E", "=", "BB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "SectionEnd", ")", "{", "SmallVector", "<", "SmallVector", "<", "IntrinsicInst", "*", ",", "<NUM_LIT>", ">>", "MergeableInsts", ";", "SectionEnd", "=", "collectMergeableInsts", "(", "I", ",", "E", ",", "MergeableInsts", ")", ";", "Modified", "|=", "optimizeSection", "(", "MergeableInsts", ")", ";", "}", "}", "return", "Modified", ";" ]

[ "bool", "PPCTargetLowering", "::", "SelectAddressRegImm34", "(", "SDValue", "N", ",", "SDValue", "&", "Disp", ",", "SDValue", "&", "Base", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "N", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i64", ")", "return", "false", ";", "SDLoc", "dl", "(", "N", ")", ";", "int64_t", "Imm", "=", "<NUM_LIT>", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "if", "(", "!", "isIntS34Immediate", "(", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Imm", ")", ")", "return", "false", ";", "Disp", "=", "DAG", ".", "getTargetConstant", "(", "Imm", ",", "dl", ",", "N", ".", "getValueType", "(", ")", ")", ";", "if", "(", "FrameIndexSDNode", "*", "FI", "=", "dyn_cast", "<", "FrameIndexSDNode", ">", "(", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "Base", "=", "DAG", ".", "getTargetFrameIndex", "(", "FI", "->", "getIndex", "(", ")", ",", "N", ".", "getValueType", "(", ")", ")", ";", "else", "Base", "=", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", "{", "if", "(", "!", "isIntS34Immediate", "(", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Imm", ")", ")", "return", "false", ";", "KnownBits", "LHSKnown", "=", "DAG", ".", "computeKnownBits", "(", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "(", "LHSKnown", ".", "Zero", ".", "getZExtValue", "(", ")", "|", "~", "(", "uint64_t", ")", "Imm", ")", "!=", "~", "<NUM_LIT>", "ULL", ")", "return", "false", ";", "if", "(", "FrameIndexSDNode", "*", "FI", "=", "dyn_cast", "<", "FrameIndexSDNode", ">", "(", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "Base", "=", "DAG", ".", "getTargetFrameIndex", "(", "FI", "->", "getIndex", "(", ")", ",", "N", ".", "getValueType", "(", ")", ")", ";", "else", "Base", "=", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Disp", "=", "DAG", ".", "getTargetConstant", "(", "Imm", ",", "dl", ",", "N", ".", "getValueType", "(", ")", ")", ";", "return", "true", ";", "}", "if", "(", "isIntS34Immediate", "(", "N", ",", "Imm", ")", ")", "{", "Disp", "=", "DAG", ".", "getTargetConstant", "(", "Imm", ",", "dl", ",", "N", ".", "getValueType", "(", ")", ")", ";", "Base", "=", "DAG", ".", "getRegister", "(", "PPC", "::", "ZERO8", ",", "N", ".", "getValueType", "(", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Similar", "to", "the", "16-bit", "case", "but", "for", "instructions", "that", "take", "a", "34-bit", "displacement", "field", "(", "prefixed", "loads/stores", ")", "." ]

[ "void", "gcn_goacc_reduction", "(", "gcall", "*", "call", ")", "{", "int", "level", "=", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "level", "==", "GOMP_DIM_VECTOR", ")", "{", "default_goacc_reduction", "(", "call", ")", ";", "return", ";", "}", "unsigned", "code", "=", "(", "unsigned", ")", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "<NUM_LIT>", ")", ")", ";", "switch", "(", "code", ")", "{", "case", "IFN_GOACC_REDUCTION_SETUP", ":", "gcn_goacc_reduction_setup", "(", "call", ")", ";", "break", ";", "case", "IFN_GOACC_REDUCTION_INIT", ":", "gcn_goacc_reduction_init", "(", "call", ")", ";", "break", ";", "case", "IFN_GOACC_REDUCTION_FINI", ":", "gcn_goacc_reduction_fini", "(", "call", ")", ";", "break", ";", "case", "IFN_GOACC_REDUCTION_TEARDOWN", ":", "gcn_goacc_reduction_teardown", "(", "call", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}" ]

[ "Implement", "TARGET_GOACC_REDUCTION", ".", "Expand", "calls", "to", "the", "GOACC", "REDUCTION", "internal", "function", ",", "into", "a", "sequence", "of", "gimple", "instructions", "." ]

[ "}" ]

[ "EVT", "ArgVT", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "if", "(", "useSVEForFixedLengthVectorVT", "(", "OpVT", ")", ")", "return", "LowerFixedLengthBitcastToSVE", "(", "Op", ",", "DAG", ")", ";", "if", "(", "OpVT", ".", "isScalableVector", "(", ")", ")", "{", "if", "(", "OpVT", ".", "getVectorElementCount", "(", ")", "!=", "ArgVT", ".", "getVectorElementCount", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "isTypeLegal", "(", "OpVT", ")", "&&", "!", "isTypeLegal", "(", "ArgVT", ")", ")", "{", "assert", "(", "OpVT", ".", "isFloatingPoint", "(", ")", "&&", "!", "ArgVT", ".", "isFloatingPoint", "(", ")", "&&", "<STR_LIT>", "Expected int->fp bitcast!", "<STR_LIT>", ")", ";", "SDValue", "ExtResult", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "SDLoc", "(", "Op", ")", ",", "getSVEContainerType", "(", "ArgVT", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "getSVESafeBitCast", "(", "OpVT", ",", "ExtResult", ",", "DAG", ")", ";", "}", "return", "getSVESafeBitCast", "(", "OpVT", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ")", ";", "}", "if", "(", "OpVT", "!=", "MVT", "::", "f16", "&&", "OpVT", "!=", "MVT", "::", "bf16", ")", "return", "SDValue", "(", ")", ";", "if", "(", "ArgVT", "==", "MVT", "::", "f16", "||", "ArgVT", "==", "MVT", "::", "bf16", ")", "return", "Op", ";", "assert", "(", "ArgVT", "==", "MVT", "::", "i16", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "MVT", "::", "i32", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "f32", ",", "Op", ")", ";", "return", "DAG", ".", "getTargetExtractSubreg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "OpVT", ",", "Op", ")", ";" ]

[ "<FIXS>", "const", "struct", "loongarch_rtx_cost_data", "<FIXE>" ]

[ "}", ";", "<BUGS>", "extern", "const", "struct", "loongarch_rtx_cost_data", "<BUGE>", "loongarch_rtx_cost_optimize_size", "=", "{", ".", "fp_add", "=", "<NUM_LIT>", ",", ".", "fp_mult_sf", "=", "<NUM_LIT>", "," ]

[ "<FIXS>", "void", "RecordRelocation", "(", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ",", "<FIXE>" ]

[ "const", "MCAsmLayout", "&", "Layout", ")", "override", "{", "}", "<BUGS>", "void", "RecordRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ",", "<BUGE>", "const", "MCFragment", "*", "Fragment", ",", "const", "MCFixup", "&", "Fixup", ",", "MCValue", "Target", ",", "bool", "&", "IsPCRel", ",", "uint64_t", "&", "FixedValue", ")", "override", "{" ]

[ "_", "imm", ",", "mve_pred16_t", "_", "_", "p", ")", "{" ]

[ "_", "_", "arm_vqrshruntq_m_n_s32", "(", "uint16x8_t", "_", "_", "a", ",", "int32x4_t", "_", "_", "b", ",", "const", "int", "_" ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "VALL_F16_NO_V2Q", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_merge", ":", "VALL_F16_NO_V2Q", "(", "vec_duplicate", ":", "VALL_F16_NO_V2Q", "<FIXE>", "<FIXS>", "(", "match_operand", ":", "VALL_F16_NO_V2Q", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>" ]

[ ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "VALL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_merge", ":", "VALL", "(", "vec_duplicate", ":", "VALL", "<BUGE>", "(", "vec_select", ":", "VEL", ">", "(", "match_operand", ":", "VSWAP_WIDTH", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", ")", ")", "<BUGS>", "(", "match_operand", ":", "VALL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{" ]

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

[ "(", "clobber", "(", "reg", ":", "CC", "CC_REGNUM", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>" ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>" ]

[ "DONE", "(", "define_insn_and_split", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "clobber", "(", "match_scratch", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "<STR_LIT>" ]

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

[ ")", ")" ]

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

[ "let", "SrcA", "=", "src", ";" ]

[ "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "Rsrc", ":", "$", "src", ",", "DimMask", ":", "$", "mask", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ";", "let", "Itinerary", "=", "IIC_ScalarOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "mask", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";" ]

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

[ "def", "SDT_MTLOHI", ":", "SDTypeProfile", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisVT", "<", "<NUM_LIT>", ",", "untyped", ">", ",", "SDTCisInt", "<", "<NUM_LIT>", ">", ",", "SDTCisSameAs", "<", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "}" ]

[ "assert", "(", "(", "Modifier", "==", "nullptr", "||", "Modifier", "[", "<NUM_LIT>", "]", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "No modifiers supported", "<STR_LIT>", ")", ";", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "O", "<<", "getRegisterName", "(", "Op", ".", "getReg", "(", ")", ")", ";", "}", "else", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "O", "<<", "'", "#", "'", "<<", "Op", ".", "getImm", "(", ")", ";", "}", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "<STR_LIT>", "unknown operand kind in printOperand", "<STR_LIT>", ")", ";", "O", "<<", "'", "#", "'", "<<", "*", "Op", ".", "getExpr", "(", ")", ";", "}" ]

[ ")" ]

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

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

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "Constraints" ]

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

[ "def", "A2_addsat", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_61830035", ",", "TypeALU32_3op", ">", ",", "Enc_5ab2be", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "SDValue", "OverflowAreaPlusN", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "OverflowArea", ",", "DAG", ".", "getConstant", "(", "VT", ".", "isInteger", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";" ]

[ "SDValue", "OverflowAreaPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "VAListPtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "OverflowArea", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "InChain", ",", "OverflowAreaPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "InChain", "=", "OverflowArea", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "RegSaveArea", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "InChain", ",", "RegSaveAreaPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "InChain", "=", "RegSaveArea", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "CC", "=", "DAG", ".", "getSetCC", "(", "dl", ",", "MVT", "::", "i32", ",", "VT", ".", "isInteger", "(", ")", "?", "GprIndex", ":", "FprIndex", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "ISD", "::", "SETLT", ")", ";", "SDValue", "RegConstant", "=", "DAG", ".", "getNode", "(", "ISD", "::", "MUL", ",", "dl", ",", "MVT", "::", "i32", ",", "VT", ".", "isInteger", "(", ")", "?", "GprIndex", ":", "FprIndex", ",", "DAG", ".", "getConstant", "(", "VT", ".", "isInteger", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "OurReg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "RegSaveArea", ",", "RegConstant", ")", ";", "if", "(", "VT", ".", "isFloatingPoint", "(", ")", ")", "OurReg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "OurReg", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "IndexPlus1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "VT", ".", "isInteger", "(", ")", "?", "GprIndex", ":", "FprIndex", ",", "DAG", ".", "getConstant", "(", "VT", "==", "MVT", "::", "i64", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "InChain", "=", "DAG", ".", "getTruncStore", "(", "InChain", ",", "dl", ",", "IndexPlus1", ",", "VT", ".", "isInteger", "(", ")", "?", "VAListPtr", ":", "FprPtr", ",", "MachinePointerInfo", "(", "SV", ")", ",", "MVT", "::", "i8", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "dl", ",", "PtrVT", ",", "CC", ",", "OurReg", ",", "OverflowArea", ")", ";" ]

[ ")", ";" ]

[ "machine_mode", "mode", "=", "GET_MODE", "(", "src_reg", ")", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "half_elts", "=", "n_elts", "/", "<NUM_LIT>", ";", "rtx", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "n_elts", ")", ")", ";", "int", "i", ",", "j", ";", "for", "(", "i", "=", "<NUM_LIT>", ",", "j", "=", "half_elts", ";", "i", "<", "half_elts", ";", "++", "i", ",", "++", "j", ")", "XVECEXP", "(", "par", ",", "<NUM_LIT>", ",", "i", ")", "=", "GEN_INT", "(", "j", ")", ";", "for", "(", "i", "=", "half_elts", ",", "j", "=", "<NUM_LIT>", ";", "j", "<", "half_elts", ";", "++", "i", ",", "++", "j", ")", "XVECEXP", "(", "par", ",", "<NUM_LIT>", ",", "i", ")", "=", "GEN_INT", "(", "j", ")", ";", "rtx", "sel", "=", "gen_rtx_VEC_SELECT", "(", "mode", ",", "src_reg", ",", "par", ")", ";", "SET_SRC", "(", "body", ")", "=", "sel", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "<NUM_LIT>", ";", "df_insn_rescan", "(", "insn" ]

[ "void", "expand_fusion_gpr_load", "(", "rtx", "*", "operands", ")", "{", "rtx", "addis_value", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "target", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "or", "ig_mem", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "new", "_", "addr", ",", "new", "_", "mem", ",", "or", "ig_addr", ",", "offset", ";", "enum", "rtx_code", "plus_or_lo_sum", ";", "machine_mode", "target_mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "extend_mode", "=", "target_mode", ";", "machine_mode", "ptr_mode", "=", "Pmode", ";", "enum", "rtx_code", "extend", "=", "UNKNOWN", ";", "if", "(", "GET_CODE", "(", "or", "ig_mem", ")", "==", "ZERO_EXTEND", "||", "(", "TARGET_P8_FUSION_SIGN", "&&", "GET_CODE", "(", "or", "ig_mem", ")", "==", "SIGN_EXTEND", ")", ")", "{", "extend", "=", "GET_CODE", "(", "or", "ig_mem", ")", ";", "or", "ig_mem", "=", "XEXP", "(", "or", "ig_mem", ",", "<NUM_LIT>", ")", ";", "target_mode", "=", "GET_MODE", "(", "or", "ig_mem", ")", ";", "}", "gcc_assert", "(", "MEM_P", "(", "or", "ig_mem", ")", ")", ";", "or", "ig_addr", "=", "XEXP", "(", "or", "ig_mem", ",", "<NUM_LIT>", ")", ";", "plus_or_lo_sum", "=", "GET_CODE", "(", "or", "ig_addr", ")", ";", "gcc_assert", "(", "plus_or_lo_sum", "==", "PLUS", "||", "plus_or_lo_sum", "==", "LO_SUM", ")", ";", "offset", "=", "XEXP", "(", "or", "ig_addr", ",", "<NUM_LIT>", ")", ";", "new", "_", "addr", "=", "gen_rtx_fmt_ee", "(", "plus_or_lo_sum", ",", "ptr_mode", ",", "addis_value", ",", "offset", ")", ";", "new", "_", "mem", "=", "replace_equiv_address_nv", "(", "or", "ig_mem", ",", "new", "_", "addr", ",", "false", ")", ";", "if", "(", "extend", "!=", "UNKNOWN", ")", "new", "_", "mem", "=", "gen_rtx_fmt_e", "(", "ZERO_EXTEND", ",", "extend_mode", ",", "new", "_", "mem", ")", ";", "new", "_", "mem", "=", "gen_rtx_UNSPEC", "(", "extend_mode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "new", "_", "mem", ")", ",", "UNSPEC_FUSION_GPR", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "new", "_", "mem", ")", ")", ";", "if", "(", "extend", "==", "SIGN_EXTEND", ")", "{", "int", "sub_off", "=", "(", "(", "BYTES_BIG_ENDIAN", ")", "?", "GET_MODE_SIZE", "(", "extend_mode", ")", "-", "GET_MODE_SIZE", "(", "target_mode", ")", ":", "<NUM_LIT>", ")", ";", "rtx", "sign_reg", "=", "simplify_subreg", "(", "target_mode", ",", "target", ",", "extend_mode", ",", "sub_off", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "gen_rtx_SIGN_EXTEND", "(", "extend_mode", ",", "sign_reg", ")", ")", ")", ";", "}", "return", ";", "}" ]

[ "During", "the", "peephole2", "pass", ",", "adjust", "and", "expand", "the", "insns", "for", "a", "load", "fusion", "sequence", ".", "We", "adjust", "the", "addis", "register", "to", "use", "the", "target", "register", ".", "If", "the", "load", "sign", "extends", ",", "we", "adjust", "the", "code", "to", "do", "the", "zero", "extending", "load", ",", "and", "an", "explicit", "sign", "extension", "later", "since", "the", "fusion", "only", "covers", "zero", "extending", "loads", ".", "The", "operands", "are", ":", "operands", "[", "0", "]", "register", "set", "with", "addis", "(", "to", "be", "replaced", "with", "target", ")", "operands", "[", "1", "]", "value", "set", "via", "addis", "operands", "[", "2", "]", "target", "register", "being", "loaded", "operands", "[", "3", "]", "D-form", "memory", "reference", "using", "operands", "[", "0", "]", "." ]

[ "_", "knot_mask32", "(", "_", "_", "mmask32", "_", "_", "A", ")", "{" ]

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

[ "<STR_LIT>" ]

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

[ "for", "(", "auto", "I", "=", "LI", "->", "begin", "(", ")", ",", "IE", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "L", "=", "df_begin", "(", "*", "I", ")", ",", "LE", "=", "df_end", "(", "*", "I", ")", ";", "L", "!=", "LE", ";", "++", "L", ")", "MadeChange", "|=", "runOnLoop", "(", "*", "L", ")", ";" ]

[ "TTI", "=", "&", "getAnalysis", "<", "TargetTransformInfoWrapperPass", ">", "(", ")", ".", "getTTI", "(", "F", ")", ";", "bool", "MadeChange", "=", "false", ";" ]

[ ")", ")" ]

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

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

[ "bits", "<", "<NUM_LIT>", ">", "RdaHiDest", ";", "bits", "<", "<NUM_LIT>", ">", "Qm", ";", "bits", "<", "<NUM_LIT>", ">", "Qn", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "bit_28", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "RdaHiDest", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qn", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "RdaLoDest", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "X", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "bit_8", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "A", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qm", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "sched_finish_none", ":" ]

[ "rs6000_debug_reg_print", "(", "VRSAVE_REGNO", ",", "VRSAVE_REGNO", ",", "<STR_LIT>", "vrsave", "<STR_LIT>", ")", ";", "rs6000_debug_reg_print", "(", "VSCR_REGNO", ",", "VSCR_REGNO", ",", "<STR_LIT>", "vscr", "<STR_LIT>", ")", ";", "fputs", "(", "<STR_LIT>", "\\nVirtual/stack/frame registers:\\n", "<STR_LIT>", ",", "stderr", ")", ";", "for", "(", "v", "=", "<NUM_LIT>", ";", "v", "<", "ARRAY_SIZE", "(", "virtual_regs", ")", ";", "v", "++", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "%s regno = %3d\\n", "<STR_LIT>", ",", "virtual_regs", "[", "v", "]", ".", "name", ",", "virtual_regs", "[", "v", "]", ".", "regno", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "\\n", "<STR_LIT>", "<STR_LIT>", "d reg_class = %s\\n", "<STR_LIT>", "<STR_LIT>", "f reg_class = %s\\n", "<STR_LIT>", "<STR_LIT>", "v reg_class = %s\\n", "<STR_LIT>", "<STR_LIT>", "wa reg_class = %s\\n", "<STR_LIT>", "<STR_LIT>", "we reg_class = %s\\n", "<STR_LIT>", "<STR_LIT>", "wr reg_class = %s\\n", "<STR_LIT>", "<STR_LIT>", "wx reg_class = %s\\n", "<STR_LIT>", "<STR_LIT>", "wA reg_class = %s\\n", "<STR_LIT>", "<STR_LIT>", "\\n", "<STR_LIT>", ",", "reg_class_names", "[", "rs6000_constraints", "[", "RS6000_CONSTRAINT_d", "]", "]", ",", "reg_class_names", "[", "rs6000_constraints", "[", "RS6000_CONSTRAINT_f", "]", "]", ",", "reg_class_names", "[", "rs6000_constraints", "[", "RS6000_CONSTRAINT_v", "]", "]", ",", "reg_class_names", "[", "rs6000_constraints", "[", "RS6000_CONSTRAINT_wa", "]", "]", ",", "reg_class_names", "[", "rs6000_constraints", "[", "RS6000_CONSTRAINT_we", "]", "]", ",", "reg_class_names", "[", "rs6000_constraints", "[", "RS6000_CONSTRAINT_wr", "]", "]", ",", "reg_class_names", "[", "rs6000_constraints", "[", "RS6000_CONSTRAINT_wx", "]", "]", ",", "reg_class_names", "[", "rs6000_constraints", "[", "RS6000_CONSTRAINT_wA", "]", "]", ")", ";", "nl", "=", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "for", "(", "m", "=", "<NUM_LIT>", ";", "m", "<", "NUM_MACHINE_MODES", ";", "++", "m", ")", "rs6000_debug_print_mode", "(", "m", ")", ";", "fputs", "(", "<STR_LIT>", "\\n", "<STR_LIT>", ",", "stderr", ")", ";", "for", "(", "m1", "=", "<NUM_LIT>", ";", "m1", "<", "ARRAY_SIZE", "(", "print_tieable_modes", ")", ";", "m1", "++", ")", "{", "machine_mode", "mode1", "=", "print_tieable_modes", "[", "m1", "]", ";", "bool", "first_time", "=", "true", ";", "nl", "=", "(", "const", "char", "*", ")", "<NUM_LIT>", ";", "for", "(", "m2", "=", "<NUM_LIT>", ";", "m2", "<", "ARRAY_SIZE", "(", "print_tieable_modes", ")", ";", "m2", "++", ")", "{", "machine_mode", "mode2", "=", "print_tieable_modes", "[", "m2", "]", ";", "if", "(", "mode1", "!=", "mode2", "&&", "rs6000_modes_tieable_p", "(", "mode1", ",", "mode2", ")", ")", "{", "if", "(", "first_time", ")", "{", "fprintf", "(", "stderr", ",", "<STR_LIT>", "Tieable modes %s:", "<STR_LIT>", ",", "GET_MODE_NAME", "(", "mode1", ")", ")", ";", "nl", "=", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "first_time", "=", "false", ";", "}", "fprintf", "(", "stderr", ",", "<STR_LIT>", " %s", "<STR_LIT>", ",", "GET_MODE_NAME", "(", "mode2", ")", ")", ";", "}", "}", "if", "(", "!", "first_time", ")", "fputs", "(", "<STR_LIT>", "\\n", "<STR_LIT>", ",", "stderr", ")", ";", "}", "if", "(", "nl", ")", "fputs", "(", "nl", ",", "stderr", ")", ";", "if", "(", "rs6000_recip_control", ")", "{", "fprintf", "(", "stderr", ",", "<STR_LIT>", "\\nReciprocal mask = 0x%x\\n", "<STR_LIT>", ",", "rs6000_recip_control", ")", ";", "for", "(", "m", "=", "<NUM_LIT>", ";", "m", "<", "NUM_MACHINE_MODES", ";", "++", "m", ")", "if", "(", "rs6000_recip_bits", "[", "m", "]", ")", "{", "fprintf", "(", "stderr", ",", "<STR_LIT>", "Reciprocal estimate mode: %-5s divide: %s rsqrt: %s\\n", "<STR_LIT>", ",", "GET_MODE_NAME", "(", "m", ")", ",", "(", "RS6000_RECIP_AUTO_RE_P", "(", "m", ")", "?", "<STR_LIT>", "auto", "<STR_LIT>", ":", "(", "RS6000_RECIP_HAVE_RE_P", "(", "m", ")", "?", "<STR_LIT>", "have", "<STR_LIT>", ":", "<STR_LIT>", "none", "<STR_LIT>", ")", ")", ",", "(", "RS6000_RECIP_AUTO_RSQRTE_P", "(", "m", ")", "?", "<STR_LIT>", "auto", "<STR_LIT>", ":", "(", "RS6000_RECIP_HAVE_RSQRTE_P", "(", "m", ")", "?", "<STR_LIT>", "have", "<STR_LIT>", ":", "<STR_LIT>", "none", "<STR_LIT>", ")", ")", ")", ";", "}", "fputs", "(", "<STR_LIT>", "\\n", "<STR_LIT>", ",", "stderr", ")", ";", "}", "if", "(", "rs6000_cpu_index", ">=", "<NUM_LIT>", ")", "{", "const", "char", "*", "name", "=", "processor_target_table", "[", "rs6000_cpu_index", "]", ".", "name", ";", "HOST_WIDE_INT", "flags", "=", "processor_target_table", "[", "rs6000_cpu_index", "]", ".", "target_enable", ";", "sprintf", "(", "flags_buffer", ",", "<STR_LIT>", "-mcpu=%s flags", "<STR_LIT>", ",", "name", ")", ";", "rs6000_print_isa_options", "(", "stderr", ",", "<NUM_LIT>", ",", "flags_buffer", ",", "flags", ")", ";", "}", "else", "fprintf", "(", "stderr", ",", "DEBUG_FMT_S", ",", "<STR_LIT>", "cpu", "<STR_LIT>", ",", "<STR_LIT>", "<none>", "<STR_LIT>", ")", ";", "if", "(", "rs6000_tune_index", ">=", "<NUM_LIT>", ")", "{", "const", "char", "*", "name", "=", "processor_target_table", "[", "rs6000_tune_index", "]", ".", "name", ";", "HOST_WIDE_INT", "flags", "=", "processor_target_table", "[", "rs6000_tune_index", "]", ".", "target_enable", ";", "sprintf", "(", "flags_buffer", ",", "<STR_LIT>", "-mtune=%s flags", "<STR_LIT>", ",", "name", ")", ";", "rs6000_print_isa_options", "(", "stderr", ",", "<NUM_LIT>", ",", "flags_buffer", ",", "flags", ")", ";", "}", "else", "fprintf", "(", "stderr", ",", "DEBUG_FMT_S", ",", "<STR_LIT>", "tune", "<STR_LIT>", ",", "<STR_LIT>", "<none>", "<STR_LIT>", ")", ";", "cl_target_option_save", "(", "&", "cl_opts", ",", "&", "global_options", ",", "&", "global_options_set", ")", ";", "rs6000_print_isa_options", "(", "stderr", ",", "<NUM_LIT>", ",", "<STR_LIT>", "rs6000_isa_flags", "<STR_LIT>", ",", "rs6000_isa_flags", ")", ";", "rs6000_print_isa_options", "(", "stderr", ",", "<NUM_LIT>", ",", "<STR_LIT>", "rs6000_isa_flags_explicit", "<STR_LIT>", ",", "rs6000_isa_flags_explicit", ")", ";", "rs6000_print_builtin_options", "(", "stderr", ",", "<NUM_LIT>", ",", "<STR_LIT>", "rs6000_builtin_mask", "<STR_LIT>", ",", "rs6000_builtin_mask", ")", ";", "rs6000_print_isa_options", "(", "stderr", ",", "<NUM_LIT>", ",", "<STR_LIT>", "TARGET_DEFAULT", "<STR_LIT>", ",", "TARGET_DEFAULT", ")", ";", "fprintf", "(", "stderr", ",", "DEBUG_FMT_S", ",", "<STR_LIT>", "--with-cpu default", "<STR_LIT>", ",", "OPTION_TARGET_CPU_DEFAULT", "?", "OPTION_TARGET_CPU_DEFAULT", ":", "<STR_LIT>", "<none>", "<STR_LIT>", ")", ";", "switch", "(", "rs6000_sched_costly_dep", ")", "{", "case", "max_dep_latency", ":", "costly_str", "=", "<STR_LIT>", "max_dep_latency", "<STR_LIT>", ";", "break", ";", "case", "no_dep_costly", ":", "costly_str", "=", "<STR_LIT>", "no_dep_costly", "<STR_LIT>", ";", "break", ";", "case", "all_deps_costly", ":", "costly_str", "=", "<STR_LIT>", "all_deps_costly", "<STR_LIT>", ";", "break", ";", "case", "true_store_to_load_dep_costly", ":", "costly_str", "=", "<STR_LIT>", "true_store_to_load_dep_costly", "<STR_LIT>", ";", "break", ";", "case", "store_to_load_dep_costly", ":", "costly_str", "=", "<STR_LIT>", "store_to_load_dep_costly", "<STR_LIT>", ";", "break", ";", "default", ":", "costly_str", "=", "costly_num", ";", "sprintf", "(", "costly_num", ",", "<STR_LIT>", "%d", "<STR_LIT>", ",", "(", "int", ")", "rs6000_sched_costly_dep", ")", ";", "break", ";", "}", "fprintf", "(", "stderr", ",", "DEBUG_FMT_S", ",", "<STR_LIT>", "sched_costly_dep", "<STR_LIT>", ",", "costly_str", ")", ";", "switch", "(", "rs6000_sched_insert_nops", ")", "{", "case", "sched_finish_regroup_exact", ":", "nop_str", "=", "<STR_LIT>", "sched_finish_regroup_exact", "<STR_LIT>", ";", "break", ";", "case", "sched_finish_pad_groups", ":", "nop_str", "=", "<STR_LIT>", "sched_finish_pad_groups", "<STR_LIT>", ";", "break", ";", "case" ]

[ "unsigned", "Kind", ")", "const", "{" ]

[ "const", "TargetRegisterClass", "*", "VERegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", "," ]

[ "}" ]

[ "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "(", "set", "ROWD", ":", "$", "wd", ",", "(", "MipsVSHF", "ROWD", ":", "$", "wd_in", ",", "ROWS", ":", "$", "ws", ",", "ROWT", ":", "$", "wt", ")", ")", "]", ";", "string", "Constraints", "=", "<STR_LIT>", ";", "InstrItinClass", "Itinerary", "=", "itin", ";" ]

[ "<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", "prefersSlot3", "=" ]

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

[ "class", "SUBSUS_U_B_ENC", ":", "MSA_3R_FMT", "<", "<NUM_LIT>", ",", "<NUM_LIT>", "," ]

[ "ret", ".", "val", "[", "<NUM_LIT>", "]", "=", "(", "float64x2_t", ")", "_", "_", "builtin_aarch64_get_qregoiv2df", "(", "_", "_", "o", ",", "<NUM_LIT>", ")", ";" ]

[ "float64x2x2_t", "ret", ";", "_", "_", "builtin_aarch64_simd_oi", "_", "_", "o", ";", "_", "_", "o", "=", "_", "_", "builtin_aarch64_ld2v2df", "(", "(", "const", "_", "_", "builtin_aarch64_simd_df", "*", ")", "_", "_", "a", ")", ";" ]

[ "GISelKnownBits", "*", "KB", "=", "&", "getAnalysis", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ".", "get", "(", "MF", ")", ";" ]

[ "bool", "AArch64PreLegalizerCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "EnableOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "skipFunction", "(", "F", ")", ";" ]

[ ")" ]

[ "(", "define_int_attr", "tls", "[", "(", "UNSPEC_TLSGD_CALL", "<STR_LIT>", ")", "(", "UNSPEC_TLSLDM_CALL", "<STR_LIT>", ")", "]" ]

[ "VECREG", ":", "$", "rA", ",", "rotNeg7imm", ":", "$", "val", ")", ",", "[", "]", ">", ";" ]

[ "class", "ROTQMBYIVecInst", "<", "ValueType", "vectype", ">", ":", "ROTQMBYIInst", "<", "(", "outs", "VECREG", ":", "$", "rT", ")", ",", "(", "ins" ]

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

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

[ "==", "<NUM_LIT>", ")", "return", "true", ";" ]

[ "FOR_EACH_INSN_USE", "(", "use", ",", "insn", ")", "{", "rtx", "x", "=", "DF_REF_REG", "(", "use", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")" ]

[ "bool", "SystemZTargetLowering", "::", "hasInlineStackProbe", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "<STR_LIT>", "probe-stack", "<STR_LIT>", ")", ")", "return", "MF", ".", "getFunction", "(", ")", ".", "getFnAttribute", "(", "<STR_LIT>", "probe-stack", "<STR_LIT>", ")", ".", "getValueAsString", "(", ")", "==", "<STR_LIT>", "inline-asm", "<STR_LIT>", ";", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "stack", "probing", "through", "inline", "assembly", "is", "requested", "." ]

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

[ "(", "DI", "<STR_LIT>", ")", "(", "V2DI", "<STR_LIT>", ")", "(", "V4HF", "<STR_LIT>", ")", "(", "V8HF", "<STR_LIT>", ")", "(", "V2SF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")", "(", "V4BF", "<STR_LIT>", ")" ]

[ "}" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "VAARG not yet implemented for the SVR4 ABI!", "<STR_LIT>", ")", ";", "return", "SDValue", "(", ")", ";" ]

[ "<FIXS>", "addRegOffset", "(", "BuildMI", "(", "restoreMBB", ",", "MIMD", ",", "TII", "->", "get", "(", "Opm", ")", ",", "BasePtr", ")", ",", "<FIXE>", "<FIXS>", "BuildMI", "(", "restoreMBB", ",", "MIMD", ",", "TII", "->", "get", "(", "X86", "::", "MOV32ri", ")", ",", "restoreDstReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "restoreMBB", ",", "MIMD", ",", "TII", "->", "get", "(", "X86", "::", "JMP_1", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "<FIXE>" ]

[ "Register", "FramePtr", "=", "RegInfo", "->", "getFrameRegister", "(", "*", "MF", ")", ";", "Register", "BasePtr", "=", "RegInfo", "->", "getBaseRegister", "(", ")", ";", "unsigned", "Opm", "=", "Uses64BitFramePtr", "?", "X86", "::", "MOV64rm", ":", "X86", "::", "MOV32rm", ";", "<BUGS>", "addRegOffset", "(", "BuildMI", "(", "restoreMBB", ",", "DL", ",", "TII", "->", "get", "(", "Opm", ")", ",", "BasePtr", ")", ",", "<BUGE>", "FramePtr", ",", "true", ",", "X86FI", "->", "getRestoreBasePointerOffset", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "<BUGS>", "BuildMI", "(", "restoreMBB", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "MOV32ri", ")", ",", "restoreDstReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "restoreMBB", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "JMP_1", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "<BUGE>", "restoreMBB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";" ]

[ "}" ]

[ "def", "g8rc", ":", "RegisterOperand", "<", "G8RC", ">", "{", "let", "ParserMatchClass", "=", "PPCRegG8RCAsmOperand", ";" ]

[ "<FIXS>", "defm", "VSQRT", ":", "sse1_fp_unop_s_avx", "<NUM_LIT>", ",", "<STR_LIT>", ">", ",", "sse2_fp_unop_s_avx", "<NUM_LIT>", ",", "<STR_LIT>", ">", ",", "VEX_4V", ";", "<FIXE>" ]

[ "let", "Predicates", "=", "[", "HasAVX", "]", "in", "{", "<BUGS>", "defm", "VSQRT", ":", "sse1_fp_unop_s_avx", "<NUM_LIT>", ",", "<STR_LIT>", ",", "fsqrt", ",", "int_x86_sse_sqrt_ss", ">", ",", "sse2_fp_unop_s_avx", "<NUM_LIT>", ",", "<STR_LIT>", ",", "fsqrt", ",", "int_x86_sse2_sqrt_sd", ">", ",", "VEX_4V", ";", "<BUGE>", "defm", "VSQRT", ":", "sse1_fp_unop_p", "<NUM_LIT>", ",", "<STR_LIT>", ",", "fsqrt", ">", ",", "sse2_fp_unop_p", "<NUM_LIT>", ",", "<STR_LIT>", ",", "fsqrt", ">", "," ]

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

[ "if", "(", "isValidToBeChangedReg", "(", "ADDMI", ",", "<NUM_LIT>", ",", "ADDIMI", ",", "OffsetAddi", ",", "OffsetImm", ")", ")", "ScaleRegIdx", "=", "<NUM_LIT>", ";", "else", "if", "(", "isValidToBeChangedReg", "(", "ADDMI", ",", "<NUM_LIT>", ",", "ADDIMI", ",", "OffsetAddi", ",", "OffsetImm", ")", ")", "ScaleRegIdx", "=", "<NUM_LIT>", ";", "else", "return", "false", ";", "assert", "(", "ADDIMI", "&&", "<STR_LIT>", "There should be ADDIMI for valid ToBeChangedReg.", "<STR_LIT>", ")", ";", "Register", "ToBeChangedReg", "=", "ADDIMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "ScaleReg", "=", "ADDMI", "->", "getOperand", "(", "ScaleRegIdx", ")", ".", "getReg", "(", ")", ";", "auto", "NewDefFor", "=", "[", "&", "]", "(", "unsigned", "Reg", ",", "MachineBasicBlock", "::", "iterator", "Start", ",", "MachineBasicBlock", "::", "iterator", "End", ")", "{", "for", "(", "auto", "It", "=", "++", "Start", ";", "It", "!=", "End", ";", "It", "++", ")", "if", "(", "It", "->", "modifiesRegister", "(", "Reg", ",", "&", "getRegisterInfo", "(", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", ";", "if", "(", "III", ".", "ZeroIsSpecialOrig", "==", "III", ".", "ImmOpNo", "&&", "(", "ScaleReg", "==", "PPC", "::", "R0", "||", "ScaleReg", "==", "PPC", "::", "X0", ")", ")", "return", "false", ";", "if", "(", "NewDefFor", "(", "ToBeChangedReg", ",", "*", "ADDMI", ",", "MI", ")", "||", "NewDefFor", "(", "ScaleReg", ",", "*", "ADDMI", ",", "MI", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Replace instruction: ", "<STR_LIT>", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "ADDIMI", "->", "dump", "(", ")", ")", ";", "LLVM_DEBUG", "(", "ADDMI", "->", "dump", "(", ")", ")", ";", "LLVM_DEBUG", "(", "MI", ".", "dump", "(" ]

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

[ "def", "A2_orir", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_2op", ">", ",", "Enc_140c83", ",", "ImmRegRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "}", ")" ]

[ "{", "return", "(", "GET_CODE", "(", "op", ")", "=", "=", "SYMBOL_REF", "|", "|", "GET_CODE", "(", "op", ")", "=", "=", "LABEL_REF", "|", "|", "GET_CODE", "(", "op", ")", "=", "=", "CONST", ")" ]

[ "_", "_", "v8si", "*", ")", "_", "_", "P", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_load_epi32", "(", "void", "const", "*", "_", "_", "P", ")", "{", "return", "(", "_", "_", "m256i", ")", "(", "*", "(" ]

[ "<FIXS>", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>", "<FIXS>", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>", "<FIXS>", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "<STR_LIT>", ")", "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "<STR_LIT>", ")", "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "<STR_LIT>", ")" ]

[ "true", ")", ";" ]

[ "assert", "(", "TheTriple", ".", "isOSBinFormatELF", "(", ")", "&&", "<STR_LIT>", "Expect either MachO or ELF target", "<STR_LIT>", ")", ";", "uint8_t", "OSABI", "=", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "TheTriple", ".", "getOS", "(", ")", ")", ";", "return", "new", "ELFAArch64AsmBackend", "(", "T", ",", "OSABI", "," ]