2 * Copyright (c) 2007 The Hewlett-Packard Development Company
3 * Copyright (c) 2011 Advanced Micro Devices, Inc.
6 * The license below extends only to copyright in the software and shall
7 * not be construed as granting a license to any other intellectual
8 * property including but not limited to intellectual property relating
9 * to a hardware implementation of the functionality of the software
10 * licensed hereunder. You may use the software subject to the license
11 * terms below provided that you ensure that this notice is replicated
12 * unmodified and in its entirety in all distributions of the software,
13 * modified or unmodified, in source code or in binary form.
15 * Redistribution and use in source and binary forms, with or without
16 * modification, are permitted provided that the following conditions are
17 * met: redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer;
19 * redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in the
21 * documentation and/or other materials provided with the distribution;
22 * neither the name of the copyright holders nor the names of its
23 * contributors may be used to endorse or promote products derived from
24 * this software without specific prior written permission.
26 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
28 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
29 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
30 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
31 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
32 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
33 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
34 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
35 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
36 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
41 #include "arch/x86/utility.hh"
43 #include "arch/x86/interrupts.hh"
44 #include "arch/x86/registers.hh"
45 #include "arch/x86/x86_traits.hh"
46 #include "cpu/base.hh"
47 #include "fputils/fp80.h"
48 #include "sim/full_system.hh"
53 getArgument(ThreadContext
*tc
, int &number
, uint16_t size
, bool fp
)
56 panic("getArgument(): Floating point arguments not implemented\n");
57 } else if (size
!= 8) {
58 panic("getArgument(): Can only handle 64-bit arguments.\n");
61 // The first 6 integer arguments are passed in registers, the rest
62 // are passed on the stack.
63 const int int_reg_map
[] = {
64 INTREG_RDI
, INTREG_RSI
, INTREG_RDX
,
65 INTREG_RCX
, INTREG_R8
, INTREG_R9
67 if (number
< sizeof(int_reg_map
) / sizeof(*int_reg_map
)) {
68 return tc
->readIntReg(int_reg_map
[number
]);
70 panic("getArgument(): Don't know how to handle stack arguments.\n");
75 initCPU(ThreadContext
*tc
, int cpuId
)
77 // This function is essentially performing a reset. The actual INIT
78 // interrupt does a subset of this, so we'll piggyback on some of its
80 InitInterrupt
init(0);
83 // Set integer register EAX to 0 to indicate that the optional BIST
84 // passed. No BIST actually runs, but software may still check this
85 // register for errors.
86 tc
->setIntReg(INTREG_RAX
, 0);
88 Interrupts
* interrupts
= dynamic_cast<Interrupts
*>(
89 tc
->getCpuPtr()->getInterruptController(0));
92 interrupts
->setRegNoEffect(APIC_ID
, cpuId
<< 24);
94 interrupts
->setRegNoEffect(APIC_VERSION
, (5 << 16) | 0x14);
97 void startupCPU(ThreadContext
*tc
, int cpuId
)
99 if (cpuId
== 0 || !FullSystem
) {
102 // This is an application processor (AP). It should be initialized to
103 // look like only the BIOS POST has run on it and put then put it into
110 copyMiscRegs(ThreadContext
*src
, ThreadContext
*dest
)
112 // This function assumes no side effects other than TLB invalidation
113 // need to be considered while copying state. That will likely not be
114 // true in the future.
115 for (int i
= 0; i
< NUM_MISCREGS
; ++i
) {
116 if (!isValidMiscReg(i
))
119 dest
->setMiscRegNoEffect(i
, src
->readMiscRegNoEffect(i
));
122 // The TSC has to be updated with side-effects if the CPUs in a
123 // CPU switch have different frequencies.
124 dest
->setMiscReg(MISCREG_TSC
, src
->readMiscReg(MISCREG_TSC
));
126 dest
->getITBPtr()->flushAll();
127 dest
->getDTBPtr()->flushAll();
131 copyRegs(ThreadContext
*src
, ThreadContext
*dest
)
134 for (int i
= 0; i
< NumIntRegs
; ++i
)
135 dest
->setIntRegFlat(i
, src
->readIntRegFlat(i
));
137 for (int i
= 0; i
< NumFloatRegs
; ++i
)
138 dest
->setFloatRegFlat(i
, src
->readFloatRegFlat(i
));
139 //copy condition-code regs
140 for (int i
= 0; i
< NumCCRegs
; ++i
)
141 dest
->setCCRegFlat(i
, src
->readCCRegFlat(i
));
142 copyMiscRegs(src
, dest
);
143 dest
->pcState(src
->pcState());
147 skipFunction(ThreadContext
*tc
)
149 panic("Not implemented for x86\n");
153 getRFlags(ThreadContext
*tc
)
155 const uint64_t ncc_flags(tc
->readMiscRegNoEffect(MISCREG_RFLAGS
));
156 const uint64_t cc_flags(tc
->readCCReg(X86ISA::CCREG_ZAPS
));
157 const uint64_t cfof_bits(tc
->readCCReg(X86ISA::CCREG_CFOF
));
158 const uint64_t df_bit(tc
->readCCReg(X86ISA::CCREG_DF
));
159 // ecf (PSEUDO(3)) & ezf (PSEUDO(4)) are only visible to
160 // microcode, so we can safely ignore them.
162 // Reconstruct the real rflags state, mask out internal flags, and
163 // make sure reserved bits have the expected values.
164 return ((ncc_flags
| cc_flags
| cfof_bits
| df_bit
) & 0x3F7FD5)
169 setRFlags(ThreadContext
*tc
, uint64_t val
)
171 tc
->setCCReg(X86ISA::CCREG_ZAPS
, val
& ccFlagMask
);
172 tc
->setCCReg(X86ISA::CCREG_CFOF
, val
& cfofMask
);
173 tc
->setCCReg(X86ISA::CCREG_DF
, val
& DFBit
);
175 // Internal microcode registers (ECF & EZF)
176 tc
->setCCReg(X86ISA::CCREG_ECF
, 0);
177 tc
->setCCReg(X86ISA::CCREG_EZF
, 0);
179 // Update the RFLAGS misc reg with whatever didn't go into the
181 tc
->setMiscReg(MISCREG_RFLAGS
, val
& ~(ccFlagMask
| cfofMask
| DFBit
));
185 convX87TagsToXTags(uint16_t ftw
)
188 for (int i
= 0; i
< 8; ++i
) {
189 // Extract the tag for the current element on the FP stack
190 const unsigned tag((ftw
>> (2 * i
)) & 0x3);
193 * Check the type of the current FP element. Valid values are:
196 * 2 == Special (Nan, unsupported, infinity, denormal)
199 // The xsave version of the tag word only keeps track of
200 // whether the element is empty or not. Set the corresponding
201 // bit in the ftwx if it's not empty,
210 convX87XTagsToTags(uint8_t ftwx
)
213 for (int i
= 0; i
< 8; ++i
) {
214 const unsigned xtag(((ftwx
>> i
) & 0x1));
216 // The xtag for an x87 stack position is 0 for empty stack positions.
218 // Set the tag word to 3 (empty) for the current element.
219 ftw
|= 0x3 << (2 * i
);
221 // TODO: We currently assume that non-empty elements are
222 // valid (0x0), but we should ideally reconstruct the full
223 // state (valid/zero/special).
231 genX87Tags(uint16_t ftw
, uint8_t top
, int8_t spm
)
233 const uint8_t new_top((top
+ spm
+ 8) % 8);
236 // Removing elements from the stack. Flag the elements as empty.
237 for (int i
= top
; i
!= new_top
; i
= (i
+ 1 + 8) % 8)
238 ftw
|= 0x3 << (2 * i
);
239 } else if (spm
< 0) {
240 // Adding elements to the stack. Flag the new elements as
241 // valid. We should ideally decode them and "do the right
243 for (int i
= new_top
; i
!= top
; i
= (i
+ 1 + 8) % 8)
244 ftw
&= ~(0x3 << (2 * i
));
251 loadFloat80(const void *_mem
)
254 memcpy(fp80
.bits
, _mem
, 10);
256 return fp80_cvtd(fp80
);
260 storeFloat80(void *_mem
, double value
)
262 fp80_t fp80
= fp80_cvfd(value
);
263 memcpy(_mem
, fp80
.bits
, 10);
266 } // namespace X86_ISA