Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "int", "eligible_for_sibcall_delay", "(", "rtx_insn", "*", "trial", ")", "{", "rtx", "pat", ";", "if", "(", "get_attr_in_branch_delay", "(", "trial", ")", "==", "IN_BRANCH_DELAY_FALSE", ")", "return", "<NUM_LIT>", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "trial", ")", ")", "return", "<NUM_LIT>", ";", "pat", "=", "PATTERN", "(", "trial", ")", ";", "if", "(", "sparc_leaf_function_p", "||", "TARGET_FLAT", ")", "{", "if", "(", "LEAF_SIBCALL_SLOT_RESERVED_P", ")", "return", "<NUM_LIT>", ";", "if", "(", "reg_mentioned_p", "(", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ",", "pat", ")", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "pat", ")", ")", "!=", "REG", "||", "(", "REGNO", "(", "SET_DEST", "(", "pat", ")", ")", ">=", "<NUM_LIT>", "&&", "REGNO", "(", "SET_DEST", "(", "pat", ")", ")", "<", "<NUM_LIT>", ")", "||", "!", "SPARC_INT_REG_P", "(", "REGNO", "(", "SET_DEST", "(", "pat", ")", ")", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "reg_mentioned_p", "(", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ",", "pat", ")", ")", "return", "<NUM_LIT>", ";", "return", "eligible_for_restore_insn", "(", "trial", ",", "false", ")", ";", "}" ]

[ "Return", "nonzero", "if", "TRIAL", "can", "go", "into", "the", "sibling", "call", "'s", "delay", "slot", "." ]

