Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";" ]

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

[ "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "pc", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "rx_split_cbranch", "(", "CC_ZSmode", ",", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "operands", "[" ]

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

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

[ "}" ]

[ "RegisterMCAsmInfoFn", "C", "(", "*", "T", ",", "createPPCMCAsmInfo", ")", ";", "TargetRegistry", "::", "RegisterMCInstrInfo", "(", "*", "T", ",", "createPPCMCInstrInfo", ")", ";", "TargetRegistry", "::", "RegisterMCRegInfo", "(", "*", "T", ",", "createPPCMCRegisterInfo", ")", ";", "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "*", "T", ",", "createPPCMCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "*", "T", ",", "createPPCMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "*", "T", ",", "createPPCAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterObjectTargetStreamer", "(", "*", "T", ",", "createObjectTargetStreamer", ")", ";", "TargetRegistry", "::", "RegisterAsmTargetStreamer", "(", "*", "T", ",", "createAsmTargetStreamer", ")", ";", "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "*", "T", ",", "createPPCMCInstPrinter", ")", ";" ]

[ "<STR_LIT>" ]

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

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

[ "AArch64MCExpr", "::", "VariantKind", "RefKind", ";", "if", "(", "parseOptionalToken", "(", "AsmToken", "::", "Colon", ")", ")", "{", "HasELFModifier", "=", "true", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Identifier", ")", ")", "return", "TokError", "(", "<STR_LIT>", "expect relocation specifier in operand after ':'", "<STR_LIT>", ")", ";", "std", "::", "string", "LowerCase", "=", "Parser", ".", "getTok", "(", ")", ".", "getIdentifier", "(", ")", ".", "lower", "(", ")", ";", "RefKind", "=", "StringSwitch", "<", "AArch64MCExpr", "::", "VariantKind", ">", "(", "LowerCase", ")", ".", "Case", "(", "<STR_LIT>", "lo12", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_LO12", ")", ".", "Case", "(", "<STR_LIT>", "abs_g3", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_ABS_G3", ")", ".", "Case", "(", "<STR_LIT>", "abs_g2", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_ABS_G2", ")", ".", "Case", "(", "<STR_LIT>", "abs_g2_s", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_ABS_G2_S", ")", ".", "Case", "(", "<STR_LIT>", "abs_g2_nc", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_ABS_G2_NC", ")", ".", "Case", "(", "<STR_LIT>", "abs_g1", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_ABS_G1", ")", ".", "Case", "(", "<STR_LIT>", "abs_g1_s", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_ABS_G1_S", ")", ".", "Case", "(", "<STR_LIT>", "abs_g1_nc", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_ABS_G1_NC", ")", ".", "Case", "(", "<STR_LIT>", "abs_g0", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_ABS_G0", ")", ".", "Case", "(", "<STR_LIT>", "abs_g0_s", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_ABS_G0_S", ")", ".", "Case", "(", "<STR_LIT>", "abs_g0_nc", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_ABS_G0_NC", ")", ".", "Case", "(", "<STR_LIT>", "dtprel_g2", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_DTPREL_G2", ")", ".", "Case", "(", "<STR_LIT>", "dtprel_g1", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_DTPREL_G1", ")", ".", "Case", "(", "<STR_LIT>", "dtprel_g1_nc", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_DTPREL_G1_NC", ")", ".", "Case", "(", "<STR_LIT>", "dtprel_g0", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_DTPREL_G0", ")", ".", "Case", "(", "<STR_LIT>", "dtprel_g0_nc", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_DTPREL_G0_NC", ")", ".", "Case", "(", "<STR_LIT>", "dtprel_hi12", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_DTPREL_HI12", ")", ".", "Case", "(", "<STR_LIT>", "dtprel_lo12", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_DTPREL_LO12", ")", ".", "Case", "(", "<STR_LIT>", "dtprel_lo12_nc", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_DTPREL_LO12_NC", ")", ".", "Case", "(", "<STR_LIT>", "tprel_g2", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_TPREL_G2", ")", ".", "Case", "(", "<STR_LIT>", "tprel_g1", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_TPREL_G1", ")", ".", "Case", "(", "<STR_LIT>", "tprel_g1_nc", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_TPREL_G1_NC", ")", ".", "Case", "(", "<STR_LIT>", "tprel_g0", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_TPREL_G0", ")", ".", "Case", "(", "<STR_LIT>", "tprel_g0_nc", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_TPREL_G0_NC", ")", ".", "Case", "(", "<STR_LIT>", "tprel_hi12", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_TPREL_HI12", ")", ".", "Case", "(", "<STR_LIT>", "tprel_lo12", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_TPREL_LO12", ")", ".", "Case", "(", "<STR_LIT>", "tprel_lo12_nc", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_TPREL_LO12_NC", ")", ".", "Case", "(", "<STR_LIT>", "tlsdesc_lo12", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_TLSDESC_LO12", ")", ".", "Case", "(", "<STR_LIT>", "got", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_GOT_PAGE", ")", ".", "Case", "(", "<STR_LIT>", "got_lo12", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_GOT_LO12", ")", ".", "Case", "(", "<STR_LIT>", "gottprel", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_GOTTPREL_PAGE", ")", ".", "Case", "(", "<STR_LIT>", "gottprel_lo12", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_GOTTPREL_LO12_NC", ")", ".", "Case", "(", "<STR_LIT>", "gottprel_g1", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_GOTTPREL_G1", ")", ".", "Case", "(", "<STR_LIT>", "gottprel_g0_nc", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_GOTTPREL_G0_NC", ")", ".", "Case", "(", "<STR_LIT>", "tlsdesc", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_TLSDESC_PAGE", ")", ".", "Case", "(", "<STR_LIT>", "secrel_lo12", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_SECREL_LO12", ")", ".", "Case", "(", "<STR_LIT>", "secrel_hi12", "<STR_LIT>", ",", "AArch64MCExpr", "::", "VK_SECREL_HI12", ")", ".", "Default", "(", "AArch64MCExpr", "::", "VK_INVALID", ")", ";", "if", "(", "RefKind", "==", "AArch64MCExpr", "::", "VK_INVALID", ")", "return", "TokError", "(", "<STR_LIT>", "expect relocation specifier in operand after ':'", "<STR_LIT>", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "parseToken", "(", "AsmToken", "::", "Colon", ",", "<STR_LIT>", "expect ':' after relocation specifier", "<STR_LIT>", ")", ")", "return", "true", ";", "}", "if", "(", "getParser", "(", ")", ".", "parseExpression", "(", "ImmVal", ")", ")", "return", "true", ";", "if", "(", "HasELFModifier", ")", "ImmVal", "=", "AArch64MCExpr", "::", "create", "(", "ImmVal", ",", "RefKind", ",", "getContext", "(", ")", ")", ";" ]

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

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

[ "<STR_LIT>", ")" ]

[ "[", "(", "trap_if", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>" ]

[ "<FIXS>", "Register", "TmpReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "<FIXE>" ]

[ "int64_t", "Offset", "=", "FrameInfo", ".", "getObjectOffset", "(", "Index", ")", ";", "FIOp", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "if", "(", "!", "TII", "->", "isImmOperandLegal", "(", "*", "MI", ",", "FIOperandNum", ",", "FIOp", ")", ")", "{", "<BUGS>", "unsigned", "TmpReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "<BUGE>", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "TmpReg", ")", ".", "addImm", "(", "Offset", ")", ";", "FIOp", ".", "ChangeToRegister", "(", "TmpReg", ",", "false", ",", "false", ",", "true", ")", ";" ]

[ "<FIXS>", "Sched", "[", "WriteVecExtractSt", "]", ">", ";", "<FIXE>" ]

[ "[", "(", "store", "(", "extractelt", "(", "_", ".", "VT", "_", ".", "RC", ":", "$", "src1", ")", ",", "imm", ":", "$", "src2", ")", ",", "addr", ":", "$", "dst", ")", "]", ">", ",", "EVEX", ",", "EVEX_CD8", "_", ".", "EltSize", ",", "CD8VT1", ">", ",", "TAPD", ",", "<BUGS>", "Sched", "[", "WriteShuffleLd", ",", "WriteRMW", "]", ">", ";", "<BUGE>", "}", "}" ]

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

[ "(", "and", "(" ]

[ "return", "sparc_check_64", "(", "SET_SRC", "(", "pat", ")", ",", "insn", ")", ";" ]

[ "case", "IOR", ":", "case", "XOR", ":", "{", "rtx", "op0", "=", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "<NUM_LIT>", ")", ";", "rtx", "op1", "=", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "!=", "REG", "||", "sparc_check_64", "(", "op0", ",", "insn", ")", "<=", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", ")", "return", "INTVAL", "(", "op1", ")", ">=", "<NUM_LIT>", ";", "return", "(", "GET_CODE", "(", "op1", ")", "==", "REG", "&&", "sparc_check_64", "(", "op1", ",", "insn", ")", "==", "<NUM_LIT>", ")", ";", "}", "case", "LSHIFTRT", ":", "return", "GET_MODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "SImode", ";", "case", "CONST_INT", ":", "return", "!", "(", "INTVAL", "(", "SET_SRC", "(", "pat", ")", ")", "&", "<NUM_LIT>", ")", ";", "case", "ASHIFTRT", ":", "case", "SIGN_EXTEND", ":", "return", "-", "(", "GET_MODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "SImode", ")", ";", "case", "REG", ":" ]

[ "Register", "physSPReg", "=", "TFI", ".", "Uses64BitFramePtr", "?", "X86", "::", "RSP", ":", "X86", "::", "ESP", ";" ]

[ "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "const", "X86FrameLowering", "&", "TFI", "=", "*", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "MBB", "->", "getBasicBlock", "(", ")", ";", "const", "unsigned", "ProbeSize", "=", "getStackProbeSize", "(", "*", "MF", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "*", "testMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "tailMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "blockMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineFunction", "::", "iterator", "MBBIter", "=", "++", "MBB", "->", "getIterator", "(", ")", ";", "MF", "->", "insert", "(", "MBBIter", ",", "testMBB", ")", ";", "MF", "->", "insert", "(", "MBBIter", ",", "blockMBB", ")", ";", "MF", "->", "insert", "(", "MBBIter", ",", "tailMBB", ")", ";", "Register", "sizeVReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";" ]

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

[ "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "==", "MVT", "::", "v64i8", ")", "{" ]

[ "EVT", "SrcVT", "=", "Src", ".", "getValueType", "(", ")", ";", "if", "(", "!", "SrcVT", ".", "isSimple", "(", ")", "||", "SrcVT", ".", "getScalarType", "(", ")", "!=", "MVT", "::", "i1", ")", "return", "SDValue", "(", ")", ";", "bool", "IsTruncated", "=", "Src", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", "&&", "Src", ".", "hasOneUse", "(", ")", "&&", "(", "Src", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "v16i8", "||", "Src", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "v32i8", "||", "Src", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "v64i8", ")", ";", "if", "(", "!", "Subtarget", ".", "hasSSE2", "(", ")", "||", "(", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "IsTruncated", ")", ")", "return", "SDValue", "(", ")", ";", "MVT", "SExtVT", ";", "bool", "PropagateSExt", "=", "false", ";", "switch", "(", "SrcVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "SDValue", "(", ")", ";", "case", "MVT", "::", "v2i1", ":", "SExtVT", "=", "MVT", "::", "v2i64", ";", "break", ";", "case", "MVT", "::", "v4i1", ":", "SExtVT", "=", "MVT", "::", "v4i32", ";", "if", "(", "Subtarget", ".", "hasAVX", "(", ")", "&&", "checkBitcastSrcVectorSize", "(", "Src", ",", "<NUM_LIT>", ")", ")", "{", "SExtVT", "=", "MVT", "::", "v4i64", ";", "PropagateSExt", "=", "true", ";", "}", "break", ";", "case", "MVT", "::", "v8i1", ":", "SExtVT", "=", "MVT", "::", "v8i16", ";", "if", "(", "Subtarget", ".", "hasAVX", "(", ")", "&&", "(", "checkBitcastSrcVectorSize", "(", "Src", ",", "<NUM_LIT>", ")", "||", "checkBitcastSrcVectorSize", "(", "Src", ",", "<NUM_LIT>", ")", ")", ")", "{", "SExtVT", "=", "MVT", "::", "v8i32", ";", "PropagateSExt", "=", "true", ";", "}", "break", ";", "case", "MVT", "::", "v16i1", ":", "SExtVT", "=", "MVT", "::", "v16i8", ";", "break", ";", "case", "MVT", "::", "v32i1", ":", "SExtVT", "=", "MVT", "::", "v32i8", ";", "break", ";", "case", "MVT", "::", "v64i1", ":", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SExtVT", "=", "MVT", "::", "v64i8", ";", "break", ";", "}", "if", "(", "checkBitcastSrcVectorSize", "(", "Src", ",", "<NUM_LIT>", ")", ")", "{", "SExtVT", "=", "MVT", "::", "v64i8", ";", "break", ";", "}", "return", "SDValue", "(", ")", ";", "}", ";", "SDValue", "V", "=", "PropagateSExt", "?", "signExtendBitcastSrcVector", "(", "DAG", ",", "SExtVT", ",", "Src", ",", "DL", ")", ":", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "DL", ",", "SExtVT", ",", "Src", ")", ";", "if", "(", "SExtVT", "==", "MVT", "::", "v16i8", "||", "SExtVT", "==", "MVT", "::", "v32i8", "||", "SExtVT" ]

[ "_", "imm", ",", "mve_pred16_t", "_", "_", "p", ")", "{" ]

[ "_", "_", "arm_vshlcq_m_s16", "(", "int16x8_t", "_", "_", "a", ",", "uint32_t", "*", "_", "_", "b", ",", "const", "int", "_" ]

[ "static", "void", "rs6000_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "HOST_WIDE_INT", "size", ")", "{", "if", "(", "first", "+", "size", "<=", "<NUM_LIT>", ")", "{", "HOST_WIDE_INT", "i", ";", "for", "(", "i", "=", "PROBE_INTERVAL", ";", "i", "<", "size", ";", "i", "+=", "PROBE_INTERVAL", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "i", ")", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "size", ")", ")", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "rounded_size", ";", "rtx", "r12", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "rtx", "r0", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "first", "<=", "<NUM_LIT>", ")", ";", "rounded_size", "=", "ROUND_DOWN", "(", "size", ",", "PROBE_INTERVAL", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "r12", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "first", ")", ")", ")", ";", "if", "(", "rounded_size", ">", "<NUM_LIT>", ")", "{", "emit_move_insn", "(", "r0", ",", "GEN_INT", "(", "-", "rounded_size", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "r0", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "r12", ",", "r0", ")", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "r0", ",", "plus_constant", "(", "Pmode", ",", "r12", ",", "-", "rounded_size", ")", ")", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_probe_stack_rangedi", "(", "r12", ",", "r12", ",", "stack_pointer_rtx", ",", "r0", ")", ")", ";", "else", "emit_insn", "(", "gen_probe_stack_rangesi", "(", "r12", ",", "r12", ",", "stack_pointer_rtx", ",", "r0", ")", ")", ";", "if", "(", "size", "!=", "rounded_size", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "r12", ",", "rounded_size", "-", "size", ")", ")", ";", "}", "}" ]

