Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

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

[ ")", ";" ]

[ "const", "MCOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "O", "<<", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "O", "<<", "*", "MO", ".", "getExpr", "(", ")", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "printImmOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unknown operand", "<STR_LIT>" ]

[ "}" ]

[ "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "return", "GR_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "return", "GR_REGS", ";", "break", ";", "case", "PR_REGS", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "return", "GR_REGS", ";", "if", "(", "regno", ">=", "<NUM_LIT>", "&&", "!", "GENERAL_REGNO_P", "(", "regno", ")", "&&", "!", "PR_REGNO_P", "(", "regno", ")", ")", "return", "GR_REGS", ";", "break", ";", "default", ":", "break", ";" ]

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

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

[ "}" ]

[ "_", "_", "asm__", "(", "<STR_LIT>", "mshards.q\t%1, %2, %0", "<STR_LIT>", ":", "<STR_LIT>", "=r", "<STR_LIT>", "(", "res", ")", ":", "<STR_LIT>", "r", "<STR_LIT>", "(", "mm", ")", ",", "<STR_LIT>", "r", "<STR_LIT>", "(", "mn", ")", ")", ";", "return", "res", ";" ]

[ "if", "(", "target", "==", "<NUM_LIT>", ")", "target", "=", "gen_reg_rtx", "(", "target_mode", ")", ";" ]

[ "case", "IA64_BUILTIN_INFQ", ":", "case", "IA64_BUILTIN_HUGE_VALQ", ":", "{", "machine_mode", "target_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "REAL_VALUE_TYPE", "inf", ";", "rtx", "tmp", ";", "real_inf", "(", "&", "inf", ")", ";", "tmp", "=", "CONST_DOUBLE_FROM_REAL_VALUE", "(", "inf", ",", "target_mode", ")", ";", "tmp", "=", "validize_mem", "(", "force_const_mem", "(", "target_mode", ",", "tmp", ")", ")", ";" ]

[ "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_ucmpd256_mask", "(", "(", "_", "_", "v8si", ")", "_", "_", "X", ",", "(", "_", "_", "v8si", ")", "_", "_", "Y", ",", "_", "_", "P", "," ]

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

[ "virtual", "bool", "isFMAFasterThanMulAndAdd", "(", "EVT" ]

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

[ "bool", "X86TargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", ",", "MachineMemOperand", "::", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Fast", ")", "{", "switch", "(", "VT", ".", "getSizeInBits", "(" ]

[ "}" ]

[ "}", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "<NUM_LIT>", ">", "Outs", ";", "subTargetRegTypeForCallingConv", "(", "F", ",", "ArgInfos", ",", "OrigArgIndices", ",", "Outs", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "bool", "IsCalleeVarArg", "=", "false", ";", "if", "(", "Info", ".", "Callee", ".", "isGlobal", "(", ")", ")", "{", "const", "Function", "*", "CF", "=", "static_cast", "<", "const", "Function", "*", ">", "(", "Info", ".", "Callee", ".", "getGlobal", "(", ")", ")", ";", "IsCalleeVarArg", "=", "CF", "->", "isVarArg", "(", ")", ";", "}", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "IsCalleeVarArg", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AllocateStack", "(", "ABI", ".", "GetCalleeAllocdArgSizeInBytes", "(", "Info", ".", "CallConv", ")", ",", "Align", "(", "<NUM_LIT>", ")", ")", ";", "const", "char", "*", "Call", "=", "Info", ".", "Callee", ".", "isSymbol", "(", ")", "?", "Info", ".", "Callee", ".", "getSymbolName", "(", ")", ":", "nullptr", ";", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "TLI", ".", "CCAssignFnForCall", "(", ")", ",", "FuncOrigArgs", ",", "Call", ")", ";", "setLocInfo", "(", "ArgLocs", ",", "Outs", ")", ";", "MipsOutgoingValueHandler", "RetHandler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ",", "MIB", ")", ";", "if", "(", "!", "RetHandler", ".", "handle", "(", "ArgLocs", ",", "ArgInfos", ")", ")", "{", "return", "false", ";", "}", "unsigned", "NextStackOffset", "=", "CCInfo", ".", "getNextStackOffset", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFL", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "unsigned", "StackAlignment", "=", "TFL", "->", "getStackAlignment", "(", ")", ";", "NextStackOffset", "=", "alignTo", "(", "NextStackOffset", ",", "StackAlignment", ")", ";", "CallSeqStart", ".", "addImm", "(", "NextStackOffset", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "IsCalleeGlobalPIC", ")", "{", "MIRBuilder", ".", "buildCopy", "(", "Register", "(", "Mips", "::", "GP", ")", ",", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "getGlobalBaseRegForGlobalISel", "(", "MF", ")", ")", ";", "MIB", ".", "addDef", "(", "Mips", "::", "GP", ",", "RegState", "::", "Implicit", ")", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "if", "(", "MIB", "->", "getOpcode", "(", ")", "==", "Mips", "::", "JALRPseudo", ")", "{", "const", "MipsSubtarget", "&", "STI", "=", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MIRBuilder", ".", "getMF", "(", ")", ".", "getSubtarget", "(", ")", ")", ";", "MIB", ".", "constrainAllUses", "(", "MIRBuilder", ".", "getTII", "(", ")", ",", "*", "STI", ".", "getRegisterInfo", "(", ")", ",", "*", "STI", ".", "getRegBankInfo", "(", ")", ")", ";", "}", "if", "(", "!", "Info", ".", "OrigRet", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "{", "ArgInfos", ".", "clear", "(", ")", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "OrigRetIndices", ";", "splitToValueTypes", "(", "DL", ",", "Info", ".", "OrigRet", ",", "<NUM_LIT>", ",", "ArgInfos", ",", "OrigRetIndices", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "<NUM_LIT>", ">", "Ins", ";", "subTargetRegTypeForCallingConv", "(", "F", ",", "ArgInfos", ",", "OrigRetIndices", ",", "Ins", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "TLI", ".", "CCAssignFnForReturn", "(", ")", ",", "Info", ".", "OrigRet", ".", "Ty", ",", "Call", ")", ";", "setLocInfo", "(", "ArgLocs", ",", "Ins", ")", ";", "CallReturnHandler", "Handler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ",", "MIB", ")", ";", "if", "(", "!", "Handler", ".", "handle", "(", "ArgLocs", ",", "ArgInfos", ")", ")", "return", "false", ";" ]

[ "static", "bool", "or", "<NUM_LIT>", "k_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "rclass", "==", "FLAG_REGS", ")", "return", "from", "==", "to", ";", "return", "true", ";", "}" ]

[ "Worker", "for", "TARGET_CAN_CHANGE_MODE_CLASS", ".", "Returns", "true", "if", "its", "ok", "to", "change", "a", "register", "in", "class", "RCLASS", "from", "mode", "FROM", "to", "mode", "TO", ".", "In", "general", "OpenRISC", "registers", ",", "other", "than", "special", "flags", ",", "handle", "all", "supported", "classes", "." ]

[ ")", ")" ]

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

[ "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "Reloc", "::", "Model", "RM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "MipsABI", "(", "UnknownABI", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasMulDivAdd", "(", "false", ")", ",", "HasMinMax", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", ",", "HasFPIdx", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "IsAndroid", "(", "false", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "<STR_LIT>", "mips32", "<STR_LIT>", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "MipsABI", "==", "UnknownABI", ")", "MipsABI", "=", "hasMips64", "(", ")", "?", "N64", ":", "O32", ";", "assert", "(", "(", "(", "!", "hasMips64", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "hasMips64", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "<STR_LIT>", "Invalid Arch & ABI pair.", "<STR_LIT>", ")", ";", "if", "(", "TT", ".", "find", "(", "<STR_LIT>", "linux", "<STR_LIT>", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "UseSmallSection", "=", "!", "IsLinux", "&&", "(", "RM", "==", "Reloc", "::", "Static", ")", ";", "}" ]

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

[ "rtx", "function_expander", "::", "get_contiguous_base", "(", "machine_mode", "mem_mode", ")", "{", "rtx", "base", "=", "convert_to_pmode", "(", "args", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "mode_suffix_id", "==", "MODE_vnum", ")", "{", "poly_int64", "size", "=", "or", "dered_min", "(", "GET_MODE_SIZE", "(", "mem_mode", ")", ",", "BYTES_PER_SVE_VECTOR", ")", ";", "rtx", "offset", "=", "gen_int_mode", "(", "size", ",", "Pmode", ")", ";", "offset", "=", "simplify_gen_binary", "(", "MULT", ",", "Pmode", ",", "args", "[", "<NUM_LIT>", "]", ",", "offset", ")", ";", "base", "=", "simplify_gen_binary", "(", "PLUS", ",", "Pmode", ",", "base", ",", "offset", ")", ";", "}", "return", "base", ";", "}" ]

[ "Return", "the", "base", "address", "for", "a", "contiguous", "load", "or", "store", "function", ".", "MEM_MODE", "is", "the", "mode", "of", "the", "addressed", "memory", "." ]

[ "if", "(", "type", "!=", "error_mark_node", "&&", "TYPE_MODE", "(", "type", ")", "==", "DFmode", ")", "align", "=", "MAX", "(", "align", ",", "<NUM_LIT>", ")", ";" ]

[ "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "while", "(", "field", "!=", "NULL", "&&", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "field", "=", "DECL_CHAIN", "(", "field", ")", ";", "if", "(", "field", "!=", "NULL", "&&", "field", "!=", "type", ")", "{", "type", "=", "TREE_TYPE", "(", "field", ")", ";", "while", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "-", "<NUM_LIT>", ")" ]

[ "{", "if", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ">", "=", "<NUM_LIT>", ")" ]

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

[ "class", "HintI", "<", "string", "mnemonic", ">", ":", "SimpleSystemI", "<", "<NUM_LIT>", ",", "(", "ins", "imm0_127", ":", "$", "imm", ")", ",", "mnemonic", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "int_aarch64_hint", "imm0_127", ":", "$", "imm", ")", "]", ">", ",", "Sched", "<", "[", "WriteHint", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "if", "(", "Pred", "->", "empty", "(", ")", ")", "return", "true", ";" ]

[ "MachineBasicBlock", "::", "const_pred_iterator", "PI", "=", "MBB", "->", "pred_begin", "(", ")", ",", "PI2", "=", "PI", ";", "++", "PI2", ";", "if", "(", "PI2", "!=", "MBB", "->", "pred_end", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Pred", "->", "isLayoutSuccessor", "(", "MBB", ")", ")", "return", "false", ";" ]

[ "<FIXS>", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "<FIXE>" ]

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

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

[ "def", "VCMPEZH", ":", "AHuI", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "HPR", ":", "$", "Sd", ")", ",", "IIC_fpCMP16", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "arm_cmpfpe0", "(", "f16", "HPR", ":", "$", "Sd", ")", ")", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "_", "_", "arm_vminq_m_u16", "(", "uint16x8_t", "_", "_", "inactive", ",", "uint16x8_t", "_", "_", "a", ",", "uint16x8_t", "_", "_", "b", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "builtin_mve_vminq_m_uv8hi", "(", "_", "_", "inactive", ",", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "p", ")", ";" ]

[ "<NUM_LIT>", ",", "DL", ",", "CmpOp0", ".", "getValueType", "(", ")", ")", ")", ";" ]

[ "unsigned", "SSECC", "=", "translateX86FSETCC", "(", "cast", "<", "CondCodeSDNode", ">", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ",", "CondOp0", ",", "CondOp1", ",", "IsAlwaysSignaling", ")", ";", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", ")", "{", "SDValue", "Cmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v1i1", ",", "CondOp0", ",", "CondOp1", ",", "DAG", ".", "getTargetConstant", "(", "SSECC", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "assert", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "<STR_LIT>", "Not a scalar type?", "<STR_LIT>", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "Cmp", ",", "Op1", ",", "Op2", ")", ";", "}", "if", "(", "SSECC", "<", "<NUM_LIT>", "||", "Subtarget", ".", "hasAVX", "(", ")", ")", "{", "SDValue", "Cmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "CondOp0", ",", "CondOp1", ",", "DAG", ".", "getTargetConstant", "(", "SSECC", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "if", "(", "Subtarget", ".", "hasAVX", "(", ")", "&&", "!", "isNullFPConstant", "(", "Op1", ")", "&&", "!", "isNullFPConstant", "(", "Op2", ")", ")", "{", "MVT", "VecVT", "=", "VT", "==", "MVT", "::", "f32", "?", "MVT", "::", "v4f32", ":", "MVT", "::", "v2f64", ";", "SDValue", "VOp1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "DL", ",", "VecVT", ",", "Op1", ")", ";", "SDValue", "VOp2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "DL", ",", "VecVT", ",", "Op2", ")", ";", "SDValue", "VCmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "DL", ",", "VecVT", ",", "Cmp", ")", ";", "MVT", "VCmpVT", "=", "VT", "==", "MVT", "::", "f32", "?", "MVT", "::", "v4i32", ":", "MVT", "::", "v2i64", ";", "VCmp", "=", "DAG", ".", "getBitcast", "(", "VCmpVT", ",", "VCmp", ")", ";", "SDValue", "VSel", "=", "DAG", ".", "getSelect", "(", "DL", ",", "VecVT", ",", "VCmp", ",", "VOp1", ",", "VOp2", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "DL", ",", "VT", ",", "VSel", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "DL", ")", ")", ";", "}", "SDValue", "AndN", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "Cmp", ",", "Op2", ")", ";", "SDValue", "And", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "Cmp", ",", "Op1", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "AndN", ",", "And", ")", ";", "}", "}", "if", "(", "isScalarFPTypeInSSEReg", "(", "VT", ")", "&&", "Subtarget", ".", "hasAVX512", "(", ")", ")", "{", "SDValue", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "DL", ",", "MVT", "::", "v1i1", ",", "Cond", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "Cmp", ",", "Op1", ",", "Op2", ")", ";", "}", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SETCC", ")", "{", "if", "(", "SDValue", "NewCond", "=", "LowerSETCC", "(", "Cond", ",", "DAG", ")", ")", "{", "Cond", "=", "NewCond", ";", "Op1", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Op2", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "}", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "isNullConstant", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "SDValue", "Cmp", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "CmpOp0", "=", "Cmp", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "CondCode", "=", "Cond", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "auto", "MatchFFSMinus1", "=", "[", "&", "]", "(", "SDValue", "Op1", ",", "SDValue", "Op2", ")", "{", "return", "(", "Op1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "CTTZ_ZERO_UNDEF", "&&", "Op1", ".", "hasOneUse", "(", ")", "&&", "Op1", ".", "getOperand", "(", "<NUM_LIT>", ")", "==", "CmpOp0", "&&", "isAllOnesConstant", "(", "Op2", ")", ")", ";", "}", ";", "if", "(", "Subtarget", ".", "hasCMov", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", ")", "&&", "(", "(", "CondCode", "==", "X86", "::", "COND_NE", "&&", "MatchFFSMinus1", "(", "Op1", ",", "Op2", ")", ")", "||", "(", "CondCode", "==", "X86", "::", "COND_E", "&&", "MatchFFSMinus1", "(", "Op2", ",", "Op1", ")", ")", ")", ")", "{", "}", "else", "if", "(", "(", "isAllOnesConstant", "(", "Op1", ")", "||", "isAllOnesConstant", "(", "Op2", ")", ")", "&&", "(", "CondCode", "==", "X86", "::", "COND_E", "||", "CondCode", "==", "X86", "::", "COND_NE", ")", ")", "{", "SDValue", "Y", "=", "isAllOnesConstant", "(", "Op2", ")", "?", "Op1", ":", "Op2", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Op", ".", "getValueType", "(", ")", ",", "MVT", "::", "i32", ")", ";", "SDVTList", "CmpVTs", "=", "DAG", ".", "getVTList", "(", "CmpOp0", ".", "getValueType", "(", ")", ",", "MVT", "::", "i32", ")", ";", "if", "(", "isNullConstant", "(", "Y", ")", "&&", "(", "isAllOnesConstant", "(", "Op1", ")", "==", "(", "CondCode", "==", "X86", "::", "COND_NE", ")", ")", ")", "{", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "CmpOp0", ".", "getValueType", "(", ")", ")", ";", "SDValue", "Neg", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "CmpVTs", ",", "Zero", ",", "CmpOp0", ")", ";", "Zero", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VTs", ",", "Zero", ",", "Zero", ",", "Neg", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}", "Cmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "CmpVTs", ",", "CmpOp0", ",", "DAG", ".", "getConstant", "(" ]

[ "bool", "AArch64CollectLOH", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "********** AArch64 Collect LOH **********\\n", "<STR_LIT>", "<<", "<STR_LIT>", "Looking in function ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", ")", ";", "LOHInfo", "LOHInfos", "[", "N_GPR_REGS", "]", ";", "AArch64FunctionInfo", "&", "AFI", "=", "*", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "for", "(", "const", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "memset", "(", "LOHInfos", ",", "<NUM_LIT>", ",", "sizeof", "(", "LOHInfos", ")", ")", ";", "for", "(", "const", "MachineBasicBlock", "*", "Succ", ":", "MBB", ".", "successors", "(", ")", ")", "{", "for", "(", "const", "auto", "&", "LI", ":", "Succ", "->", "liveins", "(", ")", ")", "{", "int", "RegIdx", "=", "mapRegToGPRIndex", "(", "LI", ".", "PhysReg", ")", ";", "if", "(", "RegIdx", ">=", "<NUM_LIT>", ")", "LOHInfos", "[", "RegIdx", "]", ".", "OneUser", "=", "true", ";", "}", "}", "for", "(", "const", "MachineInstr", "&", "MI", ":", "instructionsWithoutDebug", "(", "MBB", ".", "rbegin", "(", ")", ",", "MBB", ".", "rend", "(", ")", ")", ")", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "canDefBePartOfLOH", "(", "MI", ")", ")", "{", "const", "MachineOperand", "&", "Def", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "Def", ".", "isReg", "(", ")", "&&", "Def", ".", "isDef", "(", ")", "&&", "<STR_LIT>", "Expected reg def", "<STR_LIT>", ")", ";", "assert", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isUse", "(", ")", "&&", "<STR_LIT>", "Expected reg use", "<STR_LIT>", ")", ";", "int", "DefIdx", "=", "mapRegToGPRIndex", "(", "Def", ".", "getReg", "(", ")", ")", ";", "int", "OpIdx", "=", "mapRegToGPRIndex", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "DefIdx", ">=", "<NUM_LIT>", "&&", "OpIdx", ">=", "<NUM_LIT>", "&&", "handleMiddleInst", "(", "MI", ",", "LOHInfos", "[", "DefIdx", "]", ",", "LOHInfos", "[", "OpIdx", "]", ")", ")", "continue", ";", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "const", "MachineOperand", "&", "Op0", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "int", "Idx", "=", "mapRegToGPRIndex", "(", "Op0", ".", "getReg", "(", ")", ")", ";", "if", "(", "Idx", ">=", "<NUM_LIT>", ")", "{", "handleADRP", "(", "MI", ",", "AFI", ",", "LOHInfos", "[", "Idx", "]", ")", ";", "continue", ";", "}", "break", ";", "}", "handleNormalInst", "(", "MI", ",", "LOHInfos", ")", ";", "}", "}", "return", "false", ";", "}" ]

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

