Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "PCRelExpr", "=", "MCBinaryExpr", "::", "createAdd", "(", "PCRelExpr", ",", "MCConstantExpr", "::", "create", "(", "ACPV", "->", "getPCAdjustment", "(", ")", ",", "OutContext", ")", ",", "OutContext", ")", ";" ]

[ "ARMConstantPoolValue", "*", "ACPV", "=", "static_cast", "<", "ARMConstantPoolValue", "*", ">", "(", "MCPV", ")", ";", "if", "(", "ACPV", "->", "isPromotedGlobal", "(", ")", ")", "{", "auto", "*", "ACPC", "=", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", ";", "for", "(", "const", "auto", "*", "GV", ":", "ACPC", "->", "promotedGlobals", "(", ")", ")", "{", "if", "(", "!", "EmittedPromotedGlobalLabels", ".", "count", "(", "GV", ")", ")", "{", "MCSymbol", "*", "GVSym", "=", "getSymbol", "(", "GV", ")", ";", "OutStreamer", "->", "emitLabel", "(", "GVSym", ")", ";", "EmittedPromotedGlobalLabels", ".", "insert", "(", "GV", ")", ";", "}", "}", "return", "emitGlobalConstant", "(", "DL", ",", "ACPC", "->", "getPromotedGlobalInit", "(", ")", ",", "<NUM_LIT>", ")", ";", "}", "MCSymbol", "*", "MCSym", ";", "if", "(", "ACPV", "->", "isLSDA", "(", ")", ")", "{", "MCSym", "=", "getMBBExceptionSym", "(", "MF", "->", "front", "(", ")", ")", ";", "}", "else", "if", "(", "ACPV", "->", "isBlockAddress", "(", ")", ")", "{", "const", "BlockAddress", "*", "BA", "=", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", "->", "getBlockAddress", "(", ")", ";", "MCSym", "=", "GetBlockAddressSymbol", "(", "BA", ")", ";", "}", "else", "if", "(", "ACPV", "->", "isGlobalValue", "(", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", "->", "getGV", "(", ")", ";", "unsigned", "char", "TF", "=", "Subtarget", "->", "isTargetMachO", "(", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<NUM_LIT>", ";", "MCSym", "=", "GetARMGVSymbol", "(", "GV", ",", "TF", ")", ";", "}", "else", "if", "(", "ACPV", "->", "isMachineBasicBlock", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "cast", "<", "ARMConstantPoolMBB", ">", "(", "ACPV", ")", "->", "getMBB", "(", ")", ";", "MCSym", "=", "MBB", "->", "getSymbol", "(", ")", ";", "}", "else", "{", "assert", "(", "ACPV", "->", "isExtSymbol", "(", ")", "&&", "<STR_LIT>", "unrecognized constant pool value", "<STR_LIT>", ")", ";", "auto", "Sym", "=", "cast", "<", "ARMConstantPoolSymbol", ">", "(", "ACPV", ")", "->", "getSymbol", "(", ")", ";", "MCSym", "=", "GetExternalSymbolSymbol", "(", "Sym", ")", ";", "}", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "MCSym", ",", "getModifierVariantKind", "(", "ACPV", "->", "getModifier", "(", ")", ")", ",", "OutContext", ")", ";", "if", "(", "ACPV", "->", "getPCAdjustment", "(", ")", ")", "{", "MCSymbol", "*", "PCLabel", "=", "getPICLabel", "(", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ",", "getFunctionNumber", "(", ")", ",", "ACPV", "->", "getLabelId", "(", ")", ",", "OutContext", ")", ";", "const", "MCExpr", "*", "PCRelExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "PCLabel", ",", "OutContext", ")", ";" ]

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

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

[ "}" ]

[ "bool", "PPCFastISel", "::", "SelectLoad", "(", "const", "Instruction", "*", "I", ")", "{", "if", "(", "cast", "<", "LoadInst", ">", "(", "I", ")", "->", "isAtomic", "(", ")", ")", "return", "false", ";", "MVT", "VT", ";", "if", "(", "!", "isLoadTypeLegal", "(", "I", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "false", ";", "Address", "Addr", ";", "if", "(", "!", "PPCComputeAddress", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Addr", ")", ")", "return", "false", ";", "unsigned", "AssignedReg", "=", "FuncInfo", ".", "ValueMap", "[", "I", "]", ";", "const", "TargetRegisterClass", "*", "RC", "=", "AssignedReg", "?", "MRI", ".", "getRegClass", "(", "AssignedReg", ")", ":", "<NUM_LIT>", ";", "unsigned", "ResultReg", "=", "<NUM_LIT>", ";", "if", "(", "!", "PPCEmitLoad", "(", "VT", ",", "ResultReg", ",", "Addr", ",", "RC", ")", ")", "return", "false", ";", "UpdateValueMap", "(", "I", ",", "ResultReg", ")", ";", "return", "true", ";" ]

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

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

[ "return", "AMDGPU", "::", "SI_SPILL_V128_SAVE", ";" ]

[ "static", "unsigned", "getVGPRSpillSaveOpcode", "(", "unsigned", "Size", ")", "{", "switch", "(", "Size", ")", "{", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "SI_SPILL_V32_SAVE", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "SI_SPILL_V64_SAVE", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "SI_SPILL_V96_SAVE", ";", "case", "<NUM_LIT>", ":" ]