[ "Emit", "code", "to", "probe", "a", "range", "of", "stack", "addresses", "from", "FIRST", "to", "FIRST+SIZE", ",", "inclusive", ".", "These", "are", "offsets", "from", "the", "current", "stack", "pointer", "." ]

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

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "BI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "ne", ":", "BI", "(", "zero_extract", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ ")", ";" ]

[ "if", "(", "CFP", "->", "getType", "(", ")", "->", "isFloatTy", "(", ")", ")", "printFloat", "(", "static_cast", "<", "uint32_t", ">", "(", "Val", ")", ",", "O", ")", ";", "else", "if", "(", "CFP", "->", "getType", "(", ")", "->", "isDoubleTy", "(", ")", ")", "printDouble", "(", "Val", ",", "O", ")", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "unhandled ConstantFP", "<STR_LIT>" ]

[ "RegisterTargetMachine", "<", "ARMBETargetMachine", ">", "B", "(", "getTheThumbBETarget", "(", ")", ")", ";" ]

[ "void", "LLVMInitializeARMTarget", "(", ")", "{", "RegisterTargetMachine", "<", "ARMLETargetMachine", ">", "X", "(", "getTheARMLETarget", "(", ")", ")", ";", "RegisterTargetMachine", "<", "ARMLETargetMachine", ">", "A", "(", "getTheThumbLETarget", "(", ")", ")", ";", "RegisterTargetMachine", "<", "ARMBETargetMachine", ">", "Y", "(", "getTheARMBETarget", "(", ")", ")", ";" ]

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

[ "return", "!", "(", "(", "F", ">>", "<STR_LIT>", "::", "<STR_LIT>", ")", "&" ]

[ "M0Segment", "->", "end", "=", "Write2Index", ".", "getRegSlot", "(", ")", ";" ]

