Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "emit_move_insn", "(", "target", ",", "const_vec", ")", ";" ]

[ "x", "=", "XVECEXP", "(", "vals", ",", "<NUM_LIT>", ",", "one_var", "^", "<NUM_LIT>", ")", ";", "if", "(", "one_var", "&", "<NUM_LIT>", ")", "{", "var", "=", "convert_modes", "(", "HImode", ",", "QImode", ",", "var", ",", "true", ")", ";", "var", "=", "expand_simple_binop", "(", "HImode", ",", "ASHIFT", ",", "var", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_LIB_WIDEN", ")", ";", "x", "=", "GEN_INT", "(", "INTVAL", "(", "x", ")", "&", "<NUM_LIT>", ")", ";", "}", "else", "{", "var", "=", "convert_modes", "(", "HImode", ",", "QImode", ",", "var", ",", "true", ")", ";", "x", "=", "gen_int_mode", "(", "UINTVAL", "(", "x", ")", "<<", "<NUM_LIT>", ",", "HImode", ")", ";", "}", "if", "(", "x", "!=", "const0_rtx", ")", "var", "=", "expand_simple_binop", "(", "HImode", ",", "IOR", ",", "var", ",", "x", ",", "var", ",", "<NUM_LIT>", ",", "OPTAB_LIB_WIDEN", ")", ";", "x", "=", "gen_reg_rtx", "(", "wmode", ")", ";", "emit_move_insn", "(", "x", ",", "gen_lowpart", "(", "wmode", ",", "const_vec", ")", ")", ";", "ix86_expand_vector_set", "(", "mmx_ok", ",", "x", ",", "var", ",", "one_var", ">>", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "target", ",", "gen_lowpart", "(", "mode", ",", "x", ")", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}" ]

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

[ "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AllocateStack", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CC_XCore", ")", ";", "unsigned", "NumBytes", "=", "CCInfo", ".", "getNextStackOffset", "(", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "DAG", ".", "getConstant", "(", "NumBytes", ",", "getPointerTy", "(", ")", ",", "true", ")", ")", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ",", "<NUM_LIT>", ">", "RegsToPass", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOpChains", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "SDValue", "Arg", "=", "Outs", "[", "i", "]", ".", "Val", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown loc info!", "<STR_LIT>", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";" ]

[ "mode", ")" ]

[ "(", "unspec", ":", "TI", "[", "(", "match_dup", ":", "SI", "<NUM_LIT>", ")", "(", "match_dup", ":", "SI", "<NUM_LIT>", ")", "(", "match_dup", ":", "SI", "<NUM_LIT>", ")", "]", "UNSPEC_CPAT", ")", ")", "(", "set", "(", "match_operand", ":", "V", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V", "[", "(", "match_operand", ":", "<", "inner", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_dup", ":", "V", "<NUM_LIT>", ")", "(", "match_dup", ":", "TI", "<NUM_LIT>", ")", "]", "UNSPEC_SHUFB", ")", ")", "]", "<STR_LIT>", "{", "HOST_WIDE_INT", "size", "=", "GET_MODE_SIZE", "(", "<", "inner", ">" ]

[ "<FIXS>", "Disp", "=", "CurDAG", "->", "getTargetConstant", "(", "AM", ".", "Disp", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "<FIXE>" ]

[ "Disp", "=", "CurDAG", "->", "getTargetBlockAddress", "(", "AM", ".", "BlockAddr", ",", "MVT", "::", "i32", ",", "AM", ".", "Disp", ",", "AM", ".", "SymbolFlags", ")", ";", "else", "<BUGS>", "Disp", "=", "CurDAG", "->", "getTargetConstant", "(", "AM", ".", "Disp", ",", "MVT", "::", "i32", ")", ";", "<BUGE>", "if", "(", "AM", ".", "Segment", ".", "getNode", "(", ")", ")", "Segment", "=", "AM", ".", "Segment", ";" ]

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

[ "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "RR", ".", "Reg", ")", ")", "return", "false", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", "->", "getRegClass", "(", "RR", ".", "Reg", ")", ";", "if", "(", "RC", "==", "&", "Hexagon", "::", "IntRegsRegClass", ")", "{", "BW", "=", "<NUM_LIT>", ";", "return", "true", ";", "}", "if", "(", "RC", "==", "&", "Hexagon", "::", "DoubleRegsRegClass", ")", "{", "BW", "=", "(", "RR", ".", "Sub", "!=", "<NUM_LIT>", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "return", "true", ";", "}" ]

[ "return", "DAG", ".", "getNode", "(", "ISD", "::", "BIT_CONVERT", ",", "dl", ",", "VT", ",", "Vec", ")", ";" ]

[ "static", "SDValue", "getOnesVector", "(", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ",", "DebugLoc", "dl", ")", "{", "assert", "(", "VT", ".", "isVector", "(", ")", "&&", "<STR_LIT>", "Expected a vector type", "<STR_LIT>", ")", ";", "SDValue", "Vec", ";", "SDValue", "Cst", "=", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i8", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "MVT", "TVT", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "Ops", ".", "assign", "(", "<NUM_LIT>", ",", "Cst", ")", ";", "TVT", "=", "MVT", "::", "v8i8", ";", "}", "else", "{", "Ops", ".", "assign", "(", "<NUM_LIT>", ",", "Cst", ")", ";", "TVT", "=", "MVT", "::", "v16i8", ";", "}", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "TVT", ",", "&", "Ops", "[", "<NUM_LIT>", "]", ",", "Ops", ".", "size", "(", ")", ")", ";" ]

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

[ "return", "(", "(", "uint64_t", ")", "Imm", ")", "<", "<NUM_LIT>", ";", "}", "]", ">", "{", "let", "ParserMatchClass", "=", "VectorIndexSOperand", ";" ]

[ ")", ",", "{", "MemOp", "}", ")", ";" ]

[ "MachineMemOperand", "*", "MemOp", "=", "cast", "<", "MemSDNode", ">", "(", "N", ")", "->", "getMemOperand", "(", ")", ";", "CurDAG", "->", "setNodeMemRefs", "(", "cast", "<", "MachineSDNode", ">", "(", "Result" ]

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

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

[ "val", "=", "get_insns", "(", ")", ";" ]