[ "<NUM_LIT>", ")", ")", ")", ",", "(", "VSHLLi16", "DPR", ":", "$", "Rn", ",", "<NUM_LIT>", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v4i32", "(", "NEONvshl", "(", "zext", "(", "v4i16", "DPR", ":", "$", "Rn", ")", ")", ",", "(", "i32" ]

[ "(", "use", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "(", "mem", ":", "BLK", "(", "reg", ":", "SI", "R5_REG", ")", ")", ")", "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "}" ]

[ "def", "sys_cr_op", ":", "Operand", "<", "i32", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "SysCRAsmOperand", ";" ]

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

[ "(", "parallel", "[", "(", "set", "(", "reg", ":", "HI", "<NUM_LIT>", ")", "(", "mult", ":", "HI", "(", "reg", ":", "HI", "<NUM_LIT>", ")", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "QI", "<NUM_LIT>", ")", ")", "]", ")", "<BUGS>", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "HI", "<NUM_LIT>", ")", "(", "mult", ":", "HI", "(", "reg", ":", "HI", "<NUM_LIT>", ")", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", ")" ]

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

[ "extern", "_", "_", "inline", "_", "_", "m512h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_rsqrt_ph", "(", "_", "_", "m512h", "_", "_", "A", ",", "_", "_", "mmask32", "_", "_", "B", ",", "_", "_", "m512h", "_", "_", "C", ")", "{", "return", "_", "_", "builtin_ia32_rsqrtph512_mask", "(", "_", "_", "C", ",", "_", "_", "A", ",", "_" ]

[ "unsigned", "ARMInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "STR", ":", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<NUM_LIT>", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "FSTD", ":", "case", "ARM", "::", "FSTS", ":", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "tSpill", ":", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

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

[ "addPass", "(", "createStructurizeCFGPass", "(", ")", ")", ";", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "else", "{", "addPass", "(", "createR600TextureIntrinsicsReplacer", "(", ")", ")", ";", "}" ]

[ ";" ]

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

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

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

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

[ "default", ":", "return", ";", "case", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ":", "case", "AMDGPUAS", "::", "LOCAL_ADDRESS", ":", "break", ";", "}", "AtomicRMWInst", "::", "BinOp", "Op", "=", "I", ".", "getOperation", "(", ")", ";", "switch", "(", "Op", ")", "{", "default", ":", "return", ";", "case", "AtomicRMWInst", "::", "Add", ":", "case", "AtomicRMWInst", "::", "Sub", ":", "case", "AtomicRMWInst", "::", "And", ":", "case", "AtomicRMWInst", "::", "Or", ":", "case", "AtomicRMWInst", "::", "Xor", ":", "case", "AtomicRMWInst", "::", "Max", ":", "case", "AtomicRMWInst", "::", "Min", ":", "case", "AtomicRMWInst", "::", "UMax", ":", "case", "AtomicRMWInst", "::", "UMin", ":", "break", ";", "}", "const", "unsigned", "PtrIdx", "=", "<NUM_LIT>", ";", "const", "unsigned", "ValIdx", "=", "<NUM_LIT>", ";", "if", "(", "DA", "->", "isDivergent", "(", "I", ".", "getOperand", "(", "PtrIdx", ")", ")", ")", "{", "return", ";", "}", "const", "bool", "ValDivergent", "=", "DA", "->", "isDivergent", "(", "I", ".", "getOperand", "(" ]

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

[ "unsigned", "Result", "=", "<NUM_LIT>", ";", "unsigned", "Type", "=", "HexagonMCInstrInfo", "::", "getType", "(", "MCII", ",", "ID", ")", ";", "if", "(", "Type", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "unsigned", "subInst0Opcode", "=", "ID", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getInst", "(", ")", "->", "getOpcode", "(", ")", ";", "unsigned", "subInst1Opcode", "=", "ID", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getInst", "(", ")", "->", "getOpcode", "(", ")", ";", "Result", "+=", "!", "isDuplexAGroup", "(", "subInst0Opcode", ")", ";", "Result", "+=", "!", "isDuplexAGroup" ]

[ "}" ]

[ "if", "(", "mangledName", ".", "startswith", "(", "StringRef", "(", "str", ",", "N", "-", "<NUM_LIT>", ")", ")", ")", "{", "drop_front", "(", "mangledName", ",", "N", "-", "<NUM_LIT>", ")", ";", "return", "true", ";" ]

[ "ARM", "::", "MOVCCi", ";" ]

[ "const", "CmpInst", "*", "CI", "=", "cast", "<", "CmpInst", ">", "(", "I", ")", ";", "<STR_LIT>", "::", "<STR_LIT>", "ARMPred", "=", "getComparePred", "(", "CI", "->", "getPredicate", "(", ")", ")", ";", "if", "(", "ARMPred", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "false", ";", "if", "(", "!", "ARMEmitCmp", "(", "CI", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "CI", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "CI", "->", "isUnsigned", "(", ")", ")", ")", "return", "false", ";", "unsigned", "MovCCOpc", "=", "isThumb2", "?", "ARM", "::", "t2MOVCCi", ":" ]

[ "<FIXS>", "defm", "CPY_ZPmR", ":", "sve_int_perm_cpy_r", "<STR_LIT>", ",", "AArch64dup_mt", ">", ";", "defm", "CPY_ZPmV", ":", "sve_int_perm_cpy_v", "<STR_LIT>", ",", "AArch64dup_mt", ">", ";", "<FIXE>" ]

[ "defm", "DUP_ZZI", ":", "sve_int_perm_dup_i", "<STR_LIT>", ">", ";", "<BUGS>", "defm", "CPY_ZPmR", ":", "sve_int_perm_cpy_r", "<STR_LIT>", ",", "AArch64dup_pred", ">", ";", "defm", "CPY_ZPmV", ":", "sve_int_perm_cpy_v", "<STR_LIT>", ",", "AArch64dup_pred", ">", ";", "<BUGE>", "def", ":", "Pat", "(", "nxv8f16", "(", "AArch64dup", "(", "f16", "FPR16", ":", "$", "src", ")", ")", ")", "," ]

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

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "DImode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "DImode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>" ]

[ "<FIXS>", "if", "(", "!", "searchRange", "(", "MBB", ",", "std", "::", "next", "(", "Slot", ")", ",", "MBB", ".", "end", "(", ")", ",", "RegDU", ",", "NM", ",", "Filler", ",", "Slot", ")", ")", "<FIXE>" ]

[ "RegDU", ".", "setCallerSaved", "(", "*", "Slot", ")", ";", "<BUGS>", "if", "(", "!", "searchRange", "(", "MBB", ",", "std", "::", "next", "(", "Slot", ")", ",", "MBB", ".", "end", "(", ")", ",", "RegDU", ",", "NM", ",", "Filler", ")", ")", "<BUGE>", "return", "false", ";", "MBB", ".", "splice", "(", "std", "::", "next", "(", "Slot", ")", ",", "&", "MBB", ",", "Filler", ")", ";" ]

[ "gcc_assert", "(", "offset", "+", "GET_MODE_SIZE", "(", "GET_MODE", "(", "ref", ")", ")", "<=", "GET_MODE_SIZE", "(", "SImode", ")", ")", ";" ]

[ "}", "else", "base", "=", "XEXP", "(", "ref", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "disp", "=", "INTVAL", "(", "XEXP", "(", "base", ",", "<NUM_LIT>", ")", ")", ",", "base", "=", "XEXP", "(", "base", ",", "<NUM_LIT>", ")", ";", "else", "disp", "=", "<NUM_LIT>", ";", "if", "(", "MEM_ALIGN", "(", "ref", ")", ">=", "<NUM_LIT>", ")", "offset", "=", "<NUM_LIT>", ";", "else", "offset", "=", "disp", "&", "<NUM_LIT>", ";" ]

[ "static", "rtx", "arm_dwarf_register_span", "(", "rtx", "rtl", ")", "{", "machine_mode", "mode", ";", "unsigned", "regno", ";", "rtx", "parts", "[", "<NUM_LIT>", "]", ";", "int", "nregs", ";", "int", "i", ";", "regno", "=", "REGNO", "(", "rtl", ")", ";", "if", "(", "!", "IS_VFP_REGNUM", "(", "regno", ")", ")", "return", "NULL_RTX", ";", "mode", "=", "GET_MODE", "(", "rtl", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "<NUM_LIT>", ")", "return", "NULL_RTX", ";", "if", "(", "VFP_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ")", "{", "nregs", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nregs", ";", "i", "+=", "<NUM_LIT>", ")", "if", "(", "TARGET_BIG_END", ")", "{", "parts", "[", "i", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", "+", "<NUM_LIT>", ")", ";", "parts", "[", "i", "+", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", ")", ";", "}", "else", "{", "parts", "[", "i", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", ")", ";", "parts", "[", "i", "+", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "i", "+", "<NUM_LIT>", ")", ";", "}", "}", "else", "{", "nregs", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nregs", ";", "i", "++", ")", "parts", "[", "i", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", "+", "i", ")", ";", "}", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "nregs", ",", "parts", ")", ")", ";", "}" ]

[ "Dwarf", "models", "VFPv3", "registers", "as", "32", "64-bit", "registers", ".", "GCC", "models", "tham", "as", "64", "32-bit", "registers", ",", "so", "we", "need", "to", "describe", "this", "to", "the", "DWARF", "generation", "code", ".", "Other", "registers", "can", "use", "the", "default", "." ]

[ "static", "void", "tilegx_option_override", "(", "void", ")", "{", "if", "(", "OPTION_SET_P", "(", "tilegx_cmodel", ")", ")", "{", "switch", "(", "tilegx_cmodel", ")", "{", "case", "CM_SMALL", ":", "case", "CM_SMALL_PIC", ":", "if", "(", "flag_pic", ")", "tilegx_cmodel", "=", "CM_SMALL_PIC", ";", "break", ";", "case", "CM_LARGE", ":", "case", "CM_LARGE_PIC", ":", "if", "(", "flag_pic", ")", "tilegx_cmodel", "=", "CM_LARGE_PIC", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "tilegx_cmodel", "=", "flag_pic", "?", "CM_SMALL_PIC", ":", "CM_SMALL", ";", "if", "(", "flag_modulo_sched", ")", "flag_resched_modulo_sched", "=", "<NUM_LIT>", ";", "}" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ ")" ]

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

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

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

[ ",", "StartLoc", ",", "EndLoc", ")", ";" ]

[ "X86Operand", "*", "Res", "=", "new", "X86Operand", "(", "Register" ]

[ "case", "PROCESSOR_P6600", ":" ]

[ "case", "PROCESSOR_I6400", ":", "case", "PROCESSOR_GS264E", ":", "return", "<NUM_LIT>", ";", "case", "PROCESSOR_SB1", ":", "case", "PROCESSOR_SB1A", ":", "return", "<NUM_LIT>", ";", "case", "PROCESSOR_LOONGSON_2E", ":", "case", "PROCESSOR_LOONGSON_2F", ":", "case", "PROCESSOR_GS464", ":", "case", "PROCESSOR_GS464E", ":", "case", "PROCESSOR_P5600", ":" ]

[ ",", "Inst", "}", ")", ";" ]

[ "if", "(", "I", "!=", "Ranges", ".", "end", "(", ")", "&&", "End", ">", "I", "->", "Start", ")", "{", "return", "false", ";", "}", "Ranges", ".", "insert", "(", "I", ",", "{", "Start", ",", "End" ]

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

