ldstflags.hh revision 5912 
1/*
2 * Copyright (c) 2007 The Hewlett-Packard Development Company
3 * All rights reserved.
4 *
5 * Redistribution and use of this software in source and binary forms,
6 * with or without modification, are permitted provided that the
7 * following conditions are met:
8 *
9 * The software must be used only for Non-Commercial Use which means any
10 * use which is NOT directed to receiving any direct monetary
11 * compensation for, or commercial advantage from such use.  Illustrative
12 * examples of non-commercial use are academic research, personal study,
13 * teaching, education and corporate research & development.
14 * Illustrative examples of commercial use are distributing products for
15 * commercial advantage and providing services using the software for
16 * commercial advantage.
17 *
18 * If you wish to use this software or functionality therein that may be
19 * covered by patents for commercial use, please contact:
20 *     Director of Intellectual Property Licensing
21 *     Office of Strategy and Technology
22 *     Hewlett-Packard Company
23 *     1501 Page Mill Road
24 *     Palo Alto, California  94304
25 *
26 * Redistributions of source code must retain the above copyright notice,
27 * this list of conditions and the following disclaimer.  Redistributions
28 * in binary form must reproduce the above copyright notice, this list of
29 * conditions and the following disclaimer in the documentation and/or
30 * other materials provided with the distribution.  Neither the name of
31 * the COPYRIGHT HOLDER(s), HEWLETT-PACKARD COMPANY, nor the names of its
32 * contributors may be used to endorse or promote products derived from
33 * this software without specific prior written permission.  No right of
34 * sublicense is granted herewith.  Derivatives of the software and
35 * output created using the software may be prepared, but only for
36 * Non-Commercial Uses.  Derivatives of the software may be shared with
37 * others provided: (i) the others agree to abide by the list of
38 * conditions herein which includes the Non-Commercial Use restrictions;
39 * and (ii) such Derivatives of the software include the above copyright
40 * notice to acknowledge the contribution from this software where
41 * applicable, this list of conditions and the disclaimer below.
42 *
43 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
44 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
45 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
46 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
47 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
53 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54 *
55 * Authors: Gabe Black
56 */
57
58#ifndef __ARCH_X86_INSTS_MICROLDSTOP_HH__
59#define __ARCH_X86_INSTS_MICROLDSTOP_HH__
60
61#include "arch/x86/insts/microop.hh"
62#include "mem/packet.hh"
63#include "mem/request.hh"
64
65namespace X86ISA
66{
67    static const Request::FlagsType SegmentFlagMask = mask(4);
68    static const int FlagShift = 4;
69    enum FlagBit {
70        CPL0FlagBit = 1
71    };
72
73    /**
74     * Base class for load and store ops
75     */
76    class LdStOp : public X86MicroopBase
77    {
78      protected:
79        const uint8_t scale;
80        const RegIndex index;
81        const RegIndex base;
82        const uint64_t disp;
83        const uint8_t segment;
84        const RegIndex data;
85        const uint8_t dataSize;
86        const uint8_t addressSize;
87        const Request::FlagsType memFlags;
88        RegIndex foldOBit, foldABit;
89
90        //Constructor
91        LdStOp(ExtMachInst _machInst,
92                const char * mnem, const char * _instMnem,
93                bool isMicro, bool isDelayed, bool isFirst, bool isLast,
94                uint8_t _scale, RegIndex _index, RegIndex _base,
95                uint64_t _disp, uint8_t _segment,
96                RegIndex _data,
97                uint8_t _dataSize, uint8_t _addressSize,
98                Request::FlagsType _memFlags,
99                OpClass __opClass) :
100        X86MicroopBase(machInst, mnem, _instMnem,
101                isMicro, isDelayed, isFirst, isLast, __opClass),
102                scale(_scale), index(_index), base(_base),
103                disp(_disp), segment(_segment),
104                data(_data),
105                dataSize(_dataSize), addressSize(_addressSize),
106                memFlags(_memFlags | _segment)
107        {
108            foldOBit = (dataSize == 1 && !_machInst.rex.present) ? 1 << 6 : 0;
109            foldABit =
110                (addressSize == 1 && !_machInst.rex.present) ? 1 << 6 : 0;
111        }
112
113        std::string generateDisassembly(Addr pc,
114            const SymbolTable *symtab) const;
115
116        template<class Context, class MemType>
117        Fault read(Context *xc, Addr EA, MemType & Mem, unsigned flags) const
118        {
119            Fault fault = NoFault;
120            switch(dataSize)
121            {
122              case 1:
123                fault = xc->read(EA, (uint8_t&)Mem, flags);
124                break;
125              case 2:
126                fault = xc->read(EA, (uint16_t&)Mem, flags);
127                break;
128              case 4:
129                fault = xc->read(EA, (uint32_t&)Mem, flags);
130                break;
131              case 8:
132                fault = xc->read(EA, (uint64_t&)Mem, flags);
133                break;
134              default:
135                panic("Bad operand size %d for read at %#x.\n", dataSize, EA);
136            }
137            return fault;
138        }
139
140        template<class Context, class MemType>
141        Fault write(Context *xc, MemType & Mem, Addr EA, unsigned flags) const
142        {
143            Fault fault = NoFault;
144            switch(dataSize)
145            {
146              case 1:
147                fault = xc->write((uint8_t&)Mem, EA, flags, 0);
148                break;
149              case 2:
150                fault = xc->write((uint16_t&)Mem, EA, flags, 0);
151                break;
152              case 4:
153                fault = xc->write((uint32_t&)Mem, EA, flags, 0);
154                break;
155              case 8:
156                fault = xc->write((uint64_t&)Mem, EA, flags, 0);
157                break;
158              default:
159                panic("Bad operand size %d for write at %#x.\n", dataSize, EA);
160            }
161            return fault;
162        }
163
164        uint64_t
165        get(PacketPtr pkt) const
166        {
167            switch(dataSize)
168            {
169              case 1:
170                return pkt->get<uint8_t>();
171              case 2:
172                return pkt->get<uint16_t>();
173              case 4:
174                return pkt->get<uint32_t>();
175              case 8:
176                return pkt->get<uint64_t>();
177              default:
178                panic("Bad operand size %d for read at %#x.\n",
179                        dataSize, pkt->getAddr());
180            }
181        }
182    };
183}
184
185#endif //__ARCH_X86_INSTS_MICROLDSTOP_HH__
186