[ ")", "]" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>" ]

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

[ "(", "clobber", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "}" ]

[ "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "if_then_else", ":", "SWI248", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "{", "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", "operands", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", "}", "else", "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", "operands", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]" ]

[ "true", ";" ]

[ "if", "(", "!", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "R", ")", ")", "continue", ";", "for", "(", "MCSubRegIterator", "SR", "(", "R", ",", "&", "TRI", ",", "true", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "Live", ".", "reset", "(", "*", "SR", ")", ";", "}", "for", "(", "auto", "&", "Op", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isUse", "(", ")", ")", "continue", ";", "unsigned", "R", "=", "Op", ".", "getReg", "(", ")", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "R", ")", ")", "continue", ";", "bool", "IsLive", "=", "false", ";", "for", "(", "MCSubRegIterator", "SR", "(", "R", ",", "&", "TRI", ",", "true", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "if", "(", "!", "Live", "[", "*", "SR", "]", ")", "continue", ";", "IsLive", "=" ]

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

[ "Value", "*", "OtherObj", "=", "GetUnderlyingObject", "(", "OtherOp", ",", "*", "DL", ")", ";", "if", "(", "!", "isa", "<", "AllocaInst", ">", "(", "OtherObj", ")", ")", "return", "false", ";", "if", "(", "OtherObj", "!=", "BaseAlloca", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Found a binary instruction with another alloca object\\n", "<STR_LIT>", ")", ";" ]

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

[ "if", "(", "high", "==", "low", ")", "insn", "=", "emit_insn", "(", "gen_stack_pop", "(", "gen_rtx_REG", "(", "SImode", ",", "low", ")", ")", ")", ";", "else", "insn", "=", "emit_insn", "(", "gen_stack_popm", "(", "GEN_INT", "(", "(", "(", "high", "-", "low", ")", "+", "<NUM_LIT>", ")", "*", "UNITS_PER_WORD", ")", ",", "gen_rx_popm_vector", "(", "low", ",", "high", ")", ")", ")", ";", "add_pop_cfi_notes", "(", "insn", ",", "high", "," ]

[ ",", "getContext", "(", ")", ")", ";" ]

[ "getParser", "(", ")", ".", "parseExpression", "(", "Subsection", ")", ";", "if", "(", "!", "Subsection", "->", "evaluateAsAbsolute", "(", "Res", ")", ")", "return", "Error", "(", "L", ",", "<STR_LIT>", "Cannot evaluate subsection number", "<STR_LIT>", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "TokError", "(", "<STR_LIT>", "unexpected token in directive", "<STR_LIT>", ")", ";", "if", "(", "(", "Res", "<", "<NUM_LIT>", ")", "&&", "(", "Res", ">", "-", "<NUM_LIT>", ")", ")", "Subsection", "=", "HexagonMCExpr", "::", "create", "(", "MCConstantExpr", "::", "create", "(", "<NUM_LIT>", "+", "Res", ",", "getContext", "(", ")", ")" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "ByteAccess", ";" ]

[ "_", "B", ")", ";" ]

[ "*", "(", "_", "_", "mmask32", "*", ")", "_", "_", "A", "=", "_", "_", "builtin_ia32_kmovd", "(", "_" ]

[ "<NUM_LIT>", ",", "(", "v2i64", ")", "_", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_lsx_vsra_d", "(", "(", "v2i64", ")", "_" ]

[ "}" ]

[ "def", "KryoWrite_1cyc_X_LS_Y_295ln", ":", "SchedWriteRes", "<", "[", "KryoUnitX", ",", "KryoUnitLS", ",", "KryoUnitY", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "isInt32Immediate", "(", "Op1", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Value", ")", ")", "{" ]

[ "unsigned", "Value", ",", "SH", "=", "<NUM_LIT>", ";", "TargetMask", "=", "~", "TargetMask", ";", "InsertMask", "=", "~", "InsertMask", ";", "if", "(", "Op0Opc", "==", "ISD", "::", "AND", "&&", "Op1Opc", "==", "ISD", "::", "AND", ")", "{", "if", "(", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", "||", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", ")", "{", "if", "(", "Op1", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SHL", "&&", "Op1", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SRL", ")", "{", "std", "::", "swap", "(", "Op0", ",", "Op1", ")", ";", "std", "::", "swap", "(", "Op0Opc", ",", "Op1Opc", ")", ";", "std", "::", "swap", "(", "TargetMask", ",", "InsertMask", ")", ";", "}", "}", "}", "else", "if", "(", "Op0Opc", "==", "ISD", "::", "SHL", "||", "Op0Opc", "==", "ISD", "::", "SRL", ")", "{", "if", "(", "Op1Opc", "==", "ISD", "::", "AND", "&&", "Op1", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SHL", "&&", "Op1", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SRL", ")", "{", "std", "::", "swap", "(", "Op0", ",", "Op1", ")", ";", "std", "::", "swap", "(", "Op0Opc", ",", "Op1Opc", ")", ";", "std", "::", "swap", "(", "TargetMask", ",", "InsertMask", ")", ";", "}", "}", "unsigned", "MB", ",", "ME", ";", "if", "(", "isRunOfOnes", "(", "InsertMask", ",", "MB", ",", "ME", ")", ")", "{", "SDValue", "Tmp1", ",", "Tmp2", ";", "if", "(", "(", "Op1Opc", "==", "ISD", "::", "SHL", "||", "Op1Opc", "==", "ISD", "::", "SRL", ")", "&&" ]

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

[ "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "BranchInst", "*", "Term", ")", ";", "<FIXE>" ]

[ "Value", "*", "handleLoopCondition", "(", "Value", "*", "Cond", ",", "PHINode", "*", "Broken", ",", "llvm", "::", "Loop", "*", "L", ",", "<BUGS>", "BranchInst", "*", "Term", ",", "SmallVectorImpl", "WeakTrackingVH", ">", "&", "LoopPhiConditions", ")", ";", "<BUGE>", "void", "handleLoop", "(", "BranchInst", "*", "Term", ")", ";" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "class", "WaitcntBrackets", "{", "<FIXE>", "<FIXS>", "WaitcntBrackets", "(", "const", "GCNSubtarget", "*", "SubTarget", ")", ":", "ST", "(", "SubTarget", ")", "{", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "}", "}", "<BUGS>", "<BUGE>", "<BUGS>", "class", "BlockWaitcntBrackets", "{", "<BUGE>", "public", ":", "<BUGS>", "BlockWaitcntBrackets", "(", "const", "GCNSubtarget", "*", "SubTarget", ")", ":", "ST", "(", "SubTarget", ")", "{", "<BUGE>", "for", "(", "auto", "T", ":", "inst_counter_types", "(", ")", ")", "memset", "(", "VgprScores", "[", "T", "]", ",", "<NUM_LIT>", ",", "sizeof", "(", "VgprScores", "[", "T", "]", ")", ")", ";", "}", "<BUGS>", "~", "BlockWaitcntBrackets", "(", ")", "=", "default", ";", "<BUGE>", "static", "uint32_t", "getWaitCountMax", "(", "InstCounterType", "T", ")", "{", "switch", "(", "T", ")", "{", "case", "VM_CNT", ":" ]

[ "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "LowerCallTo", "(", "CLI", ")", ";" ]

[ "RetTy", "=", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "}", "ArgListEntry", "Entry", ";", "Entry", ".", "Node", "=", "Arg", ";", "Entry", ".", "Ty", "=", "ArgTy", ";", "Entry", ".", "isSExt", "=", "false", ";", "Entry", ".", "isZExt", "=", "false", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "const", "char", "*", "LibcallName", "=", "(", "ArgVT", "==", "MVT", "::", "f64", ")", "?", "<STR_LIT>", "__sincos_stret", "<STR_LIT>", ":", "<STR_LIT>", "__sincosf_stret", "<STR_LIT>", ";", "RTLIB", "::", "Libcall", "LC", "=", "(", "ArgVT", "==", "MVT", "::", "f64", ")", "?", "RTLIB", "::", "SINCOS_F64", ":", "RTLIB", "::", "SINCOS_F32", ";", "CallingConv", "::", "ID", "CC", "=", "getLibcallCallingConv", "(", "LC", ")", ";", "SDValue", "Callee", "=", "DAG", ".", "getExternalSymbol", "(", "LibcallName", ",", "getPointerTy", "(", "DL", ")", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "DAG", ".", "getEntryNode", "(", ")", ")", ".", "setCallee", "(", "CC", ",", "RetTy", ",", "Callee", ",", "std", "::", "move", "(", "Args", ")", ")", ".", "setDiscardResult", "(", "ShouldUseSRet", ")", ";" ]

[ "}" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "true", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "!", "IsFloat", ";", "default", ":", "return", "false", ";", "}", ";" ]

[ "ix86_expand_call", "(", "NULL", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", "," ]

[ "(", "set", "(", "reg", ":", "SI", "SP_REG", ")", "(", "plus", ":", "SI", "(", "reg", ":", "SI", "SP_REG", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", ")", ")", ")", "]", ")", "]", "<STR_LIT>", "{" ]

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

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

[ "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "(", "clobber", "(", "match_scratch", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "if_then_else", ":", "V2DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")" ]

[ "->", "operands", "(", ")", ")", "{" ]

[ "MachineInstr", "*", "KeyMI", "=", "getKeyAMXInstr", "(", "CfgMI", ")", ";", "SmallVector", "<", "MachineOperand", "*", ">", "DefTiles", ";", "for", "(", "MachineOperand", "&", "MO", ":", "KeyMI" ]

[ "}", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CC", "FLAGS_REG", ")", "(", "compare", ":", "CC", "(", "match_operand", ":", "SDWIM", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SDWIM", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "reg", ":", "CC", "FLAGS_REG", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "<", "MODE", ">", "mode", "=", "=", "(", "TARGET_64BIT", "?", "TImode", ":", "DImode", ")", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!", "=", "EQ", "&", "&", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!", "=", "NE", ")", "FAIL", "}", "else", "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "&", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "<", "MODE", ">", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "ix86_expand_setcc", "(", "operands", "[", "<NUM_LIT>", "]", ",", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", "DONE" ]

[ "if", "(", "!", "Op1", "&&", "!", "Op2", "&&", "!", "Op3", "&&", "Op4", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "Other", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "return", "SDValue", "(", "Res", ",", "<NUM_LIT>", ")", ";", "}", "unsigned", "isDev", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "!", "isDev", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "Other", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "unsigned", "Op1", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "Op2", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "Op3", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "Op4", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";" ]

[ "<FIXS>", "<STR_LIT>", "{", "avr_fix_inputs", "(", "operands", ",", "<NUM_LIT>", "<NUM_LIT>", ",", "regmask", "(", "MODE", ">", "mode", ",", "<NUM_LIT>", ")", ")", "}", ")", "<FIXE>" ]

[ "(", "clobber", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", "]", ")", "(", "set", "(", "match_operand", ":", "ALL2QA", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "reg", ":", "ALL2QA", "<NUM_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", ")", "<BUGE>" ]

[ "Changed", "=", "true", ";" ]

[ "MachineInstr", "&", "MI", "=", "*", "I", "++", ";", "if", "(", "!", "MI", ".", "mayLoadOrStore", "(", ")", ")", "continue", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "int", "MemOpNo", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "Desc", ".", "TSFlags", ")", ";", "if", "(", "MemOpNo", "<", "<NUM_LIT>", ")", "continue", ";", "MemOpNo", "+=", "<STR_LIT>", "::", "<STR_LIT>", "(", "Desc", ")", ";", "MachineInstr", "*", "DefMI", ";", "int64_t", "AddrDispShift", ";", "int", "Dist", ";", "if", "(", "!", "chooseBestLEA", "(", "LEAs", "[", "getMemOpKey", "(", "MI", ",", "MemOpNo", ")", "]", ",", "MI", ",", "DefMI", ",", "AddrDispShift", ",", "Dist", ")", ")", "continue", ";", "if", "(", "Dist", "<", "<NUM_LIT>", ")", "{", "DefMI", "->", "removeFromParent", "(", ")", ";", "MBB", "->", "insert", "(", "MachineBasicBlock", "::", "iterator", "(", "&", "MI", ")", ",", "DefMI", ")", ";", "InstrPos", "[", "DefMI", "]", "=", "InstrPos", "[", "&", "MI", "]", "-", "<NUM_LIT>", ";", "assert", "(", "(", "(", "InstrPos", "[", "DefMI", "]", "==", "<NUM_LIT>", "&&", "MachineBasicBlock", "::", "iterator", "(", "DefMI", ")", "==", "MBB", "->", "begin", "(", ")", ")", "||", "InstrPos", "[", "DefMI", "]", ">", "InstrPos", "[", "&", "*", "std", "::", "prev", "(", "MachineBasicBlock", "::", "iterator", "(", "DefMI", ")", ")", "]", ")", "&&", "<STR_LIT>", "Instruction positioning is broken", "<STR_LIT>", ")", ";", "}", "MRI", "->", "clearKillFlags", "(", "DefMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "++", "NumSubstLEAs", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "OptimizeLEAs: Candidate to replace: ", "<STR_LIT>", ";", "MI", ".", "dump", "(", ")", ";", ")", ";", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrBaseReg", ")", ".", "ChangeToRegister", "(", "DefMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrScaleAmt", ")", ".", "ChangeToImmediate", "(", "<NUM_LIT>", ")", ";", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrIndexReg", ")", ".", "ChangeToRegister", "(", "X86", "::", "NoRegister", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrDisp", ")", ".", "ChangeToImmediate", "(", "AddrDispShift", ")", ";", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrSegmentReg", ")", ".", "ChangeToRegister", "(", "X86", "::", "NoRegister", ",", "false", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "OptimizeLEAs: Replaced by: ", "<STR_LIT>", ";", "MI", ".", "dump", "(", ")", ";", ")", ";" ]

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

[ "(", "vec_concat", ":", "<", "vec_2x_nelts", ">", "(", "match_operand", ":", "V_HW_4", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V_HW_4", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ ")", ";" ]

[ "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "<NUM_LIT>", "]", ")", "return", "true", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O" ]

[ "}", "else", "if", "(", "FileFormat", "->", "hasGOTPLT", "(", ")", "&&", "(", "&", "pSection", "==", "&", "(", "FileFormat", "->", "getGOTPLT", "(", ")", ")", ")", ")", "{" ]

[ "const", "ELFFileFormat", "*", "FileFormat", "=", "getOutputFormat", "(", ")", ";", "assert", "(", "FileFormat", "&&", "<STR_LIT>", "ELFFileFormat is NULL in X86GNULDBackend::emitSectionData!", "<STR_LIT>", ")", ";", "unsigned", "int", "EntrySize", "=", "<NUM_LIT>", ";", "uint64_t", "RegionSize", "=", "<NUM_LIT>", ";", "if", "(", "FileFormat", "->", "hasPLT", "(", ")", "&&", "(", "&", "pSection", "==", "&", "(", "FileFormat", "->", "getPLT", "(", ")", ")", ")", ")", "{", "unsigned", "char", "*", "buffer", "=", "pRegion", ".", "begin", "(", ")", ";", "m_pPLT", "->", "applyPLT0", "(", ")", ";", "m_pPLT", "->", "applyPLT1", "(", ")", ";", "X86PLT", "::", "iterator", "it", "=", "m_pPLT", "->", "begin", "(", ")", ";", "unsigned", "int", "plt0_size", "=", "llvm", "::", "cast", "<", "PLTEntryBase", ">", "(", "(", "*", "it", ")", ")", ".", "size", "(", ")", ";", "memcpy", "(", "buffer", ",", "llvm", "::", "cast", "<", "PLTEntryBase", ">", "(", "(", "*", "it", ")", ")", ".", "getValue", "(", ")", ",", "plt0_size", ")", ";", "RegionSize", "+=", "plt0_size", ";", "++", "it", ";", "PLTEntryBase", "*", "plt1", "=", "<NUM_LIT>", ";", "X86PLT", "::", "iterator", "ie", "=", "m_pPLT", "->", "end", "(", ")", ";", "while", "(", "it", "!=", "ie", ")", "{", "plt1", "=", "&", "(", "llvm", "::", "cast", "<", "PLTEntryBase", ">", "(", "*", "it", ")", ")", ";", "EntrySize", "=", "plt1", "->", "size", "(", ")", ";", "memcpy", "(", "buffer", "+", "RegionSize", ",", "plt1", "->", "getValue", "(", ")", ",", "EntrySize", ")", ";", "RegionSize", "+=", "EntrySize", ";", "++", "it", ";", "}", "}", "else", "if", "(", "FileFormat", "->", "hasGOT", "(", ")", "&&", "(", "&", "pSection", "==", "&", "(", "FileFormat", "->", "getGOT", "(", ")", ")", ")", ")", "{", "RegionSize", "+=", "emitGOTSectionData", "(", "pRegion", ")", ";" ]

[ "CC_AArch64_DarwinPCS", ":", "CC_AArch64_AAPCS", ";" ]

[ "return", "Subtarget", "->", "isTargetDarwin", "(", ")", "?" ]

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

[ "if", "(", "FP_REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "return", "<STR_LIT>", "return", "<STR_LIT>", "<BUGS>", "}", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "cc0", ")" ]

[ "(", "current_function_decl", ")", ";" ]

[ "if", "(", "!", "TARGET_DSBT", ")", "return", "false", ";", "cgraph_node", "*", "local_info_node", "=", "cgraph_node", "::", "local_info_node" ]

[ "GEN_INT", "(", "mask", "&", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")" ]

[ "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "mask", "&", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "mask", "&", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "mask", "&", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", "," ]

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

[ "APInt", "NegMaskVal", "=", "MaskVal", "|", "HighZeros", ";", "unsigned", "MinWidth", "=", "NegMaskVal", ".", "getMinSignedBits", "(", ")", ";", "if", "(", "MinWidth", ">", "<NUM_LIT>", "||", "(", "MinWidth", ">", "<NUM_LIT>", "&&", "MaskVal", ".", "getMinSignedBits", "(", ")", "<=", "<NUM_LIT>", ")", ")", "return", "false", ";", "if", "(", "!", "CurDAG", "->", "MaskedValueIsZero", "(", "And0", ",", "HighZeros", ")", ")", "return", "false", ";", "if", "(", "NegMaskVal", ".", "isAllOnesValue", "(", ")", ")", "{", "ReplaceNode", "(", "And", ",", "And0", ".", "getNode", "(", ")", ")", ";", "return", "true", ";", "}", "SDValue", "NewMask", "=", "CurDAG", "->", "getConstant", "(", "NegMaskVal", ",", "SDLoc", "(", "And", ")", ",", "VT", ")", ";", "SDValue", "NewAnd", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "AND", ",", "SDLoc", "(", "And", ")", ",", "VT", ",", "And0", ",", "NewMask", ")", ";", "ReplaceNode", "(", "And", ",", "NewAnd", ".", "getNode", "(", ")", ")", ";", "SelectCode", "(", "NewAnd", ".", "getNode", "(" ]

[ ",", "Result", ".", "getValueType", "(", ")", ")", ";" ]

[ "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled conditional code!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LibCall", "=", "is64Bit", "?", "<STR_LIT>", "_Qp_feq", "<STR_LIT>", ":", "<STR_LIT>", "_Q_feq", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LibCall", "=", "is64Bit", "?", "<STR_LIT>", "_Qp_fne", "<STR_LIT>", ":", "<STR_LIT>", "_Q_fne", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LibCall", "=", "is64Bit", "?", "<STR_LIT>", "_Qp_flt", "<STR_LIT>", ":", "<STR_LIT>", "_Q_flt", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LibCall", "=", "is64Bit", "?", "<STR_LIT>", "_Qp_fgt", "<STR_LIT>", ":", "<STR_LIT>", "_Q_fgt", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LibCall", "=", "is64Bit", "?", "<STR_LIT>", "_Qp_fle", "<STR_LIT>", ":", "<STR_LIT>", "_Q_fle", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LibCall", "=", "is64Bit", "?", "<STR_LIT>", "_Qp_fge", "<STR_LIT>", ":", "<STR_LIT>", "_Q_fge", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LibCall", "=", "is64Bit", "?", "<STR_LIT>", "_Qp_cmp", "<STR_LIT>", ":", "<STR_LIT>", "_Q_cmp", "<STR_LIT>", ";", "break", ";", "}", "SDValue", "Callee", "=", "DAG", ".", "getExternalSymbol", "(", "LibCall", ",", "getPointerTy", "(", ")", ")", ";", "Type", "*", "RetTy", "=", "Type", "::", "getInt32Ty", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "ArgListTy", "Args", ";", "SDValue", "Chain", "=", "DAG", ".", "getEntryNode", "(", ")", ";", "Chain", "=", "LowerF128_LibCallArg", "(", "Chain", ",", "Args", ",", "LHS", ",", "DL", ",", "DAG", ")", ";", "Chain", "=", "LowerF128_LibCallArg", "(", "Chain", ",", "Args", ",", "RHS", ",", "DL", ",", "DAG", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "Chain", ",", "RetTy", ",", "false", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ",", "CallingConv", "::", "C", ",", "false", ",", "false", ",", "true", ",", "Callee", ",", "Args", ",", "DAG", ",", "DL", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallInfo", "=", "LowerCallTo", "(", "CLI", ")", ";", "SDValue", "Result", "=", "CallInfo", ".", "first", ";", "switch", "(", "SPCC", ")", "{", "default", ":", "{", "SDValue", "RHS", "=", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "Result", ".", "getValueType", "(", ")", ")", ";", "SPCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Glue", ",", "Result", ",", "RHS", ")", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "Mask", "=", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "Result", ".", "getValueType", "(", ")", ")", ";", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "Result", ".", "getValueType", "(", ")", ",", "Result", ",", "Mask", ")", ";", "SDValue", "RHS", "=", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "Result", ".", "getValueType", "(", ")", ")", ";", "SPCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Glue", ",", "Result", ",", "RHS", ")", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "RHS", "=", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "Result", ".", "getValueType", "(", ")", ")", ";", "SPCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Glue", ",", "Result", ",", "RHS", ")", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "RHS", "=", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "Result", ".", "getValueType", "(", ")", ")", ";", "SPCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Glue", ",", "Result", ",", "RHS", ")", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "RHS", "=", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>" ]

