Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "static", "int", "ia64_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "if", "(", "to", "==", "ADDL_REGS", ")", "to", "=", "GR_REGS", ";", "if", "(", "from", "==", "ADDL_REGS", ")", "from", "=", "GR_REGS", ";", "if", "(", "from", "<", "to", ")", "{", "reg_class_t", "tmp", "=", "to", ";", "to", "=", "from", ",", "from", "=", "tmp", ";", "}", "if", "(", "mode", "==", "XFmode", "||", "mode", "==", "RFmode", ")", "{", "if", "(", "to", "!=", "GR_REGS", "||", "from", "!=", "GR_REGS", ")", "return", "memory_move_cost", "(", "mode", ",", "to", ",", "false", ")", ";", "else", "return", "<NUM_LIT>", ";", "}", "switch", "(", "to", ")", "{", "case", "PR_REGS", ":", "if", "(", "from", "==", "PR_REGS", ")", "return", "<NUM_LIT>", ";", "if", "(", "from", "!=", "GR_REGS", ")", "return", "memory_move_cost", "(", "mode", ",", "to", ",", "false", ")", ";", "break", ";", "case", "BR_REGS", ":", "if", "(", "from", "!=", "GR_REGS", "&&", "from", "!=", "GR_AND_BR_REGS", ")", "return", "memory_move_cost", "(", "mode", ",", "to", ",", "false", ")", ";", "break", ";", "case", "AR_I_REGS", ":", "case", "AR_M_REGS", ":", "if", "(", "from", "!=", "GR_REGS", ")", "return", "memory_move_cost", "(", "mode", ",", "to", ",", "false", ")", ";", "break", ";", "case", "GR_REGS", ":", "case", "FR_REGS", ":", "case", "FP_REGS", ":", "case", "GR_AND_FR_REGS", ":", "case", "GR_AND_BR_REGS", ":", "case", "ALL_REGS", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "Calulate", "the", "cost", "of", "moving", "data", "from", "a", "register", "in", "class", "FROM", "to", "one", "in", "class", "TO", ",", "using", "MODE", "." ]

[ "getTargetMachine", "(", ")", "{" ]

[ "const", "AAPTargetMachine", "&" ]

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

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

[ "<FIXS>", "#", "define", "ADDI_REACH", "(", "<NUM_LIT>", ")", "<FIXE>" ]

[ "static", "int", "number_of_regs_before_varargs", ";", "static", "int", "current_function_anonymous_args", ";", "#", "define", "STACK_BYTES", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", "#", "define", "STORE_REACH", "(", "<NUM_LIT>", ")", "<BUGS>", "#", "define", "ADDI_REACH", "(", "<NUM_LIT>", ")", "<BUGE>", "static", "voidlayout_mcore_frame", "(", "infp", ")" ]

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

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

[ ")", ";" ]

[ "void", "X86InstrInfo", "::", "compareRegAndStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "Reg", ",", "unsigned", "StackSlot", ",", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI" ]

[ "_", "_", "a", ")", ";" ]

[ "vcvtmh_s16_f16", "(", "float16_t", "_", "_", "a", ")", "{", "return", "_", "_", "builtin_aarch64_lfloorhfhi", "(" ]

[ "Fixups", ",", "STI", ")", ";" ]

[ "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "MCFixupKind", "Fixup", "=", "MCFixupKind", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "<NUM_LIT>", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getExpr", "(", ")", ",", "Fixup", ")", ")", ";", "return", ";", "}", "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", "," ]

[ ";" ]

[ "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "SubExpr" ]

[ ")", ";" ]

[ "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Function has local memory argument. Promoting to ", "<STR_LIT>", "<STR_LIT>", "local memory disabled.\\n", "<STR_LIT>", ")", ";", "break", ";", "}", "}", "if", "(", "LocalMemAvailable", ">", "<NUM_LIT>", ")", "{", "for", "(", "Module", "::", "global_iterator", "I", "=", "Mod", "->", "global_begin", "(", ")", ",", "E", "=", "Mod", "->", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "GlobalVariable", "*", "GV", "=", "I", ";", "PointerType", "*", "GVTy", "=", "GV", "->", "getType", "(", ")", ";", "if", "(", "GVTy", "->", "getAddressSpace", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "continue", ";", "for", "(", "Value", "::", "use_iterator", "U", "=", "GV", "->", "use_begin", "(", ")", ",", "UE", "=", "GV", "->", "use_end", "(", ")", ";", "U", "!=", "UE", ";", "++", "U", ")", "{", "Instruction", "*", "Use", "=", "dyn_cast", "<", "Instruction", ">", "(", "*", "U", ")", ";", "if", "(", "!", "Use", ")", "continue", ";", "if", "(", "Use", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "==", "&", "F", ")", "LocalMemAvailable", "-=", "Mod", "->", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "GVTy", "->", "getElementType", "(", ")", ")", ";", "}", "}", "}", "LocalMemAvailable", "=", "std", "::", "max", "(", "<NUM_LIT>", ",", "LocalMemAvailable", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "LocalMemAvailable", "<<", "<STR_LIT>", "bytes free in local memory.\\n", "<STR_LIT>", ")", ";", "visit", "(", "F" ]

[ "SReg_32RegClass", ":", "&", "AMDGPU", "::", "SReg_64RegClass", ";" ]

[ "return", "isWave32", "?", "&", "AMDGPU", "::" ]

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

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

[ "addr", ",", "QPR", ":", "$", "src", ")", ",", "itin", ",", "<STR_LIT>", ">", ";" ]

[ "class", "VSTQWBfixedPseudo", "<", "InstrItinClass", "itin", ">", ":", "PseudoNLdSt", "<", "(", "outs", "GPR", ":", "$", "wb", ")", ",", "(", "ins", "addrmode6", ":", "$" ]

[ "RedundantMovElemNum", "++", ";" ]

[ "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "unsigned", "dst", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "dst_sub", "=", "TRI", "->", "getSubReg", "(", "dst", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "unsigned", "src", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "dst_sub", "!=", "src", ")", "continue", ";", "ToErase", "=", "&", "MI", ";" ]

[ ",", "_", "_", "d", ")", ";" ]

[ "return", "(", "int16x8_t", ")", "_", "_", "builtin_neon_vqrdmlah_lanev8hi", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "c" ]

[ "_", "_", "m128i", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_sra_epi16", "(", "_", "_", "m128i", "_", "_", "A", "," ]

[ "<FIXS>", "RxSBGOperands", "RISBG", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ")", ";", "<FIXE>", "<FIXS>", "while", "(", "expandRxSBG", "(", "RISBG", ")", ")", "<FIXE>" ]

[ "}", "SDNode", "*", "SystemZDAGToDAGISel", "::", "tryRISBGZero", "(", "SDNode", "*", "N", ")", "{", "<BUGS>", "RISBGOperands", "RISBG", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "unsigned", "Count", "=", "<NUM_LIT>", ";", "<BUGS>", "while", "(", "expandRISBG", "(", "RISBG", ")", ")", "<BUGE>", "Count", "+=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "<NUM_LIT>", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "AVRTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "AVRTargetMachine", "&", ">", "(", "MF", "->", "getTarget", "(", ")", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "return", "TII", ".", "getInlineAsmLength", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}" ]

[ "<FIXS>", "return", "(", "mips_output_sync_loop", "(", "MIPS_SYNC_OP_12", "(", "<STR_LIT>", ",", "MIPS_SYNC_OP_12_NOT_NOT", ")", ")", ")", "<FIXE>" ]

[ "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{", "<BUGS>", "return", "MIPS_SYNC_OP_12", "(", "<STR_LIT>", ",", "MIPS_SYNC_OP_12_NOT_NOT", ")", "<BUGE>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

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

[ "return", "new", "ARMConstantPoolSymbol", "(", "C", ",", "s", ",", "ID", ",", "PCAdj", ",", "<STR_LIT>", "::", "<STR_LIT>" ]

[ "?", ";" ]

[ "let", "hasSideEffects", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "mayStore", "=", "<NUM_LIT>", ";", "let", "InstAtomic", "=", "<NUM_LIT>", ";", "int", "atomicOperation", "=" ]

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

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

[ "{" ]

[ "IsDirectCall", "=", "false", ";", "if", "(", "(", "RetVals", ">", "<NUM_LIT>", ")", "||", "(", "NumArgs", ">", "<NUM_LIT>", ")", ")", "GetDataAddress", "(", "dl", ",", "Callee", ",", "Chain", ",", "DataAddr_Lo", ",", "DataAddr_Hi", ",", "DAG", ")", ";", "}", "SDValue", "ZeroOperand", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i8", ")", ";", "SDValue", "SeqStart", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "ZeroOperand", ")", ";", "Chain", "=", "getChain", "(", "SeqStart", ")", ";", "SDValue", "OperFlag", "=", "getOutFlag", "(", "SeqStart", ")", ";", "std", "::", "string", "Name", ";", "SDValue", "ArgLabel", ",", "RetLabel", ";", "if", "(", "IsDirectCall", ")", "{", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "GlobalValue", "*", "GV", "=", "G", "->", "getGlobal", "(", ")", ";", "Callee", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "MVT", "::", "i8", ")", ";", "Name", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "}", "else", "{", "ExternalSymbolSDNode", "*", "ES", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ";", "Callee", "=", "DAG", ".", "getTargetExternalSymbol", "(", "ES", "->", "getSymbol", "(", ")", ",", "MVT", "::", "i8", ")", ";", "Name", "=", "ES", "->", "getSymbol", "(", ")", ";", "}", "const", "char", "*", "argFrame", "=", "createESName", "(", "PAN", "::", "getArgsLabel", "(", "Name", ")", ")", ";", "ArgLabel", "=", "DAG", ".", "getTargetExternalSymbol", "(", "argFrame", ",", "MVT", "::", "i8", ")", ";", "const", "char", "*", "retName", "=", "createESName", "(", "PAN", "::", "getRetvalLabel", "(", "Name", ")", ")", ";", "RetLabel", "=", "DAG", ".", "getTargetExternalSymbol", "(", "retName", ",", "MVT", "::", "i8", ")", ";", "}", "else", "{", "SDValue", "CodeAddr_Lo", "=", "Callee", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "CodeAddr_Hi", "=", "Callee", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "CodeAddr_Hi", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i8", ",", "CodeAddr_Hi", ")", ";", "Callee", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i8", ",", "CodeAddr_Lo", ",", "CodeAddr_Hi", ")", ";", "}", "SDValue", "CallArgs", ";", "if", "(", "IsDirectCall", ")" ]

[ "<STR_LIT>" ]

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

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

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

[ ",", "DAG", ",", "InVals", ")", ";" ]

[ "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "LowerFormalArguments_64SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "else", "return", "LowerFormalArguments_32SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl" ]

[ ",", "RegState", "::", "Implicit", ")", ";" ]

[ "void", "SILowerControlFlowPass", "::", "IndirectSrc", "(", "MachineInstr", "&", "MI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "Dst", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Vec", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "int", "Off", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "Reg", ";", "computeIndirectRegAndOffset", "(", "Vec", ",", "Reg", ",", "Off", ")", ";", "MachineInstr", "*", "MovRel", "=", "BuildMI", "(", "*", "MBB", ".", "getParent", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOVRELS_B32_e32", ")", ",", "Dst", ")", ".", "addReg", "(", "Reg", ")", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "Vec" ]

[ "let", "iops", "=", "(", "ins", "MQPR", ":", "$", "Qd", ")", ";" ]

[ "let", "bit_20", "=", "<NUM_LIT>", ";", "let", "oops", "=", "(", "outs", "rGPR", ":", "$", "Rt", ")", ";" ]

[ "}" ]

[ "void", "Z80AsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unimplemented", "<STR_LIT>", ")", ";" ]

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

[ "(", "define_int_attr", "xvcvbf16", "[", "(", "UNSPEC_VSX_XVCVSPBF16", "<STR_LIT>", ")", "(", "UNSPEC_VSX_XVCVBF16SPN", "<STR_LIT>" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isSub", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "setFlags", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "ext", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "ext", "{", "<NUM_LIT>" ]

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

[ "return", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "NumInsts", "<=", "<NUM_LIT>", ";", "}", "case", "SCC_TRUE", ":", "case", "SCC_FALSE", ":", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ";", "if", "(", "MRI", ".", "getRegClass", "(", "FalseReg", ")", "!=", "RC", ")", "return", "false", ";", "int", "NumInsts", "=", "AMDGPU", "::", "getRegBitWidth", "(", "RC", "->", "getID", "(", ")", ")", "/", "<NUM_LIT>", ";", "if", "(", "NumInsts", "%", "<NUM_LIT>", "==", "<NUM_LIT>", ")", "NumInsts", "/", "=", "<NUM_LIT>", ";", "CondCycles", "=", "TrueCycles", "=", "FalseCycles", "=", "NumInsts", ";", "return", "RI", ".", "isSGPRClass", "(", "RC", ")", ";", "}", "default", ":" ]

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

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

[ "}" ]

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseLongOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "isMax", ",", "Rs", ",", "Rt", ")", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "Rs", ";", "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "isMax", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isUnsigned", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd", ";" ]

[ ";" ]

[ "def", "NormalFrm", ":", "Format", "<", "<NUM_LIT>", ">" ]

[ "Format", "F", "=", "f", ";" ]

[ "field", "bits", "<", "<NUM_LIT>", ">", "Unpredictable", "=", "<NUM_LIT>", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "Unpredictable", ";", "let", "Namespace", "=", "<STR_LIT>", ";" ]

[ "Rn", ";" ]

[ "class", "BaseSIMDVectorShift", "<", "bit", "Q", ",", "bit", "U", ",", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "bits", "<", "<NUM_LIT>", ">", "fixed_imm", ",", "RegisterOperand", "dst_reg", ",", "RegisterOperand", "src_reg", ",", "Operand", "immtype", ",", "string", "asm", ",", "string", "dst_kind", ",", "string", "src_kind", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "(", "outs", "dst_reg", ":", "$", "Rd", ")", ",", "(", "ins", "src_reg", ":", "$", "Rn", ",", "immtype", ":", "$", "imm", ")", ",", "asm", ",", "<STR_LIT>", "#", "dst_kind", "#", "<STR_LIT>", "#", "src_kind", "#", "<STR_LIT>", "#", "<STR_LIT>", "#", "dst_kind", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", ",", "Sched", "<", "[", "WriteV", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "fixed_imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

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

[ "case", "MachineOperand", "::", "MO_Immediate", ":", "OS", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "getReg", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "false", ";", "OS", "<<", "CSKYInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "PrintSymbolOperand", "(", "MO", ",", "OS", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "{", "MCSymbol", "*", "Sym", "=", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "Sym", "->", "print", "(", "OS", ",", "MAI", ")", ";" ]

[ ")", ")" ]

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

[ "TypeStr", "=", "TypeStr", ".", "substr", "(", "<NUM_LIT>", ",", "TypeStr", ".", "find", "(", "'", "]", "'", ")", ")", ";" ]

[ "if", "(", "!", "Ty", ")", "return", "nullptr", ";", "auto", "SpirvTy", "=", "getOrCreateSPIRVType", "(", "Ty", ",", "MIRBuilder", ",", "AQ", ")", ";", "if", "(", "TypeStr", ".", "starts_with", "(", "<STR_LIT>", "*", "<STR_LIT>", ")", ")", "{", "SpirvTy", "=", "getOrCreateSPIRVPointerType", "(", "SpirvTy", ",", "MIRBuilder", ",", "SC", ")", ";", "TypeStr", "=", "TypeStr", ".", "substr", "(", "strlen", "(", "<STR_LIT>", "*", "<STR_LIT>", ")", ")", ";", "}", "bool", "IsPtrToVec", "=", "TypeStr", ".", "consume_back", "(", "<STR_LIT>", "*", "<STR_LIT>", ")", ";", "if", "(", "TypeStr", ".", "consume_front", "(", "<STR_LIT>", " vector[", "<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", "addrMode", "=", "BaseRegOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";" ]

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

[ "if", "(", "MI", "->", "isCall", "(", ")", "||", "MI", "->", "isBarrier", "(", ")", "||", "MI", "->", "isBranch", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "hasUnmodeledSideEffects", "(" ]

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

[ "break", ";", "case", "ISD", "::", "BITCAST", ":", "return", "PerformBITCASTCombine", "(", "N", ",", "DCI", ")", ";", "}" ]

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

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

[ "}", "=", "Rtt", ";" ]

[ "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "MajOp", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "MinOp", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rdd", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rss", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "ANYF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fma", ":", "ANYF", "(", "match_operand", ":", "ANYF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "ANYF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "ANYF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ";" ]

[ "for", "(", "auto", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "for", "(", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "for", "(", "int", "InsertedCount", "=", "<NUM_LIT>", ";", "InsertedCount", "<", "<NUM_LIT>", ";", "InsertedCount", "++", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "NMBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "for", "(", "int", "InsertedCount", "=", "<NUM_LIT>", ";", "InsertedCount", "<", "<NUM_LIT>", ";", "InsertedCount", "++", ")", "BuildMI", "(", "MBB", ",", "NMBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "Modified", "=", "true", ";", "}", "}", "}", "return", "Modified" ]

[ ";" ]

[ "AMDGPUAS", "ASST", "=", "ST", "->", "getAMDGPUAS", "(", ")", ";", "for", "(", "const", "BasicBlock", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "const", "DataLayout", "&", "DL", "=", "BB", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "LocalGEPsSeen", "=", "<NUM_LIT>", ";", "if", "(", "llvm", "::", "any_of", "(", "L", "->", "getSubLoops", "(", ")", ",", "[", "BB", "]", "(", "const", "Loop", "*", "SubLoop", ")", "{", "return", "SubLoop", "->", "contains", "(", "BB", ")", ";", "}", ")", ")", "continue", ";", "for", "(", "const", "Instruction", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "const", "BranchInst", "*", "Br", "=", "dyn_cast", "<", "BranchInst", ">", "(", "&", "I", ")", ")", "{", "if", "(", "UP", ".", "Threshold", "<", "MaxBoost", "&&", "Br", "->", "isConditional", "(", ")", ")", "{", "if", "(", "L", "->", "isLoopExiting", "(", "Br", "->", "getSuccessor", "(", "<NUM_LIT>", ")", ")", "||", "L", "->", "isLoopExiting", "(", "Br", "->", "getSuccessor", "(", "<NUM_LIT>", ")", ")", ")", "continue", ";", "if", "(", "dependsOnLocalPhi", "(", "L", ",", "Br", "->", "getCondition", "(", ")", ")", ")", "{", "UP", ".", "Threshold", "+=", "UnrollThresholdIf", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Set unroll threshold ", "<STR_LIT>", "<<", "UP", ".", "Threshold", "<<", "<STR_LIT>", " for loop:\\n", "<STR_LIT>", "<<", "*", "L", "<<", "<STR_LIT>", " due to ", "<STR_LIT>", "<<", "*", "Br", "<<", "'", "\\n", "'", ")", ";", "if", "(", "UP", ".", "Threshold", ">=", "MaxBoost", ")", "return", ";", "}", "}", "continue", ";", "}", "const", "GetElementPtrInst", "*", "GEP", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "GEP", ")", "continue", ";", "unsigned", "AS", "=", "GEP", "->", "getAddressSpace", "(", ")", ";", "unsigned", "Threshold", "=", "<NUM_LIT>", ";", "if", "(", "AS", "==", "ASST", ".", "PRIVATE_ADDRESS", ")", "Threshold", "=", "ThresholdPrivate", ";", "else", "if", "(", "AS", "==", "ASST", ".", "LOCAL_ADDRESS", ")", "Threshold", "=", "ThresholdLocal", ";", "else", "continue", ";", "if", "(", "UP", ".", "Threshold", ">=", "Threshold", ")", "continue", ";", "if", "(", "AS", "==", "ASST", ".", "PRIVATE_ADDRESS", ")", "{", "const", "Value", "*", "Ptr", "=", "GEP", "->", "getPointerOperand", "(", ")", ";", "const", "AllocaInst", "*", "Alloca", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "GetUnderlyingObject", "(", "Ptr", ",", "DL", ")", ")", ";", "if", "(", "!", "Alloca", "||", "!", "Alloca", "->", "isStaticAlloca", "(", ")", ")", "continue", ";", "Type", "*", "Ty", "=", "Alloca", "->", "getAllocatedType", "(", ")", ";", "unsigned", "AllocaSize", "=", "Ty", "->", "isSized", "(", ")", "?", "DL", ".", "getTypeAllocSize", "(", "Ty", ")", ":", "<NUM_LIT>", ";", "if", "(", "AllocaSize", ">", "MaxAlloca", ")", "continue", ";", "}", "else", "if", "(", "AS", "==", "ASST", ".", "LOCAL_ADDRESS", ")", "{", "LocalGEPsSeen", "++", ";", "if", "(", "LocalGEPsSeen", ">", "<NUM_LIT>", "||", "L", "->", "getLoopDepth", "(", ")", ">", "<NUM_LIT>", "||", "(", "!", "isa", "<", "GlobalVariable", ">", "(", "GEP", "->", "getPointerOperand", "(", ")", ")", "&&", "!", "isa", "<", "Argument", ">", "(", "GEP", "->", "getPointerOperand", "(", ")", ")", ")", ")", "continue", ";", "}", "bool", "HasLoopDef", "=", "false" ]

[ "DL", ")", ":", "V1", ";" ]

[ "int", "M1", "=", "TargetMask", "[", "i", "+", "<NUM_LIT>", "]", ";", "int", "M2", "=", "TargetMask", "[", "i", "+", "<NUM_LIT>", "]", ";", "Undef1", "&=", "(", "SM_SentinelUndef", "==", "M1", ")", ";", "Undef2", "&=", "(", "SM_SentinelUndef", "==", "M2", ")", ";", "Zero1", "&=", "isUndefOrZero", "(", "M1", ")", ";", "Zero2", "&=", "isUndefOrZero", "(", "M2", ")", ";", "}", "assert", "(", "!", "(", "(", "Undef1", "||", "Zero1", ")", "&&", "(", "Undef2", "||", "Zero2", ")", ")", "&&", "<STR_LIT>", "Zeroable shuffle detected", "<STR_LIT>", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Unpckl", ",", "Unpckh", ";", "createUnpackShuffleMask", "(", "VT", ",", "Unpckl", ",", "true", ",", "IsUnary", ")", ";", "if", "(", "isTargetShuffleEquivalent", "(", "TargetMask", ",", "Unpckl", ")", ")", "{", "UnpackOpcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "V2", "=", "(", "Undef2", "?", "DAG", ".", "getUNDEF", "(", "VT", ")", ":", "(", "IsUnary", "?", "V1", ":", "V2", ")", ")", ";", "V1", "=", "(", "Undef1", "?", "DAG", ".", "getUNDEF", "(", "VT", ")", ":", "V1", ")", ";", "return", "true", ";", "}", "createUnpackShuffleMask", "(", "VT", ",", "Unpckh", ",", "false", ",", "IsUnary", ")", ";", "if", "(", "isTargetShuffleEquivalent", "(", "TargetMask", ",", "Unpckh", ")", ")", "{", "UnpackOpcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "V2", "=", "(", "Undef2", "?", "DAG", ".", "getUNDEF", "(", "VT", ")", ":", "(", "IsUnary", "?", "V1", ":", "V2", ")", ")", ";", "V1", "=", "(", "Undef1", "?", "DAG", ".", "getUNDEF", "(", "VT", ")", ":", "V1", ")", ";", "return", "true", ";", "}", "if", "(", "IsUnary", "&&", "(", "Zero1", "||", "Zero2", ")", ")", "{", "if", "(", "(", "Subtarget", ".", "hasSSE41", "(", ")", "||", "VT", "==", "MVT", "::", "v2i64", "||", "VT", "==", "MVT", "::", "v2f64", ")", "&&", "isSequentialOrUndefOrZeroInRange", "(", "TargetMask", ",", "<NUM_LIT>", ",", "NumElts", ",", "<NUM_LIT>", ")", ")", "return", "false", ";", "bool", "MatchLo", "=", "true", ",", "MatchHi", "=", "true", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "(", "i", "!=", "NumElts", ")", "&&", "(", "MatchLo", "||", "MatchHi", ")", ";", "++", "i", ")", "{", "int", "M", "=", "TargetMask", "[", "i", "]", ";", "if", "(", "(", "(", "(", "i", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "&&", "Zero1", ")", "||", "(", "(", "(", "i", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "&&", "Zero2", ")", "||", "(", "M", "==", "SM_SentinelUndef", ")", ")", "continue", ";", "MatchLo", "&=", "(", "M", "==", "Unpckl", "[", "i", "]", ")", ";", "MatchHi", "&=", "(", "M", "==", "Unpckh", "[", "i", "]", ")", ";", "}", "if", "(", "MatchLo", "||", "MatchHi", ")", "{", "UnpackOpcode", "=", "MatchLo", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "V2", "=", "Zero2", "?", "getZeroVector", "(", "VT", ",", "Subtarget", ",", "DAG", ",", "DL", ")", ":", "V1", ";", "V1", "=", "Zero1", "?", "getZeroVector", "(", "VT", ",", "Subtarget", ",", "DAG", "," ]

[ "}" ]

[ "In1", "=", "N01In", ";", "if", "(", "In0", ".", "getValueSizeInBits", "(", ")", "<", "VT", ".", "getSizeInBits", "(", ")", "||", "In1", ".", "getValueSizeInBits", "(", ")", "<", "VT", ".", "getSizeInBits", "(", ")", ")", "return", "SDValue", "(", ")", ";", "}", "if", "(", "In0", "!=", "N00In", ")", "std", "::", "swap", "(", "N00In", ",", "N01In", ")", ";", "if", "(", "In0", "!=", "N10In", ")", "std", "::", "swap", "(", "N10In", ",", "N11In", ")", ";", "if", "(", "In0", "!=", "N00In", "||", "In1", "!=", "N01In", "||", "In0", "!=", "N10In", "||", "In1", "!=", "N11In", ")", "return", "SDValue", "(", ")", ";", "}", "auto", "PMADDBuilder", "=", "[", "]", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "ArrayRef", "<", "SDValue", ">", "Ops", ")", "{", "EVT", "OpVT", "=", "Ops", "[", "<NUM_LIT>", "]", ".", "getValueType", "(", ")", ";", "assert", "(", "OpVT", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i16", "&&", "<STR_LIT>", "Unexpected scalar element type", "<STR_LIT>", ")", ";", "assert", "(", "OpVT", "==", "Ops", "[", "<NUM_LIT>", "]", ".", "getValueType", "(", ")", "&&", "<STR_LIT>", "Operands' types mismatch", "<STR_LIT>", ")", ";", "EVT", "ResVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "i32", ",", "OpVT", ".", "getVectorNumElements", "(", ")", "/", "<NUM_LIT>", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "ResVT", ",", "Ops", "[", "<NUM_LIT>", "]", ",", "Ops", "[", "<NUM_LIT>", "]", ")", ";", "}", ";", "EVT", "OutVT16", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "i16", ",", "VT", ".", "getVectorNumElements", "(", ")", "*", "<NUM_LIT>", ")", ";", "if", "(", "OutVT16", ".", "bitsLT", "(", "In0", ".", "getValueType", "(", ")", ")", ")", "{", "In0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "OutVT16", ",", "In0", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "DL", ")", ")", ";", "}", "if", "(", "OutVT16", ".", "bitsLT", "(", "In1", ".", "getValueType", "(", ")", ")", ")", "{", "In1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "OutVT16", ",", "In1", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "DL", ")", ")", ";", "}", "return", "SplitOpsAndApply", "(", "DAG", ",", "Subtarget", ",", "DL", ",", "VT", ",", "{", "In0", ",", "In1", "}", ",", "PMADDBuilder", ")", ";" ]

[ "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "M68kSubtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MFI", "=", "MF", ".", "getInfo", "<", "M68kMachineFunctionInfo", ">", "(", ")", ";", "FL", "=", "STI", "->", "getFrameLowering", "(", ")", ";", "bool", "Modified", "=", "false", ";", "MOVEMState", "State", ";", "unsigned", "Mask", "=", "<NUM_LIT>", ";", "unsigned", "Reg", "=", "<NUM_LIT>", ";", "int", "Offset", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "auto", "MI", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "MI", "!=", "E", ")", "{", "auto", "NMI", "=", "std", "::", "next", "(", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "if", "(", "State", ".", "hasBase", "(", ")", ")", "{", "State", ".", "setEnd", "(", "MI", ")", ";", "Finish", "(", "MBB", ",", "State", ")", ";", "Modified", "=", "true", ";", "}", "break", ";", "case", "M68k", "::", "MOVM32jm", ":", "Mask", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "<NUM_LIT>", ";", "Modified", "|=", "ProcessMI", "(", "MBB", ",", "MI", ",", "State", ",", "Mask", ",", "Offset", ",", "Reg", ",", "true", ")", ";", "break", ";", "case", "M68k", "::", "MOVM32pm", ":", "Mask", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "Modified", "|=", "ProcessMI", "(", "MBB", ",", "MI", ",", "State", ",", "Mask", ",", "Offset", ",", "Reg", ",", "true", ")", ";", "break", ";", "case", "M68k", "::", "MOVM32mj", ":", "Mask", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "<NUM_LIT>", ";", "Modified", "|=", "ProcessMI", "(", "MBB", ",", "MI", ",", "State", ",", "Mask", ",", "Offset", ",", "Reg", ",", "false", ")", ";", "break", ";", "case", "M68k", "::", "MOVM32mp", ":", "Mask", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Offset", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "Modified", "|=", "ProcessMI", "(", "MBB", ",", "MI", ",", "State", ",", "Mask", ",", "Offset", ",", "Reg", ",", "false", ")", ";", "break", ";", "}", "MI", "=", "NMI", ";", "}", "if", "(", "State", ".", "hasBase", "(", ")", ")", "{", "State", ".", "setEnd", "(", "MI", ")", ";", "Finish", "(", "MBB", ",", "State", ")", ";", "}", "}", "return", "Modified", ";", "}" ]

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

[ "<FIXS>", "asm_fprintf", "(", "stream", ",", "<STR_LIT>", "[%r]", "<STR_LIT>", ",", "REGNO", "(", "x", ")", ")", ";", "<FIXE>" ]

[ "int", "is_minus", "=", "GET_CODE", "(", "x", ")", "==", "MINUS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "<BUGS>", "asm_fprintf", "(", "stream", ",", "<STR_LIT>", "[%r, #0]", "<STR_LIT>", ",", "REGNO", "(", "x", ")", ")", ";", "<BUGE>", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "||", "is_minus", ")", "{", "rtx", "base", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";" ]

[ "}" ]

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

[ "SDValue", "First", "=", "V", ".", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

[ "static", "bool", "isSplat", "(", "SDValue", "V", ")", "{", "if", "(", "V", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "BUILD_VECTOR", ")", "return", "false", ";" ]

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

[ "SDValue", "FalseOp", "=", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "TrueOp", "=", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "(", "TrueOp", "==", "X", "&&", "FalseOp", "==", "NegX", ")", "&&", "!", "(", "TrueOp", "==", "NegX", "&&", "FalseOp", "==", "X", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "MVT", "VT", "=", "N", "->", "getSimpleValueType", "(", "<NUM_LIT>", ")", ";", "SDValue", "Cmov", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "TrueOp", ",", "FalseOp", ",", "N1", ".", "getOperand", "(" ]

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

[ "def", "Wri", ":", "BaseLogicalImm", "<", "opc", ",", "GPR32sp", ",", "GPR32", ",", "logical_imm32", ",", "mnemonic", ",", "[", "(", "set", "GPR32sp", ":", "$", "Rd", ",", "(", "OpNode", "GPR32", ":", "$", "Rn", ",", "logical_imm32", ":", "$", "imm", ")", ")", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "<FIXS>", "AsmParser", "->", "getFeatureBits", "(", ")", "[", "AMDGPU", "::", "FeatureDPALU_DPP", "]", ")", ";", "<FIXE>" ]

[ "return", "isRegClass", "(", "AMDGPU", "::", "VGPR_32RegClassID", ")", "||", "(", "isRegClass", "(", "AMDGPU", "::", "VReg_64RegClassID", ")", "&&", "<BUGS>", "AsmParser", "->", "getFeatureBits", "(", ")", "[", "AMDGPU", "::", "Feature64BitDPP", "]", ")", ";", "<BUGE>", "}", "bool", "AMDGPUOperand", "::", "isT16VRegWithInputMods", "(", ")", "const", "{" ]

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

[ "static", "bool", "resultTests", "(", "MachineInstr", "*", "MI", ",", "unsigned", "Reg", ",", "unsigned", "SubReg", ")", "{", "if", "(", "MI", "->", "getNumOperands", "(", ")", ">", "<NUM_LIT>", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDef", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "Reg", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSubReg", "(", ")", "==", "SubReg", ")", "return", "true", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ ";" ]

[ "return", "<STR_LIT>", "WebAssembly Register Stackify", "<STR_LIT>" ]

[ "return", "LT", ".", "first", "*", "<NUM_LIT>", ";" ]

[ "int", "ARMTTIImpl", "::", "getMemoryOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Src", ",", "unsigned", "Alignment", ",", "unsigned", "AddressSpace", ",", "const", "Instruction", "*", "I", ")", "{", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Src", ")", ";", "if", "(", "Src", "->", "isVectorTy", "(", ")", "&&", "Alignment", "!=", "<NUM_LIT>", "&&", "Src", "->", "getVectorElementType", "(", ")", "->", "isDoubleTy", "(", ")", ")", "{" ]

[ "}" ]

[ "if", "(", "!", "I", ".", "isPHI", "(", ")", ")", "break", ";", "unsigned", "HeadReg", "=", "<NUM_LIT>", ",", "CmpBBReg", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "oi", "=", "<NUM_LIT>", ",", "oe", "=", "I", ".", "getNumOperands", "(", ")", ";", "oi", "!=", "oe", ";", "oi", "+=", "<NUM_LIT>", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "I", ".", "getOperand", "(", "oi", "+", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "Register", "Reg", "=", "I", ".", "getOperand", "(", "oi", ")", ".", "getReg", "(", ")", ";", "if", "(", "MBB", "==", "Head", ")", "{", "assert", "(", "(", "!", "HeadReg", "||", "HeadReg", "==", "Reg", ")", "&&", "<STR_LIT>", "Inconsistent PHI operands", "<STR_LIT>", ")", ";", "HeadReg", "=", "Reg", ";", "}", "if", "(", "MBB", "==", "CmpBB", ")", "{", "assert", "(", "(", "!", "CmpBBReg", "||", "CmpBBReg", "==", "Reg", ")", "&&", "<STR_LIT>", "Inconsistent PHI operands", "<STR_LIT>", ")", ";", "CmpBBReg", "=", "Reg", ";", "}", "}", "if", "(", "HeadReg", "!=", "CmpBBReg", ")", "return", "false", ";", "}", "return", "true", ";" ]

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

[ "def", "JMP", ":", "MbrpForm", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "ins", "GPRC", ":", "$", "RS", ")", ",", "<STR_LIT>", ",", "[", "(", "brind", "GPRC", ":", "$", "RS", ")" ]

[ "}" ]

[ "unsigned", "getDarwinVers", "(", ")", "const", "{", "return", "DarwinVers", ";" ]

[ "<STR_LIT>" ]

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

[ "false", ";" ]

[ "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "!", "isCalleeSavedRegister", "(", "MI", "->", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ",", "CSRegs", ")", ")", "return", "false", ";", "return", "true", ";", "}", "if", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "LDR_POST_IMM", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "LDR_POST_REG", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2LDR_POST", ")", "&&", "isCalleeSavedRegister", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "CSRegs", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", "return", "true", ";", "return" ]

[ ";" ]

[ "else", "gcc_unreachable", "(", ")", ";", "regno", "=", "parse_cr_reg", "(", "str", ")", ";", "if", "(", "regno", "==", "INVALID_REGNUM", ")", "{", "error", "(", "<STR_LIT>", "invalid coprocessor register %qE", "<STR_LIT>", ",", "val", ")", ";", "return", "false", ";", "}", "if", "(", "do_range", ")", "{", "if", "(", "last_regno", ">", "regno", ")", "i", "=", "regno", ",", "regno", "=", "last_regno", ";", "else", "i", "=", "last_regno", ";", "do_range", "=", "false", ";", "}", "else", "last_regno", "=", "i", "=", "regno", ";", "while", "(", "i", "<=", "regno", ")", "{", "SET_HARD_REG_BIT", "(", "*", "set", ",", "i", ")", ";", "i", "++" ]

[ "const", "{" ]

[ "bool", "HexagonMCExpr", "::", "s23_2_reloc", "(", ")" ]

[ "<STR_LIT>" ]

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

[ "}" ]

[ "def", "imm32_0_15", ":", "Operand", "<", "i32", ">", ",", "ImmLeaf", "<", "i32", ",", "[", "{", "return", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ";", "}", "]", ">", "{", "let", "ParserMatchClass", "=", "Imm0_15Operand", ";" ]

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

[ "else", "{", "auto", "*", "CalleeTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Callee", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ";", "CalleeFTy", "=", "dyn_cast", "<", "FunctionType", ">", "(", "CalleeTy", ")", ";", "}", "std", "::", "string", "Sig", "=", "getSignature", "(", "CalleeFTy", ")", ";", "if", "(", "InvokeWrappers", ".", "find", "(", "Sig", ")", "!=", "InvokeWrappers", ".", "end", "(", ")", ")", "return", "InvokeWrappers", "[", "Sig", "]", ";", "ArgTys", ".", "push_back", "(", "PointerType", "::", "getUnqual", "(", "CalleeFTy", ")", ")", ";", "ArgTys", ".", "append", "(", "CalleeFTy", "->", "param_begin", "(", ")", ",", "CalleeFTy", "->", "param_end", "(", ")", ")", ";", "FunctionType", "*", "FTy", "=", "FunctionType", "::", "get", "(", "CalleeFTy", "->", "getReturnType", "(", ")", ",", "ArgTys", ",", "CalleeFTy", "->", "isVarArg", "(" ]

[ ")", "_", "_", "A", ",", "(", "_", "_", "v8sf", ")", "_", "_", "B", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m256", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_unpackhi_ps", "(", "_", "_", "m256", "_", "_", "A", ",", "_", "_", "m256", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m256", ")", "_", "_", "builtin_ia32_unpckhps256", "(", "(", "_", "_", "v8sf" ]

[ "Nx", "->", "Flags", "|=", "GepNode", "::", "Internal", "|", "InBounds", ";" ]

[ "N", "->", "Flags", "|=", "GepNode", "::", "Pointer", ";", "N", "->", "Idx", "=", "*", "GepI", "->", "idx_begin", "(", ")", ";", "UseSet", "Us", ";", "for", "(", "Value", "::", "user_iterator", "UI", "=", "GepI", "->", "user_begin", "(", ")", ",", "UE", "=", "GepI", "->", "user_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "isa", "<", "GetElementPtrInst", ">", "(", "*", "UI", ")", ")", "{", "GetElementPtrInst", "*", "UserG", "=", "cast", "<", "GetElementPtrInst", ">", "(", "*", "UI", ")", ";", "if", "(", "isHandledGepForm", "(", "UserG", ")", ")", "continue", ";", "}", "Us", ".", "insert", "(", "&", "UI", ".", "getUse", "(", ")", ")", ";", "}", "Nodes", ".", "push_back", "(", "N", ")", ";", "NodeOrder", ".", "insert", "(", "N", ")", ";", "GepNode", "*", "PN", "=", "N", ";", "Type", "*", "PtrTy", "=", "GepI", "->", "getSourceElementType", "(", ")", ";", "for", "(", "Use", "&", "U", ":", "llvm", "::", "drop_begin", "(", "GepI", "->", "indices", "(", ")", ")", ")", "{", "Value", "*", "Op", "=", "U", ";", "GepNode", "*", "Nx", "=", "new", "(", "*", "Mem", ")", "GepNode", ";", "Nx", "->", "Parent", "=", "PN", ";" ]

[ "<FIXS>", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<FIXE>" ]

[ "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "PSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGS>", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>" ]

[ "else", "return", "(", "size", "+", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";" ]

[ "static", "unsigned", "long", "rs6000_arg_size", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "long", "size", ";", "if", "(", "mode", "!=", "BLKmode", ")", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "else", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "TARGET_32BIT", ")", "return", "(", "size", "+", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";" ]

[ "<FIXS>", "}", "else", "if", "(", "parseExpr", "(", "ImmVal", ",", "<STR_LIT>", "a sendmsg macro", "<STR_LIT>", ")", ")", "{", "<FIXE>" ]

[ "}", "else", "{", "return", "MatchOperand_ParseFail", ";", "}", "<BUGS>", "}", "else", "if", "(", "parseExpr", "(", "ImmVal", ")", ")", "{", "<BUGE>", "if", "(", "ImmVal", "<NUM_LIT>", "||", "!", "isUInt", "<NUM_LIT>", ">", "(", "ImmVal", ")", ")", "{", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid immediate: only 16-bit values are legal", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";" ]

[ "SETLE", ":" ]

[ "static", "void", "FPCCToARMCC", "(", "ISD", "::", "CondCode", "CC", ",", "<STR_LIT>", "::", "<STR_LIT>", "&", "CondCode", ",", "<STR_LIT>", "::", "<STR_LIT>", "&", "CondCode2", ")", "{", "CondCode2", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown FP condition!", "<STR_LIT>", ")", ";", "case", "ISD", "::", "SETEQ", ":", "case", "ISD", "::", "SETOEQ", ":", "CondCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETGT", ":", "case", "ISD", "::", "SETOGT", ":", "CondCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETGE", ":", "case", "ISD", "::", "SETOGE", ":", "CondCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETOLT", ":", "CondCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETOLE", ":", "CondCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETONE", ":", "CondCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CondCode2", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETO", ":", "CondCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETUO", ":", "CondCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETUEQ", ":", "CondCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CondCode2", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETUGT", ":", "CondCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETUGE", ":", "CondCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETLT", ":", "case", "ISD", "::", "SETULT", ":", "CondCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::" ]

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

[ "int", "Ops", "[", "<NUM_LIT>", "]", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "<NUM_LIT>", ";", "++", "i", ")", "Ops", "[", "i", "]", "=", "i", "+", "Amt", ";", "SDValue", "T", "=", "DAG", ".", "getVectorShuffle", "(", "MVT", "::", "v16i8", ",", "dl", ",", "LHS", ",", "RHS", ",", "Ops", ")", ";" ]

[ ";" ]

[ "def", "X2AsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>" ]

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

[ "else", "{", "int", "offset", "=", "frame_pointer_needed", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "int", "avr_pc_size", "=", "AVR_HAVE_EIJMP_EICALL", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "offset", "+=", "avr_regs_to_save", "(", "NULL", ")", ";", "return", "(", "get_frame_size", "(", ")", "+", "avr_outgoing_args_size", "(", ")", "+", "avr_pc_size", "+", "<NUM_LIT>", "+" ]

[ "<FIXS>", "&", "znver3_cost", ",", "&", "znver4_cost", "<FIXE>" ]

[ "&", "btver2_cost", ",", "&", "znver1_cost", ",", "&", "znver2_cost", ",", "<BUGS>", "&", "znver3_cost", "<BUGE>", "}", ";" ]

[ ")", ")", ",", "(", "LDURQi", "GPR64sp", ":", "$", "Rn", ",", "simm9", ":", "$", "offset", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v16i8", "(", "load", "(", "am_unscaled128", "GPR64sp", ":", "$", "Rn", ",", "simm9", ":", "$", "offset", ")" ]

[ "<STR_LIT>", ")" ]

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

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

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

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

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

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

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

[ "static", "int", "function_arg_slotno", "(", "const", "struct", "sparc_args", "*", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ",", "bool", "incoming", ",", "int", "*", "pregno", ",", "int", "*", "ppadding", ")", "{", "int", "regbase", "=", "(", "incoming", "?", "SPARC_INCOMING_INT_ARG_FIRST", ":", "SPARC_OUTGOING_INT_ARG_FIRST", ")", ";", "int", "slotno", "=", "cum", "->", "words", ";", "enum", "mode_class", "mclass", ";", "int", "regno", ";", "*", "ppadding", "=", "<NUM_LIT>", ";", "if", "(", "type", "&&", "TREE_ADDRESSABLE", "(", "type", ")", ")", "return", "-", "<NUM_LIT>", ";", "if", "(", "TARGET_ARCH32", "&&", "mode", "==", "BLKmode", "&&", "type", "&&", "TYPE_ALIGN", "(", "type", ")", "%", "PARM_BOUNDARY", "!=", "<NUM_LIT>", ")", "return", "-", "<NUM_LIT>", ";", "if", "(", "TARGET_ARCH64", "&&", "(", "type", "?", "TYPE_ALIGN", "(", "type", ")", ":", "GET_MODE_ALIGNMENT", "(", "mode", ")", ")", ">=", "<NUM_LIT>", "&&", "(", "slotno", "&", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "slotno", "++", ",", "*", "ppadding", "=", "<NUM_LIT>", ";", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "REAL_TYPE", ")", "{", "gcc_assert", "(", "mode", "==", "BLKmode", ")", ";", "}", "else", "{", "gcc_assert", "(", "mode", "!=", "BLKmode", ")", ";", "mclass", "=", "MODE_FLOAT", ";", "}", "}", "switch", "(", "mclass", ")", "{", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "case", "MODE_VECTOR_INT", ":", "if", "(", "TARGET_ARCH64", "&&", "TARGET_FPU", "&&", "named", ")", "{", "if", "(", "slotno", ">=", "SPARC_FP_ARG_MAX", ")", "return", "-", "<NUM_LIT>", ";", "regno", "=", "SPARC_FP_ARG_FIRST", "+", "slotno", "*", "<NUM_LIT>", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "<NUM_LIT>", ")", "regno", "++", ";", "break", ";", "}", "case", "MODE_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "slotno", ">=", "SPARC_INT_ARG_MAX", ")", "return", "-", "<NUM_LIT>", ";", "regno", "=", "regbase", "+", "slotno", ";", "break", ";", "case", "MODE_RANDOM", ":", "if", "(", "mode", "==", "VOIDmode", ")", "return", "-", "<NUM_LIT>", ";", "gcc_assert", "(", "mode", "==", "BLKmode", ")", ";", "if", "(", "TARGET_ARCH32", "||", "!", "type", "||", "(", "TREE_CODE", "(", "type", ")", "!=", "RECORD_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "VECTOR_TYPE", ")", ")", "{", "if", "(", "slotno", ">=", "SPARC_INT_ARG_MAX", ")", "return", "-", "<NUM_LIT>", ";", "regno", "=", "regbase", "+", "slotno", ";", "}", "else", "{", "if", "(", "slotno", ">=", "SPARC_FP_ARG_MAX", ")", "return", "-", "<NUM_LIT>", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "{", "classify_data_t", "data", "=", "{", "false", ",", "false", ",", "false", "}", ";", "traverse_record_type", "<", "classify_data_t", ",", "classify_registers", ">", "(", "type", ",", "named", ",", "&", "data", ")", ";", "if", "(", "data", ".", "fp_regs", "&&", "!", "data", ".", "fp_regs_in_first_word", "&&", "slotno", ">=", "SPARC_FP_ARG_MAX", "-", "<NUM_LIT>", ")", "return", "-", "<NUM_LIT>", ";", "if", "(", "!", "data", ".", "fp_regs", "&&", "data", ".", "int_regs", "&&", "slotno", ">=", "SPARC_INT_ARG_MAX", ")", "return", "-", "<NUM_LIT>", ";", "}", "return", "slotno", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "*", "pregno", "=", "regno", ";", "return", "slotno", ";", "}" ]

[ "Compute", "the", "slot", "number", "to", "pass", "an", "argument", "in", ".", "Return", "the", "slot", "number", "or", "-1", "if", "passing", "on", "the", "stack", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "INCOMING_P", "is", "zero", "for", "FUNCTION_ARG", ",", "nonzero", "for", "FUNCTION_INCOMING_ARG", ".", "*", "PREGNO", "records", "the", "register", "number", "to", "use", "if", "scalar", "type", ".", "*", "PPADDING", "records", "the", "amount", "of", "padding", "needed", "in", "words", "." ]

[ "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "def", "VLD4LNd16", ":", "VLD4LN", "<", "<NUM_LIT>", ",", "{", "?", ",", "?", ",", "<NUM_LIT>", ",", "?", "}", ",", "<STR_LIT>", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "lane" ]

[ "case", "in_rdata", ":", "\\", "case", "in_const", ":", "return", "<NUM_LIT>", ";", "\\", "case", "in_named", ":", "return", "get_named_section_flags", "(", "in_named_name", ")", ";", "\\", "}", "\\", "abort", "(", ")", ";", "\\", "}" ]

[ "unsigned", "int", "\\", "current_section_flags", "(", ")", "\\", "{", "\\", "switch", "(", "in_section", ")", "\\", "{", "\\", "case", "no_section", ":", "return", "<NUM_LIT>", ";", "\\", "case", "in_text", ":", "return", "SECTION_CODE", ";", "\\", "case", "in_data", ":", "return", "SECTION_WRITE", ";", "\\", "case", "in_sdata", ":", "return", "SECTION_WRITE", "|", "SECTION_SMALL", ";", "\\", "case", "in_bss", ":", "return", "SECTION_WRITE", "|", "SECTION_BSS", ";", "\\" ]

[ ")", ";" ]

[ "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "!", "DisableIfConversion", "&&", "!", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "PM", ".", "add", "(", "createIfConverterPass", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "isThumb2", "(", ")", ")", "{", "PM", ".", "add", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "PM", ".", "add", "(", "createThumb2SizeReductionPass", "(", ")" ]

[ "<STR_LIT>", ")" ]

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

[ "<NUM_LIT>", "&&", "IdxVal", "!=", "NumSubElts", ")", ")", "return", "SDValue", "(", ")", ";" ]

[ "if", "(", "!", "VecVT", ".", "isFixedLengthVector", "(", ")", "||", "!", "DCI", ".", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "isTypeLegal", "(", "VecVT", ")", "||", "!", "DCI", ".", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "isTypeLegal", "(", "SubVT", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "IdxVal", "==", "<NUM_LIT>", "&&", "Vec", ".", "isUndef", "(", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "NumSubElts", "=", "SubVT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "(", "SubVT", ".", "getSizeInBits", "(", ")", "*", "<NUM_LIT>", ")", "!=", "VecVT", ".", "getSizeInBits", "(", ")", "||", "(", "IdxVal", "!=" ]

[ ")" ]

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

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

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_add_epi16", "(", "_", "_", "m512i", "_", "_", "A", ",", "_", "_", "m512i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m512i", ")", "(", "(", "_", "_", "v32hu", ")", "_", "_", "A", "+", "(" ]

[ ":", "V16QI" ]

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

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

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

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

[ "class", "BaseFlagManipulation", "<", "bit", "sf", ",", "bit", "sz", ",", "dag", "iops", ",", "string", "asm", ",", "string", "ops", ">", ":", "I", "<", "(", "outs", ")", ",", "iops", ",", "asm", ",", "ops", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteI", ",", "ReadI", ",", "ReadI", "]", ">", "{", "let", "Uses", "=", "[", "NZCV", "]", ";", "let", "Defs", "=", "[", "NZCV", "]", ";" ]

[ "Disp", ",", "SDValue", "&", "Index", ")", "const", "{" ]

[ "bool", "selectBDXAddr20Only", "(", "SDValue", "Addr", ",", "SDValue", "&", "Base", ",", "SDValue", "&" ]