Decode: Pull instruction decoding out of the StaticInst class into its own.
This change pulls the instruction decoding machinery (including caches) out of
the StaticInst class and puts it into its own class. This has a few intrinsic
benefits. First, the StaticInst code, which has gotten to be quite large, gets
simpler. Second, the code that handles decode caching is now separated out
into its own component and can be looked at in isolation, making it easier to
understand. I took the opportunity to restructure the code a bit which will
hopefully also help.
Beyond that, this change also lays some ground work for each ISA to have its
own, potentially stateful decode object. We'd be able to include less
contextualizing information in the ExtMachInst objects since that context
would be applied at the decoder. Also, the decoder could "know" ahead of time
that all the instructions it's going to see are going to be, for instance, 64
bit mode, and it will have one less thing to check when it decodes them.
Because the decode caching mechanism has been separated out, it's now possible
to have multiple caches which correspond to different types of decoding
context. Having one cache for each element of the cross product of different
configurations may become prohibitive, so it may be desirable to clear out the
cache when relatively static state changes and not to have one for each
setting.
Because the decode function is no longer universally accessible as a static
member of the StaticInst class, a new function was added to the ThreadContexts
that returns the applicable decode object.
2011-09-09 11:30:01 +02:00
|
|
|
/*
|
arm: Add support for ARMv8 (AArch64 & AArch32)
Note: AArch64 and AArch32 interworking is not supported. If you use an AArch64
kernel you are restricted to AArch64 user-mode binaries. This will be addressed
in a later patch.
Note: Virtualization is only supported in AArch32 mode. This will also be fixed
in a later patch.
Contributors:
Giacomo Gabrielli (TrustZone, LPAE, system-level AArch64, AArch64 NEON, validation)
Thomas Grocutt (AArch32 Virtualization, AArch64 FP, validation)
Mbou Eyole (AArch64 NEON, validation)
Ali Saidi (AArch64 Linux support, code integration, validation)
Edmund Grimley-Evans (AArch64 FP)
William Wang (AArch64 Linux support)
Rene De Jong (AArch64 Linux support, performance opt.)
Matt Horsnell (AArch64 MP, validation)
Matt Evans (device models, code integration, validation)
Chris Adeniyi-Jones (AArch64 syscall-emulation)
Prakash Ramrakhyani (validation)
Dam Sunwoo (validation)
Chander Sudanthi (validation)
Stephan Diestelhorst (validation)
Andreas Hansson (code integration, performance opt.)
Eric Van Hensbergen (performance opt.)
Gabe Black
2014-01-24 22:29:34 +01:00
|
|
|
* Copyright (c) 2013 ARM Limited
|
|
|
|
* All rights reserved
|
|
|
|
*
|
|
|
|
* The license below extends only to copyright in the software and shall
|
|
|
|
* not be construed as granting a license to any other intellectual
|
|
|
|
* property including but not limited to intellectual property relating
|
|
|
|
* to a hardware implementation of the functionality of the software
|
|
|
|
* licensed hereunder. You may use the software subject to the license
|
|
|
|
* terms below provided that you ensure that this notice is replicated
|
|
|
|
* unmodified and in its entirety in all distributions of the software,
|
|
|
|
* modified or unmodified, in source code or in binary form.
|
|
|
|
*
|
2012-05-25 09:53:37 +02:00
|
|
|
* Copyright (c) 2012 Google
|
Decode: Pull instruction decoding out of the StaticInst class into its own.
This change pulls the instruction decoding machinery (including caches) out of
the StaticInst class and puts it into its own class. This has a few intrinsic
benefits. First, the StaticInst code, which has gotten to be quite large, gets
simpler. Second, the code that handles decode caching is now separated out
into its own component and can be looked at in isolation, making it easier to
understand. I took the opportunity to restructure the code a bit which will
hopefully also help.
Beyond that, this change also lays some ground work for each ISA to have its
own, potentially stateful decode object. We'd be able to include less
contextualizing information in the ExtMachInst objects since that context
would be applied at the decoder. Also, the decoder could "know" ahead of time
that all the instructions it's going to see are going to be, for instance, 64
bit mode, and it will have one less thing to check when it decodes them.
Because the decode caching mechanism has been separated out, it's now possible
to have multiple caches which correspond to different types of decoding
context. Having one cache for each element of the cross product of different
configurations may become prohibitive, so it may be desirable to clear out the
cache when relatively static state changes and not to have one for each
setting.
Because the decode function is no longer universally accessible as a static
member of the StaticInst class, a new function was added to the ThreadContexts
that returns the applicable decode object.
2011-09-09 11:30:01 +02:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are
|
|
|
|
* met: redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer;
|
|
|
|
* redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution;
|
|
|
|
* neither the name of the copyright holders nor the names of its
|
|
|
|
* contributors may be used to endorse or promote products derived from
|
|
|
|
* this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* Authors: Gabe Black
|
|
|
|
*/
|
|
|
|
|
2012-05-25 09:53:37 +02:00
|
|
|
#ifndef __ARCH_ARM_DECODER_HH__
|
|
|
|
#define __ARCH_ARM_DECODER_HH__
|
Decode: Pull instruction decoding out of the StaticInst class into its own.
This change pulls the instruction decoding machinery (including caches) out of
the StaticInst class and puts it into its own class. This has a few intrinsic
benefits. First, the StaticInst code, which has gotten to be quite large, gets
simpler. Second, the code that handles decode caching is now separated out
into its own component and can be looked at in isolation, making it easier to
understand. I took the opportunity to restructure the code a bit which will
hopefully also help.
Beyond that, this change also lays some ground work for each ISA to have its
own, potentially stateful decode object. We'd be able to include less
contextualizing information in the ExtMachInst objects since that context
would be applied at the decoder. Also, the decoder could "know" ahead of time
that all the instructions it's going to see are going to be, for instance, 64
bit mode, and it will have one less thing to check when it decodes them.
Because the decode caching mechanism has been separated out, it's now possible
to have multiple caches which correspond to different types of decoding
context. Having one cache for each element of the cross product of different
configurations may become prohibitive, so it may be desirable to clear out the
cache when relatively static state changes and not to have one for each
setting.
Because the decode function is no longer universally accessible as a static
member of the StaticInst class, a new function was added to the ThreadContexts
that returns the applicable decode object.
2011-09-09 11:30:01 +02:00
|
|
|
|
2012-05-26 22:44:46 +02:00
|
|
|
#include <cassert>
|
|
|
|
|
|
|
|
#include "arch/arm/miscregs.hh"
|
|
|
|
#include "arch/arm/types.hh"
|
2012-05-26 22:45:12 +02:00
|
|
|
#include "arch/generic/decode_cache.hh"
|
2012-05-26 22:44:46 +02:00
|
|
|
#include "base/types.hh"
|
2012-05-26 22:45:12 +02:00
|
|
|
#include "cpu/static_inst.hh"
|
2012-05-26 22:44:46 +02:00
|
|
|
|
2012-05-25 09:53:37 +02:00
|
|
|
namespace ArmISA
|
|
|
|
{
|
|
|
|
|
2012-05-25 09:55:24 +02:00
|
|
|
class Decoder
|
|
|
|
{
|
2012-05-26 22:44:46 +02:00
|
|
|
protected:
|
|
|
|
//The extended machine instruction being generated
|
|
|
|
ExtMachInst emi;
|
|
|
|
MachInst data;
|
|
|
|
bool bigThumb;
|
|
|
|
bool instDone;
|
|
|
|
bool outOfBytes;
|
|
|
|
int offset;
|
|
|
|
bool foundIt;
|
|
|
|
ITSTATE itBits;
|
|
|
|
|
2013-01-05 01:09:35 +01:00
|
|
|
int fpscrLen;
|
|
|
|
int fpscrStride;
|
|
|
|
|
2012-05-26 22:44:46 +02:00
|
|
|
public:
|
|
|
|
void reset()
|
|
|
|
{
|
|
|
|
bigThumb = false;
|
|
|
|
offset = 0;
|
|
|
|
emi = 0;
|
|
|
|
instDone = false;
|
|
|
|
outOfBytes = true;
|
|
|
|
foundIt = false;
|
|
|
|
}
|
|
|
|
|
2013-01-05 02:00:45 +01:00
|
|
|
Decoder() : data(0), fpscrLen(0), fpscrStride(0)
|
2012-05-26 22:44:46 +02:00
|
|
|
{
|
|
|
|
reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
void process();
|
|
|
|
|
|
|
|
//Use this to give data to the decoder. This should be used
|
|
|
|
//when there is control flow.
|
|
|
|
void moreBytes(const PCState &pc, Addr fetchPC, MachInst inst);
|
|
|
|
|
|
|
|
//Use this to give data to the decoder. This should be used
|
|
|
|
//when instructions are executed in order.
|
|
|
|
void moreBytes(MachInst machInst)
|
|
|
|
{
|
|
|
|
moreBytes(0, 0, machInst);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void consumeBytes(int numBytes)
|
|
|
|
{
|
|
|
|
offset += numBytes;
|
|
|
|
assert(offset <= sizeof(MachInst));
|
|
|
|
if (offset == sizeof(MachInst))
|
|
|
|
outOfBytes = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool needMoreBytes() const
|
|
|
|
{
|
|
|
|
return outOfBytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool instReady() const
|
|
|
|
{
|
|
|
|
return instDone;
|
|
|
|
}
|
|
|
|
|
|
|
|
int getInstSize() const
|
|
|
|
{
|
|
|
|
return (!emi.thumb || emi.bigThumb) ? 4 : 2;
|
|
|
|
}
|
|
|
|
|
2013-01-05 01:09:35 +01:00
|
|
|
void setContext(FPSCR fpscr)
|
|
|
|
{
|
|
|
|
fpscrLen = fpscr.len;
|
|
|
|
fpscrStride = fpscr.stride;
|
|
|
|
}
|
|
|
|
|
2013-01-22 07:10:10 +01:00
|
|
|
void takeOverFrom(Decoder *old) {}
|
|
|
|
|
2012-05-25 09:55:24 +02:00
|
|
|
protected:
|
|
|
|
/// A cache of decoded instruction objects.
|
2012-05-26 22:45:12 +02:00
|
|
|
static GenericISA::BasicDecodeCache defaultCache;
|
2012-05-25 09:55:24 +02:00
|
|
|
|
|
|
|
public:
|
|
|
|
StaticInstPtr decodeInst(ExtMachInst mach_inst);
|
|
|
|
|
|
|
|
/// Decode a machine instruction.
|
|
|
|
/// @param mach_inst The binary instruction to decode.
|
|
|
|
/// @retval A pointer to the corresponding StaticInst object.
|
|
|
|
StaticInstPtr
|
|
|
|
decode(ExtMachInst mach_inst, Addr addr)
|
|
|
|
{
|
|
|
|
return defaultCache.decode(this, mach_inst, addr);
|
|
|
|
}
|
2012-05-26 22:44:46 +02:00
|
|
|
|
|
|
|
StaticInstPtr
|
|
|
|
decode(ArmISA::PCState &nextPC)
|
|
|
|
{
|
|
|
|
if (!instDone)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
assert(instDone);
|
|
|
|
ExtMachInst thisEmi = emi;
|
|
|
|
nextPC.npc(nextPC.pc() + getInstSize());
|
|
|
|
if (foundIt)
|
|
|
|
nextPC.nextItstate(itBits);
|
|
|
|
thisEmi.itstate = nextPC.itstate();
|
|
|
|
nextPC.size(getInstSize());
|
|
|
|
emi = 0;
|
|
|
|
instDone = false;
|
|
|
|
foundIt = false;
|
|
|
|
return decode(thisEmi, nextPC.instAddr());
|
|
|
|
}
|
2012-05-25 09:55:24 +02:00
|
|
|
};
|
2012-05-25 09:53:37 +02:00
|
|
|
|
|
|
|
} // namespace ArmISA
|
|
|
|
|
|
|
|
#endif // __ARCH_ARM_DECODER_HH__
|