[ "}" ]

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

[ "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", ";" ]

[ "MachineInstr", "&", "MI", "=", "*", "II", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineOperand", "&", "FIOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "unsigned", "FI", "=", "FIOp", ".", "getIndex", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "unsigned", "ImmOpIdx", "=", "<NUM_LIT>", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{" ]

[ "MI", ",", "unsigned", "OpNo", ")", "{" ]

[ "void", "printf64mem", "(", "const", "MCInst", "*" ]

[ "(", "ME", ")", ")", ";" ]

[ "if", "(", "!", "MO", ".", "isJTI", "(", ")", "&&", "MO", ".", "getOffset", "(", ")", ")", "ME", "=", "MCBinaryExpr", "::", "CreateAdd", "(", "ME", ",", "MCConstantExpr", "::", "Create", "(", "MO", ".", "getOffset", "(", ")", ",", "MC", ")", ",", "MC", ")", ";", "return", "(", "MCOperand", "::", "CreateExpr" ]

[ ",", "am_unscaled_fb8", ":", "$", "addr", ")", ">", ";" ]

[ "def", ":", "InstAlias", "<", "<STR_LIT>", ",", "(", "STURBi", "FPR8", ":", "$", "Rt" ]

[ "}" ]

[ "const", "TMS320C64XRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "TMS320C64XRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "RegInfo", "->", "requiresRegisterScavenging", "(", "MF", ")", ")", "{", "RS", "->", "setScavengingFrameIndex", "(", "MFI", "->", "CreateStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "RC", "->", "getAlignment", "(", ")", ",", "false", ")", ")", ";", "}" ]

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