[ "VT", ",", "SrcOp", ",", "ShAmt", ")", ";" ]

[ "ShOps", "[", "<NUM_LIT>", "]", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "ShOps", "[", "<NUM_LIT>", "]", "=", "ShOps", "[", "<NUM_LIT>", "]", "=", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ";", "ShAmt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "MVT", "::", "v4i32", ",", "ShOps", ")", ";", "MVT", "EltVT", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "EVT", "ShVT", "=", "MVT", "::", "getVectorVT", "(", "EltVT", ",", "<NUM_LIT>", "/", "EltVT", ".", "getSizeInBits", "(", ")", ")", ";", "ShAmt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "ShVT", ",", "ShAmt", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", "," ]

[ "=", "Pt", ";" ]

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

[ "}" ]

[ "case", "CallingConv", "::", "X86_VectorCall", ":", "case", "CallingConv", "::", "X86_FastCall", ":", "return", "true", ";", "default", ":", "return", "canGuaranteeTCO", "(", "CC", ")", ";", "}" ]

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

[ "if", "(", "!", "NoOpt", ")", "{", "if", "(", "EnableLoopPrefetch", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "EnableCommGEP", ")", "addPass", "(" ]

[ "Parser", ")", ",", "STI", "(", "sti", ")", "{" ]

[ "OR1KAsmParser", "(", "MCSubtargetInfo", "&", "sti", ",", "MCAsmParser", "&", "_", "Parser", ")", ":", "MCTargetAsmParser", "(", ")", ",", "Parser", "(", "_" ]

