src/arch/x86/predecoder.hh

   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_PREDECODER_HH__
  59 #define __ARCH_X86_PREDECODER_HH__
  60
  61 #include "arch/x86/types.hh"
  62 #include "base/bitfield.hh"
  63 #include "sim/host.hh"
  64
  65 class ThreadContext;
  66
  67 namespace X86ISA
  68 {
  69     class Predecoder
  70     {
  71       private:
  72         //These are defined and documented in predecoder_tables.cc
  73         static const uint8_t Prefixes[256];
  74         static const uint8_t UsesModRM[2][256];
  75         static const uint8_t ImmediateType[2][256];
  76         static const uint8_t SizeTypeToSize[3][10];
  77
  78       protected:
  79         ThreadContext * tc;
  80         //The bytes to be predecoded
  81         MachInst fetchChunk;
  82         //The pc of the start of fetchChunk
  83         Addr basePC;
  84         //The offset into fetchChunk of current processing
  85         int offset;
  86         //The extended machine instruction being generated
  87         ExtMachInst emi;
  88
  89         inline uint8_t getNextByte()
  90         {
  91             return (fetchChunk >> (offset * 8)) & 0xff;
  92         }
  93
  94         void getImmediate(int &collected, uint64_t &current, int size)
  95         {
  96             //Figure out how many bytes we still need to get for the
  97             //immediate.
  98             int toGet = size - collected;
  99             //Figure out how many bytes are left in our "buffer"
 100             int remaining = sizeof(MachInst) - offset;
 101             //Get as much as we need, up to the amount available.
 102             toGet = toGet > remaining ? remaining : toGet;
 103
 104             //Shift the bytes we want to be all the way to the right
 105             uint64_t partialDisp = fetchChunk >> (offset * 8);
 106             //Mask off what we don't want
 107             partialDisp &= mask(toGet * 8);
 108             //Shift it over to overlay with our displacement.
 109             partialDisp <<= (displacementCollected * 8);
 110             //Put it into our displacement
 111             current |= partialDisp;
 112             //Update how many bytes we've collected.
 113             collected += toGet;
 114             consumeBytes(toGet);
 115         }
 116
 117         inline void consumeByte()
 118         {
 119             offset++;
 120             assert(offset <= sizeof(MachInst));
 121             if(offset == sizeof(MachInst))
 122                 outOfBytes = true;
 123         }
 124
 125         inline void consumeBytes(int numBytes)
 126         {
 127             offset += numBytes;
 128             assert(offset <= sizeof(MachInst));
 129             if(offset == sizeof(MachInst))
 130                 outOfBytes = true;
 131         }
 132
 133         //State machine state
 134       protected:
 135         //Whether or not we're out of bytes
 136         bool outOfBytes;
 137         //Whether we've completed generating an ExtMachInst
 138         bool emiIsReady;
 139         //The size of the displacement value
 140         int displacementSize;
 141         int displacementCollected;
 142         //The size of the immediate value
 143         int immediateSize;
 144         int immediateCollected;
 145
 146         enum State {
 147             PrefixState,
 148             OpcodeState,
 149             ModRMState,
 150             SIBState,
 151             DisplacementState,
 152             ImmediateState,
 153             //We should never get to this state. Getting here is an error.
 154             ErrorState
 155         };
 156
 157         State state;
 158
 159         //Functions to handle each of the states
 160         State doPrefixState(uint8_t);
 161         State doOpcodeState(uint8_t);
 162         State doModRMState(uint8_t);
 163         State doSIBState(uint8_t);
 164         State doDisplacementState();
 165         State doImmediateState();
 166
 167       public:
 168         Predecoder(ThreadContext * _tc) :
 169             tc(_tc), basePC(0), offset(0),
 170             outOfBytes(true), emiIsReady(false),
 171             state(PrefixState)
 172         {}
 173
 174         ThreadContext * getTC()
 175         {
 176             return tc;
 177         }
 178
 179         void setTC(ThreadContext * _tc)
 180         {
 181             tc = _tc;
 182         }
 183
 184         void process();
 185
 186         //Use this to give data to the predecoder. This should be used
 187         //when there is control flow.
 188         void moreBytes(Addr currPC, Addr off, MachInst data)
 189         {
 190             basePC = currPC;
 191             offset = off;
 192             fetchChunk = data;
 193             assert(off < sizeof(MachInst));
 194             outOfBytes = false;
 195             process();
 196         }
 197
 198         //Use this to give data to the predecoder. This should be used
 199         //when instructions are executed in order.
 200         void moreBytes(MachInst machInst)
 201         {
 202             moreBytes(basePC + sizeof(machInst), 0, machInst);
 203         }
 204
 205         bool needMoreBytes()
 206         {
 207             return outOfBytes;
 208         }
 209
 210         bool extMachInstReady()
 211         {
 212             return emiIsReady;
 213         }
 214
 215         //This returns a constant reference to the ExtMachInst to avoid a copy
 216         const ExtMachInst & getExtMachInst()
 217         {
 218             assert(emiIsReady);
 219             emiIsReady = false;
 220             return emi;
 221         }
 222     };
 223 };
 224
 225 #endif // __ARCH_X86_PREDECODER_HH__