decoder.hh revision 11165:d90aec9435bd
1/* 2 * Copyright (c) 2013-2014 ARM Limited 3 * All rights reserved 4 * 5 * The license below extends only to copyright in the software and shall 6 * not be construed as granting a license to any other intellectual 7 * property including but not limited to intellectual property relating 8 * to a hardware implementation of the functionality of the software 9 * licensed hereunder. You may use the software subject to the license 10 * terms below provided that you ensure that this notice is replicated 11 * unmodified and in its entirety in all distributions of the software, 12 * modified or unmodified, in source code or in binary form. 13 * 14 * Copyright (c) 2012 Google 15 * All rights reserved. 16 * 17 * Redistribution and use in source and binary forms, with or without 18 * modification, are permitted provided that the following conditions are 19 * met: redistributions of source code must retain the above copyright 20 * notice, this list of conditions and the following disclaimer; 21 * redistributions in binary form must reproduce the above copyright 22 * notice, this list of conditions and the following disclaimer in the 23 * documentation and/or other materials provided with the distribution; 24 * neither the name of the copyright holders nor the names of its 25 * contributors may be used to endorse or promote products derived from 26 * this software without specific prior written permission. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 39 * 40 * Authors: Gabe Black 41 */ 42 43#ifndef __ARCH_ARM_DECODER_HH__ 44#define __ARCH_ARM_DECODER_HH__ 45 46#include <cassert> 47 48#include "arch/arm/miscregs.hh" 49#include "arch/arm/types.hh" 50#include "arch/generic/decode_cache.hh" 51#include "base/types.hh" 52#include "cpu/static_inst.hh" 53#include "enums/DecoderFlavour.hh" 54 55namespace ArmISA 56{ 57 58class ISA; 59class Decoder 60{ 61 protected: 62 //The extended machine instruction being generated 63 ExtMachInst emi; 64 MachInst data; 65 bool bigThumb; 66 bool instDone; 67 bool outOfBytes; 68 int offset; 69 bool foundIt; 70 ITSTATE itBits; 71 72 int fpscrLen; 73 int fpscrStride; 74 75 Enums::DecoderFlavour decoderFlavour; 76 77 /// A cache of decoded instruction objects. 78 static GenericISA::BasicDecodeCache defaultCache; 79 80 /** 81 * Pre-decode an instruction from the current state of the 82 * decoder. 83 */ 84 void process(); 85 86 /** 87 * Consume bytes by moving the offset into the data word and 88 * sanity check the results. 89 */ 90 void consumeBytes(int numBytes); 91 92 public: // Decoder API 93 Decoder(ISA* isa = nullptr); 94 95 /** Reset the decoders internal state. */ 96 void reset(); 97 98 /** 99 * Can the decoder accept more data? 100 * 101 * A CPU model uses this method to determine if the decoder can 102 * accept more data. Note that an instruction can be ready (see 103 * instReady() even if this method returns true. 104 */ 105 bool needMoreBytes() const { return outOfBytes; } 106 107 /** 108 * Is an instruction ready to be decoded? 109 * 110 * CPU models call this method to determine if decode() will 111 * return a new instruction on the next call. It typically only 112 * returns false if the decoder hasn't received enough data to 113 * decode a full instruction. 114 */ 115 bool instReady() const { return instDone; } 116 117 /** 118 * Feed data to the decoder. 119 * 120 * A CPU model uses this interface to load instruction data into 121 * the decoder. Once enough data has been loaded (check with 122 * instReady()), a decoded instruction can be retrieved using 123 * decode(ArmISA::PCState). 124 * 125 * This method is intended to support both fixed-length and 126 * variable-length instructions. Instruction data is fetch in 127 * MachInst blocks (which correspond to the size of a typical 128 * insturction). The method might need to be called multiple times 129 * if the instruction spans multiple blocks, in that case 130 * needMoreBytes() will return true and instReady() will return 131 * false. 132 * 133 * The fetchPC parameter is used to indicate where in memory the 134 * instruction was fetched from. This is should be the same 135 * address as the pc. If fetching multiple blocks, it indicates 136 * where subsequent blocks are fetched from (pc + n * 137 * sizeof(MachInst)). 138 * 139 * @param pc Instruction pointer that we are decoding. 140 * @param fetchPC The address this chunk was fetched from. 141 * @param inst Raw instruction data. 142 */ 143 void moreBytes(const PCState &pc, Addr fetchPC, MachInst inst); 144 145 /** 146 * Decode an instruction or fetch it from the code cache. 147 * 148 * This method decodes the currently pending pre-decoded 149 * instruction. Data must be fed to the decoder using moreBytes() 150 * until instReady() is true before calling this method. 151 * 152 * @param pc Instruction pointer that we are decoding. 153 * @return A pointer to a static instruction or NULL if the 154 * decoder isn't ready (see instReady()). 155 */ 156 StaticInstPtr decode(ArmISA::PCState &pc); 157 158 /** 159 * Decode a pre-decoded machine instruction. 160 * 161 * @warn This method takes a pre-decoded instruction as its 162 * argument. It should typically not be called directly. 163 * 164 * @param mach_inst A pre-decoded instruction 165 * @retval A pointer to the corresponding StaticInst object. 166 */ 167 StaticInstPtr decode(ExtMachInst mach_inst, Addr addr) 168 { 169 return defaultCache.decode(this, mach_inst, addr); 170 } 171 172 /** 173 * Decode a machine instruction without calling the cache. 174 * 175 * @note The implementation of this method is generated by the ISA 176 * parser script. 177 * 178 * @warn This method takes a pre-decoded instruction as its 179 * argument. It should typically not be called directly. 180 * 181 * @param mach_inst The binary instruction to decode. 182 * @retval A pointer to the corresponding StaticInst object. 183 */ 184 StaticInstPtr decodeInst(ExtMachInst mach_inst); 185 186 /** 187 * Take over the state from an old decoder when switching CPUs. 188 * 189 * @param old Decoder used in old CPU 190 */ 191 void takeOverFrom(Decoder *old) {} 192 193 194 public: // ARM-specific decoder state manipulation 195 void setContext(FPSCR fpscr) 196 { 197 fpscrLen = fpscr.len; 198 fpscrStride = fpscr.stride; 199 } 200}; 201 202} // namespace ArmISA 203 204#endif // __ARCH_ARM_DECODER_HH__ 205