[ "<NUM_LIT>", ";" ]

[ "static", "void", "init_insn_group_barriers", "(", "void", ")", "{", "memset", "(", "rws_sum", ",", "<NUM_LIT>", ",", "sizeof", "(", "rws_sum", ")", ")", ";", "first_instruction", "=" ]

[ "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")" ]

[ "(", "vec_concat", ":", "V2DI", "(", "vec_select", ":", "DI", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ";" ]

[ "if", "(", "!", "decl", ")", "return", "false", ";", "return", "decl_has_samegp", "(", "decl", ")" ]

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

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

[ "<FIXS>", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "<FIXE>", "<FIXS>", "if", "(", "StoreRegToStackSlot", "(", "*", "this", ",", "SrcReg", ",", "isKill", ",", "FrameIdx", ",", "RC", ",", "NewMIs", ",", "TM", ".", "getSubtargetImpl", "(", ")", "->", "isPPC64", "(", ")", ")", ")", "{", "PPCFunctionInfo", "*", "FuncInfo", "=", "MBB", ".", "getParent", "(", ")", "->", "getInfo", "PPCFunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "setSpillsCR", "(", ")", ";", "}", "<FIXE>", "<FIXS>", "bool", "isKill", ",", "SmallVectorImpl", "MachineOperand", ">", "&", "Addr", ",", "const", "TargetRegisterClass", "*", "RC", ",", "SmallVectorImpl", "MachineInstr", "*", ">", "&", "NewMIs", ")", "const", "{", "<FIXE>", "<FIXS>", "if", "(", "StoreRegToStackSlot", "(", "*", "this", ",", "SrcReg", ",", "isKill", ",", "Addr", "[", "<NUM_LIT>", "]", ".", "getIndex", "(", ")", ",", "RC", ",", "NewMIs", ",", "TM", ".", "getSubtargetImpl", "(", ")", "->", "isPPC64", "(", ")", ")", ")", "{", "PPCFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "PPCFunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "setSpillsCR", "(", ")", ";", "}", "<FIXE>" ]

[ "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "Unknown regclass!", "<STR_LIT>", ")", ";", "abort", "(", ")", ";", "}", "}", "voidPPCInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "<BUGS>", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "<BUGE>", "SmallVector", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "NewMIs", ";", "<BUGS>", "StoreRegToStackSlot", "(", "*", "this", ",", "SrcReg", ",", "isKill", ",", "FrameIdx", ",", "RC", ",", "NewMIs", ")", ";", "<BUGE>", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "NewMIs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MBB", ".", "insert", "(", "MI", ",", "NewMIs", "[", "i", "]", ")", ";", "}", "void", "PPCInstrInfo", "::", "storeRegToAddr", "(", "MachineFunction", "&", "MF", ",", "unsigned", "SrcReg", ",", "<BUGS>", "bool", "isKill", ",", "SmallVectorImpl", "MachineOperand", ">", "&", "Addr", ",", "const", "TargetRegisterClass", "*", "RC", ",", "SmallVectorImpl", "MachineInstr", "*", ">", "&", "NewMIs", ")", "const", "{", "<BUGE>", "if", "(", "Addr", "[", "<NUM_LIT>", "]", ".", "isFrameIndex", "(", ")", ")", "{", "<BUGS>", "StoreRegToStackSlot", "(", "*", "this", ",", "SrcReg", ",", "isKill", ",", "Addr", "[", "<NUM_LIT>", "]", ".", "getIndex", "(", ")", ",", "RC", ",", "NewMIs", ")", ";", "<BUGE>", "return", ";", "}" ]

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

[ "(", "match_code", "<STR_LIT>", ")", "{", "return", "(", "(", "mode", "=", "=", "VOIDmode", "|", "|", "mode", "=", "=", "GET_MODE", "(", "op", ")", ")", "&", "&", "REG_P", "(", "op", ")", "&", "&", "ACC_P", "(", "REGNO", "(", "op", ")", ")", "&", "&", "(", "(", "REGNO", "(", "op", ")", "-", "ACC_FIRST", ")", "&", "~", "ACC_MASK" ]

[ "(", "Sym", ",", "OutContext", ")", ")", ")", ";" ]