[ "else", "{", "assert", "(", "TheTriple", ".", "isOSBinFormatELF", "(", ")", "&&", "<STR_LIT>", "Only expect Darwin or ELF", "<STR_LIT>", ")", ";", "MAI", "=", "new", "AArch64MCAsmInfoELF", "(", "TheTriple", ")", ";", "}", "unsigned", "Reg", "=", "MRI", ".", "getDwarfRegNum", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ")", ";", "MCCFIInstruction", "Inst", "=", "MCCFIInstruction", "::", "createDefCfa", "(", "nullptr" ]

[ "false", ";" ]

[ "bool", "NMXTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return" ]

[ "_", "bu", ".", "_", "_", "o", ")", ";" ]

[ "_", "_", "builtin_neon_vst4v4hi", "(", "(", "_", "_", "builtin_neon_hi", "*", ")", "_", "_", "a", ",", "_" ]

[ "}" ]

[ "bool", "hasMP", "(", ")", "const", "{", "return", "HasMP", ";" ]

[ ")", ";" ]

[ "return", "A", ".", "getValNo", "(", ")", "<", "B", ".", "getValNo", "(", ")", ";", "}" ]

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

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

[ "Rn", ",", "sub_32", ")", ")", ",", "(", "MOVi32imm", "(", "trunc_imm", "imm", ":", "$", "C", ")", ")", ",", "GPR64", ":", "$", "Ra", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "i64", "(", "add", "(", "mul", "(", "sext_inreg", "GPR64", ":", "$", "Rn", ",", "i32", ")", ",", "(", "s64imm_32bit", ":", "$", "C", ")", ")", ",", "GPR64", ":", "$", "Ra", ")", ")", ",", "(", "SMADDLrrr", "(", "i32", "(", "EXTRACT_SUBREG", "GPR64", ":", "$" ]

[ "}" ]

[ "def", "F2_conv_df2ud_chop", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_3a867367", ",", "TypeS_2op", ">", ",", "Enc_b9c5fb", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isFP", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "USR", "]", ";" ]

[ "MBB", ".", "addLiveIn", "(", "Mips", "::", "V0", ")", ";" ]

[ "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "Mips", "::", "ADDiu", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "V0", ")", ".", "addExternalSymbol", "(", "<STR_LIT>", "__gnu_local_gp", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "MII", "->", "storeRegToStackSlot", "(", "MBB", ",", "I", ",", "GlobalBaseReg", ",", "false", ",", "FI", ",", "RC", ",", "TargetRegInfo", ")", ";", "return", ";", "}", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "Mips", "::", "T9", ")", ";", "MBB", ".", "addLiveIn", "(", "Mips", "::", "T9", ")", ";", "if", "(", "Subtarget", ".", "isABI_N32", "(", ")", ")", "{", "const", "GlobalValue", "*", "FName", "=", "MF", ".", "getFunction", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "Mips", "::", "LUi", ")", ",", "V0", ")", ".", "addGlobalAddress", "(", "FName", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "Mips", "::", "ADDu", ")", ",", "V1", ")", ".", "addReg", "(", "V0", ")", ".", "addReg", "(", "Mips", "::", "T9", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "Mips", "::", "ADDiu", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "V1", ")", ".", "addGlobalAddress", "(", "FName", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "MII", "->", "storeRegToStackSlot", "(", "MBB", ",", "I", ",", "GlobalBaseReg", ",", "false", ",", "FI", ",", "RC", ",", "TargetRegInfo", ")", ";", "return", ";", "}", "assert", "(", "Subtarget", ".", "isABI_O32", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "return", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "Mips", "::", "V0", ")", ";" ]

[ "<STR_LIT>" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "rotate", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "{", "<NUM_LIT>", ",", "MVT", "::", "v4i64", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v4f64", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v2i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v4i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v8i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v16i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v32i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v2i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v4i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v8i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v16i8", ",", "<NUM_LIT>", "}", ",", "{" ]