[ "static", "bool", "mips_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "==", "GP_RETURN", "||", "regno", "==", "FP_RETURN", "||", "(", "FP_RETURN", "!=", "GP_RETURN", "&&", "regno", "==", "FP_RETURN", "+", "<NUM_LIT>", ")", ")", "return", "true", ";", "if", "(", "(", "mips_abi", "==", "ABI_32", "&&", "TARGET_FLOAT32", ")", "&&", "FP_RETURN", "!=", "GP_RETURN", "&&", "(", "regno", "==", "FP_RETURN", "+", "<NUM_LIT>", "||", "regno", "==", "FP_RETURN", "+", "<NUM_LIT>", ")", ")", "return", "true", ";" ]

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

[ "(", "fma", ":", "FMA_F", "(", "match_operand", ":", "FMA_F", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "FMA_F", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg", ":", "FMA_F", "(", "match_operand", ":", "FMA_F", "<NUM_LIT>" ]

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

[ "return", "!", "mDebuggerABIVersion", "." ]

[ "<STR_LIT>", "\\t.globl\\t__do_global_dtors\\n", "<STR_LIT>", ")", ";" ]

[ "fprintf", "(", "asm_out_file", "," ]

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

[ "[", "(", "unspec", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DIDFVM", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_REAL_LOAD", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "AMDGPUOperand", "::", "ImmTyOffset", ")", ";" ]

[ "return", "AMDGPUOperand", "::", "CreateImm", "(", "this", ",", "<NUM_LIT>", ",", "SMLoc", "(", ")", "," ]

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

[ "(", "define_expand", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "mem", ":", "BLK", "(", "match_operand", ":", "BLK", "<NUM_LIT>", ")", ")", "(", "mem", ":", "BLK", "(", "match_operand", ":", "BLK", "<NUM_LIT>" ]

[ "unsigned", "Cpu0RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ":", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}" ]

[ "Debug", "information", "queries", "." ]

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

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

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

[ "typedef", "AArch64MachineCombinerPattern", "MCP", ";", "switch", "(", "Root", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Found", "=", "Match", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "MCP", "::", "FMULv2i32_indexed_OP1", ")", ";", "Found", "|=", "Match", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "MCP", "::", "FMULv2i32_indexed_OP2", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Found", "=", "Match", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "MCP", "::", "FMULv2i64_indexed_OP1", ")", ";", "Found", "|=", "Match", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "MCP", "::", "FMULv2i64_indexed_OP2", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Found", "=", "Match", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "MCP", "::", "FMULv4i16_indexed_OP1", ")", ";", "Found", "|=", "Match", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "MCP", "::", "FMULv4i16_indexed_OP2", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Found", "=", "Match", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "MCP", "::", "FMULv4i32_indexed_OP1", ")", ";", "Found", "|=", "Match", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "MCP", "::", "FMULv4i32_indexed_OP2", ")", ";", "break", ";", "case", "<STR_LIT>" ]

[ "}" ]

[ "def", "A2_vminuh", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rtt32", ",", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_ea23e4", "{", "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>", ";" ]

[ ")", ";" ]

[ "if", "(", "!", "MBB", "->", "empty", "(", ")", ")", "MBB", "->", "insert", "(", "MBB", "->", "begin", "(", ")", ",", "MI", ")", ";", "else", "MBB", "->", "push_back", "(", "MI", ")", ";", "SHOWNEWINSTR", "(", "MI" ]

[ "<FIXS>", "error", "(", "<STR_LIT>", "%J'%D' causes a section type conflict", "<STR_LIT>", ",", "decl", ",", "decl", ")", ";", "<FIXE>" ]

[ "else", "{", "if", "(", "decl", "&&", "*", "*", "slot", "!=", "flags", ")", "<BUGS>", "error", "(", "<STR_LIT>", "%H'%D' causes a section type conflict", "<STR_LIT>", ",", "&", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "decl", ")", ";", "<BUGE>", "}", "return", "flags", ";" ]

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

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

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

[ "(", "zero_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr" ]

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

[ "(", "xor", "<STR_LIT>", ")", "(", "and", "<STR_LIT>", ")", "(", "plus", "<STR_LIT>", ")", "(", "minus", "<STR_LIT>", ")", "(", "mult", "<STR_LIT>", ")", "(", "div", "<STR_LIT>", ")" ]

[ "::", "FeatureFast15ByteNOP", "]", ")", "MaxNopLength", "=", "<NUM_LIT>", ";" ]

[ "static", "unsigned", "MaxLongNopLength", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "uint64_t", "MaxNopLength", "=", "<NUM_LIT>", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "ProcIntelSLM", "]", ")", "MaxNopLength", "=", "<NUM_LIT>", ";", "else", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86" ]

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

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

[ "MachineInstrBuilder", "MIBSXTW", "=", "BuildMI", "(", "*", "MBB", ",", "InsertionPoint", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DstRegX", ")", ".", "addReg", "(", "DstRegX", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "}", "}", "}", "else", "{", "for", "(", "auto", "&", "MOP", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MOP", ".", "isReg", "(", ")", "&&", "!", "MOP", ".", "isDebug", "(", ")", "&&", "MOP", ".", "getReg", "(", ")", "&&", "TRI", "->", "regsOverlap", "(", "MOP", ".", "getReg", "(", ")", ",", "RegToRename", ")", ")", "{", "assert", "(", "(", "MOP", ".", "isImplicit", "(", ")", "||", "(", "MOP", ".", "isRenamable", "(", ")", "&&", "!", "MOP", ".", "isEarlyClobber", "(", ")", ")", ")", "&&", "<STR_LIT>", "Need renamable operands", "<STR_LIT>", ")", ";", "MOP", ".", "setReg", "(", "GetMatchingSubReg", "(", "MOP", ".", "getReg", "(", ")", ")", ")", ";", "}", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Renamed ", "<STR_LIT>", "<<", "MI", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "return", "true", ";", "}", ";", "forAllMIsUntilDef", "(", "*", "I", ",", "RegToRename", ",", "TRI", ",", "LdStLimit", ",", "UpdateMIs", ")", ";", "for", "(", "auto", "&", "MI", ":", "iterator_range", "<", "MachineInstrBundleIterator", "<", "llvm", "::", "MachineInstr", ">>", "(", "std", "::", "next", "(", "I", ")", ",", "std", "::", "next", "(", "Paired", ")", ")", ")", "assert", "(", "all_of", "(", "MI", ".", "operands", "(", ")", ",", "[", "this", ",", "&", "RenameReg", "]", "(", "const", "MachineOperand", "&", "MOP", ")", "{", "return", "!", "MOP", ".", "isReg", "(", ")", "||", "MOP", ".", "isDebug", "(", ")", "||", "!", "MOP", ".", "getReg", "(", ")", "||", "!", "TRI", "->", "regsOverlap", "(", "MOP", ".", "getReg", "(", ")", ",", "*", "RenameReg", ")", ";", "}", ")", "&&", "<STR_LIT>", "Rename register used between paired instruction, trashing the ", "<STR_LIT>", "<STR_LIT>", "content", "<STR_LIT>", ")", ";", "}", "MachineBasicBlock", "::", "iterator", "InsertionPoint", "=", "MergeForward", "?", "Paired", ":", "I", ";", "const", "MachineOperand", "&", "BaseRegOp", "=", "MergeForward", "?", "getLdStBaseOp", "(", "*", "Paired", ")", ":", "getLdStBaseOp", "(", "*", "I", ")", ";", "int", "Offset", "=", "getLdStOffsetOp", "(", "*", "I", ")", ".", "getImm", "(", ")", ";", "int", "PairedOffset", "=", "getLdStOffsetOp", "(", "*", "Paired", ")", ".", "getImm", "(", ")", ";", "bool", "PairedIsUnscaled", "=", "TII", "->", "isUnscaledLdSt", "(", "Paired", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "IsUnscaled", "!=", "PairedIsUnscaled", ")", "{", "int", "MemSize", "=", "TII", "->", "getMemScale", "(", "*", "Paired", ")", ";", "if", "(", "PairedIsUnscaled", ")", "{", "assert", "(", "!", "(", "PairedOffset", "%", "TII", "->", "getMemScale", "(", "*", "Paired", ")", ")", "&&", "<STR_LIT>", "Offset should be a multiple of the stride!", "<STR_LIT>", ")", ";", "PairedOffset", "/", "=", "MemSize", ";", "}", "else", "{", "PairedOffset", "*=", "MemSize", ";", "}", "}", "MachineInstr", "*", "RtMI", ",", "*", "Rt2MI", ";", "if", "(", "Offset", "==", "PairedOffset", "+", "OffsetStride", ")", "{", "RtMI", "=", "&", "*", "Paired", ";", "Rt2MI", "=", "&", "*", "I", ";", "if", "(", "SExtIdx", "!=", "-", "<NUM_LIT>", ")", "SExtIdx", "=", "(", "SExtIdx", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ";", "}", "else", "{", "RtMI", "=", "&", "*", "I", ";", "Rt2MI", "=", "&", "*", "Paired", ";", "}", "int", "OffsetImm", "=", "getLdStOffsetOp", "(", "*", "RtMI", ")", ".", "getImm", "(", ")", ";", "if", "(", "TII", "->", "isUnscaledLdSt", "(", "RtMI", "->", "getOpcode", "(", ")", ")", ")", "{", "assert", "(", "!", "(", "OffsetImm", "%", "TII", "->", "getMemScale", "(", "*", "RtMI", ")", ")", "&&", "<STR_LIT>", "Unscaled offset cannot be scaled.", "<STR_LIT>", ")", ";", "OffsetImm", "/", "=", "TII", "->", "getMemScale", "(", "*", "RtMI", ")", ";", "}", "MachineInstrBuilder", "MIB", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "I", "->", "getParent", "(", ")", ";", "MachineOperand", "RegOp0", "=", "getLdStRegOp", "(", "*", "RtMI", ")", ";", "MachineOperand", "RegOp1", "=", "getLdStRegOp", "(", "*", "Rt2MI", ")", ";", "if", "(", "RegOp0", ".", "isUse", "(", ")", ")", "{", "if", "(", "!", "MergeForward", ")", "{", "RegOp0", ".", "setIsKill", "(", "false", ")", ";", "RegOp1", ".", "setIsKill", "(", "false", ")", ";", "}", "else", "{", "Register", "Reg", "=", "getLdStRegOp", "(", "*", "I", ")", ".", "getReg", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "make_range", "(", "std", "::", "next", "(", "I", ")", ",", "Paired", ")", ")", "MI", ".", "clearRegisterKills", "(", "Reg", ",", "TRI", ")", ";", "}", "}", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "InsertionPoint", ",", "DL", ",", "TII", "->", "get", "(", "getMatchingPairOpcode", "(", "Opc", ")", ")", ")", ".", "add", "(", "RegOp0", ")", ".", "add", "(", "RegOp1", ")", ".", "add", "(", "BaseRegOp", ")", ".", "addImm", "(", "OffsetImm", ")", ".", "cloneMergedMemRefs", "(", "{", "&", "*", "I", ",", "&", "*", "Paired", "}", ")", ".", "setMIFlags", "(", "I", "->", "mergeFlagsWith", "(", "*", "Paired", ")", ")", ";", "(", "void", ")", "MIB", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Creating pair load/store. Replacing instructions:\\n ", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "I", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " ", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "Paired", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " with instruction:\\n ", "<STR_LIT>", ")", ";", "if", "(", "SExtIdx", "!=", "-", "<NUM_LIT>", ")", "{", "MachineOperand", "&", "DstMO", "=", "MIB", "->", "getOperand", "(", "SExtIdx", ")", ";", "Register", "DstRegX", "=", "DstMO", ".", "getReg", "(", ")", ";", "Register", "DstRegW", "=", "TRI", "->", "getSubReg", "(", "DstRegX", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "DstMO", ".", "setReg", "(", "DstRegW", ")", ";", "LLVM_DEBUG", "(", "(", "(", "MachineInstr", "*", ")", "MIB", ")", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MachineInstrBuilder", "MIBKill", "=", "BuildMI", "(", "*", "MBB", ",", "InsertionPoint", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "KILL", ")", ",", "DstRegW", ")", ".", "addReg", "(", "DstRegW", ")", ".", "addReg", "(", "DstRegX", ",", "RegState", "::", "Define", ")", ";", "MIBKill", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImplicit", "(", ")", ";" ]

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