[ "void", "AArch64AsmPrinter", "::", "LowerHWASAN_CHECK_MEMACCESS", "(", "const", "MachineInstr", "&", "MI", ")", "{", "Register", "Reg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "uint32_t", "AccessInfo", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "MCSymbol", "*", "&", "Sym", "=", "HwasanMemaccessSymbols", "[", "{", "Reg", ",", "AccessInfo", "}", "]", ";", "if", "(", "!", "Sym", ")", "{", "if", "(", "!", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "llvm.hwasan.check.memaccess only supported on ELF", "<STR_LIT>", ")", ";", "std", "::", "string", "SymName", "=", "<STR_LIT>", "__hwasan_check_x", "<STR_LIT>", "+", "utostr", "(", "Reg", "-", "<STR_LIT>", "::", "<STR_LIT>", ")", "+", "<STR_LIT>", "_", "<STR_LIT>", "+", "utostr", "(", "AccessInfo", ")", ";", "Sym", "=", "OutContext", ".", "getOrCreateSymbol", "(", "SymName", ")", ";", "}", "EmitToStreamer", "(", "*", "OutStreamer", ",", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addExpr", "(", "MCSymbolRefExpr", "::", "create" ]

[ "<FIXS>", ":", "SelectionDAGISel", "(", "ID", ",", "TargetMachine", ")", "{", "}", "<FIXE>" ]

[ "class", "LanaiDAGToDAGISel", ":", "public", "SelectionDAGISel", "{", "public", ":", "explicit", "LanaiDAGToDAGISel", "(", "LanaiTargetMachine", "&", "TargetMachine", ")", "<BUGS>", ":", "SelectionDAGISel", "(", "TargetMachine", ")", "{", "}", "<BUGE>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";" ]

[ "<NUM_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "mask", ";", "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "src", ";", "let", "SrcExtra", "=", "{", "<NUM_LIT>", ",", "mask", ",", "<NUM_LIT>", "}", ";", "let", "Dest", "=", "dst", ";", "let", "Switches", "=", "sw", ";", "let", "Switches", "{", "<NUM_LIT>", "}", "=", "MaskInReg", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=" ]

[ "default", ":", "break", ";" ]

[ "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "SP", ")", "{", "if", "(", "ReduceTo2Addr", "(", "MBB", ",", "MI", ",", "Entry", ",", "LiveCPSR", ",", "IsSelfLoop", ")", ")", "return", "true", ";", "return", "ReduceToNarrow", "(", "MBB", ",", "MI", ",", "Entry", ",", "LiveCPSR", ",", "IsSelfLoop", ")", ";", "}", "unsigned", "Imm", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "Imm", "&", "<NUM_LIT>", "||", "Imm", ">", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "!", "isARMLowRegister", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "false", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "MCID", ".", "hasOptionalDef", "(", ")", "&&", "MI", "->", "getOperand", "(", "MCID", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", ")", "return", "false", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "ARM", "::", "tADDrSPi", ")", ")", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addImm", "(", "Imm", "/", "<NUM_LIT>", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "MIB", ".", "setMIFlags", "(", "MI", "->", "getFlags", "(", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "Converted 32-bit: ", "<STR_LIT>", "<<", "*", "MI", "<<", "<STR_LIT>", " to 16-bit: ", "<STR_LIT>", "<<", "*", "MIB", ")", ";", "MBB", ".", "erase_instr", "(", "MI", ")", ";", "++", "NumNarrows", ";", "return", "true", ";", "}", "if", "(", "Entry", ".", "LowRegs1", "&&", "!", "VerifyLowRegs", "(", "MI", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "mayLoadOrStore", "(", ")", ")", "return", "ReduceLoadStore", "(", "MBB", ",", "MI", ",", "Entry", ")", ";", "switch", "(", "Opc", ")", "{" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "<NUM_LIT>", ")" ]

[ "{", "if", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "<NUM_LIT>", ")" ]

[ "<FIXS>", "ret", "=", "NEXT_INSN", "(", "as_a", "rtx_insn", "*", ">", "(", "ret", ")", ")", ";", "<FIXE>" ]

[ "&&", "(", "NOTE_P", "(", "ret", ")", "||", "LABEL_P", "(", "ret", ")", "||", "GET_CODE", "(", "PATTERN", "(", "ret", ")", ")", "==", "USE", ")", ")", "<BUGS>", "ret", "=", "NEXT_INSN", "(", "ret", ")", ";", "<BUGE>", "if", "(", "ret", ")", "{" ]

[ ")", "length", "+=", "<NUM_LIT>", ";" ]

[ "int", "lower_half_easy_p", "=", "<NUM_LIT>", ";", "int", "upper_half_easy_p", "=", "<NUM_LIT>", ";", "unsigned", "int", "length", "=", "<NUM_LIT>", ";", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "if", "(", "b0", "!=", "<NUM_LIT>", "&&", "b1", "!=", "<NUM_LIT>", ")", "{", "length", "=", "h8300_length_from_table", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "&", "logicw_length_table", ")", ";", "}", "else", "{", "if", "(", "b0", "!=", "<NUM_LIT>", ")", "length", "+=", "<NUM_LIT>", ";", "if", "(", "b1", "!=", "<NUM_LIT>", ")", "length", "+=", "<NUM_LIT>", ";", "}", "break", ";", "case", "E_SImode", ":", "lower_half_easy_p", "=", "(", "b0", "==", "<NUM_LIT>", "||", "b1", "==", "<NUM_LIT>", "||", "(", "code", "!=", "IOR", "&&", "w0", "==", "<NUM_LIT>", ")", ")", ";", "upper_half_easy_p", "=", "(", "(", "code", "!=", "IOR", "&&", "w1", "==", "<NUM_LIT>", ")", "||", "(", "code", "==", "AND", "&&", "w1", "==", "<NUM_LIT>", ")", ")", ";", "if", "(", "w0", "!=", "<NUM_LIT>", "&&", "w1", "!=", "<NUM_LIT>", "&&", "!", "(", "lower_half_easy_p", "&&", "upper_half_easy_p", ")", "&&", "!", "(", "code", "==", "IOR", "&&", "w1", "==", "<NUM_LIT>", "&&", "(", "w0", "&", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", "&&", "lower_half_easy_p", ")", ")", "{", "length", "=", "h8300_length_from_table", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "&", "logicl_length_table", ")", ";", "}", "else", "{", "if", "(", "w0", "==", "<NUM_LIT>", "&&", "(", "code", "!=", "IOR", ")", ")", "{", "length", "+=", "<NUM_LIT>", ";", "}", "else", "if", "(", "(", "b0", "!=", "<NUM_LIT>", ")", "&&", "(", "b1", "!=", "<NUM_LIT>", ")", ")", "{", "length", "+=", "<NUM_LIT>", ";", "}", "else", "{", "if", "(", "b0", "!=", "<NUM_LIT>" ]

[ "return", "SDValue", "(", ")", ";" ]

[ "while", "(", "Input", ".", "getOpcode", "(", ")", "==", "ISD", "::", "EXTRACT_SUBVECTOR", "&&", "Input", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueSizeInBits", "(", ")", "<=", "WideSizeInBits", ")", "{", "uint64_t", "Idx", "=", "Input", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "if", "(", "Idx", "!=", "<NUM_LIT>", ")", "{", "++", "AdjustedMasks", ";", "unsigned", "InputEltSizeInBits", "=", "Input", ".", "getScalarValueSizeInBits", "(", ")", ";", "Idx", "=", "(", "Idx", "*", "InputEltSizeInBits", ")", "/", "RootEltSizeInBits", ";", "int", "lo", "=", "I", "*", "WideMask", ".", "size", "(", ")", ";", "int", "hi", "=", "(", "I", "+", "<NUM_LIT>", ")", "*", "WideMask", ".", "size", "(", ")", ";", "for", "(", "int", "&", "M", ":", "WideMask", ")", "if", "(", "lo", "<=", "M", "&&", "M", "<", "hi", ")", "M", "+=", "Idx", ";", "}", "Input", "=", "peekThroughBitcasts", "(", "Input", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "}", "resolveTargetShuffleInputsAndMask", "(", "WideInputs", ",", "WideMask", ")", ";", "assert", "(", "!", "WideInputs", ".", "empty", "(", ")", "&&", "<STR_LIT>", "Shuffle with no inputs detected", "<STR_LIT>", ")", ";", "if", "(", "AdjustedMasks", "==", "<NUM_LIT>", "||", "WideInputs", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "while", "(", "WideMask", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "{", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "WidenedMask", ";", "if", "(", "!", "canWidenShuffleElements", "(", "WideMask", ",", "WidenedMask", ")", ")", "break", ";", "WideMask", "=", "std", "::", "move", "(", "WidenedMask", ")", ";", "}", "if", "(", "WideInputs", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "canonicalizeShuffleMaskWithCommute", "(", "WideMask", ")", ")", "{", "ShuffleVectorSDNode", "::", "commuteMask", "(", "WideMask", ")", ";", "std", "::", "swap", "(", "WideInputs", "[", "<NUM_LIT>", "]", ",", "WideInputs", "[", "<NUM_LIT>", "]", ")", ";", "}", "Depth", "+=", "AdjustedMasks", ";", "SDValue", "WideRoot", "=", "WideInputs", ".", "front", "(", ")", ".", "getValueSizeInBits", "(", ")", ">", "WideInputs", ".", "back", "(", ")", ".", "getValueSizeInBits", "(", ")", "?", "WideInputs", ".", "front", "(", ")", ":", "WideInputs", ".", "back", "(", ")", ";", "assert", "(", "WideRoot", ".", "getValueSizeInBits", "(", ")", "==", "WideSizeInBits", "&&", "<STR_LIT>", "WideRootSize mismatch", "<STR_LIT>", ")", ";", "if", "(", "SDValue", "WideShuffle", "=", "combineX86ShuffleChain", "(", "WideInputs", ",", "WideRoot", ",", "WideMask", ",", "Depth", ",", "HasVariableMask", ",", "AllowVariableCrossLaneMask", ",", "AllowVariablePerLaneMask", ",", "DAG", ",", "Subtarget", ")", ")", "{", "WideShuffle", "=", "extractSubVector", "(", "WideShuffle", ",", "<NUM_LIT>", ",", "DAG", ",", "SDLoc", "(", "Root", ")", ",", "RootSizeInBits", ")", ";", "return", "DAG", ".", "getBitcast", "(", "RootVT", ",", "WideShuffle", ")", ";", "}" ]

[ ":", "$", "vp", ")", ">", ";" ]

[ "def", ":", "MVEInstAlias", "<", "<STR_LIT>", "#", "s", "#", "<STR_LIT>", ",", "(", "MVE_VEOR", "MQPR", ":", "$", "QdSrc", ",", "MQPR", ":", "$", "QnSrc", ",", "MQPR", ":", "$", "QmSrc", ",", "vpred_r" ]

[ "nullptr", ";" ]

[ "return", "Parent", "==" ]

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

[ "def", "v16i8_shift", ":", "BaseSIMDVectorShiftTied", "<", "<NUM_LIT>", ",", "U", ",", "opc", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "?", ",", "?", ",", "?", "}", ",", "V128", ",", "V128", ",", "vecshiftR16Narrow", ",", "asm", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "imm", ";" ]

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

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

[ "}", "else", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "Reg", ")", ")", "LastDef", "[", "Reg", "]", "=", "&", "MI", ";" ]

[ "}", "for", "(", "MachineOperand", "&", "Op", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isDef", "(", ")", "||", "!", "Op", ".", "getReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "for", "(", "MCSubRegIterator", "SubRegs", "(", "Reg", ",", "TRI", ")", ";", "SubRegs", ".", "isValid", "(", ")", ";", "++", "SubRegs", ")", "LastDef", "[", "*", "SubRegs", "]", "=", "&", "MI", ";" ]

[ "else", "if", "(", "Subtarget", "->", "isPICStyleStubPIC", "(", ")", ")", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "CodeModel", "::", "Model", "M", "=", "DAG", ".", "getTarget", "(", ")", ".", "getCodeModel", "(", ")", ";", "if", "(", "Subtarget", "->", "isPICStyleRIPRel", "(", ")", "&&", "(", "M", "==", "CodeModel", "::", "Small", "||", "M", "==", "CodeModel", "::", "Kernel", ")", ")", "WrapperKind", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "Subtarget", "->", "isPICStyleGOT", "(", ")", ")", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "<FIXS>", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tfstds,ma %s,8(0,%%r1)\\n", "<STR_LIT>", ",", "reg_names", "[", "i", "]", ")", ";", "<FIXE>" ]

[ "for", "(", "i", "=", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "{", "if", "(", "regs_ever_live", "[", "i", "]", ")", "<BUGS>", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tfstds,ma %s,8(0,1)\\n", "<STR_LIT>", ",", "reg_names", "[", "i", "]", ")", ";", "<BUGE>", "}", "}", "else" ]

[ "*", "p", "++", "=", "'", ",", "'", ";" ]

[ "break", ";", "case", "LT", ":", "strcpy", "(", "string", ",", "<STR_LIT>", "brlz", "<STR_LIT>", ")", ";", "break", ";", "case", "LE", ":", "strcpy", "(", "string", ",", "<STR_LIT>", "brlez", "<STR_LIT>", ")", ";", "break", ";", "case", "GT", ":", "strcpy", "(", "string", ",", "<STR_LIT>", "brgz", "<STR_LIT>", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "p", "=", "strchr", "(", "string", ",", "'", "\\0", "'", ")", ";", "if", "(", "annul", "&&", "!", "far", ")", "{", "strcpy", "(", "p", ",", "<STR_LIT>", ",a", "<STR_LIT>", ")", ";", "p", "+=", "<NUM_LIT>", ";", "}", "if", "(", "insn", "&&", "(", "not", "e", "=", "find_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "NULL_RTX", ")", ")", ")", "{", "strcpy", "(", "p", ",", "(", "(", "INTVAL", "(", "XEXP", "(", "not", "e", ",", "<NUM_LIT>", ")", ")", ">=", "REG_BR_PROB_BASE", "/", "<NUM_LIT>", ")", "^", "far", ")", "?", "<STR_LIT>", ",pt", "<STR_LIT>", ":", "<STR_LIT>", ",pn", "<STR_LIT>", ")", ";", "p", "+=", "<NUM_LIT>", ";", "}", "*", "p", "=", "p", "<", "string", "+", "<NUM_LIT>", "?", "'", "\\t", "'", ":", "'", "'", ";", "p", "++", ";", "*", "p", "++", "=", "'", "%", "'", ";", "*", "p", "++", "=", "'", "<NUM_LIT>", "'", "+", "reg", ";" ]

[ "ResultReg", ")", ".", "addReg", "(", "DstReg", ",", "getKillRegState", "(", "true", ")", ")", ";" ]

[ "}", "static", "const", "MCPhysReg", "GPR32ArgRegs", "[", "]", "=", "{", "X86", "::", "EDI", ",", "X86", "::", "ESI", ",", "X86", "::", "EDX", ",", "X86", "::", "ECX", ",", "X86", "::", "R8D", ",", "X86", "::", "R9D", "}", ";", "static", "const", "MCPhysReg", "GPR64ArgRegs", "[", "]", "=", "{", "X86", "::", "RDI", ",", "X86", "::", "RSI", ",", "X86", "::", "RDX", ",", "X86", "::", "RCX", ",", "X86", "::", "R8", ",", "X86", "::", "R9", "}", ";", "static", "const", "MCPhysReg", "XMMArgRegs", "[", "]", "=", "{", "X86", "::", "XMM0", ",", "X86", "::", "XMM1", ",", "X86", "::", "XMM2", ",", "X86", "::", "XMM3", ",", "X86", "::", "XMM4", ",", "X86", "::", "XMM5", ",", "X86", "::", "XMM6", ",", "X86", "::", "XMM7", "}", ";", "unsigned", "GPRIdx", "=", "<NUM_LIT>", ";", "unsigned", "FPRIdx", "=", "<NUM_LIT>", ";", "for", "(", "auto", "const", "&", "Arg", ":", "F", "->", "args", "(", ")", ")", "{", "MVT", "VT", "=", "TLI", ".", "getSimpleValueType", "(", "DL", ",", "Arg", ".", "getType", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "VT", ")", ";", "unsigned", "SrcReg", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected value type.", "<STR_LIT>", ")", ";", "case", "MVT", "::", "i32", ":", "SrcReg", "=", "GPR32ArgRegs", "[", "GPRIdx", "++", "]", ";", "break", ";", "case", "MVT", "::", "i64", ":", "SrcReg", "=", "GPR64ArgRegs", "[", "GPRIdx", "++", "]", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "SrcReg", "=", "XMMArgRegs", "[", "FPRIdx", "++", "]", ";", "break", ";", "}", "unsigned", "DstReg", "=", "FuncInfo", ".", "MF", "->", "addLiveIn", "(", "SrcReg", ",", "RC", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", "," ]

[ "<FIXS>", "unsigned", "NumBytes", "=", "getFixupKindLog2Size", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "NumBytes", "<=", "DF", ".", "getContents", "(", ")", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid fixup offset!", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "DF", ".", "getContents", "(", ")", "[", "Fixup", ".", "getOffset", "(", ")", "+", "i", "]", "|=", "uint8_t", "(", "Value", ">>", "(", "i", "*", "<NUM_LIT>", ")", ")", ";", "<FIXE>" ]

[ "}", "}", ";", "void", "DarwinARMAsmBackend", "::", "ApplyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "MCDataFragment", "&", "DF", ",", "uint64_t", "Value", ")", "const", "{", "<BUGS>", "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "DarwinARMAsmBackend::ApplyFixup() unimplemented", "<STR_LIT>", ")", ";", "<BUGE>", "}", "}" ]

[ "is128BitVector", "(", ")", ")", "{" ]

[ "if", "(", "SrcVT", ".", "getScalarSizeInBits", "(", ")", ">", "<NUM_LIT>", "&&", "(", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Subtarget", ".", "hasSSE41", "(", ")", ")", ")", "{", "InVT", "=", "MVT", "::", "i32", ";", "OutVT", "=", "MVT", "::", "i16", ";", "}", "if", "(", "SrcVT", ".", "is128BitVector", "(", ")", ")", "{", "InVT", "=", "EVT", "::", "getVectorVT", "(", "Ctx", ",", "InVT", ",", "<NUM_LIT>", "/", "InVT", ".", "getSizeInBits", "(", ")", ")", ";", "OutVT", "=", "EVT", "::", "getVectorVT", "(", "Ctx", ",", "OutVT", ",", "<NUM_LIT>", "/", "OutVT", ".", "getSizeInBits", "(", ")", ")", ";", "In", "=", "DAG", ".", "getBitcast", "(", "InVT", ",", "In", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "Opcode", ",", "DL", ",", "OutVT", ",", "In", ",", "DAG", ".", "getUNDEF", "(", "InVT", ")", ")", ";", "Res", "=", "extractSubVector", "(", "Res", ",", "<NUM_LIT>", ",", "DAG", ",", "DL", ",", "<NUM_LIT>", ")", ";", "return", "DAG", ".", "getBitcast", "(", "DstVT", ",", "Res", ")", ";", "}", "unsigned", "NumSubElts", "=", "NumElems", "/", "<NUM_LIT>", ";", "SDValue", "Lo", "=", "extractSubVector", "(", "In", ",", "<NUM_LIT>", "*", "NumSubElts", ",", "DAG", ",", "DL", ",", "SrcSizeInBits", "/", "<NUM_LIT>", ")", ";", "SDValue", "Hi", "=", "extractSubVector", "(", "In", ",", "<NUM_LIT>", "*", "NumSubElts", ",", "DAG", ",", "DL", ",", "SrcSizeInBits", "/", "<NUM_LIT>", ")", ";", "unsigned", "SubSizeInBits", "=", "SrcSizeInBits", "/", "<NUM_LIT>", ";", "InVT", "=", "EVT", "::", "getVectorVT", "(", "Ctx", ",", "InVT", ",", "SubSizeInBits", "/", "InVT", ".", "getSizeInBits", "(", ")", ")", ";", "OutVT", "=", "EVT", "::", "getVectorVT", "(", "Ctx", ",", "OutVT", ",", "SubSizeInBits", "/", "OutVT", ".", "getSizeInBits", "(", ")", ")", ";", "if", "(", "SrcVT", ".", "is256BitVector", "(", ")", "&&", "DstVT", "." ]

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

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

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

[ "(", "compare", ":", "CC", "(", "const_int", "<NUM_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "DI" ]

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

[ "(", "define_predicate", "<STR_LIT>", "(", "and", "(" ]

[ "j", ";" ]

[ "int", "i", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "return", "<NUM_LIT>", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'", "E", "'", ")", "{", "int" ]

[ "uint64_t", "Address", ",", "const", "void", "*", "Decoder", ")", "{" ]

[ "static", "DecodeStatus", "decodeCallTarget", "(", "MCInst", "&", "Inst", ",", "unsigned", "Field", "," ]

[ "}" ]

[ "else", "offset", "=", "<NUM_LIT>", ";", "offset", "+=", "SPARC_STACK_BIAS", ";", "return", "offset", ";" ]

[ "}" ]

[ "def", "AdrLabelAsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "adrlabel", ":", "Operand", "<", "i32", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "AdrLabelAsmOperand", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "\t", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "div", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>" ]

[ "case", "ISD", "::", "FP_EXTEND", ":", "return", "LowerF128_FPEXTEND", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";" ]

[ "case", "ISD", "::", "FSUB", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "SUB_F128", ")", ",", "<NUM_LIT>", ")", ";", "case", "ISD", "::", "FMUL", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "MUL_F128", ")", ",", "<NUM_LIT>", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "DIV_F128", ")", ",", "<NUM_LIT>", ")", ";", "case", "ISD", "::", "FSQRT", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "SQRT_F128", ")", ",", "<NUM_LIT>", ")", ";", "case", "ISD", "::", "FNEG", ":", "return", "LowerFNEG", "(", "Op", ",", "DAG", ",", "*", "this", ",", "is64Bit", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "LowerFABS", "(", "Op", ",", "DAG", ",", "isV9", ")", ";" ]

[ "<FIXS>", "(", "compare", "(", "match_operand", ":", "ALL1", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "ALL1", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<FIXE>" ]

[ "(", "define_peephole", "[", "(", "set", "(", "cc0", ")", "<BUGS>", "(", "compare", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGE>", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "eq", "(", "cc0", ")", "(", "const_int", "<NUM_LIT>", ")", ")" ]

[ "static", "rtx", "dump_constants_1", "(", "enum", "machine_mode", "mode", ",", "rtx", "value", ",", "rtx", "insn", ")", "{", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_INT", ":", "{", "rtx", "size", "=", "GEN_INT", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "return", "emit_insn_after", "(", "gen_consttable_int", "(", "value", ",", "size", ")", ",", "insn", ")", ";", "}", "case", "MODE_FLOAT", ":", "return", "emit_insn_after", "(", "gen_consttable_float", "(", "value", ")", ",", "insn", ")", ";", "case", "MODE_VECTOR_FLOAT", ":", "case", "MODE_VECTOR_INT", ":", "{", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "CONST_VECTOR_NUNITS", "(", "value", ")", ";", "i", "++", ")", "insn", "=", "dump_constants_1", "(", "GET_MODE_INNER", "(", "mode", ")", ",", "CONST_VECTOR_ELT", "(", "value", ",", "i", ")", ",", "insn", ")", ";", "return", "insn", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}" ]

[ "Output", "constant", "VALUE", "after", "instruction", "INSN", "and", "return", "the", "last", "instruction", "emitted", ".", "MODE", "is", "the", "mode", "of", "the", "constant", "." ]

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

[ "(", "define_bypass", "<NUM_LIT>" ]

[ "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "<STR_LIT>", "Target parity for forest #%d: %s\\n", "<STR_LIT>", ",", "this", "->", "m_id", ",", "this", "->", "m_target_parity", "?", "<STR_LIT>", "odd", "<STR_LIT>", ":", "<STR_LIT>", "even", "<STR_LIT>", ")", ";" ]

[ "void", "fma_forest", "::", "dispatch", "(", ")", "{", "this", "->", "m_target_parity", "=", "this", "->", "m_roots", "->", "front", "(", ")", "->", "get_parity", "(", ")", ";", "int", "fpu_balance", "=", "this", "->", "m_globals", "->", "get_fpu_balance", "(", ")", ";", "if", "(", "fpu_balance", "!=", "<NUM_LIT>", ")", "this", "->", "m_target_parity", "=", "(", "fpu_balance", "<", "<NUM_LIT>", ")", ";" ]

[ "}" ]

[ "long", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "tzmsk_u64", "(", "unsigned", "long", "long", "_", "_", "X", ")", "{", "return", "~", "_", "_", "X", "&", "(", "_", "_", "X", "-", "<NUM_LIT>", ")", ";" ]

[ "(", "clobber", "(", "reg", ":", "CC_FP", "CCFP_REGNUM", ")", ")", "]", ")", "]", ")" ]

[ "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

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

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

[ "}" ]

[ "static", "Reloc", "::", "Model", "getEffectiveRelocModel", "(", "std", "::", "optional", "<", "Reloc", "::", "Model", ">", "RM", ")", "{", "return", "RM", ".", "value_or", "(", "Reloc", "::", "Static", ")", ";" ]

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

[ "def", ":", "InstAlias", "<", "<STR_LIT>", ",", "(", "VMOVAPDYrr_REV", "VR256", ":", "$", "dst", ",", "VR256", ":", "$", "src", ")" ]

[ "SDNode", "*", "N", ")", "{" ]

[ "Value", "*", "X86IREmitter", "::", "visitMOVLHPS", "(", "const" ]

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

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

[ "_", "_", "X", ",", "_", "_", "m256i", "_", "_", "Y", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_permutexvar_epi64", "(", "_", "_", "mmask8", "_", "_", "M", ",", "_", "_", "m256i" ]

[ "int", "rs6000_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "length", ")", "{", "if", "(", "TARGET_PREFIXED", "&&", "NONJUMP_INSN_P", "(", "insn", ")", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "!=", "USE", "&&", "GET_CODE", "(", "pattern", ")", "!=", "CLOBBER", "&&", "get_attr_prefixed", "(", "insn", ")", "==", "PREFIXED_YES", ")", "{", "int", "num_prefixed", "=", "get_attr_max_prefixed_insns", "(", "insn", ")", ";", "length", "+=", "<NUM_LIT>", "*", "(", "num_prefixed", "+", "<NUM_LIT>", ")", ";", "}", "}", "return", "length", ";", "}" ]

[ "Adjust", "the", "length", "of", "an", "INSN", ".", "LENGTH", "is", "the", "currently-computed", "length", "and", "should", "be", "adjusted", "to", "reflect", "any", "required", "changes", ".", "This", "macro", "is", "used", "when", "there", "is", "some", "systematic", "length", "adjustment", "required", "that", "would", "be", "difficult", "to", "express", "in", "the", "length", "attribute", ".", "In", "the", "PowerPC", ",", "we", "use", "this", "to", "adjust", "the", "length", "of", "an", "instruction", "if", "one", "or", "more", "prefixed", "instructions", "are", "generated", ",", "using", "the", "attribute", "num_prefixed_insns", ".", "A", "prefixed", "instruction", "is", "8", "bytes", "instead", "of", "4", ",", "but", "the", "hardware", "requires", "that", "a", "prefied", "instruciton", "does", "not", "cross", "a", "64-byte", "boundary", ".", "This", "means", "the", "compiler", "has", "to", "assume", "the", "length", "of", "the", "first", "prefixed", "instruction", "is", "12", "bytes", "instead", "of", "8", "bytes", ".", "Since", "the", "length", "is", "already", "set", "for", "the", "non-prefixed", "instruction", ",", "we", "just", "need", "to", "udpate", "for", "the", "difference", "." ]

[ ";" ]

[ "MCOperand", "displacement", ";", "MCOperand", "segmentReg", ";", "uint64_t", "pcrel", "=", "<NUM_LIT>", ";", "if", "(", "insn", ".", "eaBase", "==", "EA_BASE_sib", "||", "insn", ".", "eaBase", "==", "EA_BASE_sib64", ")", "{", "if", "(", "insn", ".", "sibBase", "!=", "SIB_BASE_NONE", ")", "{", "switch", "(", "insn", ".", "sibBase", ")", "{", "default", ":", "debug", "(", "<STR_LIT>", "Unexpected sibBase", "<STR_LIT>", ")", ";", "return", "true", ";", "case", "SIB_BASE_", "#", "#", "x", ":", "\\", "baseReg", "=", "MCOperand", "::", "CreateReg", "(", "X86", "::", "x", ")", ";", "break", ";", "ALL_SIB_BASES", "}", "}", "else", "{", "baseReg", "=", "MCOperand", "::", "CreateReg", "(", "<NUM_LIT>", ")", ";", "}", "uint32_t", "Opcode", "=", "mcInst", ".", "getOpcode", "(", ")", ";", "bool", "IndexIs128", "=", "(", "Opcode", "==", "X86", "::", "VGATHERDPDrm", "||", "Opcode", "==", "X86", "::", "VGATHERDPDYrm", "||", "Opcode", "==", "X86", "::", "VGATHERQPDrm", "||", "Opcode", "==", "X86", "::", "VGATHERDPSrm", "||", "Opcode", "==", "X86", "::", "VGATHERQPSrm", "||", "Opcode", "==", "X86", "::", "VPGATHERDQrm", "||", "Opcode", "==", "X86", "::", "VPGATHERDQYrm", "||", "Opcode", "==", "X86", "::", "VPGATHERQQrm", "||", "Opcode", "==", "X86", "::", "VPGATHERDDrm", "||", "Opcode", "==", "X86", "::", "VPGATHERQDrm", ")", ";", "bool", "IndexIs256", "=", "(", "Opcode", "==", "X86", "::", "VGATHERQPDYrm", "||", "Opcode", "==", "X86", "::", "VGATHERDPSYrm", "||", "Opcode", "==", "X86", "::", "VGATHERQPSYrm", "||", "Opcode", "==", "X86", "::", "VPGATHERQQYrm", "||", "Opcode", "==", "X86", "::", "VPGATHERDDYrm", "||", "Opcode", "==", "X86", "::", "VPGATHERQDYrm", ")", ";", "if", "(", "IndexIs128", "||", "IndexIs256", ")", "{", "unsigned", "IndexOffset", "=", "insn", ".", "sibIndex", "-", "(", "insn", ".", "addressSize", "==", "<NUM_LIT>", "?", "SIB_INDEX_RAX", ":", "SIB_INDEX_EAX", ")", ";", "SIBIndex", "IndexBase", "=", "IndexIs256", "?", "SIB_INDEX_YMM0", ":", "SIB_INDEX_XMM0", ";", "insn", ".", "sibIndex", "=", "(", "SIBIndex", ")", "(", "IndexBase", "+", "(", "insn", ".", "sibIndex", "==", "SIB_INDEX_NONE", "?", "<NUM_LIT>", ":", "IndexOffset", ")", ")", ";", "}", "if", "(", "insn", ".", "sibIndex", "!=", "SIB_INDEX_NONE", ")", "{", "switch", "(", "insn", ".", "sibIndex", ")", "{", "default", ":", "debug", "(", "<STR_LIT>", "Unexpected sibIndex", "<STR_LIT>", ")", ";", "return", "true", ";", "case", "SIB_INDEX_", "#", "#", "x", ":", "\\", "indexReg", "=", "MCOperand", "::", "CreateReg", "(", "X86", "::", "x", ")", ";", "break", ";", "EA_BASES_32BIT", "EA_BASES_64BIT", "REGS_XMM", "REGS_YMM", "}", "}", "else", "{", "indexReg", "=", "MCOperand", "::", "CreateReg", "(", "<NUM_LIT>", ")", ";", "}", "scaleAmount", "=", "MCOperand", "::", "CreateImm", "(", "insn", ".", "sibScale", ")", ";", "}", "else", "{", "switch", "(", "insn", ".", "eaBase", ")", "{", "case", "EA_BASE_NONE", ":", "if", "(", "insn", ".", "eaDisplacement", "==", "EA_DISP_NONE", ")", "{", "debug", "(", "<STR_LIT>", "EA_BASE_NONE and EA_DISP_NONE for ModR/M base", "<STR_LIT>", ")", ";", "return", "true", ";", "}", "if", "(", "insn", ".", "mode", "==", "MODE_64BIT", ")", "{", "pcrel", "=", "insn", ".", "startLocation", "+", "insn", ".", "displacementOffset", "+", "insn", ".", "displacementSize", ";", "tryAddingPcLoadReferenceComment", "(", "insn", ".", "startLocation", "+", "insn", ".", "displacementOffset", ",", "insn", ".", "displacement", "+", "pcrel", ",", "Dis", ")", ";", "baseReg", "=", "MCOperand", "::", "CreateReg", "(", "X86", "::", "RIP", ")", ";", "}", "else", "baseReg", "=", "MCOperand", "::", "CreateReg", "(", "<NUM_LIT>", ")", ";", "indexReg", "=", "MCOperand", "::", "CreateReg", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "EA_BASE_BX_SI", ":", "baseReg", "=", "MCOperand", "::", "CreateReg", "(", "X86", "::", "BX", ")", ";", "indexReg", "=", "MCOperand", "::", "CreateReg", "(", "X86", "::", "SI", ")", ";", "break", ";", "case", "EA_BASE_BX_DI", ":", "baseReg", "=", "MCOperand", "::", "CreateReg", "(", "X86", "::", "BX", ")", ";", "indexReg", "=", "MCOperand", "::", "CreateReg", "(", "X86", "::", "DI", ")", ";", "break", ";", "case", "EA_BASE_BP_SI", ":", "baseReg", "=", "MCOperand", "::", "CreateReg", "(", "X86", "::", "BP", ")", ";", "indexReg", "=", "MCOperand", "::", "CreateReg", "(", "X86", "::", "SI", ")", ";", "break", ";", "case", "EA_BASE_BP_DI", ":", "baseReg", "=", "MCOperand", "::", "CreateReg", "(", "X86", "::", "BP", ")", ";", "indexReg", "=", "MCOperand", "::", "CreateReg", "(", "X86", "::", "DI", ")", ";", "break", ";", "default", ":", "indexReg", "=", "MCOperand", "::", "CreateReg", "(", "<NUM_LIT>", ")", ";", "switch", "(", "insn", ".", "eaBase", ")", "{", "default", ":", "debug", "(", "<STR_LIT>", "Unexpected eaBase", "<STR_LIT>", ")", ";", "return", "true", ";", "case", "EA_BASE_", "#", "#", "x", ":", "\\", "baseReg", "=", "MCOperand", "::", "CreateReg", "(", "X86", "::", "x", ")", ";", "break", ";", "ALL_EA_BASES", "ALL_REGS", "debug", "(", "<STR_LIT>", "A R/M memory operand may not be a register; ", "<STR_LIT>", "<STR_LIT>", "the base field must be a base.", "<STR_LIT>", ")", ";", "return", "true", ";", "}", "}", "scaleAmount", "=", "MCOperand", "::", "CreateImm", "(", "<NUM_LIT>", ")", ";", "}", "displacement", "=", "MCOperand", "::", "CreateImm", "(", "insn", ".", "displacement", ")", ";", "static", "const", "uint8_t", "segmentRegnums", "[", "SEG_OVERRIDE_max", "]", "=", "{", "<NUM_LIT>", ",", "X86", "::", "CS", ",", "X86", "::", "SS", ",", "X86", "::", "DS", ",", "X86", "::", "ES", ",", "X86", "::", "FS", ",", "X86", "::", "GS", "}", ";", "segmentReg", "=", "MCOperand", "::", "CreateReg", "(", "segmentRegnums", "[", "insn", ".", "segmentOverride", "]", ")", ";", "mcInst", ".", "addOperand", "(", "baseReg", ")", ";", "mcInst", ".", "addOperand", "(", "scaleAmount", ")", ";", "mcInst", ".", "addOperand", "(", "indexReg", ")", ";", "if", "(", "!", "tryAddingSymbolicOperand", "(", "insn", ".", "displacement", "+", "pcrel", ",", "false", ",", "insn", ".", "startLocation", ",", "insn", ".", "displacementOffset", ",", "insn", ".", "displacementSize", ",", "mcInst", ",", "Dis", ")", ")", "mcInst", ".", "addOperand", "(", "displacement", ")", ";", "mcInst", ".", "addOperand", "(", "segmentReg", ")", ";", "return", "false" ]

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

[ "unsigned", "LaneReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcValReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "VecRC", "=", "nullptr", ";", "const", "TargetRegisterClass", "*", "GPRRC", "=", "Subtarget", ".", "isABI_N64", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "unsigned", "SubRegIdx", "=", "Subtarget", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "sub_32", ":", "<NUM_LIT>", ";", "unsigned", "ShiftOp", "=", "Subtarget", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DSLL", ":", "Mips", "::", "SLL", ";", "unsigned", "EltLog2Size", ";", "unsigned", "InsertOp", "=", "<NUM_LIT>", ";", "unsigned", "InsveOp", "=", "<NUM_LIT>", ";", "switch", "(", "EltSizeInBytes", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected size", "<STR_LIT>", ")", ";", "case", "<NUM_LIT>", ":", "EltLog2Size", "=", "<NUM_LIT>", ";", "InsertOp", "=", "Mips", "::", "INSERT_B", ";", "InsveOp", "=", "Mips", "::", "INSVE_B", ";", "VecRC", "=", "&", "Mips", "::", "MSA128BRegClass", ";", "break", ";", "case", "<NUM_LIT>", ":", "EltLog2Size", "=", "<NUM_LIT>", ";", "InsertOp", "=", "Mips", "::", "INSERT_H", ";", "InsveOp", "=", "Mips", "::", "INSVE_H", ";", "VecRC", "=", "&", "Mips", "::", "MSA128HRegClass", ";", "break", ";", "case", "<NUM_LIT>", ":", "EltLog2Size", "=", "<NUM_LIT>", ";", "InsertOp", "=", "Mips", "::", "INSERT_W", ";", "InsveOp", "=", "Mips", "::", "INSVE_W", ";", "VecRC", "=", "&", "Mips", "::", "MSA128WRegClass", ";", "break", ";", "case", "<NUM_LIT>", ":", "EltLog2Size", "=", "<NUM_LIT>", ";", "InsertOp", "=", "Mips", "::", "INSERT_D", ";", "InsveOp", "=", "Mips", "::", "INSVE_D", ";", "VecRC", "=", "&", "Mips", "::", "MSA128DRegClass", ";", "break", ";", "}", "if", "(", "IsFP", ")", "{", "unsigned", "Wt", "=", "RegInfo", ".", "createVirtualRegister", "(", "VecRC", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SUBREG_TO_REG", ")", ",", "Wt", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcValReg", ")", ".", "addImm", "(", "EltSizeInBytes", "==", "<NUM_LIT>", "?", "Mips", "::", "sub_64", ":", "Mips", "::", "sub_lo", ")", ";", "SrcValReg", "=", "Wt", ";", "}", "if", "(", "EltSizeInBytes", "!=", "<NUM_LIT>", ")", "{", "unsigned", "LaneTmp1", "=", "RegInfo", ".", "createVirtualRegister", "(", "GPRRC", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "ShiftOp", ")", ",", "LaneTmp1", ")", ".", "addReg", "(", "LaneReg", ")", ".", "addImm", "(", "EltLog2Size", ")", ";", "LaneReg", "=", "LaneTmp1", ";", "}", "unsigned", "WdTmp1", "=", "RegInfo", ".", "createVirtualRegister", "(", "VecRC", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SLD_B", ")", ",", "WdTmp1", ")", ".", "addReg", "(", "SrcVecReg", ")", ".", "addReg", "(", "SrcVecReg", ")", ".", "addReg", "(", "LaneReg", ",", "<NUM_LIT>", ",", "SubRegIdx", ")", ";", "unsigned", "WdTmp2", "=", "RegInfo", ".", "createVirtualRegister", "(", "VecRC", ")", ";", "if", "(", "IsFP", ")", "{", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "InsveOp", ")", ",", "WdTmp2", ")", ".", "addReg", "(", "WdTmp1", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcValReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "InsertOp", ")", ",", "WdTmp2", ")", ".", "addReg", "(", "WdTmp1", ")", ".", "addReg", "(", "SrcValReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "unsigned", "LaneTmp2", "=", "RegInfo", ".", "createVirtualRegister", "(" ]

[ "if", "(", "IncludeDominator", ")", "DT", "->", "changeImmediateDominator", "(", "NewExit", ",", "BB", ")", ";" ]

[ "if", "(", "!", "SubRegion", "->", "contains", "(", "BB", ")", ")", "continue", ";", "delPhiValues", "(", "BB", ",", "OldExit", ")", ";", "BB", "->", "getTerminator", "(", ")", "->", "replaceUsesOfWith", "(", "OldExit", ",", "NewExit", ")", ";", "addPhiValues", "(", "BB", ",", "NewExit", ")", ";", "if", "(", "IncludeDominator", ")", "{", "if", "(", "!", "Dominator", ")", "Dominator", "=", "BB", ";", "else", "Dominator", "=", "DT", "->", "findNearestCommonDominator", "(", "Dominator", ",", "BB", ")", ";", "}", "}", "if", "(", "Dominator", ")", "DT", "->", "changeImmediateDominator", "(", "NewExit", ",", "Dominator", ")", ";", "SubRegion", "->", "replaceExit", "(", "NewExit", ")", ";", "}", "else", "{", "BasicBlock", "*", "BB", "=", "Node", "->", "getNodeAs", "<", "BasicBlock", ">", "(", ")", ";", "killTerminator", "(", "BB", ")", ";", "BranchInst", "::", "Create", "(", "NewExit", ",", "BB", ")", ";", "addPhiValues", "(", "BB", ",", "NewExit", ")", ";" ]

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

[ "def", "VLD1DUPd32", ":", "VLD1DUP", "<", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "?", "}", ",", "<STR_LIT>", ",", "v2i32", ",", "load" ]

[ "brtarget26", ":", "$", "d26", ")", ",", "<STR_LIT>", ">", ";" ]

[ "def", "BRn", ":", "F_BRANCH", "<", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins" ]

[ "}" ]

[ "if", "(", "!", "User", "->", "isMachineOpcode", "(", ")", ")", "return", "false", ";", "if", "(", "User", "->", "getMachineOpcode", "(", ")", "!=", "PPC", "::", "SELECT_I4", "&&", "User", "->", "getMachineOpcode", "(", ")", "!=", "PPC", "::", "SELECT_I8", ")", "return", "false", ";", "SDNode", "*", "Op1", "=", "User", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ";", "SDNode", "*", "Op2", "=", "User", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ";", "if", "(", "Op1", "==", "Op2", ")", "return", "false", ";", "if", "(", "!", "Op2", "->", "isMachineOpcode", "(", ")", ")", "return", "false", ";", "if", "(", "Op2", "->", "getMachineOpcode", "(", ")", "!=", "PPC", "::", "LI", "&&", "Op2", "->", "getMachineOpcode", "(", ")", "!=", "PPC", "::", "LI8", ")", "return", "false", ";", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op2", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "C", ")", "return", "false", ";", "if", "(", "!", "C", "->", "isZero", "(", ")", ")", "return", "false", ";", "}", "return", "true", ";" ]

[ "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tSpill", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";" ]

[ "if", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", "||", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "SrcReg", ")", "&&", "isARMLowRegister", "(", "SrcReg", ")", ")", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "<NUM_LIT>", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";" ]

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

[ "def", "FeatureGFX90AInsts", ":", "SubtargetFeature", "<", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", "," ]

[ "SELBr8", ",", "CGTBr8", ">", ";" ]

[ "def", ":", "SELECTNegCondImm", "<", "setle", ",", "R8C", ",", "i8", ",", "immSExt8", "," ]

[ "<FIXS>", "bool", "emitRLDICWhenLoweringJumpTables", "(", "MachineInstr", "&", "MI", ")", ";", "<FIXE>" ]

[ "bool", "eliminateRedundantCompare", "(", "void", ")", ";", "bool", "eliminateRedundantTOCSaves", "(", "std", "::", "map", "MachineInstr", "*", ",", "bool", ">", "&", "TOCSaves", ")", ";", "<BUGS>", "void", "emitRLDICWhenLoweringJumpTables", "(", "MachineInstr", "&", "MI", ")", ";", "<BUGE>", "void", "UpdateTOCSaves", "(", "std", "::", "map", "MachineInstr", "*", ",", "bool", ">", "&", "TOCSaves", ",", "MachineInstr", "*", "MI", ")", ";" ]

[ "}" ]

[ "assert", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "i32", "&&", "<STR_LIT>", "Unexpected result type", "<STR_LIT>", ")", ";", "APInt", "Imm", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "Idx", "=", "<NUM_LIT>", ",", "e", "=", "Src", ".", "getNumOperands", "(", ")", ";", "Idx", "<", "e", ";", "++", "Idx", ")", "{", "SDValue", "In", "=", "Src", ".", "getOperand", "(", "Idx", ")", ";", "if", "(", "!", "In", ".", "isUndef", "(", ")", "&&", "cast", "<", "ConstantSDNode", ">", "(", "In", ")", "->", "getAPIntValue", "(", ")", ".", "isNegative", "(", ")", ")", "Imm", ".", "setBit", "(", "Idx", ")", ";", "}", "return", "DAG", ".", "getConstant", "(", "Imm", ",", "SDLoc", "(", "N", ")", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ")", ";", "}", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "TargetLowering", "::", "TargetLoweringOpt", "TLO", "(", "DAG", ",", "!", "DCI", ".", "isBeforeLegalize", "(", ")", ",", "!", "DCI", ".", "isBeforeLegalizeOps", "(", ")", ")", ";", "KnownBits", "Known", ";", "APInt", "DemandedMask", "(", "APInt", "::", "getSignMask", "(", "SrcVT", ".", "getScalarSizeInBits", "(", ")", ")", ")", ";", "if", "(", "TLI", ".", "SimplifyDemandedBits", "(", "Src", ",", "DemandedMask", ",", "Known", ",", "TLO", ")", ")", "{", "DCI", ".", "AddToWorklist", "(", "Src", ".", "getNode", "(", ")", ")", ";", "DCI", ".", "CommitTargetLoweringOpt", "(", "TLO", ")", ";", "return", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ";", "}", "return", "SDValue", "(", ")", ";" ]

[ "(", "_", "_", "v16qi", ")", "_", "_", "O", ",", "_", "_", "M", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pmovsdb512_mask", "(", "(", "_", "_", "v16si", ")", "_", "_", "A", "," ]

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

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

[ "<STR_LIT>" ]

[ "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "VQ", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPEC_VSTRUCTDUMMY", ")", "]" ]

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

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

[ ")", ";" ]

[ "if", "(", "crtl", "->", "profile", ")", "return", "false", ";", "aarch64_layout_frame", "(" ]

[ ";" ]

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

[ "}" ]

[ "Register", "PtrReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "RegisterBank", "*", "PtrBank", "=", "getRegBank", "(", "PtrReg", ",", "MRI", ",", "*", "TRI", ")", ";", "if", "(", "PtrBank", "==", "&", "AMDGPU", "::", "SGPRRegBank", ")", "return", "false", ";", "SrcRegs", ".", "push_back", "(", "PtrReg", ")", ";", "}", "assert", "(", "LoadSize", "%", "MaxNonSmrdLoadSize", "==", "<NUM_LIT>", ")", ";", "MachineInstr", "*", "RepairInst", "=", "getOtherVRegDef", "(", "MRI", ",", "DstReg", ",", "MI", ")", ";", "Register", "BasePtrReg", "=", "SrcRegs", "[", "<NUM_LIT>", "]", ";", "LLT", "PtrTy", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "MRI", ".", "setType", "(", "BasePtrReg", ",", "PtrTy", ")", ";", "MachineIRBuilder", "B", "(", "MI", ")", ";", "unsigned", "SplitElts", "=", "MaxNonSmrdLoadSize", "/", "LoadTy", ".", "getScalarType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "const", "LLT", "LoadSplitTy", "=", "LLT", "::", "vector", "(", "SplitElts", ",", "LoadTy", ".", "getScalarType", "(", ")", ")", ";", "ApplyRegBankMapping", "O", "(", "MRI", ",", "&", "AMDGPU", "::", "VGPRRegBank", ")", ";", "GISelObserverWrapper", "Observer", "(", "&", "O", ")", ";", "B", ".", "setChangeObserver", "(", "Observer", ")", ";", "LegalizerHelper", "Helper", "(", "B", ".", "getMF", "(", ")", ",", "Observer", ",", "B", ")", ";", "if", "(", "Helper", ".", "fewerElementsVector", "(", "MI", ",", "<NUM_LIT>", ",", "LoadSplitTy", ")", "!=", "LegalizerHelper", "::", "Legalized", ")", "return", "false", ";", "MachineInstr", "*", "LegalizedInst", "=", "getOtherVRegDef", "(", "MRI", ",", "DstReg", ",", "*", "RepairInst", ")", ";", "Register", "TmpReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "MRI", ".", "getType", "(", "DstReg", ")", ")", ";", "LegalizedInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "TmpReg", ")", ";", "B", ".", "setInsertPt", "(", "*", "RepairInst", "->", "getParent", "(", ")", ",", "RepairInst", ")", ";", "for", "(", "unsigned", "DefIdx", "=", "<NUM_LIT>", ",", "e", "=", "DefRegs", ".", "size", "(", ")", ";", "DefIdx", "!=", "e", ";", "++", "DefIdx", ")", "{", "Register", "IdxReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ")", ";", "B", ".", "buildConstant", "(", "IdxReg", ",", "DefIdx", ")", ";", "MRI", ".", "setRegBank", "(", "IdxReg", ",", "AMDGPU", "::", "VGPRRegBank", ")", ";", "B", ".", "buildExtractVectorElement", "(", "DefRegs", "[", "DefIdx", "]", ",", "TmpReg", ",", "IdxReg", ")", ";", "}", "MRI", ".", "setRegBank", "(", "DstReg", ",", "AMDGPU", "::", "VGPRRegBank", ")", ";", "return", "true", ";" ]

[ "<FIXS>", "int", "BaseCost", "=", "ST", "->", "hasMVEIntegerOps", "(", ")", "&&", "ValTy", "->", "isVectorTy", "(", ")", "?", "ST", "->", "getMVEVectorCostFactor", "(", ")", ":", "<NUM_LIT>", ";", "return", "BaseCost", "*", "BaseT", "::", "getCmpSelInstrCost", "(", "Opcode", ",", "ValTy", ",", "CondTy", ",", "I", ")", ";", "<FIXE>" ]

[ "return", "LT", ".", "first", ";", "}", "<BUGS>", "return", "BaseT", "::", "getCmpSelInstrCost", "(", "Opcode", ",", "ValTy", ",", "CondTy", ",", "I", ")", ";", "<BUGE>", "}", "int", "ARMTTIImpl", "::", "getAddressComputationCost", "(", "Type", "*", "Ty", ",", "ScalarEvolution", "*", "SE", "," ]

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

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

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "V1TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V1TI", "[", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VMULOUD", ")", ")", "]", "<STR_LIT>" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_mul_epu32", "(", "_", "_", "m256i", "_", "_", "A", ",", "_", "_", "m256i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_pmuludq256", "(", "(", "_", "_", "v8si", ")", "_", "_", "A", ",", "(", "_", "_", "v8si", ")", "_", "_", "B", ")", ";" ]

[ "<FIXS>", "FrameAddr", "=", "DAG", ".", "getLoad", "(", "VT", ",", "dl", ",", "Chain", ",", "Ptr", ",", "MachinePointerInfo", "(", ")", ")", ";", "<FIXE>" ]

[ "while", "(", "depth", "--", ")", "{", "SDValue", "Ptr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "VT", ",", "FrameAddr", ",", "DAG", ".", "getIntPtrConstant", "(", "Offset", ",", "dl", ")", ")", ";", "<BUGS>", "FrameAddr", "=", "DAG", ".", "getLoad", "(", "VT", ",", "dl", ",", "Chain", ",", "Ptr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "}", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "FrameAddr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "VT", ",", "FrameAddr", "," ]

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

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

[ "}" ]

[ "bool", "canBeRepresentedAsSls", "(", "const", "ConstantSDNode", "&", "CN", ")", "{", "return", "isInt", "<", "<NUM_LIT>", ">", "(", "CN", ".", "getSExtValue", "(", ")", ")", "&&", "(", "(", "CN", ".", "getSExtValue", "(", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", ";" ]