[ "{", "<NUM_LIT>", ",", "MVT", "::", "v4i64", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v4f64", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v2i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v4i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v8i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v16i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v32i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v8f32", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v2i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v4i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v8i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v16i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v32i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v8f32", ",", "<NUM_LIT>", "}", "}", ";", "static", "const", "CostTblEntry", "AVX2InterleavedStoreTbl", "[", "]", "=", "{" ]

[ "<FIXS>", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "<FIXE>" ]

[ "if", "(", "CONSTANT_P", "(", "op0", ")", "&&", "!", "CONSTANT_P", "(", "op1", ")", ")", "{", "<BUGS>", "tmp", "=", "op0", ",", "op0", "=", "op1", ",", "op1", "=", "tmp", ";", "<BUGE>", "code", "=", "swap_condition", "(", "code", ")", ";", "}" ]

[ ")", ";" ]

[ "pcs_variant", "=", "arm_get_pcs_model", "(", "fntype", ",", "fndecl", ")", ";", "}", "else", "pcs_variant", "=", "arm_pcs_default", ";", "if", "(", "type", "&&", "INTEGRAL_TYPE_P", "(", "type", ")", ")", "mode", "=", "arm_promote_function_mode", "(", "type", ",", "mode", ",", "&", "unsignedp", ",", "fntype", ",", "<NUM_LIT>", ")", ";", "if", "(", "pcs_variant", "!=", "ARM_PCS_AAPCS", ")", "{", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "ARM_NUM_COPROC_SLOTS", ";", "i", "++", ")", "if", "(", "aapcs_cp_arg_layout", "[", "i", "]", ".", "is_return_candidate", "(", "pcs_variant", ",", "mode", ",", "type", ")", ")", "return", "aapcs_cp_arg_layout", "[", "i", "]", ".", "allocate_return_reg", "(", "pcs_variant", ",", "mode", ",", "type", ")", ";", "}", "if", "(", "type", "&&", "arm_return_in_msb", "(", "type", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "V8QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "us_minus", ":", "V8QI", "(", "match_operand", ":", "V8QI" ]

[ "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "]", "<NUM_LIT>", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "<BUGS>", "]", "<NUM_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

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

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

[ "[", "(", "set", "(", "reg", ":", "CC", "CC_REGNUM", ")", "(", "compare", ":", "CC", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr" ]

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

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

[ ">", "{", "*", "Op0", "|", "*", "Op1", "}", ";" ]

[ "if", "(", "!", "Op0", "||", "!", "Op1", ")", "return", "std", "::", "optional", "<", "int64_t", ">", "{", "}", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Add", ")", "return", "std", "::", "optional", "<", "int64_t", ">", "{", "*", "Op0", "+", "*", "Op1", "}", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Mul", ")", "return", "std", "::", "optional", "<", "int64_t", ">", "{", "*", "Op0", "*", "*", "Op1", "}", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Shl", ")", "return", "std", "::", "optional", "<", "int64_t", ">", "{", "*", "Op0", "<<", "*", "Op1", "}", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Or", ")", "return", "std", "::", "optional", "<", "int64_t" ]

[ "VexOpcode", ";" ]

[ "TableChecked", ".", "store", "(", "true", ",", "std", "::", "memory_order_relaxed", ")", ";", "}", "ArrayRef", "<", "X86EvexToVexCompressTableEntry", ">", "Table", "=", "(", "Desc", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "?", "makeArrayRef", "(", "X86EvexToVex256CompressTable", ")", ":", "makeArrayRef", "(", "X86EvexToVex128CompressTable", ")", ";", "auto", "I", "=", "std", "::", "lower_bound", "(", "Table", ".", "begin", "(", ")", ",", "Table", ".", "end", "(", ")", ",", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "I", "==", "Table", ".", "end", "(", ")", "||", "I", "->", "EvexOpcode", "!=", "MI", ".", "getOpcode", "(", ")", ")", "return", "false", ";", "unsigned", "NewOpc", "=", "I", "->" ]

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

[ "def", "J2_jumprt_nopred_map", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_85c9c08f", ",", "TypeMAPPING", ">", ",", "Requires", "<", "[", "HasV60", "]", ">", "{", "let", "isPseudo", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "assert", "(", "isRhu", "(", ")", "&&", "<STR_LIT>", "Invalid operand type", "<STR_LIT>", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Rhu", ".", "Val", ")", ")", ";" ]

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

[ "}", "break", ";", "}", "case", "ARM", "::", "FCPYS", ":", "{", "unsigned", "Pred", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "PredReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "OpNum", "==", "<NUM_LIT>", ")", "{", "unsigned", "SrcReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "ARM", "::", "FSTS", ")", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ";", "}", "else", "{", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "ARM", "::", "FLDS", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ";", "}", "break", ";", "}", "case", "ARM", "::", "FCPYD", ":", "{", "unsigned", "Pred", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "PredReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "OpNum", "==", "<NUM_LIT>", ")", "{", "unsigned", "SrcReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "ARM", "::", "FSTD", ")", ")", ".", "addReg", "(", "SrcReg", ",", "false", ",", "false", ",", "isKill", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ";", "}", "else", "{", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg" ]

[ "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";" ]

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

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

[ ")", "{" ]

[ "PPCPreRASchedStrategy", "(", "const", "MachineSchedContext", "*", "C", ")", ":", "GenericScheduler", "(", "C" ]

[ "<FIXS>", "MBBI", "=", "next_nodbg", "(", "MBBI", ",", "E", ")", ";", "<FIXE>" ]

[ "MachineBasicBlock", "::", "iterator", "MBBI", "=", "I", ";", "MachineBasicBlock", "::", "iterator", "MBBIWithRenameReg", ";", "MachineInstr", "&", "FirstMI", "=", "*", "I", ";", "<BUGS>", "++", "MBBI", ";", "<BUGE>", "bool", "MayLoad", "=", "FirstMI", ".", "mayLoad", "(", ")", ";", "bool", "IsUnscaled", "=", "TII", "->", "isUnscaledLdSt", "(", "FirstMI", ")", ";" ]

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

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

[ "class", "Enc_8d8a30", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Ii", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Pv4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pv4", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rt32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Vd32", ";" ]

[ "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "AArch64RegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opc", ")", ")", "{", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "}", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "G_ADD", ":", "case", "TargetOpcode", "::", "G_SUB", ":", "case", "TargetOpcode", "::", "G_GEP", ":", "case", "TargetOpcode", "::", "G_MUL", ":", "case", "TargetOpcode", "::", "G_SDIV", ":", "case", "TargetOpcode", "::", "G_UDIV", ":", "case", "TargetOpcode", "::", "G_AND", ":", "case", "TargetOpcode", "::", "G_OR", ":", "case", "TargetOpcode", "::", "G_XOR", ":", "case", "TargetOpcode", "::", "G_SHL", ":", "case", "TargetOpcode", "::", "G_LSHR", ":", "case", "TargetOpcode", "::", "G_ASHR", ":", "case", "TargetOpcode", "::", "G_FADD", ":", "case", "TargetOpcode", "::", "G_FSUB", ":", "case", "TargetOpcode", "::", "G_FMUL", ":", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "getSameKindOfOperandsMapping", "(", "MI", ")", ";", "case", "TargetOpcode", "::", "G_BITCAST", ":", "{", "LLT", "DstTy", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "LLT", "SrcTy", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "unsigned", "Size", "=", "DstTy", ".", "getSizeInBits", "(", ")", ";", "bool", "DstIsGPR", "=", "!", "DstTy", ".", "isVector", "(", ")", ";", "bool", "SrcIsGPR", "=", "!", "SrcTy", ".", "isVector", "(", ")", ";", "const", "RegisterBank", "&", "DstRB", "=", "DstIsGPR", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "const", "RegisterBank", "&", "SrcRB", "=", "SrcIsGPR", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "getInstructionMapping", "(", "DefaultMappingID", ",", "copyCost", "(", "DstRB", ",", "SrcRB", ",", "Size", ")", ",", "getCopyMapping", "(", "DstRB", ".", "getID", "(", ")", ",", "SrcRB", ".", "getID", "(", ")", ",", "Size", ")", ",", "<NUM_LIT>", ")", ";", "}", "case", "TargetOpcode", "::", "G_SEQUENCE", ":", "return", "getInvalidInstructionMapping", "(", ")", ";", "default", ":", "break", ";", "}", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "OpSize", "(", "NumOperands", ")", ";", "SmallVector", "<", "PartialMappingIdx", ",", "<NUM_LIT>", ">", "OpRegBankIdx", "(", "NumOperands", ")", ";", "for", "(", "unsigned", "Idx", "=", "<NUM_LIT>", ";", "Idx", "<", "NumOperands", ";", "++", "Idx", ")", "{", "auto", "&", "MO", "=", "MI", ".", "getOperand", "(", "Idx", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "getReg", "(", ")", ")", "continue", ";", "LLT", "Ty", "=", "MRI", ".", "getType", "(", "MO", ".", "getReg", "(", ")", ")", ";", "OpSize", "[", "Idx", "]", "=", "Ty", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Ty", ".", "isVector", "(", ")", "||", "isPreISelGenericFloatingPointOpcode", "(", "Opc", ")", ")", "OpRegBankIdx", "[", "Idx", "]", "=", "PMI_FirstFPR", ";", "else", "OpRegBankIdx", "[", "Idx", "]", "=", "PMI_FirstGPR", ";", "}", "unsigned", "Cost", "=", "<NUM_LIT>", ";", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "G_SITOFP", ":", "case", "TargetOpcode", "::", "G_UITOFP", ":", "OpRegBankIdx", "=", "{", "PMI_FirstFPR", ",", "PMI_FirstGPR", "}", ";", "break", ";", "case", "TargetOpcode", "::", "G_FPTOSI", ":", "case", "TargetOpcode", "::", "G_FPTOUI", ":", "OpRegBankIdx", "=", "{", "PMI_FirstGPR", ",", "PMI_FirstFPR", "}", ";", "break", ";", "case", "TargetOpcode", "::", "G_FCMP", ":", "OpRegBankIdx", "=", "{", "PMI_FirstGPR", ",", "PMI_None", ",", "PMI_FirstFPR", ",", "PMI_FirstFPR", "}", ";", "break", ";", "case", "TargetOpcode", "::", "G_BITCAST", ":", "if", "(", "OpRegBankIdx", "[", "<NUM_LIT>", "]", "!=", "OpRegBankIdx", "[", "<NUM_LIT>", "]", ")", "Cost", "=", "copyCost", "(", "*", "AArch64GenRegisterBankInfo", "::", "PartMappings", "[", "OpRegBankIdx", "[", "<NUM_LIT>", "]", "]", ".", "RegBank", ",", "*", "AArch64GenRegisterBankInfo", "::", "PartMappings", "[", "OpRegBankIdx", "[", "<NUM_LIT>", "]", "]", ".", "RegBank", ",", "OpSize", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "if", "(", "OpRegBankIdx", "[", "<NUM_LIT>", "]", "!=", "PMI_FirstGPR", ")", "Cost", "=", "<NUM_LIT>", ";", "else", "for", "(", "const", "MachineInstr", "&", "UseMI", ":", "MRI", ".", "use_instructions", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "if", "(", "isPreISelGenericFloatingPointOpcode", "(", "UseMI", ".", "getOpcode", "(", ")", ")", ")", "{", "OpRegBankIdx", "[", "<NUM_LIT>", "]", "=", "PMI_FirstFPR", ";", "break", ";", "}", "break", ";", "case", "TargetOpcode", "::", "G_STORE", ":", "if", "(", "OpRegBankIdx", "[", "<NUM_LIT>", "]", "==", "PMI_FirstGPR", ")", "{", "unsigned", "VReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "VReg", ")", "break", ";", "MachineInstr", "*", "DefMI", "=", "MRI", ".", "getVRegDef", "(", "VReg", ")", ";", "if", "(", "isPreISelGenericFloatingPointOpcode", "(", "DefMI", "->", "getOpcode", "(", ")", ")", ")", "OpRegBankIdx", "[", "<NUM_LIT>", "]", "=", "PMI_FirstFPR", ";", "break", ";", "}", "}", "SmallVector", "<", "const", "ValueMapping", "*", ",", "<NUM_LIT>", ">", "OpdsMapping", "(", "NumOperands", ")", ";", "for", "(", "unsigned", "Idx", "=", "<NUM_LIT>", ";", "Idx", "<", "NumOperands", ";", "++", "Idx", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "Idx", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "Idx", ")", ".", "getReg", "(", ")", ")", "{", "auto", "Mapping", "=", "getValueMapping", "(", "OpRegBankIdx", "[", "Idx", "]", ",", "OpSize", "[", "Idx", "]", ")", ";", "if", "(", "!", "Mapping", "->", "isValid", "(", ")", ")", "return", "getInvalidInstructionMapping", "(", ")", ";", "OpdsMapping", "[", "Idx", "]", "=", "Mapping", ";", "}", "}", "return", "getInstructionMapping", "(", "DefaultMappingID", ",", "Cost", ",", "getOperandsMapping", "(", "OpdsMapping", ")", ",", "NumOperands", ")", ";", "}" ]