[ "if", "(", "GET_CODE", "(", "src", ")", "==", "SUBREG", ")", "alter_subreg", "(", "&", "src", ",", "true", ")", ";", "start_sequence", "(", ")", ";", "if", "(", "REG_P", "(", "dest", ")", ")", "{", "int", "dregno", "=", "REGNO", "(", "dest", ")", ";", "if", "(", "REG_P", "(", "src", ")", ")", "{", "int", "sregno", "=", "REGNO", "(", "src", ")", ";", "int", "reverse", "=", "(", "dregno", "==", "sregno", "+", "<NUM_LIT>", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operand_subword", "(", "dest", ",", "reverse", ",", "TRUE", ",", "mode", ")", ",", "operand_subword", "(", "src", ",", "reverse", ",", "TRUE", ",", "mode", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operand_subword", "(", "dest", ",", "!", "reverse", ",", "TRUE", ",", "mode", ")", ",", "operand_subword", "(", "src", ",", "!", "reverse", ",", "TRUE", ",", "mode", ")", ")", ")", ";", "}", "else", "if", "(", "CONST_INT_P", "(", "src", ")", "||", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", ")", "{", "rtx", "words", "[", "<NUM_LIT>", "]", ";", "split_double", "(", "src", ",", "&", "words", "[", "<NUM_LIT>", "]", ",", "&", "words", "[", "<NUM_LIT>", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operand_subword", "(", "dest", ",", "<NUM_LIT>", ",", "TRUE", ",", "mode", ")", ",", "words", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operand_subword", "(", "dest", ",", "<NUM_LIT>", ",", "TRUE", ",", "mode", ")", ",", "words", "[", "<NUM_LIT>", "]", ")", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "src", ")", ")", "{", "int", "reverse", "=", "refers_to_regno_p", "(", "dregno", ",", "XEXP", "(", "src", ",", "<NUM_LIT>", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operand_subword", "(", "dest", ",", "reverse", ",", "TRUE", ",", "mode", ")", ",", "adjust_address", "(", "src", ",", "SImode", ",", "reverse", "*", "UNITS_PER_WORD", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operand_subword", "(", "dest", ",", "!", "reverse", ",", "TRUE", ",", "mode", ")", ",", "adjust_address", "(", "src", ",", "SImode", ",", "!", "reverse", "*", "UNITS_PER_WORD", ")", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "dest", ")", "&&", "REG_P", "(", "src", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "adjust_address", "(", "dest", ",", "SImode", ",", "<NUM_LIT>", ")", ",", "operand_subword", "(", "src", ",", "<NUM_LIT>", ",", "TRUE", ",", "mode", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "adjust_address", "(", "dest", ",", "SImode", ",", "UNITS_PER_WORD", ")", ",", "operand_subword", "(", "src", ",", "<NUM_LIT>", ",", "TRUE", ",", "mode", ")", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";" ]

[ "<STR_LIT>" ]

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "M4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "I3", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "bool", "ForceDPP_", ")", "{" ]

[ "void", "setForcedDPP", "(" ]

[ "override", "{" ]

[ "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const" ]

[ "<STR_LIT>" ]

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

[ "MII", "=", "MBB", ".", "erase", "(", "MII", ")", ";" ]

[ "unsigned", "InstOffset", "=", "<NUM_LIT>", ";", "DenseMap", "<", "const", "MachineBasicBlock", "*", ",", "unsigned", ">", "BlockToInstOffset", ";", "const", "HexagonInstrInfo", "*", "HII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "for", "(", "const", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "if", "(", "MBB", ".", "getAlignment", "(", ")", ")", "{", "int", "ByteAlign", "=", "(", "<NUM_LIT>", "u", "<<", "MBB", ".", "getAlignment", "(", ")", ")", "-", "<NUM_LIT>", ";", "InstOffset", "=", "(", "InstOffset", "+", "ByteAlign", ")", "&", "~", "(", "ByteAlign", ")", ";", "}", "BlockToInstOffset", "[", "&", "MBB", "]", "=", "InstOffset", ";", "for", "(", "const", "MachineInstr", "&", "MI", ":", "MBB", ")", "InstOffset", "+=", "HII", "->", "getSize", "(", "&", "MI", ")", ";", "}", "InstOffset", "=", "<NUM_LIT>", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "InstOffset", "=", "BlockToInstOffset", "[", "&", "MBB", "]", ";", "MachineBasicBlock", "::", "iterator", "MII", "=", "MBB", ".", "begin", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MIE", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "MII", "!=", "MIE", ")", "{", "InstOffset", "+=", "HII", "->", "getSize", "(", "&", "*", "MII", ")", ";", "if", "(", "MII", "->", "isDebugValue", "(", ")", ")", "{", "++", "MII", ";", "continue", ";", "}", "if", "(", "isHardwareLoop", "(", "MII", ")", ")", "{", "assert", "(", "MII", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isMBB", "(", ")", "&&", "<STR_LIT>", "Expect a basic block as loop operand", "<STR_LIT>", ")", ";", "int", "diff", "=", "InstOffset", "-", "BlockToInstOffset", "[", "MII", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", "]", ";", "if", "(", "(", "unsigned", ")", "abs", "(", "diff", ")", ">", "MaxLoopRange", ")", "{", "useExtLoopInstr", "(", "MF", ",", "MII", ")", ";" ]

[ "const_int", "-", "<NUM_LIT>", ")", ")", ")", ")" ]

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

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

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

[ "CLI", ".", "Call", "=", "MIB", ";" ]

[ "bool", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "const", "Value", "*", "Callee", "=", "CLI", ".", "Callee", ";", "MCSymbol", "*", "Symbol", "=", "CLI", ".", "Symbol", ";", "if", "(", "CC", "==", "CallingConv", "::", "Fast", ")", "return", "false", ";", "if", "(", "IsTailCall", ")", "return", "false", ";", "if", "(", "IsVarArg", ")", "return", "false", ";", "MVT", "RetVT", ";", "if", "(", "CLI", ".", "RetTy", "->", "isVoidTy", "(", ")", ")", "RetVT", "=", "MVT", "::", "isVoid", ";", "else", "if", "(", "!", "isTypeSupported", "(", "CLI", ".", "RetTy", ",", "RetVT", ")", ")", "return", "false", ";", "for", "(", "auto", "Flag", ":", "CLI", ".", "OutFlags", ")", "if", "(", "Flag", ".", "isInReg", "(", ")", "||", "Flag", ".", "isSRet", "(", ")", "||", "Flag", ".", "isNest", "(", ")", "||", "Flag", ".", "isByVal", "(", ")", ")", "return", "false", ";", "SmallVector", "<", "MVT", ",", "<NUM_LIT>", ">", "OutVTs", ";", "OutVTs", ".", "reserve", "(", "CLI", ".", "OutVals", ".", "size", "(", ")", ")", ";", "for", "(", "auto", "*", "Val", ":", "CLI", ".", "OutVals", ")", "{", "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "Val", "->", "getType", "(", ")", ",", "VT", ")", "&&", "!", "(", "VT", "==", "MVT", "::", "i1", "||", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "isVector", "(", ")", "||", "VT", ".", "getSizeInBits", "(", ")", ">", "<NUM_LIT>", ")", "return", "false", ";", "OutVTs", ".", "push_back", "(", "VT", ")", ";", "}", "Address", "Addr", ";", "if", "(", "!", "computeCallAddress", "(", "Callee", ",", "Addr", ")", ")", "return", "false", ";", "unsigned", "NumBytes", ";", "if", "(", "!", "processCallArgs", "(", "CLI", ",", "OutVTs", ",", "NumBytes", ")", ")", "return", "false", ";", "if", "(", "!", "Addr", ".", "getGlobalValue", "(", ")", ")", "return", "false", ";", "unsigned", "DestAddress", ";", "if", "(", "Symbol", ")", "DestAddress", "=", "materializeExternalCallSym", "(", "Symbol", ")", ";", "else", "DestAddress", "=", "materializeGV", "(", "Addr", ".", "getGlobalValue", "(", ")", ",", "MVT", "::", "i32", ")", ";", "emitInst", "(", "TargetOpcode", "::", "COPY", ",", "Mips", "::", "T9", ")", ".", "addReg", "(", "DestAddress", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Mips", "::", "JALR", ")", ",", "Mips", "::", "RA", ")", ".", "addReg", "(", "Mips", "::", "T9", ")", ";", "for", "(", "auto", "Reg", ":", "CLI", ".", "OutRegs", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Implicit", ")", ";", "MIB", ".", "addRegMask", "(", "TRI", ".", "getCallPreservedMask", "(", "*", "FuncInfo", ".", "MF", ",", "CC", ")", ")", ";" ]

[ "KillMI", "->", "clearRegisterKills", "(", "Reg", ",", "TRI", ")", ";" ]

[ "if", "(", "!", "Br", ".", "MI", "->", "killsRegister", "(", "ARM", "::", "CPSR", ")", ")", "return", "false", ";", "Register", "PredReg", ";", "unsigned", "NewOpc", "=", "<NUM_LIT>", ";", "<STR_LIT>", "::", "<STR_LIT>", "Pred", "=", "getInstrPredicate", "(", "*", "Br", ".", "MI", ",", "PredReg", ")", ";", "if", "(", "Pred", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "NewOpc", "=", "ARM", "::", "tCBZ", ";", "else", "if", "(", "Pred", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "NewOpc", "=", "ARM", "::", "tCBNZ", ";", "else", "return", "false", ";", "unsigned", "BrOffset", "=", "BBUtils", "->", "getOffsetOf", "(", "Br", ".", "MI", ")", "+", "<NUM_LIT>", "-", "<NUM_LIT>", ";", "BBInfoVector", "&", "BBInfo", "=", "BBUtils", "->", "getBBInfo", "(", ")", ";", "unsigned", "DestOffset", "=", "BBInfo", "[", "DestBB", "->", "getNumber", "(", ")", "]", ".", "Offset", ";", "if", "(", "BrOffset", ">=", "DestOffset", "||", "(", "DestOffset", "-", "BrOffset", ")", ">", "<NUM_LIT>", ")", "return", "false", ";", "auto", "*", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MachineInstr", "*", "CmpMI", "=", "findCMPToFoldIntoCBZ", "(", "Br", ".", "MI", ",", "TRI", ")", ";", "if", "(", "!", "CmpMI", "||", "CmpMI", "->", "getOpcode", "(", ")", "!=", "ARM", "::", "tCMPi8", ")", "return", "false", ";", "ImmCmp", ".", "MI", "=", "CmpMI", ";", "ImmCmp", ".", "NewOpc", "=", "NewOpc", ";", "return", "true", ";", "}", ";", "auto", "TryConvertToLE", "=", "[", "this", "]", "(", "ImmBranch", "&", "Br", ",", "ImmCompare", "&", "Cmp", ")", "{", "if", "(", "Br", ".", "MI", "->", "getOpcode", "(", ")", "!=", "ARM", "::", "t2Bcc", "||", "!", "STI", "->", "hasLOB", "(", ")", "||", "STI", "->", "hasMinSize", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "*", "MBB", "=", "Br", ".", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "DestBB", "=", "Br", ".", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "if", "(", "BBUtils", "->", "getOffsetOf", "(", "MBB", ")", "<", "BBUtils", "->", "getOffsetOf", "(", "DestBB", ")", "||", "!", "BBUtils", "->", "isBBInRange", "(", "Br", ".", "MI", ",", "DestBB", ",", "<NUM_LIT>", ")", ")", "return", "false", ";", "if", "(", "!", "DT", "->", "dominates", "(", "DestBB", ",", "MBB", ")", ")", "return", "false", ";", "Cmp", ".", "NewOpc", "=", "Cmp", ".", "NewOpc", "==", "ARM", "::", "tCBZ", "?", "ARM", "::", "tCBNZ", ":", "ARM", "::", "tCBZ", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "Br", ".", "MI", ",", "Br", ".", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARM", "::", "t2LE", ")", ")", ";", "MIB", ".", "add", "(", "Br", ".", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Br", ".", "MI", "->", "eraseFromParent", "(", ")", ";", "Br", ".", "MI", "=", "MIB", ";", "++", "NumLEInserted", ";", "return", "true", ";", "}", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "ImmBranch", "&", "Br", ":", "reverse", "(", "ImmBranches", ")", ")", "{", "MachineBasicBlock", "*", "DestBB", "=", "Br", ".", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "Br", ".", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "ExitBB", "=", "&", "MBB", "->", "back", "(", ")", "==", "Br", ".", "MI", "?", "MBB", "->", "getFallThrough", "(", ")", ":", "MBB", "->", "back", "(", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "ImmCompare", "Cmp", ";", "if", "(", "FindCmpForCBZ", "(", "Br", ",", "Cmp", ",", "ExitBB", ")", "&&", "TryConvertToLE", "(", "Br", ",", "Cmp", ")", ")", "{", "DestBB", "=", "ExitBB", ";", "MadeChange", "=", "true", ";", "}", "else", "{", "FindCmpForCBZ", "(", "Br", ",", "Cmp", ",", "DestBB", ")", ";", "MadeChange", "|=", "TryShrinkBranch", "(", "Br", ")", ";", "}", "unsigned", "Opcode", "=", "Br", ".", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode", "!=", "ARM", "::", "tBcc", "&&", "Opcode", "!=", "ARM", "::", "t2LE", ")", "||", "!", "Cmp", ".", "NewOpc", ")", "continue", ";", "Register", "Reg", "=", "Cmp", ".", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "auto", "*", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "KillMI", "=", "Br", ".", "MI", ";", "bool", "RegKilled", "=", "false", ";", "do", "{", "--", "KillMI", ";", "if", "(", "KillMI", "->", "killsRegister", "(", "Reg", ",", "TRI", ")", ")", "{" ]

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

[ "_", "_", "arm_vbicq_f32", "(", "float32x4_t", "_", "_", "a", ",", "float32x4_t", "_" ]

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

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

[ "}", ";" ]

[ "if", "(", "XVT", ".", "isVector", "(", ")", ")", "return", "false", ";", "auto", "VTIsOk", "=", "[", "]", "(", "EVT", "VT", ")", "->", "bool", "{", "return", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", ";" ]

[ "(", "LOGICAL", ":", "PRED_ALL" ]

[ "(", "unspec", ":", "CC_NZC", "[", "(", "match_operand", ":", "VNx16BI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "and", ":", "PRED_ALL" ]

[ "Src", "=", "DAG", ".", "getNode", "(", "N", "->", "getOpcode", "(", ")", ",", "DL", ",", "SrcVT", ",", "Src", ")", ";" ]

[ "EVT", "ResVT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "ResVT", ".", "isVector", "(", ")", "||", "TLI", ".", "isTypeLegal", "(", "ResVT", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Src", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "SrcVT", "=", "Src", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "ResVT", ".", "isSimple", "(", ")", "||", "!", "SrcVT", ".", "isSimple", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "SrcVT", ".", "getSizeInBits", "(", ")", ".", "getKnownMinSize", "(", ")", "!=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "unsigned", "SrcEltSize", "=", "SrcVT", ".", "getScalarSizeInBits", "(", ")", ";", "ElementCount", "SrcEC", "=", "SrcVT", ".", "getVectorElementCount", "(", ")", ";", "SrcVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "getIntegerVT", "(", "SrcEltSize", "*", "<NUM_LIT>", ")", ",", "SrcEC", ")", ";", "SDLoc", "DL", "(", "N", ")", ";" ]

[ "<STR_LIT>" ]

[ "(", "set", "(", "mem", ":", "GPF", "(", "plus", ":", "P", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "match_operand", ":", "GPF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "mem", ":", "GPF", "(", "plus", ":", "P", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_operand", ":", "P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "match_operand", ":", "GPF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", ")", "]", "<STR_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>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>" ]

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

[ "(", "define_mode_iterator", "V_128", "[", "V16QI", "V8HI", "V8HF", "V8BF", "V4SI", "V2DI", "V4SF", "(", "V2DF", "<STR_LIT>" ]

[ ")" ]

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

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

[ "(", "zero_extend", ":", "GPR", "(", "truncate", ":", "SHORT", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "{", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "GET_MODE_MASK", "(", "<", "SHORT", ":", "MODE", ">", "mode", ")", ")", "return", "<STR_LIT>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "(", "unspec", ":", "DI", "[", "(", "match_operand", ":", "XF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_FIST_CEIL", ")", ")", "(", "use", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec", ":", "DI", "[", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_FIST_CEIL", ")", ")", "(", "use", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "use", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_dup" ]

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

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

[ "}" ]

[ "case", "'", "r", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i8", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "!", "HasMips64", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "HasMips64", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "CPU64RegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "<NUM_LIT>", ")", ")", ";", "case", "'", "f", "'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "FGR32RegClass", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f64", ")", "&&", "(", "!", "Subtarget", "->", "isSingleFloat", "(", ")", ")", ")", "{", "if", "(", "Subtarget", "->", "isFP64bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "FGR64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "AFGR64RegClass", ")", ";", "}", "break", ";", "case", "'", "c", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9", ",", "&", "Mips", "::", "CPURegsRegClass", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i64", "&&", "<STR_LIT>", "Unexpected type.", "<STR_LIT>", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9_64", ",", "&", "Mips", "::", "CPU64RegsRegClass", ")", ";", "case", "'", "l", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO", ",", "&", "Mips", "::", "HILORegClass", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO64", ",", "&", "Mips", "::", "HILO64RegClass", ")", ";", "case", "'", "x", "'", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "}" ]

[ "Predicate", "SubtargetPredicate", ";", "string", "Constraints", ";", "string", "DisableEncoding", ";", "list", "<", "SchedReadWrite", ">", "SchedRW", ";", "list", "<", "Register", ">", "Uses", ";", "list", "<", "Register", ">", "Defs", ";" ]

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

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

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "BLK", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "BLK", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "P", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "(", "if_then_else", ":", "HI", "(", "lt", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "ashiftrt", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>" ]

[ ")", ",", "(", "PPCfctiwuz", "node", ":", "$", "op", ")", "]", ">", ";" ]

[ "def", "PPCany_fctiwuz", ":", "PatFrags", "<", "(", "ops", "node", ":", "$", "op", ")", ",", "[", "(", "PPCstrict_fctiwuz", "node", ":", "$", "op" ]

[ "return", ";" ]

[ "SDValue", "Ops", "[", "]", "=", "{", "eax", ",", "edx", "}", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "dl", ",", "MVT", "::", "i64", ",", "Ops", ",", "<NUM_LIT>", ")", ")", ";", "Results", ".", "push_back", "(", "edx", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "{", "EVT", "T", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "assert", "(", "T", "==", "MVT", "::", "i64", "&&", "<STR_LIT>", "Only know how to expand i64 Cmp and Swap", "<STR_LIT>", ")", ";", "SDValue", "cpInL", ",", "cpInH", ";", "cpInL", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "cpInH", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "cpInL", "=", "DAG", ".", "getCopyToReg", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "EAX", ",", "cpInL", ",", "SDValue", "(", ")", ")", ";", "cpInH", "=", "DAG", ".", "getCopyToReg", "(", "cpInL", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "EDX", ",", "cpInH", ",", "cpInL", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "swapInL", ",", "swapInH", ";", "swapInL", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "swapInH", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "swapInL", "=", "DAG", ".", "getCopyToReg", "(", "cpInH", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "EBX", ",", "swapInL", ",", "cpInH", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "swapInH", "=", "DAG", ".", "getCopyToReg", "(", "swapInL", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "ECX", ",", "swapInH", ",", "swapInL", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "swapInH", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "swapInH", ".", "getValue", "(", "<NUM_LIT>", ")", "}", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Flag", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Tys", ",", "Ops", ",", "<NUM_LIT>", ")", ";", "SDValue", "cpOutL", "=", "DAG", ".", "getCopyFromReg", "(", "Result", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "EAX", ",", "MVT", "::", "i32", ",", "Result", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "cpOutH", "=", "DAG", ".", "getCopyFromReg", "(", "cpOutL", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "EDX", ",", "MVT", "::", "i32", ",", "cpOutL", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "OpsF", "[", "]", "=", "{", "cpOutL", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "cpOutH", ".", "getValue", "(", "<NUM_LIT>", ")", "}", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "dl", ",", "MVT", "::", "i64", ",", "OpsF", ",", "<NUM_LIT>", ")", ")", ";", "Results", ".", "push_back", "(", "cpOutH", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_SWAP", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

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

[ "def", "A2_paddifnew", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_05c070ec", ",", "TypeALU32_2op", ">", ",", "Enc_e38e1f", ",", "PredNewRel", ",", "ImmRegRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "PredPolarity", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "PredAddress", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "const", "AArch64TargetLowering", "*", "TLI", "=", "Subtarget", ".", "getTargetLowering", "(", ")", ";", "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", "->", "hasSwiftAsyncContext", "(", ")", ")", "{", "const", "AArch64RegisterInfo", "&", "TRI", "=", "*", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "LivePhysRegs", "LiveRegs", "(", "TRI", ")", ";", "getLiveRegsForEntryMBB", "(", "LiveRegs", ",", "MBB", ")", ";", "if", "(", "!", "LiveRegs", ".", "available", "(", "MRI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", "||", "!", "LiveRegs", ".", "available", "(", "MRI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", "false", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "sqrt", ":", "DF", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

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

[ "def", "J4_cmpgti_t_jumpnv_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Ns8", ",", "u5_0Imm", ":", "$", "II", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_bd8382d1", ",", "TypeNCJ", ">", ",", "Enc_eafd18", ",", "PredRel", "{", "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", "isPredicated", "=", "<NUM_LIT>", ";" ]

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

[ "if", "(", "ExtType", "==", "ISD", "::", "NON_EXTLOAD", ")", "Opcode", "=", "IsPre", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "ExtType", "==", "ISD", "::", "SEXTLOAD", ")", "Opcode", "=", "IsPre", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "{", "Opcode", "=", "IsPre", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "InsertTo64", "=", "true", ";", "DstVT", "=", "MVT", "::", "i32", ";", "}", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "{", "if", "(", "ExtType", "==", "ISD", "::", "SEXTLOAD", ")", "{", "if", "(", "DstVT", "==", "MVT", "::", "i64", ")", "Opcode", "=", "IsPre", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "Opcode", "=", "IsPre", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "{", "Opcode", "=", "IsPre", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "InsertTo64", "=", "DstVT", "==", "MVT", "::", "i64", ";", "DstVT", "=", "MVT", "::", "i32", ";", "}", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "{", "if", "(", "ExtType", "==", "ISD", "::", "SEXTLOAD", ")", "{", "if", "(", "DstVT", "==", "MVT", "::", "i64", ")", "Opcode", "=", "IsPre", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "Opcode", "=", "IsPre", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "{", "Opcode", "=", "IsPre", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "InsertTo64", "=", "DstVT", "==", "MVT", "::", "i64", ";", "DstVT", "=", "MVT", "::", "i32", ";", "}", "}", "else", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "{", "Opcode", "=", "IsPre", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", ".", "is64BitVector", "(", ")", ")", "{", "Opcode", "=", "IsPre", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "VT", ".", "is128BitVector", "(", ")", ")", "{", "Opcode", "=", "IsPre", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "return", "nullptr", ";", "SDValue", "Chain", "=", "LD", "->", "getChain", "(", ")", ";", "SDValue", "Base", "=", "LD", "->", "getBasePtr" ]

[ "poly8x8_t", "_", "_", "b", ",", "const", "int", "_", "_", "lane2", ")", "{" ]

[ "vcopyq_lane_p8", "(", "poly8x16_t", "_", "_", "a", ",", "const", "int", "_", "_", "lane1", "," ]

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

[ "(", "truncate", ":", "V2HI", "(", "ashiftrt", ":", "V2SI", "(", "plus", ":", "V2SI", "(", "sign_extend", ":", "V2SI", "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "sign_extend", ":", "V2SI", "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr" ]

[ "_", "_", "rv", ".", "_", "_", "o", "=", "_", "_", "builtin_neon_vld2v16qi", "(", "(", "const", "_", "_", "builtin_neon_qi", "*", ")", "_", "_", "a", ")", ";" ]

[ "vld2q_p8", "(", "const", "poly8_t", "*", "_", "_", "a", ")", "{", "union", "{", "poly8x16x2_t", "_", "_", "i", ";", "_", "_", "builtin_neon_oi", "_", "_", "o", ";", "}", "_", "_", "rv", ";" ]

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

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

[ "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "TmpReg", ")", ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ "unsigned", "DestReg", "=", "createResultReg", "(", "RC", ")", ";", "CodeModel", "::", "Model", "CModel", "=", "TM", ".", "getCodeModel", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "FuncInfo", ".", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getConstantPool", "(", "*", "FuncInfo", ".", "MF", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "(", "VT", "==", "MVT", "::", "f32", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "Align", ")", ";", "unsigned", "Opc", ";", "if", "(", "HasSPE", ")", "Opc", "=", "(", "(", "VT", "==", "MVT", "::", "f32", ")", "?", "PPC", "::", "SPELWZ", ":", "PPC", "::", "EVLDD", ")", ";", "else", "Opc", "=", "(", "(", "VT", "==", "MVT", "::", "f32", ")", "?", "PPC", "::", "LFS", ":", "PPC", "::", "LFD", ")", ";", "unsigned", "TmpReg", "=", "createResultReg", "(", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ")", ";", "PPCFuncInfo", "->", "setUsesTOCBasePtr", "(", ")", ";", "if", "(", "CModel", "==", "CodeModel", "::", "Small", ")", "{", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "PPC", "::", "LDtocCPT", ")", ",", "TmpReg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addReg", "(", "PPC", "::", "X2", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "TmpReg", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "PPC", "::", "ADDIStocHA8", ")", ",", "TmpReg", ")", ".", "addReg", "(", "PPC", "::", "X2", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ";", "if", "(", "CModel", "==", "CodeModel", "::", "Large", ")", "{", "unsigned", "TmpReg2", "=", "createResultReg", "(", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "PPC", "::", "LDtocL", ")", ",", "TmpReg2", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addReg", "(", "TmpReg", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "TmpReg2", ")", ";", "}", "else", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addConstantPoolIndex", "(", "Idx", "," ]

[ ")", "const", "{" ]

[ "bool", "can_invert_condition", "(", "void" ]

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

[ "let", "AsmString", "=", "asmstr", ";", "let", "AsmVariantName", "=", "?", ";", "let", "hasSideEffects", "=", "<NUM_LIT>", ";", "let", "isNotUsedInDisasm", "=", "<NUM_LIT>", ";", "let", "Size", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "Opcode", "=", "opc", ";", "bits", "<", "<NUM_LIT>", ">", "OType", "=", "OpType", ".", "INT32", ";", "bit", "HasImm", "=", "<NUM_LIT>", ";", "bit", "IsPredicated", "=", "<NUM_LIT>", ";", "bit", "OutOfSlotData", "=", "<NUM_LIT>", ";", "bit", "HasCompositeImm", "=", "<NUM_LIT>", ";", "SlotType", "Slot", "=", "slot", ";", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Slot", ".", "Value", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "HasImm", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "IsPredicated", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "OutOfSlotData", ";", "bits", "<", "<NUM_LIT>", ">", "hasImmField", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasImmField", ";", "bits", "<", "<NUM_LIT>", ">", "startBit", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "startBit", ";", "bits", "<", "<NUM_LIT>", ">", "endBit", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "endBit", ";", "bits", "<", "<NUM_LIT>", ">", "immOpNum", "=", "<NUM_LIT>", ";" ]

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

[ "return", "visium_function_value_1", "(", "TYPE_MODE", "(" ]

[ "<STR_LIT>", ")" ]

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

[ "v8di", ")", "_", "_", "index", ",", "_", "_", "mask", ",", "_", "_", "scale", ")", ";" ]

[ "return", "(", "_", "_", "m256", ")", "_", "_", "builtin_ia32_gatherdiv16sf", "(", "(", "_", "_", "v8sf", ")", "_", "_", "v1_old", ",", "_", "_", "addr", ",", "(", "_", "_" ]

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

[ "static", "bool", "pru_arg_in_reg_bysize", "(", "size_t", "sz", ")", "{", "return", "sz", "==", "<NUM_LIT>", "||", "sz", "==", "<NUM_LIT>", "||", "sz", "==", "<NUM_LIT>", "||", "sz", "==", "<NUM_LIT>", "||" ]

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

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

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

[ "bits", "<", "<NUM_LIT>", ">", "XA", ";", "bits", "<", "<NUM_LIT>", ">", "XB", ";", "bits", "<", "<NUM_LIT>", ">", "D", ";", "let", "Pattern", "=", "pattern", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "XT", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "XA", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "XB", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

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

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

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

[ "def", "bb", ":", "NeonI_Scalar2SameMisc_size", "<", "u", ",", "<NUM_LIT>", ",", "opcode", ",", "asmop", ",", "FPR8", "," ]

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

[ "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_cmpordss", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4sf" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "L", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "dst2", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "static", "unsigned", "getBasePointerSaveOffset", "(", "bool", "isPPC64", ",", "bool", "isDarwinABI", ",", "bool", "isPIC", ")", "{", "if", "(", "isDarwinABI", ")", "return", "isPPC64", "?", "-", "<NUM_LIT>", "U", ":", "-", "<NUM_LIT>", "U", ";", "return", "isPPC64", "?", "-", "<NUM_LIT>", "U", ":", "isPIC", "?", "-", "<NUM_LIT>", "U", ":", "-", "<NUM_LIT>", "U", ";", "}" ]

[ "getBasePointerSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "base", "pointer", "." ]

[ "}" ]

[ "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "i32imm", ",", "addsub_shift", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "[", "(", "parallel", "[", "(", "call", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "reg", ":", "DI", "<NUM_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>" ]

[ "}" ]

[ "break", ";", "}", "}", "if", "(", "Callee", "&&", "(", "Callee", "->", "getName", "(", ")", "==", "<STR_LIT>", "\\01__gnu_mcount_nc", "<STR_LIT>", "||", "Callee", "->", "getName", "(", ")", "==", "<STR_LIT>", "\\01mcount", "<STR_LIT>", "||", "Callee", "->", "getName", "(", ")", "==", "<STR_LIT>", "__mcount", "<STR_LIT>", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "auto", "UnknownCallOutlineType", "=", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "Opc", "==", "ARM", "::", "BL", "||", "Opc", "==", "ARM", "::", "tBL", "||", "Opc", "==", "ARM", "::", "BLX", "||", "Opc", "==", "ARM", "::", "BLX_noip", "||", "Opc", "==", "ARM", "::", "tBLXr", "||", "Opc", "==", "ARM", "::", "tBLXr_noip", "||", "Opc", "==", "ARM", "::", "tBLXi", ")", "UnknownCallOutlineType", "=", "outliner", "::", "InstrType", "::", "LegalTerminator", ";", "if", "(", "!", "Callee", ")", "return", "UnknownCallOutlineType", ";", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineFunction", "*", "CalleeMF", "=", "MF", "->", "getMMI", "(", ")", ".", "getMachineFunction", "(", "*", "Callee", ")", ";", "if", "(", "!", "CalleeMF", ")", "return", "UnknownCallOutlineType", ";", "MachineFrameInfo", "&", "MFI", "=", "CalleeMF", "->", "getFrameInfo", "(", ")", ";", "if", "(", "!", "MFI", ".", "isCalleeSavedInfoValid", "(", ")", "||", "MFI", ".", "getStackSize", "(", ")", ">", "<NUM_LIT>", "||", "MFI", ".", "getNumObjects", "(", ")", ">", "<NUM_LIT>", ")", "return", "UnknownCallOutlineType", ";", "return", "outliner", "::", "InstrType", "::", "Legal", ";", "}", "if", "(", "MI", ".", "modifiesRegister", "(", "ARM", "::", "LR", ",", "TRI", ")", "||", "MI", ".", "modifiesRegister", "(", "ARM", "::", "PC", ",", "TRI", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "ARM", "::", "SP", ",", "TRI", ")", "||", "MI", ".", "readsRegister", "(", "ARM", "::", "SP", ",", "TRI", ")", ")", "{", "bool", "MightNeedStackFixUp", "=", "(", "Flags", "&", "(", "MachineOutlinerMBBFlags", "::", "LRUnavailableSomewhere", "|", "MachineOutlinerMBBFlags", "::", "HasCalls", ")", ")", ";", "if", "(", "!", "MightNeedStackFixUp", ")", "return", "outliner", "::", "InstrType", "::", "Legal", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "ARM", "::", "SP", ",", "TRI", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "checkAndUpdateStackOffset", "(", "&", "MI", ",", "Subtarget", ".", "getStackAlignment", "(", ")", ".", "value", "(", ")", ",", "false", ")", ")", "return", "outliner", "::", "InstrType", "::", "Legal", ";", "return", "outliner", "::", "InstrType", "::", "Illegal", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_max_round_ph", "(", "_", "_", "m512h", "_", "_", "A", ",", "_", "_", "mmask32", "_", "_", "B", ",", "_", "_", "m512h", "_", "_", "C", ",", "_", "_", "m512h", "_", "_", "D", ",", "const", "int", "_", "_", "E", ")", "{", "return", "_", "_", "builtin_ia32_maxph512_mask_round", "(", "_", "_", "C", ",", "_", "_", "D", ",", "_", "_", "A", ",", "_", "_", "B", ",", "_", "_", "E", ")", ";" ]

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

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

[ "=", "VOIDmode", ")" ]

[ "{", "gcc_assert", "(", "mode", "!" ]

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

[ "def", "VecList4QAsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "let", "ParserMethod", "=", "<STR_LIT>", ";" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "Dest", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "Switches", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "OperandType", "=", "OpType", ".", "FP32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SrcA", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SrcB", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SrcC", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SrcD", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Dest", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "OperandType", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ ")" ]

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

[ "case", "FK_Data_2", ":" ]

[ "Type", "=", "ELF", "::", "R_PPC64_ADDR16_HIGHER", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_HIGHERA", ":", "Type", "=", "ELF", "::", "R_PPC64_ADDR16_HIGHERA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_HIGHEST", ":", "Type", "=", "ELF", "::", "R_PPC64_ADDR16_HIGHEST", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_HIGHESTA", ":", "Type", "=", "ELF", "::", "R_PPC64_ADDR16_HIGHESTA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_GOT", ":", "Type", "=", "ELF", "::", "R_PPC_GOT16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_LO", ":", "Type", "=", "ELF", "::", "R_PPC_GOT16_LO", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_HI", ":", "Type", "=", "ELF", "::", "R_PPC_GOT16_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_HA", ":", "Type", "=", "ELF", "::", "R_PPC_GOT16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TOC", ":", "Type", "=", "ELF", "::", "R_PPC64_TOC16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TOC_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_TOC16_LO", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TOC_HI", ":", "Type", "=", "ELF", "::", "R_PPC64_TOC16_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TOC_HA", ":", "Type", "=", "ELF", "::", "R_PPC64_TOC16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL", ":", "Type", "=", "ELF", "::", "R_PPC_TPREL16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL_LO", ":", "Type", "=", "ELF", "::", "R_PPC_TPREL16_LO", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL_HI", ":", "Type", "=", "ELF", "::", "R_PPC_TPREL16_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL_HA", ":", "Type", "=", "ELF", "::", "R_PPC_TPREL16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL_HIGHER", ":", "Type", "=", "ELF", "::", "R_PPC64_TPREL16_HIGHER", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL_HIGHERA", ":", "Type", "=", "ELF", "::", "R_PPC64_TPREL16_HIGHERA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL_HIGHEST", ":", "Type", "=", "ELF", "::", "R_PPC64_TPREL16_HIGHEST", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL_HIGHESTA", ":", "Type", "=", "ELF", "::", "R_PPC64_TPREL16_HIGHESTA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL16_LO", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL_HI", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL16_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL_HA", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL_HIGHER", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL16_HIGHER", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL_HIGHERA", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL16_HIGHERA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL_HIGHEST", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL16_HIGHEST", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL_HIGHESTA", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL16_HIGHESTA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TLSGD", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TLSGD16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TLSGD_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TLSGD16_LO", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TLSGD_HI", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TLSGD16_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TLSGD_HA", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TLSGD16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TLSLD", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TLSLD16", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TLSLD_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TLSLD16_LO", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TLSLD_HI", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TLSLD16_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TLSLD_HA", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TLSLD16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TPREL", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TPREL16_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TPREL_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TPREL16_LO_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TPREL_HI", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TPREL16_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_DTPREL", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_DTPREL16_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_DTPREL_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_DTPREL16_LO_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TPREL_HA", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TPREL16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_DTPREL_HI", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_DTPREL16_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_DTPREL_HA", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_DTPREL16_HA", ";", "break", ";", "}", "break", ";", "case", "PPC", "::", "fixup_ppc_half16ds", ":", "switch", "(", "Modifier", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported Modifier", "<STR_LIT>", ")", ";", "case", "MCSymbolRefExpr", "::", "VK_None", ":", "Type", "=", "ELF", "::", "R_PPC64_ADDR16_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_ADDR16_LO_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_GOT", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT16_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT16_LO_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TOC", ":", "Type", "=", "ELF", "::", "R_PPC64_TOC16_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TOC_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_TOC16_LO_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL", ":", "Type", "=", "ELF", "::", "R_PPC64_TPREL16_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_TPREL16_LO_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL16_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL16_LO_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TPREL", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TPREL16_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TPREL_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TPREL16_LO_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_DTPREL", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_DTPREL16_DS", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_DTPREL_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_DTPREL16_LO_DS", ";", "break", ";", "}", "break", ";", "case", "PPC", "::", "fixup_ppc_nofixup", ":", "switch", "(", "Modifier", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported Modifier", "<STR_LIT>", ")", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TLSGD", ":", "Type", "=", "ELF", "::", "R_PPC64_TLSGD", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TLSLD", ":", "Type", "=", "ELF", "::", "R_PPC64_TLSLD", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TLS", ":", "Type", "=", "ELF", "::", "R_PPC64_TLS", ";", "break", ";", "}", "break", ";", "case", "FK_Data_8", ":", "switch", "(", "Modifier", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported Modifier", "<STR_LIT>", ")", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TOCBASE", ":", "Type", "=", "ELF", "::", "R_PPC64_TOC", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_None", ":", "Type", "=", "ELF", "::", "R_PPC64_ADDR64", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPMOD", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPMOD64", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL", ":", "Type", "=", "ELF", "::", "R_PPC64_TPREL64", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL64", ";", "break", ";", "}", "break", ";", "case", "FK_Data_4", ":", "Type", "=", "ELF", "::", "R_PPC_ADDR32", ";", "break", ";" ]

[ ".", "addMBB", "(", "FBB", ")", ";" ]

[ "}", "unsigned", "Count", "=", "<NUM_LIT>", ";", "<STR_LIT>", "::", "<STR_LIT>", "CC", "=", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "getBrCond", "(", "CC", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "++", "Count", ";", "if", "(", "FBB", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")" ]

[ "Warning", ";", "}" ]

[ "unsigned", "getWarning", "(", ")", "{", "getErrInfo", "(", ")", ";", "return", "CrntErrInfo", ".", "s", "." ]

[ "}" ]

[ "class", "AI_ext_rrot_np", "<", "bits", "<", "<NUM_LIT>", ">", "opcod", ",", "string", "opc", ">", ":", "AExtI", "<", "opcod", ",", "(", "outs", "GPRnopc", ":", "$", "Rd", ")", ",", "(", "ins", "GPRnopc", ":", "$", "Rm", ",", "rot_imm", ":", "$", "rot", ")", ",", "IIC_iEXTr", ",", "opc", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Requires", "<", "[", "IsARM", ",", "HasV6", "]", ">", ",", "Sched", "<", "[", "WriteALUsi", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "rot", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "rot", ";" ]

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

[ "(", "set", "(", "reg", ":", "CCRAW", "CC_REGNUM", ")", "(", "unspec", ":", "CCRAW", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_VEC_VFEECC", ")", ")", "]", ")", "(", "set", "(", "match_operand", ":" ]

[ ")", ".", "addReg", "(", "X86", "::", "ECX", ")", ";" ]

[ "case", "X86", "::", "TCRETURNmi64", ":", "{", "bool", "isMem", "=", "Opcode", "==", "X86", "::", "TCRETURNmi", "||", "Opcode", "==", "X86", "::", "TCRETURNmi64", ";", "MachineOperand", "&", "JumpTarget", "=", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "MachineOperand", "&", "StackAdjust", "=", "MBBI", "->", "getOperand", "(", "isMem", "?", "X86", "::", "AddrNumOperands", ":", "<NUM_LIT>", ")", ";", "assert", "(", "StackAdjust", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "Expecting immediate value.", "<STR_LIT>", ")", ";", "int", "StackAdj", "=", "StackAdjust", ".", "getImm", "(", ")", ";", "int", "MaxTCDelta", "=", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "int", "Offset", "=", "<NUM_LIT>", ";", "assert", "(", "MaxTCDelta", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "MaxTCDelta should never be positive", "<STR_LIT>", ")", ";", "Offset", "=", "StackAdj", "-", "MaxTCDelta", ";", "assert", "(", "Offset", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Offset should never be negative", "<STR_LIT>", ")", ";", "if", "(", "Opcode", "==", "X86", "::", "TCRETURNdicc", "||", "Opcode", "==", "X86", "::", "TCRETURNdi64cc", ")", "{", "assert", "(", "Offset", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Conditional tail call cannot adjust the stack.", "<STR_LIT>", ")", ";", "}", "if", "(", "Offset", ")", "{", "Offset", "+=", "X86FL", "->", "mergeSPUpdates", "(", "MBB", ",", "MBBI", ",", "true", ")", ";", "X86FL", "->", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "DL", ",", "Offset", ",", "true", ")", ";", "}", "bool", "IsWin64", "=", "STI", "->", "isTargetWin64", "(", ")", ";", "if", "(", "Opcode", "==", "X86", "::", "TCRETURNdi", "||", "Opcode", "==", "X86", "::", "TCRETURNdicc", "||", "Opcode", "==", "X86", "::", "TCRETURNdi64", "||", "Opcode", "==", "X86", "::", "TCRETURNdi64cc", ")", "{", "unsigned", "Op", ";", "switch", "(", "Opcode", ")", "{", "case", "X86", "::", "TCRETURNdi", ":", "Op", "=", "X86", "::", "TAILJMPd", ";", "break", ";", "case", "X86", "::", "TCRETURNdicc", ":", "Op", "=", "X86", "::", "TAILJMPd_CC", ";", "break", ";", "case", "X86", "::", "TCRETURNdi64cc", ":", "assert", "(", "!", "MBB", ".", "getParent", "(", ")", "->", "hasWinCFI", "(", ")", "&&", "<STR_LIT>", "Conditional tail calls confuse ", "<STR_LIT>", "<STR_LIT>", "the Win64 unwinder.", "<STR_LIT>", ")", ";", "Op", "=", "X86", "::", "TAILJMPd64_CC", ";", "break", ";", "default", ":", "Op", "=", "X86", "::", "TAILJMPd64", ";", "break", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "Op", ")", ")", ";", "if", "(", "JumpTarget", ".", "isGlobal", "(", ")", ")", "{", "MIB", ".", "addGlobalAddress", "(", "JumpTarget", ".", "getGlobal", "(", ")", ",", "JumpTarget", ".", "getOffset", "(", ")", ",", "JumpTarget", ".", "getTargetFlags", "(", ")", ")", ";", "}", "else", "{", "assert", "(", "JumpTarget", ".", "isSymbol", "(", ")", ")", ";", "MIB", ".", "addExternalSymbol", "(", "JumpTarget", ".", "getSymbolName", "(", ")", ",", "JumpTarget", ".", "getTargetFlags", "(", ")", ")", ";", "}", "if", "(", "Op", "==", "X86", "::", "TAILJMPd_CC", "||", "Op", "==", "X86", "::", "TAILJMPd64_CC", ")", "{", "MIB", ".", "addImm", "(", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "}", "}", "else", "if", "(", "Opcode", "==", "X86", "::", "TCRETURNmi", "||", "Opcode", "==", "X86", "::", "TCRETURNmi64", ")", "{", "unsigned", "Op", "=", "(", "Opcode", "==", "X86", "::", "TCRETURNmi", ")", "?", "X86", "::", "TAILJMPm", ":", "(", "IsWin64", "?", "X86", "::", "TAILJMPm64_REX", ":", "X86", "::", "TAILJMPm64", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "Op", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "X86", "::", "AddrNumOperands", ";", "++", "i", ")", "MIB", ".", "add", "(", "MBBI", "->", "getOperand", "(", "i", ")", ")", ";", "}", "else", "if", "(", "Opcode", "==", "X86", "::", "TCRETURNri64", ")", "{", "JumpTarget", ".", "setIsKill", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "IsWin64", "?", "X86", "::", "TAILJMPr64_REX", ":", "X86", "::", "TAILJMPr64", ")", ")", ".", "add", "(", "JumpTarget", ")", ";", "}", "else", "{", "JumpTarget", ".", "setIsKill", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "TAILJMPr", ")", ")", ".", "add", "(", "JumpTarget", ")", ";", "}", "MachineInstr", "&", "NewMI", "=", "*", "std", "::", "prev", "(", "MBBI", ")", ";", "NewMI", ".", "copyImplicitOps", "(", "*", "MBBI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "*", "MBBI", ")", ";", "if", "(", "MBBI", "->", "isCandidateForCallSiteEntry", "(", ")", ")", "MBB", ".", "getParent", "(", ")", "->", "moveCallSiteInfo", "(", "&", "*", "MBBI", ",", "&", "NewMI", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "return", "true", ";", "}", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "{", "MachineOperand", "&", "DestAddr", "=", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "DestAddr", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "Offset should be in register!", "<STR_LIT>", ")", ";", "const", "bool", "Uses64BitFramePtr", "=", "STI", "->", "isTarget64BitLP64", "(", ")", "||", "STI", "->", "isTargetNaCl64", "(", ")", ";", "Register", "StackPtr", "=", "TRI", "->", "getStackRegister", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "Uses64BitFramePtr", "?", "X86", "::", "MOV64rr", ":", "X86", "::", "MOV32rr", ")", ",", "StackPtr", ")", ".", "addReg", "(", "DestAddr", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "case", "X86", "::", "IRET", ":", "{", "int64_t", "StackAdj", "=", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "X86FL", "->", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "DL", ",", "StackAdj", ",", "true", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "STI", "->", "is64Bit", "(", ")", "?", "X86", "::", "IRET64", ":", "X86", "::", "IRET32", ")", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "return", "true", ";", "}", "case", "X86", "::", "RET", ":", "{", "int64_t", "StackAdj", "=", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "MachineInstrBuilder", "MIB", ";", "if", "(", "StackAdj", "==", "<NUM_LIT>", ")", "{", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "STI", "->", "is64Bit", "(", ")", "?", "X86", "::", "RETQ", ":", "X86", "::", "RETL", ")", ")", ";", "}", "else", "if", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "StackAdj", ")", ")", "{", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "STI", "->", "is64Bit", "(", ")", "?", "X86", "::", "RETIQ", ":", "X86", "::", "RETIL", ")", ")", ".", "addImm", "(", "StackAdj", ")", ";", "}", "else", "{", "assert", "(", "!", "STI", "->", "is64Bit", "(", ")", "&&", "<STR_LIT>", "shouldn't need to do this for x86_64 targets!", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "POP32r", ")", ")", ".", "addReg", "(", "X86", "::", "ECX", ",", "RegState", "::", "Define", ")", ";", "X86FL", "->", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "DL", ",", "StackAdj", ",", "true", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "PUSH32r", ")" ]

[ "MEM_VOLATILE_P", "(", "lraddr", ")", "=", "true", ";" ]

[ "void", "or", "<NUM_LIT>", "k_expand_eh_return", "(", "rtx", "eh_addr", ")", "{", "rtx", "lraddr", ";", "lraddr", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "-", "UNITS_PER_WORD", ")", ")", ";" ]

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

[ "if", "(", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_vec_perm_const_ps", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "const1_rtx", ",", "const2_rtx", ")", ")", "else", "emit_insn", "(", "gen_vec_perm_const_ps", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]" ]

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

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

[ "MRI", ",", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", ";" ]

[ "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " -> ", "<STR_LIT>", "<<", "*", "MI", ")", ";", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "LowerToCopyInstrs", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_SET_INACTIVE_B32", "||", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_SET_INACTIVE_B64", ")", "{", "assert", "(", "MI", "->", "getNumExplicitOperands", "(", ")", "==", "<NUM_LIT>", ")", ";", "assert", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isUndef", "(", ")", ")", ";", "MI", "->", "removeOperand", "(", "<NUM_LIT>", ")", ";", "MI", "->", "untieRegOperand", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "assert", "(", "MI", "->", "getNumExplicitOperands", "(", ")", "==", "<NUM_LIT>", ")", ";", "}", "unsigned", "CopyOp", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "?", "(", "unsigned", ")", "AMDGPU", "::", "COPY", ":", "TII", "->", "getMovOpcode", "(", "TRI", "->", "getRegClassForOperandReg", "(", "*" ]

[ "(", "eq_attr", "<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>", ")" ]

[ "}" ]

[ "if", "(", "llvm", "::", "is_contained", "(", "AsmPieces", ",", "<STR_LIT>", "~{cc}", "<STR_LIT>", ")", "&&", "llvm", "::", "is_contained", "(", "AsmPieces", ",", "<STR_LIT>", "~{flags}", "<STR_LIT>", ")", "&&", "llvm", "::", "is_contained", "(", "AsmPieces", ",", "<STR_LIT>", "~{fpsr}", "<STR_LIT>", ")", ")", "{", "if", "(", "AsmPieces", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "return", "true", ";", "else", "if", "(", "llvm", "::", "is_contained", "(", "AsmPieces", ",", "<STR_LIT>", "~{dirflag}", "<STR_LIT>", ")", ")", "return", "true", ";" ]

[ "let", "opNewValue", "=", "<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", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ ")", ";" ]

[ "void", "TMS320C64XHazardRecognizer", "::", "fixResources", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "const", "TargetInstrDesc", "desc", "=", "MI", "->", "getDesc", "(", ")", ";", "int", "regside", ",", "instside", ";", "if", "(", "!", "isFlexibleInstruction", "(", "desc", ")", ")", "return", ";", "if", "(", "desc", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "if", "(", "desc", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "MachineOperand", "&", "reg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "reg", ".", "isReg", "(", ")", "&&", "reg", ".", "isUse", "(", ")", ")", ";", "regside", "=", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "reg", ".", "getReg", "(", ")", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "}", "else", "{", "MachineOperand", "&", "dst", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "dst", ".", "isReg", "(", ")", "&&", "dst", ".", "isDef", "(", ")", "&&", "!", "dst", ".", "isImplicit", "(", ")", ")", ";", "regside", "=", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "dst", ".", "getReg", "(", ")", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "}", "setXPath", "(", "MI", ",", "regside", ")", ";", "return", ";", "}", "bool", "mixed", ";", "tie", "(", "mixed", ",", "regside", ")", "=", "analyzeOpRegs", "(", "MI", ")", ";", "instside", "=", "IS_BSIDE", "(", "desc", ".", "TSFlags", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "if", "(", "mixed", "||", "(", "(", "regside", ">=", "<NUM_LIT>", ")", "&&", "(", "regside", "!=", "instside", ")", ")", ")", "setXPath", "(", "MI", ",", "true", ")", ";", "else", "setXPath", "(", "MI", ",", "false" ]

[ "{" ]

[ "static", "bool", "check_required_registers", "(", "location_t", "location", ",", "tree", "fndecl", ")", "{", "if", "(", "reported_missing_registers_p", ")", "return", "false", ";", "if", "(", "TARGET_GENERAL_REGS_ONLY", ")" ]

[ "void", "SIFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "return", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "unsigned", "ScratchExecCopy", "=", "AMDGPU", "::", "NoRegister", ";", "for", "(", "const", "SIMachineFunctionInfo", "::", "SGPRSpillVGPRCSR", "&", "Reg", ":", "FuncInfo", "->", "getSGPRSpillVGPRs", "(", ")", ")", "{", "if", "(", "!", "Reg", ".", "FI", ".", "hasValue", "(", ")", ")", "continue", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "if", "(", "ScratchExecCopy", "==", "AMDGPU", "::", "NoRegister", ")", "{", "LivePhysRegs", "LiveRegs", "(", "*", "ST", ".", "getRegisterInfo", "(", ")", ")", ";", "LiveRegs", ".", "addLiveIns", "(", "MBB", ")", ";", "ScratchExecCopy", "=", "findScratchNonCalleeSaveRegister", "(", "MF", ",", "LiveRegs", ",", "*", "TRI", ".", "getWaveMaskRegClass", "(", ")", ")", ";", "const", "unsigned", "OrSaveExec", "=", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_OR_SAVEEXEC_B32", ":", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "OrSaveExec", ")", ",", "ScratchExecCopy", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ";", "}", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ".", "VGPR", ",", "Reg", ".", "FI", ".", "getValue", "(", ")", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "&", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "}", "if", "(", "ScratchExecCopy", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "unsigned", "ExecMov", "=", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_MOV_B32", ":", "AMDGPU", "::", "S_MOV_B64", ";", "unsigned", "Exec", "=", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "EXEC_LO", ":", "AMDGPU", "::", "EXEC", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "ExecMov", ")", ",", "Exec", ")", ".", "addReg", "(", "ScratchExecCopy", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint32_t", "NumBytes", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint32_t", "RoundedSize", "=", "FuncInfo", "->", "isStackRealigned", "(", ")", "?", "NumBytes", "+", "MFI", ".", "getMaxAlignment", "(", ")", ":", "NumBytes", ";", "const", "unsigned", "StackPtrReg", "=", "FuncInfo", "->", "getStackPtrOffsetReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_SUB_U32", ")", ",", "StackPtrReg", ")", ".", "addReg", "(", "StackPtrReg", ")", ".", "addImm", "(", "RoundedSize", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "}" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "}" ]

[ "int", "h8300_can_use_return_insn_p", "(", "void", ")", "{", "return", "(", "reload_completed", "&&", "!", "frame_pointer_needed", "&&", "get_frame_size", "(", ")", "==", "<NUM_LIT>", "&&", "compute_saved_regs", "(", ")", "==", "<NUM_LIT>", ")", ";" ]

[ "Value", "*", "DivLo", "=", "Builder", ".", "CreateCast", "(", "Instruction", "::", "ZExt", ",", "Op1", ",", "FullType", ")", ";" ]

[ "Instruction", "::", "BinaryOps", "DivOp", ",", "RemOp", ";", "if", "(", "isSigned", ")", "{", "ExtOp", "=", "Instruction", "::", "SExt", ";", "DivOp", "=", "Instruction", "::", "SDiv", ";", "RemOp", "=", "Instruction", "::", "SRem", ";", "}", "else", "{", "ExtOp", "=", "Instruction", "::", "ZExt", ";", "DivOp", "=", "Instruction", "::", "UDiv", ";", "RemOp", "=", "Instruction", "::", "URem", ";", "}", "Value", "*", "Dividend", ",", "*", "Divisor", ";", "if", "(", "isThreeOperand", ")", "{", "Value", "*", "Op0", "=", "getOperand", "(", "<NUM_LIT>", ")", ",", "*", "Op1", "=", "getOperand", "(", "<NUM_LIT>", ")", ";", "IntegerType", "*", "HalfType", "=", "cast", "<", "IntegerType", ">", "(", "getResultTy", "(", "<NUM_LIT>", ")", ")", ";", "unsigned", "HalfBits", "=", "HalfType", "->", "getPrimitiveSizeInBits", "(", ")", ";", "IntegerType", "*", "FullType", "=", "IntegerType", "::", "get", "(", "getContext", "(", ")", ",", "HalfBits", "*", "<NUM_LIT>", ")", ";", "Value", "*", "DivHi", "=", "Builder", ".", "CreateCast", "(", "Instruction", "::", "ZExt", ",", "Op0", ",", "FullType", ")", ";" ]

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

[ "vst1q_p16", "(", "poly16_t", "*", "_", "_", "a", ",", "poly16x8_t", "_", "_" ]

[ ")", "!=", "AtomicRMWInst", "::", "UMin", "&&", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "UMax", ")", "{" ]

[ "if", "(", "Subtarget", "->", "outlineAtomics", "(", ")", ")", "{", "if", "(", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "Min", "&&", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "Max", "&&", "AI", "->", "getOperation", "(" ]

[ "void", "avr_expand_epilogue", "(", "bool", "sibcall_p", ")", "{", "int", "reg", ";", "int", "live_seq", ";", "HARD_REG_SET", "set", ";", "int", "minimize", ";", "HOST_WIDE_INT", "size", ";", "bool", "isr_p", "=", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ";", "size", "=", "get_frame_size", "(", ")", "+", "avr_outgoing_args_size", "(", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_naked", ")", "{", "gcc_assert", "(", "!", "sibcall_p", ")", ";", "emit_jump_insn", "(", "gen_return", "(", ")", ")", ";", "return", ";", "}", "avr_regs_to_save", "(", "&", "set", ")", ";", "live_seq", "=", "sequent_regs_live", "(", ")", ";", "minimize", "=", "(", "TARGET_CALL_PROLOGUES", "&&", "live_seq", "&&", "!", "isr_p", "&&", "!", "cfun", "->", "machine", "->", "is_OS_task", "&&", "!", "cfun", "->", "machine", "->", "is_OS_main", "&&", "!", "AVR_TINY", ")", ";", "if", "(", "minimize", "&&", "(", "live_seq", ">", "<NUM_LIT>", "||", "frame_pointer_needed", "||", "size", ")", ")", "{", "if", "(", "!", "frame_pointer_needed", ")", "{", "emit_move_insn", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "}", "if", "(", "size", ")", "{", "emit_move_insn", "(", "frame_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "frame_pointer_rtx", ",", "size", ")", ")", ";", "}", "emit_insn", "(", "gen_epilogue_restores", "(", "gen_int_mode", "(", "live_seq", ",", "HImode", ")", ")", ")", ";", "return", ";", "}", "if", "(", "size", ")", "{", "int", "irq_state", "=", "-", "<NUM_LIT>", ";", "rtx", "fp", ",", "my_fp", ";", "rtx_insn", "*", "fp_plus_insns", ";", "HOST_WIDE_INT", "size_max", ";", "gcc_assert", "(", "frame_pointer_needed", "||", "!", "isr_p", "||", "!", "crtl", "->", "is_leaf", ")", ";", "fp", "=", "my_fp", "=", "(", "frame_pointer_needed", "?", "frame_pointer_rtx", ":", "gen_rtx_REG", "(", "Pmode", ",", "REG_X", ")", ")", ";", "if", "(", "AVR_HAVE_8BIT_SP", ")", "{", "my_fp", "=", "all_regs_rtx", "[", "FRAME_POINTER_REGNUM", "]", ";", "}", "size_max", "=", "(", "HOST_WIDE_INT", ")", "GET_MODE_MASK", "(", "GET_MODE", "(", "my_fp", ")", ")", ";", "if", "(", "size", ">", "size_max", ")", "size", "=", "size_max", ";", "size", "=", "trunc_int_for_mode", "(", "size", ",", "GET_MODE", "(", "my_fp", ")", ")", ";", "start_sequence", "(", ")", ";", "if", "(", "!", "frame_pointer_needed", ")", "emit_move_insn", "(", "fp", ",", "stack_pointer_rtx", ")", ";", "emit_move_insn", "(", "my_fp", ",", "plus_constant", "(", "GET_MODE", "(", "my_fp", ")", ",", "my_fp", ",", "size", ")", ")", ";", "if", "(", "TARGET_NO_INTERRUPTS", ")", "irq_state", "=", "<NUM_LIT>", ";", "if", "(", "AVR_HAVE_8BIT_SP", ")", "irq_state", "=", "<NUM_LIT>", ";", "emit_insn", "(", "gen_movhi_sp_r", "(", "stack_pointer_rtx", ",", "fp", ",", "GEN_INT", "(", "irq_state", ")", ")", ")", ";", "fp_plus_insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "if", "(", "avr_sp_immediate_operand", "(", "gen_int_mode", "(", "size", ",", "HImode", ")", ",", "HImode", ")", ")", "{", "rtx_insn", "*", "sp_plus_insns", ";", "start_sequence", "(", ")", ";", "emit_move_insn", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "size", ")", ")", ";", "sp_plus_insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_insn", "(", "get_sequence_length", "(", "sp_plus_insns", ")", "<", "get_sequence_length", "(", "fp_plus_insns", ")", "?", "sp_plus_insns", ":", "fp_plus_insns", ")", ";", "}", "else", "emit_insn", "(", "fp_plus_insns", ")", ";", "}", "if", "(", "frame_pointer_needed", "&&", "!", "(", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", ")", ")", "{", "emit_pop_byte", "(", "REG_Y", "+", "<NUM_LIT>", ")", ";", "emit_pop_byte", "(", "REG_Y", ")", ";", "}", "for", "(", "reg", "=", "<NUM_LIT>", ";", "reg", ">=", "<NUM_LIT>", ";", "--", "reg", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "set", ",", "reg", ")", ")", "emit_pop_byte", "(", "reg", ")", ";", "if", "(", "isr_p", ")", "{", "if", "(", "AVR_HAVE_RAMPZ", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", "+", "<NUM_LIT>", ")", ")", "{", "emit_pop_byte", "(", "TMP_REGNO", ")", ";", "emit_move_insn", "(", "rampz_rtx", ",", "tmp_reg_rtx", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPY", "&&", "(", "frame_pointer_needed", "||", "(", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", "+", "<NUM_LIT>", ")", ")", ")", ")", "{", "emit_pop_byte", "(", "TMP_REGNO", ")", ";", "emit_move_insn", "(", "rampy_rtx", ",", "tmp_reg_rtx", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPX", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", "+", "<NUM_LIT>", ")", ")", "{", "emit_pop_byte", "(", "TMP_REGNO", ")", ";", "emit_move_insn", "(", "rampx_rtx", ",", "tmp_reg_rtx", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPD", ")", "{", "emit_pop_byte", "(", "TMP_REGNO", ")", ";", "emit_move_insn", "(", "rampd_rtx", ",", "tmp_reg_rtx", ")", ";", "}", "emit_pop_byte", "(", "AVR_TMP_REGNO", ")", ";", "emit_move_insn", "(", "sreg_rtx", ",", "tmp_reg_rtx", ")", ";", "emit_pop_byte", "(", "AVR_TMP_REGNO", ")", ";", "emit_pop_byte", "(", "AVR_ZERO_REGNO", ")", ";", "}", "if", "(", "!", "sibcall_p", ")", "emit_jump_insn", "(", "gen_return", "(", ")", ")", ";", "}" ]

[ "Output", "RTL", "epilogue", "." ]

[ ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "bswap", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "Extract", "=", "DAG", ".", "getBitcast", "(", "VT", ",", "Extract", ")", ";" ]

[ "EVT", "MemVT", "=", "MemIntrin", "->", "getMemoryVT", "(", ")", ";", "for", "(", "SDNode", "*", "User", ":", "Ptr", "->", "uses", "(", ")", ")", "if", "(", "User", "!=", "N", "&&", "User", "->", "getOpcode", "(", ")", "==", "N", "->", "getOpcode", "(", ")", "&&", "cast", "<", "MemIntrinsicSDNode", ">", "(", "User", ")", "->", "getBasePtr", "(", ")", "==", "Ptr", "&&", "cast", "<", "MemIntrinsicSDNode", ">", "(", "User", ")", "->", "getChain", "(", ")", "==", "Chain", "&&", "cast", "<", "MemIntrinsicSDNode", ">", "(", "User", ")", "->", "getMemoryVT", "(", ")", ".", "getSizeInBits", "(", ")", "==", "MemVT", ".", "getSizeInBits", "(", ")", "&&", "!", "User", "->", "hasAnyUseOfValue", "(", "<NUM_LIT>", ")", "&&", "User", "->", "getValueSizeInBits", "(", "<NUM_LIT>", ")", ".", "getFixedValue", "(", ")", ">", "VT", ".", "getFixedSizeInBits", "(", ")", ")", "{", "SDValue", "Extract", "=", "extractSubVector", "(", "SDValue", "(", "User", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "DAG", ",", "SDLoc", "(", "N", ")", ",", "VT", ".", "getSizeInBits", "(", ")", ")", ";" ]

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

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

[ "MCDisassembler", "::", "Fail", ";" ]

[ "unsigned", "Rn", "=", "fieldFromInstruction32", "(", "Val", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "Rm", "=", "fieldFromInstruction32", "(", "Val", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "Check", "(", "S", ",", "DecodetGPRRegisterClass", "(", "Inst", ",", "Rn", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "!", "Check", "(", "S", ",", "DecodetGPRRegisterClass", "(", "Inst", ",", "Rm", ",", "Address", ",", "Decoder", ")", ")", ")", "return" ]

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

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

[ "SDValue", "X86TargetLowering", "::", "getRecipEstimate", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "RefinementSteps", ")", "const", "{", "SDLoc", "DL", "(", "Op", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "f32", "&&", "Subtarget", ".", "hasSSE1", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", ".", "hasSSE1", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v8f32", "&&", "Subtarget", ".", "hasAVX", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v16f32", "&&", "Subtarget", ".", "useAVX512Regs", "(", ")", ")", ")", "{", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "Enabled", "==", "ReciprocalEstimate", "::", "Unspecified", ")", "return", "SDValue", "(", ")", ";", "if", "(", "RefinementSteps", "==", "ReciprocalEstimate", "::", "Unspecified", ")", "RefinementSteps", "=", "<NUM_LIT>", ";", "unsigned", "Opcode", "=", "VT", "==", "MVT", "::", "v16f32", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "DAG", ".", "getNode", "(", "Opcode", ",", "DL", ",", "VT", ",", "Op", ")", ";", "}", "if", "(", "VT", ".", "getScalarType", "(", ")", "==", "MVT", "::", "f16", "&&", "isTypeLegal", "(", "VT", ")", "&&", "Subtarget", ".", "hasFP16", "(", ")", ")", "{", "if", "(", "RefinementSteps", "==", "ReciprocalEstimate", "::", "Unspecified", ")", "RefinementSteps", "=", "<NUM_LIT>", ";", "if", "(", "VT", "==", "MVT", "::", "f16", ")", "{", "SDValue", "Zero", "=", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "DL", ")", ";", "SDValue", "Undef", "=", "DAG", ".", "getUNDEF", "(", "MVT", "::", "v8f16", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "DL", ",", "MVT", "::", "v8f16", ",", "Op", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v8f16", ",", "Undef", ",", "Op", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "DL", ",", "MVT", "::", "f16", ",", "Op", ",", "Zero", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "Op", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}" ]

[ "Return", "a", "reciprocal", "estimate", "value", "for", "the", "input", "operand", "." ]