[ "if", "(", "NumElts", "%", "<NUM_LIT>", "!=", "<NUM_LIT>", ")", "return", "false", ";", "WhichResult", "=", "(", "M", "[", "<NUM_LIT>", "]", "==", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumElts", ";", "i", "+=" ]

[ "<FIXS>", "FS", "=", "<STR_LIT>", "+64bit-mode,-32bit-mode,-16bit-mode", "<STR_LIT>", ";", "<FIXE>", "<FIXS>", "FS", "=", "<STR_LIT>", "-64bit-mode,+32bit-mode,-16bit-mode", "<STR_LIT>", ";", "<FIXE>" ]

[ "Triple", "TheTriple", "(", "TT", ")", ";", "std", "::", "string", "FS", ";", "if", "(", "TheTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "<BUGS>", "FS", "=", "<STR_LIT>", "+64bit-mode", "<STR_LIT>", ";", "<BUGE>", "else", "<BUGS>", "FS", "=", "<STR_LIT>", "-64bit-mode", "<STR_LIT>", ";", "<BUGE>", "return", "FS", ";", "}" ]

[ "Operand", "Xext", "=", "xextend", ";" ]

[ "ComplexPattern", "Wpat", "=", "windex", ";", "ComplexPattern", "Xpat", "=", "xindex", ";", "Operand", "Wext", "=", "wextend", ";" ]

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

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

[ ",", "IP_REGNUM", ",", "PC_REGNUM", ")", ";" ]

[ "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "<NUM_LIT>", ")", ")", "==", "SYMBOL_REF", ")", ";", "name", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "\\torr\\t%r, %r, #1\\n", "<STR_LIT>" ]

[ "if", "(", "ATUsed", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ATMACRO", ")", ")", ";" ]