[ "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "SlotIndex", "PairedIndex", "=", "LIS", "->", "getInstructionIndex", "(", "Paired", ")", ";", "LiveRange", "&", "M0Range", "=", "LIS", "->", "getRegUnit", "(", "*", "MCRegUnitIterator", "(", "AMDGPU", "::", "M0", ",", "TRI", ")", ")", ";", "LiveRange", "::", "Segment", "*", "M0Segment", "=", "M0Range", ".", "getSegmentContaining", "(", "PairedIndex", ")", ";", "bool", "UpdateM0Range", "=", "M0Segment", "->", "end", "==", "PairedIndex", ".", "getRegSlot", "(", ")", ";", "MachineInstrBuilder", "Write2", "=", "BuildMI", "(", "*", "MBB", ",", "I", ",", "DL", ",", "Write2Desc", ")", ".", "addOperand", "(", "*", "Addr", ")", ".", "addOperand", "(", "*", "Data0", ")", ".", "addOperand", "(", "*", "Data1", ")", ".", "addImm", "(", "NewOffset0", ")", ".", "addImm", "(", "NewOffset1", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "*", "I", "->", "memoperands_begin", "(", ")", ")", ".", "addMemOperand", "(", "*", "Paired", "->", "memoperands_begin", "(", ")", ")", ";", "unsigned", "OrigRegs", "[", "]", "=", "{", "Data0", "->", "getReg", "(", ")", ",", "Data1", "->", "getReg", "(", ")", ",", "Addr", "->", "getReg", "(", ")", "}", ";", "LIS", "->", "RemoveMachineInstrFromMaps", "(", "I", ")", ";", "LIS", "->", "RemoveMachineInstrFromMaps", "(", "Paired", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "Paired", "->", "eraseFromParent", "(", ")", ";", "LIS", "->", "repairIntervalsInRange", "(", "MBB", ",", "Write2", ",", "Write2", ",", "OrigRegs", ")", ";", "if", "(", "UpdateM0Range", ")", "{", "SlotIndex", "Write2Index", "=", "LIS", "->", "getInstructionIndex", "(", "Write2", ")", ";" ]

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

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

[ "(", "if_then_else", "(", "match_op_dup", "<NUM_LIT>" ]

[ "(", "pc", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CC", "CC_REGNUM", ")", "(", "compare", ":", "CC", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "pc", ")" ]

[ "}" ]

[ "let", "MIOperandInfo", "=", "(", "ops", "dispRI34", ":", "$", "imm", ",", "ptr_rc_nor0", ":", "$", "reg", ")", ";", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

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

[ "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ior", ":", "SI", "(", "not", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ior", ":", "SI", "(", "not", ":", "SI", "(", "ashiftrt", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ")", ";" ]

[ "if", "(", "DestReg", "==", "BaseReg", "||", "TRI", "->", "isSubRegister", "(", "BaseReg", ",", "DestReg", ")", ")", "return", "E", ";", "}", "}", "ModifiedRegUnits", ".", "clear", "(", ")", ";", "UsedRegUnits", ".", "clear", "(", ")", ";", "unsigned", "Count", "=", "<NUM_LIT>", ";", "do", "{", "--", "MBBI", ";", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "if", "(", "!", "MI", ".", "isTransient", "(", ")", ")", "++", "Count", ";", "if", "(", "isMatchingUpdateInsn", "(", "*", "I", ",", "MI", ",", "BaseReg", ",", "Offset", ")", ")", "return", "MBBI", ";", "LiveRegUnits", "::", "accumulateUsedDefed", "(", "MI", ",", "ModifiedRegUnits", ",", "UsedRegUnits", ",", "TRI" ]

[ "}" ]

[ "addPass", "(", "createNios2ISelDag", "(", "getNios2TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";" ]

[ "bool", "PPCTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "ppc_altivec_lvx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvxl", ":", "case", "Intrinsic", "::", "ppc_altivec_lvebx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvehx", ":", "case", "Intrinsic", "::", "ppc_altivec_lvewx", ":", "{", "EVT", "VT", ";", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "ppc_altivec_lvebx", ":", "VT", "=", "MVT", "::", "i8", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_lvehx", ":", "VT", "=", "MVT", "::", "i16", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_lvewx", ":", "VT", "=", "MVT", "::", "i32", ";", "break", ";", "default", ":", "VT", "=", "MVT", "::", "v4i32", ";", "break", ";", "}", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "VT", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "offset", "=", "-", "VT", ".", "getStoreSize", "(", ")", "+", "<NUM_LIT>", ";", "Info", ".", "size", "=", "<NUM_LIT>", "*", "VT", ".", "getStoreSize", "(", ")", "-", "<NUM_LIT>", ";", "Info", ".", "align", "=", "<NUM_LIT>", ";", "Info", ".", "vol", "=", "false", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "false", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "ppc_altivec_stvx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvxl", ":", "case", "Intrinsic", "::", "ppc_altivec_stvebx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvehx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvewx", ":", "{", "EVT", "VT", ";", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "ppc_altivec_stvebx", ":", "VT", "=", "MVT", "::", "i8", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_stvehx", ":", "VT", "=", "MVT", "::", "i16", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_stvewx", ":", "VT", "=", "MVT", "::", "i32", ";", "break", ";", "default", ":", "VT", "=", "MVT", "::", "v4i32", ";", "break", ";", "}", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "Info", ".", "memVT", "=", "VT", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "offset", "=", "-", "VT", ".", "getStoreSize", "(", ")", "+", "<NUM_LIT>", ";", "Info", ".", "size", "=", "<NUM_LIT>", "*", "VT", ".", "getStoreSize", "(", ")", "-", "<NUM_LIT>", ";", "Info", ".", "align", "=", "<NUM_LIT>", ";", "Info", ".", "vol", "=", "false", ";", "Info", ".", "readMem", "=", "false", ";", "Info", ".", "writeMem", "=", "true", ";", "return", "true", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

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

[ "vmlal_u8", "(", "uint16x8_t", "_", "_", "a", ",", "uint8x8_t", "_", "_" ]

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

[ "static", "void", "arm_asm_init_sections", "(", "void", ")", "{", "exception_section", "=", "get_unnamed_section", "(", "<NUM_LIT>", ",", "output_section_asm_op", ",", "<STR_LIT>", "\\t.handlerdata" ]

[ "(", "MaxSize", ")", ",", "SyncID", "(", "SyncID", ")", ",", "TII", "(", "TII", ")", ",", "DAG", "(", "DAG", ")", "{" ]

[ "SchedGroup", "(", "SchedGroupMask", "SGMask", ",", "std", "::", "optional", "<", "unsigned", ">", "MaxSize", ",", "int", "SyncID", ",", "ScheduleDAGInstrs", "*", "DAG", ",", "const", "SIInstrInfo", "*", "TII", ")", ":", "SGMask", "(", "SGMask", ")", ",", "MaxSize" ]

[ "<STR_LIT>" ]

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

[ ".", "createDFAPacketizer", "(", "II", ")", ";" ]

[ "return", "TM", "->", "getSubtarget", "<", "HexagonGenSubtargetInfo", ">", "(", ")" ]

[ "}" ]

[ "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "getMSACtrlReg", "(", ")", ")", ")", ";" ]

[ ";" ]

[ "def", "J4_tstbit0_t_jumpnv_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Ns8", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_8c945be0", ",", "TypeNCJ", ">", ",", "Enc_69d63b", "{", "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", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>" ]

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

[ "(", "plus", ":", "I48MODE", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "DI", "[", "(", "unspec", ":", "DI", "[", "(", "mem", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", ")", "]" ]

[ "}", "=", "Rm", ";" ]

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

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

[ "class", "InstVRV", "<", "bits", "<", "<NUM_LIT>", ">", "op", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "InstSystemZ", "<", "<NUM_LIT>", ",", "outs", ",", "ins", ",", "asmstr", ",", "pattern", ">", "{", "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "V1", ";", "bits", "<", "<NUM_LIT>", ">", "VBD2", ";", "bits", "<", "<NUM_LIT>", ">", "M3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "VBD2", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "M3", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "}", ";" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", "CC_REGNUM", ")", "(", "compare", "(", "match_operand", ":", "HQI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "HQI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "HQI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]" ]

[ "if", "(", "I", "==", "<NUM_LIT>", ")", "ElemTypeId", "=", "addType", "(", "std", "::", "move", "(", "TypeEntry", ")", ",", "CTy", ")", ";" ]

[ "auto", "TypeEntry", "=", "llvm", "::", "make_unique", "<", "BTFTypeArray", ">", "(", "ElemType", ",", "ElemTypeId", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "ArrayTypes", ".", "push_back", "(", "TypeEntry", ".", "get", "(", ")", ")", ";", "ElemTypeId", "=", "addType", "(", "std", "::", "move", "(", "TypeEntry", ")", ",", "CTy", ")", ";", "}", "else", "{", "DINodeArray", "Elements", "=", "CTy", "->", "getElements", "(", ")", ";", "for", "(", "int", "I", "=", "Elements", ".", "size", "(", ")", "-", "<NUM_LIT>", ";", "I", ">=", "<NUM_LIT>", ";", "--", "I", ")", "{", "if", "(", "auto", "*", "Element", "=", "dyn_cast_or_null", "<", "DINode", ">", "(", "Elements", "[", "I", "]", ")", ")", "if", "(", "Element", "->", "getTag", "(", ")", "==", "dwarf", "::", "DW_TAG_subrange_type", ")", "{", "const", "DISubrange", "*", "SR", "=", "cast", "<", "DISubrange", ">", "(", "Element", ")", ";", "auto", "*", "CI", "=", "SR", "->", "getCount", "(", ")", ".", "dyn_cast", "<", "ConstantInt", "*", ">", "(", ")", ";", "int64_t", "Count", "=", "CI", "->", "getSExtValue", "(", ")", ";", "const", "DIType", "*", "ArrayElemTy", "=", "(", "I", "==", "<NUM_LIT>", ")", "?", "ElemType", ":", "nullptr", ";", "auto", "TypeEntry", "=", "llvm", "::", "make_unique", "<", "BTFTypeArray", ">", "(", "ArrayElemTy", ",", "ElemTypeId", ",", "ElemSize", ",", "Count", ")", ";", "ArrayTypes", ".", "push_back", "(", "TypeEntry", ".", "get", "(", ")", ")", ";" ]

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

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

[ "unsigned", "NumPredBBs", "=", "MBB", ".", "pred_size", "(", ")", ";", "if", "(", "NumPredBBs", "==", "<NUM_LIT>", ")", "{", "MachineBasicBlock", "*", "TmpMBB", "=", "*", "MBB", ".", "pred_begin", "(", ")", ";", "if", "(", "isEligibleBB", "(", "*", "TmpMBB", ")", ")", "{", "PredMBB", "=", "TmpMBB", ";", "MBBtoMoveCmp", "=", "nullptr", ";", "return", "true", ";", "}", "}", "else", "if", "(", "NumPredBBs", "==", "<NUM_LIT>", ")", "{", "MachineBasicBlock", "::", "pred_iterator", "PI", "=", "MBB", ".", "pred_begin", "(", ")", ";", "MachineBasicBlock", "*", "Pred1MBB", "=", "*", "PI", ";", "MachineBasicBlock", "*", "Pred2MBB", "=", "*", "(", "PI", "+", "<NUM_LIT>", ")", ";", "if", "(", "isEligibleBB", "(", "*", "Pred1MBB", ")", "&&", "isEligibleForMoveCmp", "(", "*", "Pred2MBB", ")", ")", "{", "}", "else", "if", "(", "isEligibleBB", "(", "*", "Pred2MBB", ")", "&&", "isEligibleForMoveCmp", "(", "*", "Pred1MBB", ")", ")", "{", "std", "::", "swap", "(", "Pred1MBB", ",", "Pred2MBB", ")", ";", "}", "else", "return", "false", ";", "if", "(", "Pred1MBB", "==", "&", "MBB", ")", "return", "false", ";", "MachineInstr", "*", "BI", "=", "&", "*", "MBB", "." ]

[ "}" ]

[ "static", "bool", "avr_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "(", "frame_pointer_needed", "&&", "to", "==", "FRAME_POINTER_REGNUM", ")", "||", "!", "frame_pointer_needed", ")", ";" ]

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

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

[ "bool", "LanaiInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ")", "const", "{", "assert", "(", "MIa", ".", "mayLoadOrStore", "(", ")", "&&", "<STR_LIT>", "MIa must be a load or store.", "<STR_LIT>", ")", ";", "assert", "(", "MIb", ".", "mayLoadOrStore", "(", ")", "&&", "<STR_LIT>", "MIb must be a load or store.", "<STR_LIT>", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "const", "MachineOperand", "*", "BaseOpA", "=", "nullptr", ",", "*", "BaseOpB", "=", "nullptr", ";", "int64_t", "OffsetA", "=", "<NUM_LIT>", ",", "OffsetB", "=", "<NUM_LIT>", ";", "unsigned", "int", "WidthA", "=", "<NUM_LIT>", ",", "WidthB", "=", "<NUM_LIT>", ";", "if", "(", "getMemOperandWithOffsetWidth", "(", "MIa", ",", "BaseOpA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getMemOperandWithOffsetWidth", "(", "MIb", ",", "BaseOpB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseOpA", "->", "isIdenticalTo", "(", "*", "BaseOpB", ")", ")", "{", "int", "LowOffset", "=", "std", "::", "min", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "HighOffset", "=", "std", "::", "max", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "if", "(", "IMemI", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "prefetch", "||", "IMemI", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "ppc_vsx_lxvp", ")", "{" ]

[ "Type", "*", "PointerElementType", "=", "nullptr", ";", "if", "(", "LoadInst", "*", "LMemI", "=", "dyn_cast", "<", "LoadInst", ">", "(", "MemI", ")", ")", "{", "PtrValue", "=", "LMemI", "->", "getPointerOperand", "(", ")", ";", "PointerElementType", "=", "LMemI", "->", "getType", "(", ")", ";", "}", "else", "if", "(", "StoreInst", "*", "SMemI", "=", "dyn_cast", "<", "StoreInst", ">", "(", "MemI", ")", ")", "{", "PtrValue", "=", "SMemI", "->", "getPointerOperand", "(", ")", ";", "PointerElementType", "=", "SMemI", "->", "getValueOperand", "(", ")", "->", "getType", "(", ")", ";", "}", "else", "if", "(", "IntrinsicInst", "*", "IMemI", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "MemI", ")", ")", "{", "PointerElementType", "=", "Type", "::", "getInt8Ty", "(", "MemI", "->", "getContext", "(", ")", ")", ";" ]

[ "rtx", "i", "=", "get_insns", "(", ")", ";" ]

[ "if", "(", "GET_MODE", "(", "dst_reg", ")", "==", "SImode", ")", "emit_move_insn", "(", "dst_reg", ",", "m_ccreg", ")", ";", "else", "if", "(", "GET_MODE", "(", "dst_reg", ")", "==", "DImode", ")", "{", "emit_move_insn", "(", "gen_lowpart", "(", "SImode", ",", "dst_reg", ")", ",", "m_ccreg", ")", ";", "emit_move_insn", "(", "gen_highpart", "(", "SImode", ",", "dst_reg", ")", ",", "const0_rtx", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";" ]

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

[ "(", "ior", ":", "MVE_0", "(", "not", ":", "MVE_0", "(", "match_operand", ":", "MVE_0", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "MVE_0", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "BuildMI", "(", "*", "BB", ",", "MI", ",", "dl", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "X86", "::", "EAX", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";" ]

[ "const", "TargetInstrInfo", "*", "TII", "=", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "dl", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "X86", "::", "ECX", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";" ]

[ "<FIXS>", "LC", "=", "IsSigned", "?", "RTLIB", "::", "SDIVREM_I8", ":", "RTLIB", "::", "UDIVREM_I8", ";", "<FIXE>", "<FIXS>", "LC", "=", "IsSigned", "?", "RTLIB", "::", "SDIVREM_I16", ":", "RTLIB", "::", "UDIVREM_I16", ";", "<FIXE>", "<FIXS>", "LC", "=", "IsSigned", "?", "RTLIB", "::", "SDIVREM_I32", ":", "RTLIB", "::", "UDIVREM_I32", ";", "<FIXE>", "<FIXS>", "LC", "=", "IsSigned", "?", "RTLIB", "::", "SDIVREM_I64", ":", "RTLIB", "::", "UDIVREM_I64", ";", "<FIXE>" ]

[ "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected request for libcall!", "<STR_LIT>", ")", ";", "case", "MVT", "::", "i8", ":", "<BUGS>", "LC", "=", "isSigned", "?", "RTLIB", "::", "SDIVREM_I8", ":", "RTLIB", "::", "UDIVREM_I8", ";", "<BUGE>", "break", ";", "case", "MVT", "::", "i16", ":", "<BUGS>", "LC", "=", "isSigned", "?", "RTLIB", "::", "SDIVREM_I16", ":", "RTLIB", "::", "UDIVREM_I16", ";", "<BUGE>", "break", ";", "case", "MVT", "::", "i32", ":", "<BUGS>", "LC", "=", "isSigned", "?", "RTLIB", "::", "SDIVREM_I32", ":", "RTLIB", "::", "UDIVREM_I32", ";", "<BUGE>", "break", ";", "case", "MVT", "::", "i64", ":", "<BUGS>", "LC", "=", "isSigned", "?", "RTLIB", "::", "SDIVREM_I64", ":", "RTLIB", "::", "UDIVREM_I64", ";", "<BUGE>", "break", ";", "}" ]

[ ")", ",", "-", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";" ]

[ "static", "unsigned", "int", "h8300_constant_length", "(", "rtx", "constant", ")", "{", "if", "(", "GET_CODE", "(", "constant", ")", "==", "CONST_INT", "&&", "IN_RANGE", "(", "INTVAL", "(", "constant" ]

[ "}" ]

[ "let", "addrMode", "=", "AbsoluteSet", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "struct", "machine_function", ")", ")", ";" ]

[ "static", "struct", "machine_function", "*", "mmix_init_machine_status", "(", "void", ")", "{", "return", "ggc_alloc_cleared", "(", "sizeof", "(" ]

[ "(", "V16QI", "<STR_LIT>", ")", "(", "V8HI", "<STR_LIT>", ")" ]

[ "(", "V4SI", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")", "(", "V8SI", "<STR_LIT>", ")", "(", "V8SF", "<STR_LIT>", ")", "(", "V16SI", "<STR_LIT>", ")", "(", "V16SF", "<STR_LIT>", ")" ]

[ "}" ]

[ "case", "Hexagon", "::", "PS_vloadrv_ai", ":", "case", "Hexagon", "::", "PS_vloadrv_nt_ai", ":", "case", "Hexagon", "::", "PS_vstorerv_ai", ":", "case", "Hexagon", "::", "PS_vstorerv_nt_ai", ":", "case", "Hexagon", "::", "V6_vL32b_ai", ":", "case", "Hexagon", "::", "V6_vS32b_ai", ":", "{", "unsigned", "HwLen", "=", "HST", ".", "getVectorLength", "(", ")", ";", "if", "(", "RealOffset", "%", "HwLen", "==", "<NUM_LIT>", ")", "{", "int", "VecOffset", "=", "RealOffset", "/", "HwLen", ";", "VecOffset", "+=", "<NUM_LIT>", ";", "if", "(", "!", "IsPair", "||", "(", "VecOffset", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", "!=", "<NUM_LIT>", ")", "{", "RealOffset", "=", "(", "VecOffset", "&", "-", "<NUM_LIT>", ")", "*", "HwLen", ";", "InstOffset", "=", "(", "VecOffset", "%", "<NUM_LIT>", "-", "<NUM_LIT>", ")", "*", "HwLen", ";", "}", "}", "}", "}", "Register", "ReuseBP", ";", "if", "(", "ReuseCount", "<", "FrameIndexReuseLimit", ")", "{", "unsigned", "SearchCount", "=", "<NUM_LIT>", ",", "SearchRange", "=", "FrameIndexSearchRange", ";", "SmallSet", "<", "Register", ",", "<NUM_LIT>", ">", "SeenVRegs", ";", "bool", "PassedCall", "=", "false", ";", "LiveRegUnits", "Defs", "(", "*", "this", ")", ",", "Uses", "(", "*", "this", ")", ";", "for", "(", "auto", "I", "=", "std", "::", "next", "(", "II", ".", "getReverse", "(", ")", ")", ",", "E", "=", "MB", ".", "rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "SearchCount", "==", "SearchRange", ")", "break", ";", "++", "SearchCount", ";", "const", "MachineInstr", "&", "BI", "=", "*", "I", ";", "LiveRegUnits", "::", "accumulateUsedDefed", "(", "BI", ",", "Defs", ",", "Uses", ",", "this", ")", ";", "PassedCall", "|=", "BI", ".", "isCall", "(", ")", ";", "for", "(", "const", "MachineOperand", "&", "Op", ":", "BI", ".", "operands", "(", ")", ")", "{", "if", "(", "SeenVRegs", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "break", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "getReg", "(", ")", ".", "isVirtual", "(", ")", ")", "SeenVRegs", ".", "insert", "(", "Op", ".", "getReg", "(", ")", ")", ";", "}", "if", "(", "BI", ".", "getOpcode", "(", ")", "!=", "Hexagon", "::", "A2_addi", ")", "continue", ";", "if", "(", "BI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "!=", "BP", ")", "continue", ";", "const", "auto", "&", "Op2", "=", "BI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "Op2", ".", "isImm", "(", ")", "||", "Op2", ".", "getImm", "(", ")", "!=", "RealOffset", ")", "continue", ";", "Register", "R", "=", "BI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "R", ".", "isPhysical", "(", ")", ")", "{", "if", "(", "Defs", ".", "available", "(", "R", ")", ")", "ReuseBP", "=", "R", ";", "}", "else", "if", "(", "R", ".", "isVirtual", "(", ")", ")", "{", "if", "(", "!", "PassedCall", "&&", "SeenVRegs", ".", "size", "(", ")", "<=", "<NUM_LIT>", ")", "ReuseBP", "=", "R", ";", "}", "break", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask3_fmaddsub_round_pd", "(", "_", "_", "m512d", "_", "_", "A", ",", "_", "_", "m512d", "_", "_", "B", ",", "_", "_", "m512d", "_", "_", "C", ",", "_", "_", "mmask8", "_", "_", "U", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_vfmaddsubpd512_mask3", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8df", ")", "_", "_", "B", ",", "(", "_", "_", "v8df", ")", "_", "_", "C", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "_", "R", ")", ";" ]

[ "FoldList", ".", "push_back", "(", "FoldCandidate", "(", "MI", ",", "CommuteOpNo", ",", "OpToFold", ",", "true", ")", ")", ";" ]

[ "if", "(", "FoldAsMAD", ")", "{", "MI", "->", "untieRegOperand", "(", "OpNo", ")", ";", "return", "true", ";", "}", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "Opc", ")", ")", ";", "}", "if", "(", "Opc", "==", "AMDGPU", "::", "S_SETREG_B32", "&&", "OpToFold", "->", "isImm", "(", ")", ")", "{", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "AMDGPU", "::", "S_SETREG_IMM32_B32", ")", ")", ";", "FoldList", ".", "push_back", "(", "FoldCandidate", "(", "MI", ",", "OpNo", ",", "OpToFold", ")", ")", ";", "return", "true", ";", "}", "if", "(", "isUseMIInFoldList", "(", "FoldList", ",", "MI", ")", ")", "return", "false", ";", "unsigned", "CommuteOpNo", "=", "OpNo", ";", "unsigned", "CommuteIdx0", "=", "TargetInstrInfo", "::", "CommuteAnyOperandIndex", ";", "unsigned", "CommuteIdx1", "=", "TargetInstrInfo", "::", "CommuteAnyOperandIndex", ";", "bool", "CanCommute", "=", "TII", "->", "findCommutedOpIndices", "(", "*", "MI", ",", "CommuteIdx0", ",", "CommuteIdx1", ")", ";", "if", "(", "CanCommute", ")", "{", "if", "(", "CommuteIdx0", "==", "OpNo", ")", "CommuteOpNo", "=", "CommuteIdx1", ";", "else", "if", "(", "CommuteIdx1", "==", "OpNo", ")", "CommuteOpNo", "=", "CommuteIdx0", ";", "}", "if", "(", "CanCommute", "&&", "(", "!", "MI", "->", "getOperand", "(", "CommuteIdx0", ")", ".", "isReg", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "CommuteIdx1", ")", ".", "isReg", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "CanCommute", "||", "!", "TII", "->", "commuteInstruction", "(", "*", "MI", ",", "false", ",", "CommuteIdx0", ",", "CommuteIdx1", ")", ")", "return", "false", ";", "if", "(", "!", "TII", "->", "isOperandLegal", "(", "*", "MI", ",", "CommuteOpNo", ",", "OpToFold", ")", ")", "{", "if", "(", "(", "Opc", "==", "AMDGPU", "::", "V_ADD_I32_e64", "||", "Opc", "==", "AMDGPU", "::", "V_SUB_I32_e64", "||", "Opc", "==", "AMDGPU", "::", "V_SUBREV_I32_e64", ")", "&&", "(", "OpToFold", "->", "isImm", "(", ")", "||", "OpToFold", "->", "isFI", "(", ")", "||", "OpToFold", "->", "isGlobal", "(", ")", ")", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "OtherIdx", "=", "CommuteOpNo", "==", "CommuteIdx0", "?", "CommuteIdx1", ":", "CommuteIdx0", ";", "MachineOperand", "&", "OtherOp", "=", "MI", "->", "getOperand", "(", "OtherIdx", ")", ";", "if", "(", "!", "OtherOp", ".", "isReg", "(", ")", "||", "!", "TII", "->", "getRegisterInfo", "(", ")", ".", "isVGPR", "(", "MRI", ",", "OtherOp", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "assert", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDef", "(", ")", ")", ";", "unsigned", "MaybeCommutedOpc", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Op32", "=", "AMDGPU", "::", "getVOPe32", "(", "MaybeCommutedOpc", ")", ";", "FoldList", ".", "push_back", "(", "FoldCandidate", "(", "MI", ",", "CommuteOpNo", ",", "OpToFold", ",", "true", ",", "Op32", ")", ")", ";", "return", "true", ";", "}", "TII", "->", "commuteInstruction", "(", "*", "MI", ",", "false", ",", "CommuteIdx0", ",", "CommuteIdx1", ")", ";", "return", "false", ";", "}" ]

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

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

[ "false", ";" ]

[ "Result", ".", "reset", "(", ")", ";", "return" ]

[ "default", ":" ]

[ "switch", "(", "NT", ")", "{", "case", "Function", ":", "return", "{", "<STR_LIT>", "function", "<STR_LIT>", ",", "<STR_LIT>", "end_function", "<STR_LIT>", "}", ";", "case", "Block", ":", "return", "{", "<STR_LIT>", "block", "<STR_LIT>", ",", "<STR_LIT>", "end_block", "<STR_LIT>", "}", ";", "case", "Loop", ":", "return", "{", "<STR_LIT>", "loop", "<STR_LIT>", ",", "<STR_LIT>", "end_loop", "<STR_LIT>", "}", ";", "case", "Try", ":", "return", "{", "<STR_LIT>", "try", "<STR_LIT>", ",", "<STR_LIT>", "end_try/delegate", "<STR_LIT>", "}", ";", "case", "CatchAll", ":", "return", "{", "<STR_LIT>", "catch_all", "<STR_LIT>", ",", "<STR_LIT>", "end_try", "<STR_LIT>", "}", ";", "case", "If", ":", "return", "{", "<STR_LIT>", "if", "<STR_LIT>", ",", "<STR_LIT>", "end_if", "<STR_LIT>", "}", ";", "case", "Else", ":", "return", "{", "<STR_LIT>", "else", "<STR_LIT>", ",", "<STR_LIT>", "end_if", "<STR_LIT>", "}", ";" ]

[ "static", "int", "fast_interrupt_p", "(", "tree", "node", "ATTRIBUTE_UNUSED", ")", "{", "tree", "list", "=", "M32C_ATTRIBUTES", "(", "node", ")", ";", "while", "(", "list", ")", "{", "if", "(", "is_attribute_p", "(", "<STR_LIT>", "fast_interrupt", "<STR_LIT>", ",", "TREE_PURPOSE", "(", "list", ")", ")", ")", "return", "<NUM_LIT>", ";", "list", "=", "TREE_CHAIN", "(", "list", ")", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "Returns", "TRUE", "if", "the", "given", "tree", "has", "the", "``", "fast_interrupt", "''", "attribute", "." ]

[ "for", "(", "auto", "&", "Op", ":", "MI", ".", "explicit_uses", "(", ")", ")", "{" ]

[ "auto", "*", "CP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "int", "Size", "=", "CP", "->", "getConstants", "(", ")", ".", "size", "(", ")", ";", "int", "*", "Indices", "=", "new", "int", "[", "Size", "]", ";", "for", "(", "int", "Old", "=", "<NUM_LIT>", ",", "New", "=", "<NUM_LIT>", ";", "Old", "<", "Size", ";", "++", "Old", ")", "{", "Indices", "[", "Old", "]", "=", "CPIndices", ".", "count", "(", "Old", ")", "?", "-", "<NUM_LIT>", ":", "New", "++", ";", "}", "for", "(", "auto", "&", "BB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "BB", ")", "{" ]

[ ")", ";" ]

[ "auto", "*", "I", "=", "Use", ".", "getParent", "(", ")", ";", "if", "(", "I", "->", "getParent", "(", ")", "!=", "BB", ")", "return", "false", ";", "Uses", ".", "insert", "(", "I", ")", ";", "}", "auto", "E", "=", "BB", "->", "end", "(", ")", ";", "for", "(", "auto", "I", "=", "std", "::", "next", "(", "DefI", "->", "getIterator", "(", ")", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Uses", ".", "erase", "(", "&", "*", "I", ")", ";", "if", "(", "Uses", ".", "empty", "(", ")", "||", "I", "->", "modifiesRegister", "(", "AMDGPU", "::", "EXEC", ",", "TRI", ")", ")", "break", ";", "}", "return", "Uses", ".", "empty", "(" ]

[ "<FIXS>", "rtx", "op1", "=", "ix86_expand_fast_convert_bf_to_sf", "(", "operands", "[", "<NUM_LIT>", "]", ")", "rtx", "op2", "=", "ix86_expand_fast_convert_bf_to_sf", "(", "operands", "[", "<NUM_LIT>", "]", ")", "<FIXE>" ]

[ "(", "pc", ")", ")", ")", "]", "<STR_LIT>", "{", "<BUGS>", "rtx", "op1", "=", "gen_lowpart", "(", "HImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "if", "(", "CONST_INT_P", "(", "op1", ")", ")", "op1", "=", "simplify_const_unary_operation", "(", "FLOAT_EXTEND", ",", "SFmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "BFmode", ")", "else", "{", "rtx", "t1", "=", "gen_reg_rtx", "(", "SImode", ")", "emit_insn", "(", "gen_zero_extendhisi2", "(", "t1", ",", "op1", ")", ")", "emit_insn", "(", "gen_ashlsi3", "(", "t1", ",", "t1", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", "op1", "=", "gen_lowpart", "(", "SFmode", ",", "t1", ")", "}", "rtx", "op2", "=", "gen_lowpart", "(", "HImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "if", "(", "CONST_INT_P", "(", "op2", ")", ")", "op2", "=", "simplify_const_unary_operation", "(", "FLOAT_EXTEND", ",", "SFmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "BFmode", ")", "else", "{", "rtx", "t2", "=", "gen_reg_rtx", "(", "SImode", ")", "emit_insn", "(", "gen_zero_extendhisi2", "(", "t2", ",", "op2", ")", ")", "emit_insn", "(", "gen_ashlsi3", "(", "t2", ",", "t2", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", "op2", "=", "gen_lowpart", "(", "SFmode", ",", "t2", ")", "}", "<BUGE>", "do_compare_rtx_and_jump", "(", "op1", ",", "op2", ",", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "<NUM_LIT>", ",", "SFmode", ",", "NULL_RTX", ",", "NULL", ",", "as_a", "rtx_code_label", "*", ">", "(", "operands", "[", "<NUM_LIT>", "]", ")", "," ]

[ "auto", "*", "Node", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ".", "getNode", "(", ")", ")", ";" ]

[ "SDLoc", "DL", "(", "Op", ")", ";", "bool", "IsWrite", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "Code", "=", "IsWrite", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "emit_move_insn", "(", "rampx_rtx", ",", "all_regs_rtx", "[", "treg", "]", ")", ";" ]

[ "if", "(", "TARGET_NO_INTERRUPTS", ")", "irq_state", "=", "<NUM_LIT>", ";", "if", "(", "AVR_HAVE_8BIT_SP", ")", "irq_state", "=", "<NUM_LIT>", ";", "emit_insn", "(", "gen_movhi_sp_r", "(", "stack_pointer_rtx", ",", "fp", ",", "GEN_INT", "(", "irq_state", ")", ")", ")", ";", "fp_plus_insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "if", "(", "avr_sp_immediate_operand", "(", "gen_int_mode", "(", "size", ",", "HImode", ")", ",", "HImode", ")", ")", "{", "rtx_insn", "*", "sp_plus_insns", ";", "start_sequence", "(", ")", ";", "emit_move_insn", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "size", ")", ")", ";", "sp_plus_insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_insn", "(", "get_sequence_length", "(", "sp_plus_insns", ")", "<", "get_sequence_length", "(", "fp_plus_insns", ")", "?", "sp_plus_insns", ":", "fp_plus_insns", ")", ";", "}", "else", "emit_insn", "(", "fp_plus_insns", ")", ";", "}", "if", "(", "frame_pointer_needed", "&&", "!", "(", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", ")", ")", "{", "emit_pop_byte", "(", "REG_Y", "+", "<NUM_LIT>", ")", ";", "emit_pop_byte", "(", "REG_Y", ")", ";", "}", "int", "treg", "=", "AVR_TMP_REGNO", ";", "if", "(", "isr_p", "&&", "cfun", "->", "machine", "->", "gasisr", ".", "yes", ")", "{", "treg", "=", "cfun", "->", "machine", "->", "gasisr", ".", "regno", ";", "CLEAR_HARD_REG_BIT", "(", "set", ",", "treg", ")", ";", "}", "for", "(", "int", "reg", "=", "<NUM_LIT>", ";", "reg", ">=", "<NUM_LIT>", ";", "--", "reg", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "set", ",", "reg", ")", ")", "emit_pop_byte", "(", "reg", ")", ";", "if", "(", "isr_p", ")", "{", "if", "(", "AVR_HAVE_RAMPZ", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", "+", "<NUM_LIT>", ")", ")", "{", "emit_pop_byte", "(", "treg", ")", ";", "emit_move_insn", "(", "rampz_rtx", ",", "all_regs_rtx", "[", "treg", "]", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPY", "&&", "(", "frame_pointer_needed", "||", "(", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", "+", "<NUM_LIT>", ")", ")", ")", ")", "{", "emit_pop_byte", "(", "treg", ")", ";", "emit_move_insn", "(", "rampy_rtx", ",", "all_regs_rtx", "[", "treg", "]", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPX", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", "+", "<NUM_LIT>", ")", ")", "{", "emit_pop_byte", "(", "treg", ")", ";" ]

[ ")" ]

[ "(", "ANY_EXTEND", ":", "<", "VWIDE", ">", "(", "vec_duplicate", ":", "<", "VCOND", ">", "(", "match_operand", ":", "<", "VEL", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "==", "CallingConv", "::", "SwiftTail", ";" ]

[ "return", "(", "GuaranteedTailCallOpt", "&&", "canGuaranteeTCO", "(", "CC", ")", ")", "||", "CC", "==", "CallingConv", "::", "Tail", "||", "CC" ]

[ "}" ]

[ "InitTL45MCRegisterInfo", "(", "X", ",", "<NUM_LIT>", ")", ";", "return", "X", ";" ]

[ "$", "SPR", ",", "gprc", ":", "$", "RT", ")", ",", "<STR_LIT>", ",", "IIC_SprMTPMR", ">", ";" ]

[ "def", "MTPMR", ":", "XFXForm_1", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "i32imm", ":" ]

[ "<STR_LIT>", ")", ",", "[", "]", ",", "II_JR", ",", "FrmR", ">", ",", "MMR6Arch", "<", "opstr", ">", ",", "MicroMipsR6Inst16", "{" ]

[ "class", "JRC16_MMR6_DESC_BASE", "<", "string", "opstr", ",", "RegisterOperand", "RO", ">", ":", "MicroMipsInst16", "<", "(", "outs", ")", ",", "(", "ins", "RO", ":", "$", "rs", ")", ",", "!", "strconcat", "(", "opstr", "," ]

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

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "if_then_else", ":", "V8QI", "(", "ne", ":", "V8QI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_vector", ":", "V8QI", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_vector", ":", "V8QI", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")" ]

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

[ "addPass", "(", "createGBZ80PreRAPass", "(" ]

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

[ "(", "us_plus", ":", "UADDSUB", "(", "match_operand", ":", "UADDSUB", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "UADDSUB", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":", "CCDSP", "CCDSP_OU_REGNUM", ")", "(", "unspec", ":", "CCDSP", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_ADDQ_S" ]

[ "<STR_LIT>", ")" ]

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

[ "SI", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")", "]", ")" ]

[ "(", "define_mode_attr", "size", "[", "(", "QI", "<STR_LIT>", ")", "(", "HI", "<STR_LIT>", ")", "(" ]

[ "unsigned", "P2MCCodeEmitter", "::", "getJumpTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "<STR_LIT>", "getJumpTargetOpValue expects only expressions", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "--- creating fixup for jump operand\\n", "<STR_LIT>", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "<NUM_LIT>", ",", "Expr", ",", "MCFixupKind", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ")", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "getJumpTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "jump", "target", "operand", "." ]

[ ";" ]

[ "def", "J2_jump", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_ae53734a", ",", "TypeJ", ">", ",", "Enc_81ac1d", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>" ]

[ "<FIXS>", "bool", "IsSigned", ",", "SDValue", "&", "Chain", ")", "const", "{", "bool", "IsStrict", "=", "Op", "->", "isStrictFPOpcode", "(", ")", ";", "<FIXE>", "<FIXS>", "SDValue", "Value", "=", "Op", ".", "getOperand", "(", "IsStrict", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "EVT", "TheVT", "=", "Value", ".", "getValueType", "(", ")", ";", "<FIXE>" ]

[ "SDValueX86TargetLowering", "::", "FP_TO_INTHelper", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "<BUGS>", "bool", "IsSigned", ")", "const", "{", "<BUGE>", "SDLoc", "DL", "(", "Op", ")", ";", "EVT", "DstTy", "=", "Op", ".", "getValueType", "(", ")", ";", "<BUGS>", "EVT", "TheVT", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "<BUGE>", "auto", "PtrVT", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "if", "(", "TheVT", "!=", "MVT", "::", "f32", "&&", "TheVT", "!=", "MVT", "::", "f64", "&&", "TheVT", "!=", "MVT", "::", "f80", ")", "{" ]

[ "<FIXS>", "DiagnosticInfoUnsupported", "NoGraphicsHSA", "(", "*", "Fn", ",", "<STR_LIT>", "unsupported non-compute shaders with HSA", "<STR_LIT>", ",", "DL", ")", ";", "<FIXE>" ]

[ "if", "(", "Subtarget", "->", "isAmdHsaOS", "(", ")", "&&", "Info", "->", "getShaderType", "(", ")", "!=", "ShaderType", "::", "COMPUTE", ")", "{", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "<BUGS>", "DiagnosticInfoUnsupported", "NoGraphicsHSA", "(", "*", "Fn", ",", "<STR_LIT>", "non-compute shaders with HSA", "<STR_LIT>", ")", ";", "<BUGE>", "DAG", ".", "getContext", "(", ")", "->", "diagnose", "(", "NoGraphicsHSA", ")", ";", "return", "SDValue", "(", ")", ";", "}" ]

[ "SDValue", "ZeroIndex", "=", "DAG", ".", "getVectorIdxConstant", "(", "<NUM_LIT>", ",", "DL", ")", ";" ]

[ "if", "(", "!", "(", "(", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", "&&", "N1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", "||", "(", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SETCC", "&&", "N1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SETCC", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "N00", "=", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "N10", "=", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "N00Type", "=", "N00", ".", "getValueType", "(", ")", ";", "EVT", "N10Type", "=", "N10", ".", "getValueType", "(", ")", ";", "if", "(", "N00Type", "!=", "N10Type", "||", "!", "(", "(", "Subtarget", ".", "hasSSE1", "(", ")", "&&", "N00Type", "==", "MVT", "::", "f32", ")", "||", "(", "Subtarget", ".", "hasSSE2", "(", ")", "&&", "N00Type", "==", "MVT", "::", "f64", ")", "||", "(", "Subtarget", ".", "hasFP16", "(", ")", "&&", "N00Type", "==", "MVT", "::", "f16", ")", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", "&&", "!", "DCI", ".", "isBeforeLegalizeOps", "(", ")", ")", "{", "unsigned", "FPOpcode", "=", "convertIntLogicToFPLogicOpcode", "(", "N", "->", "getOpcode", "(", ")", ")", ";", "SDValue", "FPLogic", "=", "DAG", ".", "getNode", "(", "FPOpcode", ",", "DL", ",", "N00Type", ",", "N00", ",", "N10", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "FPLogic", ")", ";", "}", "if", "(", "VT", "!=", "MVT", "::", "i1", "||", "N0", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SETCC", "||", "!", "N0", ".", "hasOneUse", "(", ")", "||", "!", "N1", ".", "hasOneUse", "(", ")", ")", "return", "SDValue", "(", ")", ";", "ISD", "::", "CondCode", "CC0", "=", "cast", "<", "CondCodeSDNode", ">", "(", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "ISD", "::", "CondCode", "CC1", "=", "cast", "<", "CondCodeSDNode", ">", "(", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "hasAVX", "(", ")", "&&", "!", "(", "cheapX86FSETCC_SSE", "(", "CC0", ")", "&&", "cheapX86FSETCC_SSE", "(", "CC1", ")", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "NumElts", "=", "<NUM_LIT>", "/", "N00Type", ".", "getSizeInBits", "(", ")", ";", "EVT", "VecVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "N00Type", ",", "NumElts", ")", ";", "EVT", "BoolVecVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "i1", ",", "NumElts", ")", ";" ]

[ "}" ]

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

[ "static", "bool", "expand_vec_perm_pshufb2", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "rtx", "rperm", "[", "<NUM_LIT>", "]", "[", "<NUM_LIT>", "]", ",", "vperm", ",", "l", ",", "h", ",", "op", ",", "m128", ";", "unsigned", "int", "i", ",", "nelt", ",", "eltsz", ";", "if", "(", "!", "TARGET_SSSE3", "||", "GET_MODE_SIZE", "(", "d", "->", "vmode", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "gcc_assert", "(", "!", "d", "->", "one_operand_p", ")", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "nelt", "=", "d", "->", "nelt", ";", "eltsz", "=", "GET_MODE_SIZE", "(", "GET_MODE_INNER", "(", "d", "->", "vmode", ")", ")", ";", "m128", "=", "GEN_INT", "(", "-", "<NUM_LIT>", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "unsigned", "j", ",", "e", "=", "d", "->", "perm", "[", "i", "]", ";", "unsigned", "which", "=", "(", "e", ">=", "nelt", ")", ";", "if", "(", "e", ">=", "nelt", ")", "e", "-=", "nelt", ";", "for", "(", "j", "=", "<NUM_LIT>", ";", "j", "<", "eltsz", ";", "++", "j", ")", "{", "rperm", "[", "which", "]", "[", "i", "*", "eltsz", "+", "j", "]", "=", "GEN_INT", "(", "e", "*", "eltsz", "+", "j", ")", ";", "rperm", "[", "<NUM_LIT>", "-", "which", "]", "[", "i", "*", "eltsz", "+", "j", "]", "=", "m128", ";", "}", "}", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V16QImode", ",", "gen_rtvec_v", "(", "<NUM_LIT>", ",", "rperm", "[", "<NUM_LIT>", "]", ")", ")", ";", "vperm", "=", "force_reg", "(", "V16QImode", ",", "vperm", ")", ";", "l", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "op", "=", "gen_lowpart", "(", "V16QImode", ",", "d", "->", "op0", ")", ";", "emit_insn", "(", "gen_ssse3_pshufbv16qi3", "(", "l", ",", "op", ",", "vperm", ")", ")", ";", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V16QImode", ",", "gen_rtvec_v", "(", "<NUM_LIT>", ",", "rperm", "[", "<NUM_LIT>", "]", ")", ")", ";", "vperm", "=", "force_reg", "(", "V16QImode", ",", "vperm", ")", ";", "h", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "op", "=", "gen_lowpart", "(", "V16QImode", ",", "d", "->", "op1", ")", ";", "emit_insn", "(", "gen_ssse3_pshufbv16qi3", "(", "h", ",", "op", ",", "vperm", ")", ")", ";", "op", "=", "d", "->", "target", ";", "if", "(", "d", "->", "vmode", "!=", "V16QImode", ")", "op", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_insn", "(", "gen_iorv16qi3", "(", "op", ",", "l", ",", "h", ")", ")", ";", "if", "(", "op", "!=", "d", "->", "target", ")", "emit_move_insn", "(", "d", "->", "target", ",", "gen_lowpart", "(", "d", "->", "vmode", ",", "op", ")", ")", ";", "return", "true", ";", "}" ]

[ "A", "subroutine", "of", "expand_vec_perm_even_odd_1", ".", "Implement", "the", "double-word", "permutation", "with", "two", "pshufb", "insns", "and", "an", "ior", ".", "We", "should", "have", "already", "failed", "all", "two", "instruction", "sequences", "." ]

[ "InsS", "=", "Hexagon", "::", "isub_hi", ";" ]

[ "}", "for", "(", "IFMapType", "::", "iterator", "I", "=", "IFMap", ".", "begin", "(", ")", ",", "E", "=", "IFMap", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "MRI", "->", "getVRegDef", "(", "I", "->", "first", ")", ";", "MachineBasicBlock", "&", "B", "=", "*", "MI", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "NewR", "=", "RegMap", "[", "I", "->", "first", "]", ";", "bool", "R32", "=", "MRI", "->", "getRegClass", "(", "NewR", ")", "==", "&", "Hexagon", "::", "IntRegsRegClass", ";", "const", "MCInstrDesc", "&", "D", "=", "R32", "?", "HII", "->", "get", "(", "Hexagon", "::", "S2_insert", ")", ":", "HII", "->", "get", "(", "Hexagon", "::", "S2_insertp", ")", ";", "IFRecord", "IF", "=", "I", "->", "second", "[", "<NUM_LIT>", "]", ".", "first", ";", "unsigned", "Wdh", "=", "IF", ".", "Wdh", ",", "Off", "=", "IF", ".", "Off", ";", "unsigned", "InsS", "=", "<NUM_LIT>", ";", "if", "(", "R32", "&&", "MRI", "->", "getRegClass", "(", "IF", ".", "InsR", ")", "==", "&", "Hexagon", "::", "DoubleRegsRegClass", ")", "{", "InsS", "=", "Hexagon", "::", "isub_lo", ";", "if", "(", "Off", ">=", "<NUM_LIT>", ")", "{" ]

[ "<FIXS>", "BuildMI", "(", "MBB", ",", "I", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opcode", ")", ")", "<FIXE>" ]

[ "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "<BUGS>", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ")", "<BUGE>", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")" ]

[ "<FIXS>", "foreach", "Scale", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", "in", "{", "<FIXE>" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", "#", "Scale", "#", "<STR_LIT>", ";", "}", "<BUGS>", "foreach", "Scale", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", "in", "{", "<BUGE>", "def", "GPR64shiftedAsmOpnd", "#", "Scale", ":", "GPR64ShiftExtendAsmOperand", "<STR_LIT>", ",", "Scale", ",", "<STR_LIT>", ">", ";", "def", "GPR64shifted", "#", "Scale", ":", "GPR64ExtendRegisterOperand", "<STR_LIT>", "#", "Scale", ",", "Scale", ",", "GPR64", ">", ";" ]

[ "[", "CPSR", "]", ";" ]

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

[ "}" ]

[ "def", "A64FXWrite_LD112", ":", "SchedWriteRes", "<", "[", "A64FXGI56", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "case", "AMDGPUAS", "::", "FLAT_ADDRESS", ":", "return", "<NUM_LIT>", ";", "case", "AMDGPUAS", "::", "LOCAL_ADDRESS", ":", "case", "AMDGPUAS", "::", "REGION_ADDRESS", ":", "return", "<NUM_LIT>", ";", "case", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ":", "return", "<NUM_LIT>", "*", "ST", "->", "getMaxPrivateElementSize", "(", ")", ";", "default", ":", "if", "(", "ST", "->", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", "&&", "(", "AddrSpace", "==", "AMDGPUAS", "::", "PARAM_D_ADDRESS", "||", "AddrSpace", "==", "AMDGPUAS", "::", "PARAM_I_ADDRESS", "||", "(", "AddrSpace", ">=", "AMDGPUAS", "::", "CONSTANT_BUFFER_0", "&&", "AddrSpace", "<=", "AMDGPUAS", "::", "CONSTANT_BUFFER_15", ")", ")", ")", "return", "<NUM_LIT>", ";", "llvm_unreachable", "(", "<STR_LIT>", "unhandled address space", "<STR_LIT>", ")", ";", "}" ]

[ "Count", ";" ]

[ "}", "bool", "FallThru", "=", "FBB", "==", "nullptr", ";", "unsigned", "Count", "=", "<NUM_LIT>", ";", "M68k", "::", "CondCode", "CC", "=", "(", "M68k", "::", "CondCode", ")", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ";", "unsigned", "Opc", "=", "GetCondBranchFromCond", "(", "CC", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "++", "Count", ";", "if", "(", "!", "FallThru", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "M68k", "::", "BRA8", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "++" ]

[ "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";" ]

[ "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "AVR_BUILTIN", ")", "{", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_AVR_BUILTIN", ")", ";", "}", "else", "{", "analyzeReturnValues", "(", "Ins", ",", "CCInfo", ",", "Subtarget", ".", "hasTinyEncoding", "(", ")", ")", ";", "}", "for", "(", "CCValAssign", "const", "&", "RVLoc", ":", "RVLocs", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLoc", ".", "getLocReg", "(", ")", ",", "RVLoc", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "<NUM_LIT>", ")", ";" ]

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

[ "return", "gen_rtx_REG", "(", "Pmode" ]

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

[ "_", "_", "arm_vrshrnbq", "(", "uint16x8_t", "_", "_", "a", ",", "uint32x4_t", "_", "_", "b", ",", "const", "int", "_", "_" ]

[ "}" ]

[ "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "SDValue", "StackPtr", "=", "DAG", ".", "getRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "PtrVT", ")", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "VA", ".", "getLocMemOffset", "(", ")", "+", "Subtarget", "->", "getStackPointerBias", "(", ")", "+", "<NUM_LIT>", ",", "DL", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "StackPtr", ",", "PtrOff", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "DL", ",", "Arg", ",", "PtrOff", ",", "MachinePointerInfo", "(", ")", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "DL", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "SDValue", "InGlue", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InGlue", ")", ";", "InGlue", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "hasReturnsTwice", "=", "hasReturnsTwiceAttr", "(", "DAG", ",", "Callee", ",", "CLI", ".", "CS", ")", ";", "unsigned", "TF", "=", "isPositionIndependent", "(", ")", "?", "SparcMCExpr", "::", "VK_Sparc_WPLT30", ":", "<NUM_LIT>", ";", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "Callee", "=", "DAG", ".", "getTargetGlobalAddress", "(", "G", "->", "getGlobal", "(", ")", ",", "DL", ",", "PtrVT", ",", "<NUM_LIT>", ",", "TF", ")", ";", "else", "if", "(", "ExternalSymbolSDNode", "*", "E", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "Callee", "=", "DAG", ".", "getTargetExternalSymbol", "(", "E", "->", "getSymbol", "(", ")", ",", "PtrVT", ",", "TF", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "Ops", ".", "push_back", "(", "Chain", ")", ";", "Ops", ".", "push_back", "(", "Callee", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "const", "SparcRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "Mask", "=", "(", "(", "hasReturnsTwice", ")", "?", "TRI", "->", "getRTCallPreservedMask", "(", "CLI", ".", "CallConv", ")", ":", "TRI", "->", "getCallPreservedMask", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "CLI", ".", "CallConv", ")", ")", ";", "assert", "(", "Mask", "&&", "<STR_LIT>", "Missing call preserved mask for calling convention", "<STR_LIT>", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InGlue", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InGlue", ")", ";", "SDVTList", "NodeTys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "NodeTys", ",", "Ops", ")", ";", "InGlue", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_END", "(", "Chain", ",", "DAG", ".", "getIntPtrConstant", "(", "ArgsSize", ",", "DL", ",", "true", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "DL", ",", "true", ")", ",", "InGlue", ",", "DL", ")", ";", "InGlue", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "CCState", "RVInfo", "(", "CLI", ".", "CallConv", ",", "CLI", ".", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "CLI", ".", "Ins", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "CLI", ".", "Ins", "[", "<NUM_LIT>", "]", ".", "VT", "==", "MVT", "::", "f32", "&&", "CLI", ".", "CS", "==", "nullptr", ")", "CLI", ".", "Ins", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "setInReg", "(", ")", ";", "RVInfo", ".", "AnalyzeCallResult", "(", "CLI", ".", "Ins", ",", "RetCC_Sparc64", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "unsigned", "Reg", "=", "toCallerWindow", "(", "VA", ".", "getLocReg", "(", ")", ")", ";", "SDValue", "RV", ";", "if", "(", "RegisterSDNode", "*", "SrcReg", "=", "dyn_cast", "<", "RegisterSDNode", ">", "(", "Chain", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "if", "(", "SrcReg", "->", "getReg", "(", ")", "==", "Reg", "&&", "Chain", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyFromReg", ")", "RV", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "RV", ".", "getNode", "(", ")", ")", "{", "RV", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "InGlue", ")", ";", "Chain", "=", "RV", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InGlue", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i32", "&&", "VA", ".", "needsCustom", "(", ")", ")", "RV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "RV", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "SExt", ":", "RV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "RV", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "RV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "RV", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "VA", ".", "isExtInLoc", "(", ")", ")", "RV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "RV", ")", ";", "InVals", ".", "push_back", "(", "RV", ")", ";" ]

[ "unsigned", "SIInstrInfo", "::", "getInstrLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "&", "MI", ",", "unsigned", "*", "PredCost", ")", "const", "{", "if", "(", "MI", ".", "isBundle", "(", ")", ")", "{", "MachineBasicBlock", "::", "const_instr_iterator", "I", "(", "MI", ".", "getIterator", "(", ")", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "(", "MI", ".", "getParent", "(", ")", "->", "instr_end", "(", ")", ")", ";", "unsigned", "Lat", "=", "<NUM_LIT>", ",", "Count", "=", "<NUM_LIT>", ";", "for", "(", "++", "I", ";", "I", "!=", "E", "&&", "I", "->", "isBundledWithPred", "(", ")", ";", "++", "I", ")", "{", "++", "Count", ";", "Lat", "=", "std", "::", "max", "(", "Lat", ",", "SchedModel", ".", "computeInstrLatency", "(", "&", "*", "I", ")", ")", ";", "}", "return", "Lat", "+", "Count", "-", "<NUM_LIT>", ";", "}", "return", "SchedModel", ".", "computeInstrLatency", "(", "&", "MI", ")", ";", "}" ]

[ "Compute", "the", "instruction", "latency", "of", "a", "given", "instruction", "." ]

[ "int", "j", "=", "i", ";" ]

[ "unsigned", "Reg", ";", "for", "(", "int", "s", "=", "<NUM_LIT>", ";", "s", "<", "<NUM_LIT>", ";", "s", "+=", "<NUM_LIT>", ")", "{", "HalfMask", "=", "(", "Mask", ">>", "s", ")", "&", "<NUM_LIT>", ";", "if", "(", "s", "!=", "<NUM_LIT>", "&&", "(", "Mask", "&", "<NUM_LIT>", ")", "&&", "HalfMask", ")", "O", "<<", "'", ",", "'", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "HalfMask", ";", "++", "i", ")", "{", "if", "(", "(", "HalfMask", ">>", "i", ")", "&", "<NUM_LIT>", ")", "{", "HalfMask", "^=", "<NUM_LIT>", "<<", "i", ";", "Reg", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "i", "+", "s", ")", ";", "printRegName", "(", "O", ",", "Reg", ")", ";" ]

[ "}" ]

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

[ "<FIXS>", "CCIfVarArg", "CCIfSubtarget", "<STR_LIT>", ",", "CCDelegateTo", "CC_AArch64_DarwinPCS", ">", ">", ">", ",", "CCIfVarArg", "CCIfSubtarget", "<STR_LIT>", ",", "CCDelegateTo", "CC_AArch64_Win64PCS", ">", ">", ">", ",", "CCIfVarArg", "CCDelegateTo", "CC_AArch64_AAPCS", ">", ">", ",", "CCIfType", "[", "i32", "]", ",", "CCAssignToReg", "[", "W20", ",", "W21", ",", "W22", ",", "W23", ",", "W24", ",", "W25", ",", "W26", ",", "W27", ",", "W28", ",", "W0", ",", "W1", ",", "W2", ",", "W3", ",", "W4", ",", "W5", ",", "W6", ",", "W7", ",", "W10", ",", "W11", ",", "W12", ",", "W13", ",", "W14", ",", "W9", "]", ">", ">", ",", "CCIfType", "[", "i64", "]", ",", "CCAssignToReg", "[", "X20", ",", "X21", ",", "X22", ",", "X23", ",", "X24", ",", "X25", ",", "X26", ",", "X27", ",", "X28", ",", "X0", ",", "X1", ",", "X2", ",", "X3", ",", "X4", ",", "X5", ",", "X6", ",", "X7", ",", "X10", ",", "X11", ",", "X12", ",", "X13", ",", "X14", ",", "X9", "]", ">", ">", ",", "CCIf", "<STR_LIT>", ",", "CCIfType", "[", "i32", "]", ",", "CCAssignToReg", "[", "W15", "]", ">", ">", ">", ",", "CCIf", "<STR_LIT>", ",", "CCIfType", "[", "i64", "]", ",", "CCAssignToReg", "[", "X15", "]", ">", ">", ">", ",", "CCDelegateTo", "CC_AArch64_AAPCS", ">", "<FIXE>" ]

[ "let", "Entry", "=", "<NUM_LIT>", "indef", "CC_AArch64_Preserve_None", ":", "CallingConv", "[", "<BUGS>", "CCIfType", "[", "i32", "]", ",", "CCAssignToReg", "[", "W20", ",", "W21", ",", "W22", ",", "W23", ",", "W24", ",", "W25", ",", "W26", ",", "W27", ",", "W28", ",", "W0", ",", "W1", ",", "W2", ",", "W3", ",", "W4", ",", "W5", ",", "W6", ",", "W7", ",", "W10", ",", "W11", ",", "W12", ",", "W13", ",", "W14", ",", "W9", "]", ">", ">", ",", "CCIfType", "[", "i64", "]", ",", "CCAssignToReg", "[", "X20", ",", "X21", ",", "X22", ",", "X23", ",", "X24", ",", "X25", ",", "X26", ",", "X27", ",", "X28", ",", "X0", ",", "X1", ",", "X2", ",", "X3", ",", "X4", ",", "X5", ",", "X6", ",", "X7", ",", "X10", ",", "X11", ",", "X12", ",", "X13", ",", "X14", ",", "X9", "]", ">", ">", ",", "CCIf", "<STR_LIT>", ",", "CCIfType", "[", "i32", "]", ",", "CCAssignToReg", "[", "W15", "]", ">", ">", ">", ",", "CCIf", "<STR_LIT>", ",", "CCIfType", "[", "i64", "]", ",", "CCAssignToReg", "[", "X15", "]", ">", ">", ">", ",", "CCDelegateTo", "CC_AArch64_AAPCS", ">", "<BUGE>", "]", ">", ";" ]

[ "void", "Z80TargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "&", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected instr type to insert", "<STR_LIT>", ")", ";", "case", "Z80", "::", "ADJCALLSTACKUP16", ":", "case", "Z80", "::", "ADJCALLSTACKUP24", ":", "case", "Z80", "::", "ADJCALLSTACKDOWN16", ":", "case", "Z80", "::", "ADJCALLSTACKDOWN24", ":", "return", "AdjustAdjCallStack", "(", "MI", ")", ";", "}", "}" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'hasPostISelHook", "'", "flag", "." ]