[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "lt", ":", "DF", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "if_then_else", ":", "DF", "(", "ne", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]" ]

[ ")", ")" ]

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

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

[ "static", "void", "alpha_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fputs", "(", "<STR_LIT>", "\\t.set noreorder\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "fputs", "(", "<STR_LIT>", "\\t.set volatile\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_ABI_OSF", ")", "fputs", "(", "<STR_LIT>", "\\t.set noat\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_EXPLICIT_RELOCS", ")", "fputs", "(", "<STR_LIT>", "\\t.set nomacro\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_SUPPORT_ARCH", "|", "TARGET_BWX", "|", "TARGET_MAX", "|", "TARGET_FIX", "|", "TARGET_CIX", ")", "{", "const", "char", "*", "arch", ";", "if", "(", "alpha_cpu", "==", "PROCESSOR_EV6", "||", "TARGET_FIX", "||", "TARGET_CIX", ")", "arch", "=", "<STR_LIT>", "ev6", "<STR_LIT>", ";", "else", "if", "(", "TARGET_MAX", ")", "arch", "=" ]

[ "TII", "->", "GetInstSizeInBytes", "(", "UserMI", ")", "+", "<NUM_LIT>", ")", ";" ]

[ "unsigned", "CPELogAlign", "=", "getCPELogAlign", "(", "CPEMI", ")", ";", "MachineBasicBlock", "*", "UserMBB", "=", "UserMI", "->", "getParent", "(", ")", ";", "const", "BasicBlockInfo", "&", "UserBBI", "=", "BBInfo", "[", "UserMBB", "->", "getNumber", "(", ")", "]", ";", "if", "(", "BBHasFallthrough", "(", "UserMBB", ")", ")", "{", "unsigned", "Delta", "=", "isThumb1", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "unsigned", "CPEOffset", "=", "UserBBI", ".", "postOffset", "(", "CPELogAlign", ")", "+", "Delta", ";", "if", "(", "isOffsetInRange", "(", "UserOffset", ",", "CPEOffset", ",", "U", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Split at end of BB#", "<STR_LIT>", "<<", "UserMBB", "->", "getNumber", "(", ")", "<<", "format", "(", "<STR_LIT>", ", expected CPE offset %#x\\n", "<STR_LIT>", ",", "CPEOffset", ")", ")", ";", "NewMBB", "=", "&", "*", "++", "UserMBB", "->", "getIterator", "(", ")", ";", "int", "UncondBr", "=", "isThumb", "?", "(", "(", "isThumb2", ")", "?", "ARM", "::", "t2B", ":", "ARM", "::", "tB", ")", ":", "ARM", "::", "B", ";", "if", "(", "!", "isThumb", ")", "BuildMI", "(", "UserMBB", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "UncondBr", ")", ")", ".", "addMBB", "(", "NewMBB", ")", ";", "else", "BuildMI", "(", "UserMBB", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "UncondBr", ")", ")", ".", "addMBB", "(", "NewMBB", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "unsigned", "MaxDisp", "=", "getUnconditionalBrDisp", "(", "UncondBr", ")", ";", "ImmBranches", ".", "push_back", "(", "ImmBranch", "(", "&", "UserMBB", "->", "back", "(", ")", ",", "MaxDisp", ",", "false", ",", "UncondBr", ")", ")", ";", "computeBlockSize", "(", "UserMBB", ")", ";", "adjustBBOffsetsAfter", "(", "UserMBB", ")", ";", "return", ";", "}", "}", "unsigned", "LogAlign", "=", "MF", "->", "getAlignment", "(", ")", ";", "assert", "(", "LogAlign", ">=", "CPELogAlign", "&&", "<STR_LIT>", "Over-aligned constant pool entry", "<STR_LIT>", ")", ";", "unsigned", "KnownBits", "=", "UserBBI", ".", "internalKnownBits", "(", ")", ";", "unsigned", "UPad", "=", "UnknownPadding", "(", "LogAlign", ",", "KnownBits", ")", ";", "unsigned", "BaseInsertOffset", "=", "UserOffset", "+", "U", ".", "getMaxDisp", "(", ")", "-", "UPad", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "format", "(", "<STR_LIT>", "Split in middle of big block before %#x", "<STR_LIT>", ",", "BaseInsertOffset", ")", ")", ";", "BaseInsertOffset", "-=", "<NUM_LIT>", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "format", "(", "<STR_LIT>", ", adjusted to %#x", "<STR_LIT>", ",", "BaseInsertOffset", ")", "<<", "<STR_LIT>", " la=", "<STR_LIT>", "<<", "LogAlign", "<<", "<STR_LIT>", " kb=", "<STR_LIT>", "<<", "KnownBits", "<<", "<STR_LIT>", " up=", "<STR_LIT>", "<<", "UPad", "<<", "'", "\\n", "'", ")", ";", "if", "(", "BaseInsertOffset", "+", "<NUM_LIT>", ">=", "UserBBI", ".", "postOffset", "(", ")", ")", "{", "BaseInsertOffset", "=", "std", "::", "max", "(", "UserBBI", ".", "postOffset", "(", ")", "-", "UPad", "-", "<NUM_LIT>", ",", "UserOffset", "+" ]

[ "<FIXS>", "<NUM_LIT>", "U", ",", "<NUM_LIT>", "U", ",", "<NUM_LIT>", "U", ",", "<FIXE>", "<FIXS>", "<NUM_LIT>", "U", ",", "<FIXE>" ]

[ "<NUM_LIT>", "U", ",", "<NUM_LIT>", "U", ",", "<NUM_LIT>", "U", ",", "<BUGS>", "<NUM_LIT>", "U", ",", "<NUM_LIT>", "U", ",", "<NUM_LIT>", "U", ",", "<BUGE>", "<NUM_LIT>", "U", ",", "<NUM_LIT>", "U", ",", "<NUM_LIT>", "U", ",", "<NUM_LIT>", "U", ",", "<NUM_LIT>", "U", ",", "<BUGS>", "<NUM_LIT>", "U", ",", "<BUGE>", "<NUM_LIT>", "U", ",", "<NUM_LIT>", "U", ",", "<NUM_LIT>", "U", "," ]

[ "DONE" ]

[ "gen_frame_mem", "(", "SImode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ")", ")", ",", "REG_INC", ",", "stack_pointer_rtx", ")" ]

[ "<FIXS>", "resv", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "res", ",", "ac", ".", "modemaski", ",", "<FIXE>", "<FIXS>", "cc", "=", "s390_emit_compare", "(", "NE", ",", "resv", ",", "val", ")", ";", "<FIXE>", "<FIXS>", "convert_move", "(", "target", ",", "expand_simple_binop", "(", "SImode", ",", "LSHIFTRT", ",", "res", ",", "ac", ".", "shift", ",", "<FIXE>" ]

[ "cmpv", ",", "new", "v", ")", ")", ";", "<BUGS>", "resv", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "res", ",", "ac", ".", "modemaski", ",", "<BUGE>", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "<BUGS>", "cc", "=", "s390_emit_compare", "(", "NE", ",", "resv", ",", "val", ")", ";", "<BUGE>", "emit_move_insn", "(", "val", ",", "resv", ")", ";", "s390_emit_jump", "(", "csloop", ",", "cc", ")", ";", "emit_label", "(", "csend", ")", ";", "<BUGS>", "convert_move", "(", "target", ",", "expand_simple_binop", "(", "SImode", ",", "LSHIFTRT", ",", "res", ",", "ac", ".", "shift", ",", "<BUGE>", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ",", "<NUM_LIT>", ")", ";", "}" ]

[ "bool", "R600InstrInfo", "::", "isPredicated", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "int", "idx", "=", "MI", ".", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "idx", "<", "<NUM_LIT>", ")", "return", "false", ";", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "idx", ")", ".", "getReg", "(", ")", ";", "switch", "(", "Reg", ")", "{", "default", ":", "return", "false", ";", "case", "AMDGPU", "::", "PRED_SEL_ONE", ":", "case", "AMDGPU", "::", "PRED_SEL_ZERO", ":", "case", "AMDGPU", "::", "PREDICATE_BIT", ":", "return", "true", ";", "}", "}" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

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

[ "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Opcode has no pre-indexed equivalent!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ ":", "<NUM_LIT>", ")", ";", "\\", "fprintf", "(", "FILE", ",", "<STR_LIT>", "\\tjal\\t_mcount\\n", "<STR_LIT>", ")", ";", "\\", "fprintf", "(", "FILE", ",", "<STR_LIT>", "\\t.set\\tat\\n", "<STR_LIT>", ")", ";", "\\", "}" ]

[ "mips_va_arg", "(", "valist", ",", "type", ")", "{", "\\", "if", "(", "TARGET_MIPS16", ")", "\\", "sorry", "(", "<STR_LIT>", "mips16 function profiling", "<STR_LIT>", ")", ";", "\\", "fprintf", "(", "FILE", ",", "<STR_LIT>", "\\t.set\\tnoat\\n", "<STR_LIT>", ")", ";", "\\", "fprintf", "(", "FILE", ",", "<STR_LIT>", "\\tmove\\t%s,%s\\t\\t# save current return address\\n", "<STR_LIT>", ",", "\\", "reg_names", "[", "GP_REG_FIRST", "+", "<NUM_LIT>", "]", ",", "reg_names", "[", "GP_REG_FIRST", "+", "<NUM_LIT>", "]", ")", ";", "\\", "fprintf", "(", "FILE", ",", "\\", "<STR_LIT>", "\\t%s\\t%s,%s,%d\\t\\t# _mcount pops 2 words from stack\\n", "<STR_LIT>", ",", "\\", "TARGET_64BIT", "?", "<STR_LIT>", "dsubu", "<STR_LIT>", ":", "<STR_LIT>", "subu", "<STR_LIT>", ",", "\\", "reg_names", "[", "STACK_POINTER_REGNUM", "]", ",", "\\", "reg_names", "[", "STACK_POINTER_REGNUM", "]", ",", "\\", "Pmode", "==", "DImode", "?", "<NUM_LIT>" ]

[ "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "(", "define_attr", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "(", "const_string", "<STR_LIT>", ")", ")" ]

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

[ "class", "FEXUPR_W_ENC", ":", "MSA_2RF_FMT", "<", "<NUM_LIT>", ",", "<NUM_LIT>", "," ]

[ "}" ]

[ "unsigned", "StartOp", "=", "<NUM_LIT>", "+", "<NUM_LIT>", ";", "unsigned", "NumOffset", "=", "<NUM_LIT>", ";", "switch", "(", "Opc", ")", "{", "default", ":", "MI", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported opcode for unwinding information", "<STR_LIT>", ")", ";", "case", "ARM", "::", "tPUSH", ":", "StartOp", "=", "<NUM_LIT>", ";", "NumOffset", "=", "<NUM_LIT>", ";", "case", "ARM", "::", "STMDB_UPD", ":", "case", "ARM", "::", "t2STMDB_UPD", ":", "case", "ARM", "::", "VSTMDDB_UPD", ":", "assert", "(", "SrcReg", "==", "ARM", "::", "SP", "&&", "<STR_LIT>", "Only stack pointer as a source reg is supported", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "StartOp", ",", "NumOps", "=", "MI", "->", "getNumOperands", "(", ")", "-", "NumOffset", ";", "i", "!=", "NumOps", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "continue", ";", "RegList", ".", "push_back", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "break", ";", "case", "ARM", "::", "STR_PRE_IMM", ":", "case", "ARM", "::", "STR_PRE_REG", ":", "case", "ARM", "::", "t2STR_PRE", ":", "assert", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", "&&", "<STR_LIT>", "Only stack pointer as a source reg is supported", "<STR_LIT>", ")", ";", "RegList", ".", "push_back", "(", "SrcReg", ")", ";", "break", ";", "}", "if", "(", "MAI", "->", "getExceptionHandlingType", "(", ")", "==", "ExceptionHandling", "::", "ARM", ")", "ATS", ".", "emitRegSave", "(", "RegList", ",", "Opc", "==", "ARM", "::", "VSTMDDB_UPD", ")", ";", "}", "else", "{", "if", "(", "SrcReg", "==", "ARM", "::", "SP", ")", "{", "int64_t", "Offset", "=", "<NUM_LIT>", ";", "switch", "(", "Opc", ")", "{", "default", ":", "MI", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported opcode for unwinding information", "<STR_LIT>", ")", ";", "case", "ARM", "::", "MOVr", ":", "case", "ARM", "::", "tMOVr", ":", "Offset", "=", "<NUM_LIT>", ";", "break", ";", "case", "ARM", "::", "ADDri", ":", "case", "ARM", "::", "t2ADDri", ":", "Offset", "=", "-", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "break", ";", "case", "ARM", "::", "SUBri", ":", "case", "ARM", "::", "t2SUBri", ":", "Offset", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "break", ";", "case", "ARM", "::", "tSUBspi", ":", "Offset", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "*", "<NUM_LIT>", ";", "break", ";", "case", "ARM", "::", "tADDspi", ":", "case", "ARM", "::", "tADDrSPi", ":", "Offset", "=", "-", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "*", "<NUM_LIT>", ";", "break", ";", "case", "ARM", "::", "tLDRpci", ":", "{", "unsigned", "CPI", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "const", "MachineConstantPool", "*", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "if", "(", "CPI", ">=", "MCP", "->", "getConstants", "(", ")", ".", "size", "(", ")", ")", "CPI", "=", "AFI", ".", "getOriginalCPIdx", "(", "CPI", ")", ";", "assert", "(", "CPI", "!=", "-", "<NUM_LIT>", "U", "&&", "<STR_LIT>", "Invalid constpool index", "<STR_LIT>", ")", ";", "const", "MachineConstantPoolEntry", "&", "CPE", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPI", "]", ";", "assert", "(", "!", "CPE", ".", "isMachineConstantPoolEntry", "(", ")", "&&", "<STR_LIT>", "Invalid constpool entry", "<STR_LIT>", ")", ";", "Offset", "=", "-", "cast", "<", "ConstantInt", ">", "(", "CPE", ".", "Val", ".", "ConstVal", ")", "->", "getSExtValue", "(", ")", ";", "break", ";", "}", "}", "if", "(", "MAI", "->", "getExceptionHandlingType", "(", ")", "==", "ExceptionHandling", "::", "ARM", ")", "{", "if", "(", "DstReg", "==", "FramePtr", "&&", "FramePtr", "!=", "ARM", "::", "SP", ")", "ATS", ".", "emitSetFP", "(", "FramePtr", ",", "ARM", "::", "SP", ",", "-", "Offset", ")", ";", "else", "if", "(", "DstReg", "==", "ARM", "::", "SP", ")", "{", "ATS", ".", "emitPad", "(", "Offset", ")", ";", "}", "else", "{", "ATS", ".", "emitMovSP", "(", "DstReg", ",", "-", "Offset", ")", ";", "}", "}", "}", "else", "if", "(", "DstReg", "==", "ARM", "::", "SP", ")", "{", "MI", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported opcode for unwinding information", "<STR_LIT>", ")", ";", "}", "else", "{", "MI", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported opcode for unwinding information", "<STR_LIT>", ")", ";" ]

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

[ "assert", "(", "!", "HexagonMCInstrInfo", "::", "isBundle", "(", "I", ")", ")", ";", "MCInstrDesc", "const", "&", "Desc", "=", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "I", ")", ";", "return", "(", "Desc", ".", "isBranch", "(", ")", "||", "Desc", ".", "isCall", "(", ")", "||", "Desc", ".", "isReturn", "(" ]

[ "b", ")", "{" ]

[ "vqrdmulh_n_s32", "(", "int32x2_t", "_", "_", "a", ",", "int32_t", "_", "_" ]

[ "<FIXS>", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "<FIXE>" ]

[ "LD", "->", "getAlignment", "(", ")", ")", ";", "SDValue", "OffsetPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "MVT", "::", "i32", ",", "BasePtr", ",", "<BUGS>", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "<BUGE>", "SDValue", "NewLD2", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "DL", ",", "NewLD1", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "OffsetPtr", ",", "LD", "->", "getPointerInfo", "(", ")", ",", "LD", "->", "isVolatile", "(", ")", ",", "LD", "->", "isNonTemporal", "(", ")", ",", "LD", "->", "isInvariant", "(", ")", "," ]

[ "<FIXS>", "(", "minus", ":", "GPI", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CC_NZ", "CC_REGNUM", ")", "(", "compare", ":", "CC_NZ", "<BUGS>", "(", "minus", ":", "GPI", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "ANY_EXTRACT", ":", "GPI", "(", "mult", ":", "GPI", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "Mask", ";" ]

[ "uint64_t", "CurVal", "=", "<NUM_LIT>", ";", "bool", "microMipsLEByteOrder", "=", "needsMMLEByteOrder", "(", "(", "unsigned", ")", "Kind", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "(", "microMipsLEByteOrder", "?", "calculateMMLEIndex", "(", "i", ")", ":", "i", ")", ":", "(", "FullSize", "-", "<NUM_LIT>", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "<NUM_LIT>", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "<NUM_LIT>", ")", ">>", "(", "<NUM_LIT>", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&" ]

[ ")" ]

[ "(", "define_mode_iterator", "TFD", "[", "TD", "TF", "]" ]

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

[ "def", "_S", ":", "sve_intx_dot_by_indexed_elem", "<", "<NUM_LIT>", ",", "opc", ",", "asm", ",", "ZPR32", ",", "ZPR8", ",", "ZPR3b8", ",", "VectorIndexS", ">", "{", "bits", "<", "<NUM_LIT>", ">", "iop", ";", "bits", "<", "<NUM_LIT>", ">", "Zm", ";" ]

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

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "P", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "W", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "dir", ".", "load", ";" ]

[ "}" ]

[ "unsigned", "Opc", "=", "Orig", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "X86", "::", "MOV32r0", "&&", "!", "isSafeToClobberEFLAGS", "(", "MBB", ",", "I", ")", ")", "{", "DebugLoc", "DL", "=", "Orig", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "X86", "::", "MOV32ri", ")", ")", ".", "addOperand", "(", "Orig", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "Orig", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";" ]

[ ")", ";" ]

[ "DeadCopies", ".", "push_back", "(", "&", "MI", ")", ";", "continue", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Lower Other: ", "<STR_LIT>", "<<", "MI", ")", ";", "MRI", "->", "setRegClass", "(", "DstReg", ",", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", "continue", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "SrcReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "assert", "(", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSubReg", "(", ")", ")", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", "||", "!", "isLaneMaskReg", "(", "SrcReg", ")", ")", "{", "assert", "(", "TII", "->", "getRegisterInfo", "(", ")", ".", "getRegSizeInBits", "(", "SrcReg", ",", "*", "MRI", ")", "==", "<NUM_LIT>", ")", ";", "unsigned", "TmpReg", "=", "createLaneMaskReg", "(", "*", "MF", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_CMP_NE_U32_e64", ")", ",", "TmpReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "TmpReg", ")", ";", "SrcReg", "=", "TmpReg", ";", "}", "MachineBasicBlock", "*", "PostDomBound", "=", "&", "MBB", ";", "for", "(", "MachineInstr", "&", "Use", ":", "MRI", "->", "use_instructions", "(", "DstReg", ")", ")", "{", "PostDomBound", "=", "PDT", "->", "findNearestCommonDominator", "(", "PostDomBound", ",", "Use", ".", "getParent", "(", ")", ")", ";", "}", "unsigned", "FoundLoopLevel", "=", "LF", ".", "findLoop", "(", "PostDomBound", ")", ";", "if", "(", "FoundLoopLevel", ")", "{", "SSAUpdater", ".", "Initialize", "(", "DstReg", ")", ";", "SSAUpdater", ".", "AddAvailableValue", "(", "&", "MBB", ",", "DstReg", ")", ";", "LF", ".", "addLoopEntries", "(", "FoundLoopLevel", ",", "SSAUpdater", ")", ";", "buildMergeLaneMasks", "(", "MBB", ",", "MI", ",", "DL", ",", "DstReg", ",", "SSAUpdater", ".", "GetValueInMiddleOfBlock", "(", "&", "MBB", ")", ",", "SrcReg", ")", ";", "DeadCopies", ".", "push_back", "(", "&", "MI", ")", ";", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "DeadCopies", ")", "MI", "->", "eraseFromParent", "(" ]

[ "_", "_", "bu", ".", "_", "_", "o", ",", "_", "_", "c", ")", ";" ]

[ "vld3_lane_u16", "(", "const", "uint16_t", "*", "_", "_", "a", ",", "uint16x4x3_t", "_", "_", "b", ",", "const", "int", "_", "_", "c", ")", "{", "union", "{", "uint16x4x3_t", "_", "_", "i", ";", "_", "_", "builtin_neon_ei", "_", "_", "o", ";", "}", "_", "_", "bu", "=", "{", "_", "_", "b", "}", ";", "union", "{", "uint16x4x3_t", "_", "_", "i", ";", "_", "_", "builtin_neon_ei", "_", "_", "o", ";", "}", "_", "_", "rv", ";", "_", "_", "rv", ".", "_", "_", "o", "=", "_", "_", "builtin_neon_vld3_lanev4hi", "(", "(", "const", "_", "_", "builtin_neon_hi", "*", ")", "_", "_", "a", "," ]

[ "insn" ]

[ "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "XVECEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "XVECLEN", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "XVECEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "XVECLEN", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", "rtx", "insn", "=", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "gen_rtx_SET", "(", "operands", "[", "<NUM_LIT>", "]", ",", "gen_rtx_MULT", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CC_FPmode", ",", "CCFP_REGNUM", ")", ")", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ")", "insn", "=", "emit_insn", "(", "insn", ")", "add_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "gen_rtx_ASHIFT", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ "<STR_LIT>", ";" ]

[ "case", "ISD", "::", "SETNE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETLT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETGT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETLE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETGE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETULT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETULE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETUGT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETUGE", ":", "return", "<STR_LIT>", "::" ]

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

[ "}", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "AMDGPUInstPrinter", "::", "printRegOperand", "(", "MO", ".", "getReg", "(", ")", ",", "O", ",", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "return", "false", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "int64_t", "Val", "=", "MO", ".", "getImm", "(", ")", ";", "if", "(", "AMDGPU", "::", "isInlinableIntLiteral", "(", "Val", ")", ")", "{", "O", "<<", "Val", ";", "}", "else", "if", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "Val", ")", ")", "{", "O", "<<", "format", "(", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", "PRIx16", ",", "static_cast", "<", "uint16_t", ">", "(", "Val", ")", ")", ";", "}", "else", "if", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "Val", ")", ")", "{", "O", "<<", "format", "(", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", "PRIx32", ",", "static_cast", "<", "uint32_t", ">", "(", "Val", ")", ")", ";", "}", "else", "{", "O", "<<", "format", "(", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", "PRIx64", ",", "static_cast", "<", "uint64_t", ">", "(" ]

[ "static", "rtx", "aarch64_simd_make_constant", "(", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vals", ")", ";", "rtx", "const_dup", ";", "rtx", "const_vec", "=", "NULL_RTX", ";", "int", "n_const", "=", "<NUM_LIT>", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "vals", ")", "==", "CONST_VECTOR", ")", "const_vec", "=", "vals", ";", "else", "if", "(", "GET_CODE", "(", "vals", ")", "==", "PARALLEL", ")", "{", "int", "n_elts", "=", "XVECLEN", "(", "vals", ",", "<NUM_LIT>", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "vals", ",", "<NUM_LIT>", ",", "i", ")", ";", "if", "(", "CONST_INT_P", "(", "x", ")", "||", "CONST_DOUBLE_P", "(", "x", ")", ")", "n_const", "++", ";", "}", "if", "(", "n_const", "==", "n_elts", ")", "const_vec", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "<NUM_LIT>", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "const_vec", "!=", "NULL_RTX", "&&", "aarch64_simd_valid_immediate", "(", "const_vec", ",", "NULL", ")", ")", "return", "const_vec", ";", "else", "if", "(", "(", "const_dup", "=", "aarch64_simd_dup_constant", "(", "vals", ")", ")", "!=", "NULL_RTX", ")", "return", "const_dup", ";", "else", "if", "(", "const_vec", "!=", "NULL_RTX", ")", "return", "const_vec", ";", "else", "return", "NULL_RTX", ";", "}" ]

[ "Generate", "code", "to", "load", "VALS", ",", "which", "is", "a", "PARALLEL", "containing", "only", "constants", "(", "for", "vec_init", ")", "or", "CONST_VECTOR", ",", "efficiently", "into", "a", "register", ".", "Returns", "an", "RTX", "to", "copy", "into", "the", "register", ",", "or", "NULL_RTX", "for", "a", "PARALLEL", "that", "can", "not", "be", "converted", "into", "a", "CONST_VECTOR", "." ]