[ "unsigned", "NewReg", "=", "<NUM_LIT>", ";", "int", "NewImm", "=", "<NUM_LIT>", ";", "bool", "ATUsed", ";", "adjustMipsStackFrame", "(", "MF", ")", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "<NUM_LIT>", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", ")", "return", ";", "int", "FPOffset", "=", "MipsFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MipsFI", "->", "getRAStackOffset", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "NOREORDER", ")", ")", ";", "if", "(", "isPIC", "&&", "STI", ".", "isABI_O32", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "CPLOAD", ")", ")", ".", "addReg", "(", "RegInfo", "->", "getPICCallReg", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "NOMACRO", ")", ")", ";", "ATUsed", "=", "expandRegLargeImmPair", "(", "Mips", "::", "SP", ",", "-", "StackSize", ",", "NewReg", ",", "NewImm", ",", "MBB", ",", "MBBI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDiu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "NewReg", ")", ".", "addImm", "(", "NewImm", ")", ";", "if", "(", "ATUsed", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ATMACRO", ")", ")", ";", "if", "(", "MFI", "->", "adjustsStack", "(", ")", ")", "{", "expandRegLargeImmPair", "(", "Mips", "::", "SP", ",", "RAOffset", ",", "NewReg", ",", "NewImm", ",", "MBB", ",", "MBBI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "SW", ")", ")", ".", "addReg", "(", "Mips", "::", "RA", ")", ".", "addImm", "(", "NewImm", ")", ".", "addReg", "(", "NewReg", ")", ";", "if", "(", "ATUsed", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ATMACRO", ")", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "expandRegLargeImmPair", "(", "Mips", "::", "SP", ",", "FPOffset", ",", "NewReg", ",", "NewImm", ",", "MBB", ",", "MBBI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "SW", ")", ")", ".", "addReg", "(", "Mips", "::", "FP", ")", ".", "addImm", "(", "NewImm", ")", ".", "addReg", "(", "NewReg", ")", ";" ]

[ "if", "(", "HasBP", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "BPReg", ")", ".", "addImm", "(", "BPOffset", ")", ".", "addReg", "(", "RBReg", ")", ";" ]

[ "if", "(", "!", "isLargeFrame", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "AddImmInst", ",", "RBReg", ")", ".", "addReg", "(", "FPReg", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadImmShiftedInst", ",", "ScratchReg", ")", ".", "addImm", "(", "FrameSize", ">>", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "OrImmInst", ",", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "FrameSize", "&", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "AddInst", ")", ".", "addReg", "(", "RBReg", ")", ".", "addReg", "(", "FPReg", ")", ".", "addReg", "(", "ScratchReg", ")", ";", "}", "}", "else", "if", "(", "!", "isLargeFrame", "&&", "!", "HasBP", "&&", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "if", "(", "HasRedZone", ")", "{", "BuildMI", "(", "MBB", ",", "StackUpdateLoc", ",", "dl", ",", "AddImmInst", ",", "SPReg", ")", ".", "addReg", "(", "SPReg", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "else", "{", "assert", "(", "FPOffset", "<=", "<NUM_LIT>", "&&", "BPOffset", "<=", "<NUM_LIT>", "&&", "PBPOffset", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "Local offsets should be negative", "<STR_LIT>", ")", ";", "SPAdd", "=", "FrameSize", ";", "FPOffset", "+=", "FrameSize", ";", "BPOffset", "+=", "FrameSize", ";", "PBPOffset", "+=", "FrameSize", ";", "}", "}", "else", "{", "if", "(", "!", "HasRedZone", ")", "{", "if", "(", "!", "HasFP", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "OrInst", ",", "ScratchReg", ")", ".", "addReg", "(", "FPReg", ")", ".", "addReg", "(", "FPReg", ")", ";", "RBReg", "=", "FPReg", ";", "}", "BuildMI", "(", "MBB", ",", "StackUpdateLoc", ",", "dl", ",", "LoadInst", ",", "RBReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SPReg", ")", ";", "}", "}", "assert", "(", "RBReg", "!=", "ScratchReg", "&&", "<STR_LIT>", "Should have avoided ScratchReg", "<STR_LIT>", ")", ";", "assert", "(", "(", "isPPC64", "||", "!", "MustSaveCR", ")", "&&", "<STR_LIT>", "Epilogue CR restoring supported only in 64-bit mode", "<STR_LIT>", ")", ";", "if", "(", "MustSaveCR", "&&", "SingleScratchReg", "&&", "MustSaveLR", ")", "{", "assert", "(", "HasRedZone", "&&", "<STR_LIT>", "Expecting red zone", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "LWZ8", ")", ",", "TempReg", ")", ".", "addImm", "(", "getCRSaveOffset", "(", ")", ")", ".", "addReg", "(", "SPReg", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MustSaveCRs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MTOCRF8", ")", ",", "MustSaveCRs", "[", "i", "]", ")", ".", "addReg", "(", "TempReg", ",", "getKillRegState", "(", "i", "==", "e", "-", "<NUM_LIT>", ")", ")", ";", "}", "bool", "LoadedLR", "=", "false", ";", "if", "(", "MustSaveLR", "&&", "RBReg", "==", "SPReg", "&&", "isInt", "<", "<NUM_LIT>", ">", "(", "LROffset", "+", "SPAdd", ")", ")", "{", "BuildMI", "(", "MBB", ",", "StackUpdateLoc", ",", "dl", ",", "LoadInst", ",", "ScratchReg", ")", ".", "addImm", "(", "LROffset", "+", "SPAdd", ")", ".", "addReg", "(", "RBReg", ")", ";", "LoadedLR", "=", "true", ";", "}", "if", "(", "MustSaveCR", "&&", "!", "(", "SingleScratchReg", "&&", "MustSaveLR", ")", ")", "{", "assert", "(", "isPPC64", "&&", "<STR_LIT>", "Expecting 64-bit mode", "<STR_LIT>", ")", ";", "assert", "(", "RBReg", "==", "SPReg", "&&", "<STR_LIT>", "Should be using SP as a base register", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "LWZ8", ")", ",", "TempReg", ")", ".", "addImm", "(", "getCRSaveOffset", "(", ")", ")", ".", "addReg", "(", "RBReg", ")", ";", "}", "if", "(", "HasFP", ")", "{", "if", "(", "HasRedZone", "||", "RBReg", "==", "SPReg", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "FPReg", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "SPReg", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "ScratchReg", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "RBReg", ")", ";", "}", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "LoadInst", ",", "PPC", "::", "R30", ")", ".", "addImm", "(", "PBPOffset", ")", ".", "addReg", "(", "RBReg", ")", ";" ]

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

[ "let", "SuperClasses", "=", "[", "ArithmeticShifterOperand", "]", ";", "let", "Name" ]

[ ")", ")" ]

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

[ "TPCII", "::", "TypeLOOP", ";" ]

[ "return", "getInstrType", "(", "MCInstD", ")", "==" ]

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

[ "static", "MCSubtargetInfo", "*", "createSparcMCSubtargetInfo", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "if", "(", "CPU", ".", "empty", "(", ")", ")", "CPU", "=", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "sparcv9", ")", "?", "<STR_LIT>", "v9", "<STR_LIT>", ":", "<STR_LIT>", "v8", "<STR_LIT>", ";", "return", "createSparcMCSubtargetInfoImpl", "(", "TT", ",", "CPU", ",", "CPU", "," ]

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

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

[ "if", "(", "reg1", "!=", "reg2", ")", "return", "<NUM_LIT>", ";" ]

[ "int", "mems_ok_for_quad_peep", "(", "rtx", "mem1", ",", "rtx", "mem2", ")", "{", "rtx", "addr1", ",", "addr2", ";", "unsigned", "int", "reg1", ",", "reg2", ";", "int", "offset1", ",", "offset2", ";", "if", "(", "MEM_VOLATILE_P", "(", "mem1", ")", "||", "MEM_VOLATILE_P", "(", "mem2", ")", ")", "return", "<NUM_LIT>", ";", "addr1", "=", "XEXP", "(", "mem1", ",", "<NUM_LIT>", ")", ";", "addr2", "=", "XEXP", "(", "mem2", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "addr1", ")", "==", "PLUS", ")", "{", "if", "(", "!", "REG_P", "(", "XEXP", "(", "addr1", ",", "<NUM_LIT>", ")", ")", ")", "return", "<NUM_LIT>", ";", "else", "{", "reg1", "=", "REGNO", "(", "XEXP", "(", "addr1", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "addr1", ",", "<NUM_LIT>", ")", ")", ")", "return", "<NUM_LIT>", ";", "offset1", "=", "INTVAL", "(", "XEXP", "(", "addr1", ",", "<NUM_LIT>", ")", ")", ";", "}", "}", "else", "if", "(", "!", "REG_P", "(", "addr1", ")", ")", "return", "<NUM_LIT>", ";", "else", "{", "reg1", "=", "REGNO", "(", "addr1", ")", ";", "offset1", "=", "<NUM_LIT>", ";", "}", "if", "(", "GET_CODE", "(", "addr2", ")", "==", "PLUS", ")", "{", "if", "(", "!", "REG_P", "(", "XEXP", "(", "addr2", ",", "<NUM_LIT>", ")", ")", ")", "return", "<NUM_LIT>", ";", "else", "{", "reg2", "=", "REGNO", "(", "XEXP", "(", "addr2", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "addr2", ",", "<NUM_LIT>", ")", ")", ")", "return", "<NUM_LIT>", ";", "offset2", "=", "INTVAL", "(", "XEXP", "(", "addr2", ",", "<NUM_LIT>", ")", ")", ";", "}", "}", "else", "if", "(", "!", "REG_P", "(", "addr2", ")", ")", "return", "<NUM_LIT>", ";", "else", "{", "reg2", "=", "REGNO", "(", "addr2", ")", ";", "offset2", "=", "<NUM_LIT>", ";", "}" ]

[ "]", ")" ]

[ "[", "(", "unspec_volatile", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPECV_SP_SWITCH_E", ")", "]", "<STR_LIT>", "{", "return", "<STR_LIT>", "\t", "<STR_LIT>", "<STR_LIT>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "SDNode", "*", "New", "=", "CurDAG", "->", "getMachineNode", "(", "ARM", "::", "tLDR_postidx", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Ops", ")", ";", "transferMemOperands", "(", "N", ",", "New", ")", ";", "ReplaceNode", "(", "N", ",", "New", ")", ";", "<FIXE>" ]

[ "SDValue", "Base", "=", "LD", "->", "getBasePtr", "(", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Base", ",", "getAL", "(", "CurDAG", ",", "SDLoc", "(", "N", ")", ")", ",", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "Chain", "}", ";", "<BUGS>", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "ARM", "::", "tLDR_postidx", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Ops", ")", ")", ";", "<BUGE>", "return", "true", ";", "}" ]

[ ";" ]

[ "if", "(", "I", "!=", "<NUM_LIT>", ")", "{", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "RBrac", ")", ")", "break", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Comma", ")", ")", "return", "MatchOperand_ParseFail", ";", "Parser", ".", "Lex", "(", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Integer", ")", ")", "return", "MatchOperand_ParseFail", ";", "int64_t", "Op", ";", "if", "(", "getParser", "(", ")", ".", "parseAbsoluteExpression", "(", "Op", ")", ")", "return", "MatchOperand_ParseFail", ";", "if", "(", "Op", "!=", "<NUM_LIT>", "&&", "Op", "!=", "<NUM_LIT>", ")", "return", "MatchOperand_ParseFail", ";", "Val", "|=", "(", "Op", "<<", "I", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateImm", "(", "this", ",", "Val", ",", "S", ",", "ImmTy", ")", ")", ";", "return", "MatchOperand_Success" ]

[ ";" ]

[ "<STR_LIT>", "::", "<STR_LIT>", "CC", "=", "static_cast", "<", "<STR_LIT>", "::", "<STR_LIT>", ">", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ";", "Cond", "[", "<NUM_LIT>", "]", ".", "setImm", "(", "GetOppositeBranchCondition", "(", "CC", ")", ")", ";", "return", "false" ]

[ ";" ]

[ "assert", "(", "(", "Subtarget", "->", "isTargetLinux", "(", ")", "||", "Subtarget", "->", "isTargetDarwin", "(", ")", "||", "Subtarget", "->", "isTargetNaCl", "(", ")", ")", "&&", "<STR_LIT>", "Unhandled target in LowerVAARG", "<STR_LIT>", ")", ";", "assert", "(", "Op", ".", "getNode", "(", ")", "->", "getNumOperands", "(", ")", "==", "<NUM_LIT>", ")", ";", "SDValue", "Chain", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "SrcPtr", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "const", "Value", "*", "SV", "=", "cast", "<", "SrcValueSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getValue", "(", ")", ";", "unsigned", "Align", "=", "Op", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "EVT", "ArgVT", "=", "Op", ".", "getNode", "(", ")", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "Type", "*", "ArgTy", "=", "ArgVT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "uint32_t", "ArgSize", "=", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "ArgTy", ")", ";", "uint8_t", "ArgMode", ";", "if", "(", "ArgVT", "==", "MVT", "::", "f80", ")", "{", "llvm_unreachable", "(", "<STR_LIT>", "va_arg for f80 not yet implemented", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "ArgVT", ".", "isFloatingPoint", "(", ")", "&&", "ArgSize", "<=", "<NUM_LIT>", ")", "{", "ArgMode", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "ArgVT", ".", "isInteger", "(", ")", "&&", "ArgSize", "<=", "<NUM_LIT>", ")", "{", "ArgMode", "=", "<NUM_LIT>", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled argument type in LowerVAARG", "<STR_LIT>", ")" ]

[ "}" ]

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

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

[ "def", "A2_vavguh", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_6132ba3d", ",", "TypeALU64", ">", ",", "Enc_a56825", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "Insert", "=", "MoveForSingleUse", "(", "Reg", ",", "Op", ",", "Def", ",", "MBB", ",", "Insert", ",", "LIS", ",", "MFI", ",", "MRI", ")", ";" ]

[ "if", "(", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "UseTee", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MII", "=", "MBB", ".", "rbegin", "(", ")", ";", "MII", "!=", "MBB", ".", "rend", "(", ")", ";", "++", "MII", ")", "{", "MachineInstr", "*", "Insert", "=", "&", "*", "MII", ";", "if", "(", "Insert", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "INLINEASM", ")", "continue", ";", "if", "(", "Insert", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "DBG_VALUE", ")", "continue", ";", "CommutingState", "Commuting", ";", "TreeWalkerState", "TreeWalker", "(", "Insert", ")", ";", "while", "(", "!", "TreeWalker", ".", "Done", "(", ")", ")", "{", "MachineOperand", "&", "Op", "=", "TreeWalker", ".", "Pop", "(", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "assert", "(", "Op", ".", "isUse", "(", ")", "&&", "<STR_LIT>", "explicit_uses() should only iterate over uses", "<STR_LIT>", ")", ";", "assert", "(", "!", "Op", ".", "isImplicit", "(", ")", "&&", "<STR_LIT>", "explicit_uses() should only iterate over explicit operands", "<STR_LIT>", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "Reg", ")", ")", "continue", ";", "MachineInstr", "*", "Def", "=", "GetVRegDef", "(", "Reg", ",", "Insert", ",", "MRI", ",", "LIS", ")", ";", "if", "(", "!", "Def", ")", "continue", ";", "if", "(", "Def", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "INLINEASM", ")", "continue", ";", "if", "(", "WebAssembly", "::", "isArgument", "(", "*", "Def", ")", ")", "continue", ";", "bool", "SameBlock", "=", "Def", "->", "getParent", "(", ")", "==", "&", "MBB", ";", "bool", "CanMove", "=", "SameBlock", "&&", "IsSafeToMove", "(", "Def", ",", "Insert", ",", "AA", ",", "MRI", ")", "&&", "!", "TreeWalker", ".", "IsOnStack", "(", "Reg", ")", ";", "if", "(", "CanMove", "&&", "HasOneUse", "(", "Reg", ",", "Def", ",", "MRI", ",", "MDT", ",", "LIS", ")", ")", "{" ]

[ ")", ")" ]

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

[ "<FIXS>", "unsigned", "getArgRegsSaveSize", "(", ")", "const", "{", "return", "ArgRegsSaveSize", ";", "}", "<FIXE>" ]

[ "unsigned", "getStoredByValParamsPadding", "(", ")", "const", "{", "return", "StByValParamsPadding", ";", "}", "void", "setStoredByValParamsPadding", "(", "unsigned", "p", ")", "{", "StByValParamsPadding", "=", "p", ";", "}", "<BUGS>", "unsigned", "getArgRegsSaveSize", "(", "unsigned", "Align", "=", "<NUM_LIT>", ")", "const", "{", "if", "(", "!", "Align", ")", "return", "ArgRegsSaveSize", ";", "return", "(", "ArgRegsSaveSize", "+", "Align", "-", "<NUM_LIT>", ")", "&", "~", "(", "Align", "-", "<NUM_LIT>", ")", ";", "}", "<BUGE>", "void", "setArgRegsSaveSize", "(", "unsigned", "s", ")", "{", "ArgRegsSaveSize", "=", "s", ";", "}", "unsigned", "getReturnRegsCount", "(", ")", "const", "{", "return", "ReturnRegsCount", ";", "}" ]

[ ")", ")" ]

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

[ ",", "_", "_", "imm", ")", ";" ]

[ "_", "_", "arm_vddupq_u16", "(", "uint32_t", "*", "_", "_", "a", ",", "const", "int", "_", "_", "imm", ")", "{", "return", "_", "_", "arm_vddupq_wb_u16", "(", "_", "_", "a" ]

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

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

[ "dl", ",", "VariableOffsetTGA", ")", ";" ]

[ "GlobalAddressSDNode", "*", "GA", "=", "cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ";", "if", "(", "DAG", ".", "getTarget", "(", ")", ".", "useEmulatedTLS", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Emulated TLS is not yet supported on AIX", "<STR_LIT>", ")", ";", "SDLoc", "dl", "(", "GA", ")", ";", "const", "GlobalValue", "*", "GV", "=", "GA", "->", "getGlobal", "(", ")", ";", "EVT", "PtrVT", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "VariableOffsetTGA", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "dl", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SDValue", "RegionHandleTGA", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "dl", ",", "PtrVT", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SDValue", "VariableOffset", "=", "getTOCEntry", "(", "DAG", "," ]

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

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

[ "}" ]

[ "def", "v4i32", ":", "N2VQSh", "<", "op24", ",", "op23", ",", "op11_8", ",", "<NUM_LIT>", ",", "op4", ",", "N2RegVShRFrm", ",", "itin", ",", "shr_imm32", ",", "OpcodeStr", ",", "!", "strconcat", "(", "Dt", ",", "<STR_LIT>", ")", ",", "v4i32", ",", "OpNode", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "if", "(", "Code", ".", "LastM", "==", "<NUM_LIT>", ")", "return", "NodeAddr", "<", "NodeBase", "*", ">", "(", ")", ";", "return", "G", ".", "addr", "<", "NodeBase", "*", ">", "(", "Code", "." ]

[ "ARMVCCThen", ",", "$", "pred", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "i32", "(", "add", "(", "int_arm_mve_addv_predicated", "(", "VTI", ".", "Vec", "MQPR", ":", "$", "vec", ")", ",", "(", "i32", "VTI", ".", "Unsigned", ")", ",", "(", "VTI", ".", "Pred", "VCCR", ":", "$", "pred", ")", ")", ",", "(", "i32", "tGPREven", ":", "$", "acc", ")", ")", ")", ",", "(", "i32", "(", "InstA", "$", "acc", ",", "$", "vec", "," ]

[ "<FIXS>", "static", "inline", "void", "invertBccCondition", "(", "MachineInstr", "&", "MI", ")", "{", "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "<STR_LIT>", "Unexpected opcode!", "<STR_LIT>", ")", ";", "<STR_LIT>", "::", "<STR_LIT>", "CC", "=", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "<FIXE>", "<FIXS>", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "(", "int64_t", ")", "CC", ")", ";", "<FIXE>", "<FIXS>", "bool", "AArch64BranchRelaxation", "::", "fixupConditionalBranch", "(", "MachineInstr", "&", "MI", ")", "{", "<FIXE>" ]

[ "}", "}", "<BUGS>", "static", "inline", "void", "invertBccCondition", "(", "MachineInstr", "*", "MI", ")", "{", "assert", "(", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "<STR_LIT>", "Unexpected opcode!", "<STR_LIT>", ")", ";", "<STR_LIT>", "::", "<STR_LIT>", "CC", "=", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "<BUGE>", "CC", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "CC", ")", ";", "<BUGS>", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "(", "int64_t", ")", "CC", ")", ";", "<BUGE>", "}", "<BUGS>", "bool", "AArch64BranchRelaxation", "::", "fixupConditionalBranch", "(", "MachineInstr", "*", "MI", ")", "{", "<BUGE>", "MachineBasicBlock", "*", "DestBB", "=", "getDestBlock", "(", "MI", ")", ";" ]

[ "<FIXS>", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_altivec_vmrghw_direct_v4si_be", ":", "CODE_FOR_altivec_vmrglw_direct_v4si_le", ",", "<FIXE>" ]

[ ":", "CODE_FOR_altivec_vmrglh_direct", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "OPTION_MASK_ALTIVEC", ",", "<BUGS>", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_altivec_vmrghw_direct_v4si", ":", "CODE_FOR_altivec_vmrglw_direct_v4si", ",", "<BUGE>", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "OPTION_MASK_ALTIVEC", ",", "BYTES_BIG_ENDIAN", "?", "CODE_FOR_altivec_vmrglb_direct" ]

[ "const", "auto", "&", "ST", "=", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";" ]

[ "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "<NUM_LIT>", ",", "false", ",", "false", ",", "true", ",", "true", ",", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{" ]

[ "int64_t", "Val", "=", "AArch64_AM", ":", ":", "decodeLogicalImmediate", "(", "MCOp", ".", "getImm", "(", ")", ",", "<NUM_LIT>", ")", ";" ]

[ "def", "sve_logical_imm8", ":", "Operand", "<", "i64", ">", "{", "let", "ParserMatchClass", "=", "SVELogicalImmOperand", "<", "<NUM_LIT>", ">", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "MCOperandPredicate", "=", "[", "{", "if", "(", "!", "MCOp", ".", "isImm", "(", ")", ")", "return", "false", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "base", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "dst", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "<STR_LIT>" ]

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

[ "case", "ISD", "::", "SETLE", ":" ]

[ "return", "M68k", "::", "COND_EQ", ";", "case", "ISD", "::", "SETGT", ":", "return", "M68k", "::", "COND_GT", ";", "case", "ISD", "::", "SETGE", ":", "return", "M68k", "::", "COND_GE", ";", "case", "ISD", "::", "SETLT", ":", "return", "M68k", "::", "COND_LT", ";" ]

[ ">", "mode", ")" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<", "MODE", ">", "mode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<", "MODE", ">", "mode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<", "MODE" ]

[ "CLI", ".", "Chain", ";" ]

[ "DebugLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "<NUM_LIT>", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "<NUM_LIT>", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_fmadd_round_sch", "(", "_", "_", "m128h", "_", "_", "A", ",", "_", "_", "mmask8", "_", "_", "B", ",", "_", "_", "m128h", "_", "_", "C", ",", "_", "_", "m128h", "_", "_", "D", ",", "const", "int", "_", "_", "E", ")", "{", "return", "(", "_", "_", "m128h", ")", "_", "_", "builtin_ia32_vfmaddcsh_mask_round", "(", "(", "_", "_", "v8hf", ")", "_", "_", "A", ",", "(", "_", "_", "v8hf", ")", "_", "_", "C", ",", "(", "_", "_", "v8hf", ")", "_", "_", "D", ",", "_", "_", "B", ",", "_", "_", "E", ")", ";" ]

[ "rT", ",", "(", "mul", "(", "zext", "R16C", ":", "$", "rA", ")", ",", "(", "zext", "R16C", ":", "$", "rB", ")", ")", ")", "]", ">", ";" ]

[ "def", "MPYUr16", ":", "MPYUInst", "<", "(", "outs", "R32C", ":", "$", "rT", ")", ",", "(", "ins", "R16C", ":", "$", "rA", ",", "R16C", ":", "$", "rB", ")", ",", "[", "(", "set", "R32C", ":", "$" ]

[ "unsigned", ")", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";" ]

[ "}", "else", "{", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "FramePtr", ",", "true", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "AfterPush", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "if", "(", "GPRCS1Size", ">", "<NUM_LIT>", ")", "{", "MachineBasicBlock", "::", "iterator", "Pos", "=", "std", "::", "next", "(", "GPRCS1Push", ")", ";", "int", "CFIIndex", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "int", "FI", "=", "Entry", ".", "getFrameIdx", "(", ")", ";", "switch", "(", "Reg", ")", "{", "case", "ARM", "::", "R8", ":", "case", "ARM", "::", "R9", ":", "case", "ARM", "::", "R10", ":", "case", "ARM", "::", "R11", ":", "case", "ARM", "::", "R12", ":", "if", "(", "STI", ".", "splitFramePushPop", "(", ")", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "case", "ARM", "::", "R0", ":", "case", "ARM", "::", "R1", ":", "case", "ARM", "::", "R2", ":", "case", "ARM", "::", "R3", ":", "case", "ARM", "::", "R4", ":", "case", "ARM", "::", "R5", ":", "case", "ARM", "::", "R6", ":", "case", "ARM", "::", "R7", ":", "case", "ARM", "::", "LR", ":", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ",", "MFI", ".", "getObjectOffset", "(", "FI", ")", ")", ")", ";", "BuildMI", "(", "MBB", ",", "Pos", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "break", ";", "}", "}", "}", "if", "(", "GPRCS2Size", ">", "<NUM_LIT>", ")", "{", "MachineBasicBlock", "::", "iterator", "Pos", "=", "std", "::", "next", "(", "GPRCS2Push", ")", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "int", "FI", "=", "Entry", ".", "getFrameIdx", "(", ")", ";", "switch", "(", "Reg", ")", "{", "case", "ARM", "::", "R8", ":", "case", "ARM", "::", "R9", ":", "case", "ARM", "::", "R10", ":", "case", "ARM", "::", "R11", ":", "case", "ARM", "::", "R12", ":", "if", "(", "STI", ".", "splitFramePushPop", "(", ")", ")", "{", "unsigned", "DwarfReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "unsigned", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DwarfReg", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "Pos", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "break", ";", "}", "}", "}", "if", "(", "DPRCSSize", ">", "<NUM_LIT>", ")", "{", "MachineBasicBlock", "::", "iterator", "Pos", "=", "std", "::", "next", "(", "LastPush", ")", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "int", "FI", "=", "Entry", ".", "getFrameIdx", "(", ")", ";", "if", "(", "(", "Reg", ">=", "ARM", "::", "D0", "&&", "Reg", "<=", "ARM", "::", "D31", ")", "&&", "(", "Reg", "<", "ARM", "::", "D8", "||", "Reg", ">=", "ARM", "::", "D8", "+", "AFI", "->", "getNumAlignedDPRCS2Regs", "(", ")", ")", ")", "{", "unsigned", "DwarfReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "unsigned", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DwarfReg", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "Pos", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "}", "DefCFAOffsetCandidates", ".", "emitDefCFAOffsets", "(", "MMI", ",", "MBB", ",", "dl", ",", "TII", ",", "HasFP", ")", ";", "if", "(", "STI", ".", "isTargetELF", "(", ")", "&&", "hasFP", "(", "MF", ")", ")", "MFI", ".", "setOffsetAdjustment", "(", "MFI", ".", "getOffsetAdjustment", "(", ")", "-", "AFI", "->", "getFramePtrSpillOffset", "(", ")", ")", ";", "AFI", "->", "setGPRCalleeSavedArea1Size", "(", "GPRCS1Size", ")", ";", "AFI", "->", "setGPRCalleeSavedArea2Size", "(", "GPRCS2Size", ")", ";", "AFI", "->", "setDPRCalleeSavedGapSize", "(", "DPRGapSize", ")", ";", "AFI", "->", "setDPRCalleeSavedAreaSize", "(", "DPRCSSize", ")", ";", "if", "(", "!", "AFI", "->", "getNumAlignedDPRCS2Regs", "(", ")", "&&", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "unsigned", "MaxAlign", "=", "MFI", ".", "getMaxAlignment", "(", ")", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "{", "emitAligningInstructions", "(", "MF", ",", "AFI", ",", "TII", ",", "MBB", ",", "MBBI", ",", "dl", ",", "ARM", "::", "SP", ",", "MaxAlign", ",", "false", ")", ";", "}", "else", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ",", "ARM", "::", "R4", ")", ".", "addReg", "(", "ARM", "::", "SP", ",", "RegState", "::", "Kill", ")", ")", ";", "emitAligningInstructions", "(", "MF", ",", "AFI", ",", "TII", ",", "MBB", ",", "MBBI", ",", "dl", ",", "ARM", "::", "R4", ",", "MaxAlign", ",", "false", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "ARM", "::", "R4", ",", "RegState", "::", "Kill", ")", ")", ";", "}", "AFI", "->", "setShouldRestoreSPFromFP", "(", "true", ")", ";", "}", "if", "(", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "isARM", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "MOVr", ")", ",", "RegInfo", "->", "getBaseRegister", "(", ")", ")", ".", "addReg", "(", "ARM", "::", "SP", ")", ".", "addImm", "(", "(" ]

[ "}" ]

[ "def", "uimm6s4", ":", "Operand", "<", "i64", ">", ",", "ImmLeaf", "<", "i64", ",", "[", "{", "return", "Imm", ">", "=", "<NUM_LIT>", "&", "&", "Imm", "<", "(", "<NUM_LIT>", "*", "<NUM_LIT>", ")", "&", "&", "(", "(", "Imm", "%", "<NUM_LIT>", ")", "=", "=", "<NUM_LIT>", ")", ";", "}", "]", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "UImm6s4Operand", ";" ]

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

[ "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "Addr", "->", "getType", "(", ")", "}", ";" ]

[ "Value", "*", "Hi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "Val", ",", "<NUM_LIT>", ")", ",", "Int32Ty", ",", "<STR_LIT>", "hi", "<STR_LIT>", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Builder", ".", "CreateCall3", "(", "Strex", ",", "Lo", ",", "Hi", ",", "Addr", ")", ";", "}", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlex", ":", "Intrinsic", "::", "arm_strex", ";", "Type", "*", "Tys", "[", "]", "=", "{" ]

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

[ "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "n", ";", "i", "++", ")", "{", "c", "=", "*", "p", "++", ";", "if", "(", "c", ">=", "'", "'", "&&", "c", "<", "<NUM_LIT>", ")", "{", "if", "(", "for_string", ")", "fputs", "(", "for_string", ",", "file", ")", ";", "putc", "(", "c", ",", "file", ")", ";", "if", "(", "c", "==", "'", "<STR_LIT>", "'", ")", "{", "putc", "(", "c", ",", "file", ")", ";", "++", "count_string", ";", "}", "for_string", "=", "NULL", ";", "for_decimal", "=", "<STR_LIT>", "\\\"\\n\\t.byte ", "<STR_LIT>", ";", "to_close", "=", "<STR_LIT>", "\\\"\\n", "<STR_LIT>", ";", "++", "count_string", ";", "if", "(", "count_string" ]

[ "bool", "SIAnnotateControlFlow", "::", "isUniform", "(", "BranchInst", "*", "T", ")", "{", "return", "UA", "->", "isUniform", "(", "T", ")", "||", "T", "->", "hasMetadata", "(", "<STR_LIT>", "structurizecfg.uniform", "<STR_LIT>", ")", ";", "}" ]

[ "Returns", "true", "if", "value", "V", "is", "uniform", "across", "VF", "lanes", ",", "when", "VF", "is", "provided", ",", "and", "otherwise", "if", "V", "is", "invariant", "across", "all", "loop", "iterations", "." ]

[ "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "MVT", "::", "i64", ",", "Vec", ")", ";" ]

[ "return", "DAG", ".", "getZExtOrTrunc", "(", "Shl", ",", "SL", ",", "VT", ")", ";", "}", "}", "if", "(", "VT", "!=", "MVT", "::", "i64", ")", "return", "SDValue", "(", ")", ";", "if", "(", "RHSVal", "<", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "SDValue", "ShiftAmt", "=", "DAG", ".", "getConstant", "(", "RHSVal", "-", "<NUM_LIT>", ",", "SL", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "SL", ",", "MVT", "::", "i32", ",", "LHS", ")", ";", "SDValue", "NewShift", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "SL", ",", "MVT", "::", "i32", ",", "Lo", ",", "ShiftAmt", ")", ";", "const", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "SL", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Vec", "=", "DAG", ".", "getBuildVector", "(", "MVT", "::", "v2i32", ",", "SL", ",", "{", "Zero", ",", "NewShift", "}", ")", ";" ]

[ "setLoadExtAction", "(", "ISD", "::", "ZEXTLOAD", ",", "VT", ",", "MVT", "::", "i1", ",", "Promote", ")", ";" ]

[ "setOperationAction", "(", "ISD", "::", "CTTZ", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTTZ_ZERO_UNDEF", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTLZ_ZERO_UNDEF", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i1", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i16", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "GlobalAddress", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SHL_PARTS", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SRA_PARTS", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SRL_PARTS", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "SDIVREM", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "UDIVREM", ")", ";", "setBooleanContents", "(", "ZeroOrOneBooleanContent", ")", ";", "setBooleanVectorContents", "(", "ZeroOrNegativeOneBooleanContent", ")", ";", "for", "(", "MVT", "VT", ":", "MVT", "::", "integer_valuetypes", "(", ")", ")", "{", "setLoadExtAction", "(", "ISD", "::", "EXTLOAD", ",", "VT", ",", "MVT", "::", "i1", ",", "Promote", ")", ";" ]

[ "<NUM_LIT>", ";" ]

[ "def", "XDr", ":", "BaseUnscaledConversion", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "GPR64", ",", "FPR64", ",", "asm", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=" ]

[ "<FIXS>", "bool", "AMDGPUDAGToDAGISel", "::", "checkType", "(", "const", "Value", "*", "Ptr", ",", "unsigned", "AS", ")", "{", "assert", "(", "AS", "!=", "<NUM_LIT>", "&&", "<STR_LIT>", "Use checkPrivateAddress instead.", "<STR_LIT>", ")", ";", "if", "(", "!", "Ptr", ")", "<FIXE>", "<FIXS>", "return", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", "==", "AS", ";", "<FIXE>", "<FIXS>", "if", "(", "Op", "->", "getPseudoValue", "(", ")", ")", "return", "true", ";", "if", "(", "PointerType", "*", "PT", "=", "dyn_cast", "PointerType", ">", "(", "Op", "->", "getValue", "(", ")", "->", "getType", "(", ")", ")", ")", "return", "PT", "->", "getAddressSpace", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "false", ";", "<FIXE>" ]

[ "}", "<BUGS>", "bool", "AMDGPUDAGToDAGISel", "::", "checkType", "(", "const", "Value", "*", "ptr", ",", "unsigned", "int", "addrspace", ")", "{", "assert", "(", "addrspace", "!=", "<NUM_LIT>", "&&", "<STR_LIT>", "Use checkPrivateAddress instead.", "<STR_LIT>", ")", ";", "if", "(", "!", "ptr", ")", "{", "<BUGE>", "return", "false", ";", "<BUGS>", "}", "Type", "*", "ptrType", "=", "ptr", "->", "getType", "(", ")", ";", "return", "dyn_cast", "PointerType", ">", "(", "ptrType", ")", "->", "getAddressSpace", "(", ")", "==", "addrspace", ";", "<BUGE>", "}", "bool", "AMDGPUDAGToDAGISel", "::", "checkPrivateAddress", "(", "const", "MachineMemOperand", "*", "Op", ")", "{", "<BUGS>", "if", "(", "Op", "->", "getPseudoValue", "(", ")", ")", "return", "true", ";", "const", "Value", "*", "ptr", "=", "Op", "->", "getValue", "(", ")", ";", "if", "(", "!", "ptr", ")", "return", "false", ";", "PointerType", "*", "ptrType", "=", "dyn_cast", "PointerType", ">", "(", "ptr", "->", "getType", "(", ")", ")", ";", "return", "ptrType", "->", "getAddressSpace", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "<BUGE>", "}", "bool", "AMDGPUDAGToDAGISel", "::", "isGlobalStore", "(", "const", "StoreSDNode", "*", "N", ")", "{" ]