2 * Copyright (c) 2007 The Hewlett-Packard Development Company
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.
14 * Copyright (c) 2003-2007 The Regents of The University of Michigan
15 * All rights reserved.
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.
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.
43 #include "arch/x86/decoder.hh"
44 #include "arch/x86/faults.hh"
45 #include "arch/x86/isa_traits.hh"
46 #include "base/trace.hh"
47 #include "cpu/thread_context.hh"
48 #include "debug/Faults.hh"
49 #include "sim/full_system.hh"
53 void X86FaultBase::invoke(ThreadContext
* tc
, StaticInstPtr inst
)
56 FaultBase::invoke(tc
, inst
);
60 PCState pcState
= tc
->pcState();
61 Addr pc
= pcState
.pc();
62 DPRINTF(Faults
, "RIP %#x: vector %d: %s\n",
63 pc
, vector
, describe());
64 using namespace X86ISAInst::RomLabels
;
65 HandyM5Reg m5reg
= tc
->readMiscRegNoEffect(MISCREG_M5_REG
);
67 if (m5reg
.mode
== LongMode
) {
69 entry
= extern_label_longModeSoftInterrupt
;
71 entry
= extern_label_longModeInterrupt
;
74 entry
= extern_label_legacyModeInterrupt
;
76 tc
->setIntReg(INTREG_MICRO(1), vector
);
77 tc
->setIntReg(INTREG_MICRO(7), pc
);
78 if (errorCode
!= (uint64_t)(-1)) {
79 if (m5reg
.mode
== LongMode
) {
80 entry
= extern_label_longModeInterruptWithError
;
82 panic("Legacy mode interrupts with error codes "
83 "aren't implementde.\n");
85 // Software interrupts shouldn't have error codes. If one
86 // does, there would need to be microcode to set it up.
88 tc
->setIntReg(INTREG_MICRO(15), errorCode
);
90 pcState
.upc(romMicroPC(entry
));
91 pcState
.nupc(romMicroPC(entry
) + 1);
96 X86FaultBase::describe() const
99 ccprintf(ss
, "%s", mnemonic());
100 if (errorCode
!= (uint64_t)(-1)) {
101 ccprintf(ss
, "(%#x)", errorCode
);
107 void X86Trap::invoke(ThreadContext
* tc
, StaticInstPtr inst
)
109 X86FaultBase::invoke(tc
);
113 // This is the same as a fault, but it happens -after- the
115 PCState pc
= tc
->pcState();
119 void X86Abort::invoke(ThreadContext
* tc
, StaticInstPtr inst
)
121 panic("Abort exception!");
125 InvalidOpcode::invoke(ThreadContext
* tc
, StaticInstPtr inst
)
128 X86Fault::invoke(tc
, inst
);
130 panic("Unrecognized/invalid instruction executed:\n %s",
135 void PageFault::invoke(ThreadContext
* tc
, StaticInstPtr inst
)
138 HandyM5Reg m5reg
= tc
->readMiscRegNoEffect(MISCREG_M5_REG
);
139 X86FaultBase::invoke(tc
);
141 * If something bad happens while trying to enter the page fault
142 * handler, I'm pretty sure that's a double fault and then all
143 * bets are off. That means it should be safe to update this
146 if (m5reg
.mode
== LongMode
) {
147 tc
->setMiscReg(MISCREG_CR2
, addr
);
149 tc
->setMiscReg(MISCREG_CR2
, (uint32_t)addr
);
152 PageFaultErrorCode code
= errorCode
;
153 const char *modeStr
= "";
160 panic("Tried to %s unmapped address %#x.\n", modeStr
, addr
);
165 PageFault::describe() const
167 std::stringstream ss
;
168 ccprintf(ss
, "%s at %#x", X86FaultBase::describe(), addr
);
173 InitInterrupt::invoke(ThreadContext
*tc
, StaticInstPtr inst
)
175 DPRINTF(Faults
, "Init interrupt.\n");
176 // The otherwise unmodified integer registers should be set to 0.
177 for (int index
= 0; index
< NUM_INTREGS
; index
++) {
178 tc
->setIntReg(index
, 0);
181 CR0 cr0
= tc
->readMiscReg(MISCREG_CR0
);
185 tc
->setMiscReg(MISCREG_CR0
, newCR0
);
186 tc
->setMiscReg(MISCREG_CR2
, 0);
187 tc
->setMiscReg(MISCREG_CR3
, 0);
188 tc
->setMiscReg(MISCREG_CR4
, 0);
190 tc
->setMiscReg(MISCREG_RFLAGS
, 0x0000000000000002ULL
);
192 tc
->setMiscReg(MISCREG_EFER
, 0);
194 SegAttr dataAttr
= 0;
196 dataAttr
.unusable
= 0;
197 dataAttr
.defaultSize
= 0;
198 dataAttr
.longMode
= 0;
200 dataAttr
.granularity
= 0;
201 dataAttr
.present
= 1;
203 dataAttr
.writable
= 1;
204 dataAttr
.readable
= 1;
205 dataAttr
.expandDown
= 0;
208 for (int seg
= 0; seg
!= NUM_SEGMENTREGS
; seg
++) {
209 tc
->setMiscReg(MISCREG_SEG_SEL(seg
), 0);
210 tc
->setMiscReg(MISCREG_SEG_BASE(seg
), 0);
211 tc
->setMiscReg(MISCREG_SEG_EFF_BASE(seg
), 0);
212 tc
->setMiscReg(MISCREG_SEG_LIMIT(seg
), 0xffff);
213 tc
->setMiscReg(MISCREG_SEG_ATTR(seg
), dataAttr
);
216 SegAttr codeAttr
= 0;
218 codeAttr
.unusable
= 0;
219 codeAttr
.defaultSize
= 0;
220 codeAttr
.longMode
= 0;
222 codeAttr
.granularity
= 0;
223 codeAttr
.present
= 1;
225 codeAttr
.writable
= 0;
226 codeAttr
.readable
= 1;
227 codeAttr
.expandDown
= 0;
230 tc
->setMiscReg(MISCREG_CS
, 0xf000);
231 tc
->setMiscReg(MISCREG_CS_BASE
,
232 0x00000000ffff0000ULL
);
233 tc
->setMiscReg(MISCREG_CS_EFF_BASE
,
234 0x00000000ffff0000ULL
);
235 // This has the base value pre-added.
236 tc
->setMiscReg(MISCREG_CS_LIMIT
, 0xffffffff);
237 tc
->setMiscReg(MISCREG_CS_ATTR
, codeAttr
);
239 PCState
pc(0x000000000000fff0ULL
+ tc
->readMiscReg(MISCREG_CS_BASE
));
242 tc
->setMiscReg(MISCREG_TSG_BASE
, 0);
243 tc
->setMiscReg(MISCREG_TSG_LIMIT
, 0xffff);
245 tc
->setMiscReg(MISCREG_IDTR_BASE
, 0);
246 tc
->setMiscReg(MISCREG_IDTR_LIMIT
, 0xffff);
248 tc
->setMiscReg(MISCREG_TSL
, 0);
249 tc
->setMiscReg(MISCREG_TSL_BASE
, 0);
250 tc
->setMiscReg(MISCREG_TSL_LIMIT
, 0xffff);
251 tc
->setMiscReg(MISCREG_TSL_ATTR
, 0);
253 tc
->setMiscReg(MISCREG_TR
, 0);
254 tc
->setMiscReg(MISCREG_TR_BASE
, 0);
255 tc
->setMiscReg(MISCREG_TR_LIMIT
, 0xffff);
256 tc
->setMiscReg(MISCREG_TR_ATTR
, 0);
258 // This value should be the family/model/stepping of the processor.
259 // (page 418). It should be consistent with the value from CPUID, but
260 // the actual value probably doesn't matter much.
261 tc
->setIntReg(INTREG_RDX
, 0);
263 tc
->setMiscReg(MISCREG_DR0
, 0);
264 tc
->setMiscReg(MISCREG_DR1
, 0);
265 tc
->setMiscReg(MISCREG_DR2
, 0);
266 tc
->setMiscReg(MISCREG_DR3
, 0);
268 tc
->setMiscReg(MISCREG_DR6
, 0x00000000ffff0ff0ULL
);
269 tc
->setMiscReg(MISCREG_DR7
, 0x0000000000000400ULL
);
271 // Update the handy M5 Reg.
272 tc
->setMiscReg(MISCREG_M5_REG
, 0);
273 MicroPC entry
= X86ISAInst::RomLabels::extern_label_initIntHalt
;
274 pc
.upc(romMicroPC(entry
));
275 pc
.nupc(romMicroPC(entry
) + 1);
280 StartupInterrupt::invoke(ThreadContext
*tc
, StaticInstPtr inst
)
282 DPRINTF(Faults
, "Startup interrupt with vector %#x.\n", vector
);
283 HandyM5Reg m5Reg
= tc
->readMiscReg(MISCREG_M5_REG
);
284 if (m5Reg
.mode
!= LegacyMode
|| m5Reg
.submode
!= RealMode
) {
285 panic("Startup IPI recived outside of real mode. "
286 "Don't know what to do. %d, %d", m5Reg
.mode
, m5Reg
.submode
);
289 tc
->setMiscReg(MISCREG_CS
, vector
<< 8);
290 tc
->setMiscReg(MISCREG_CS_BASE
, vector
<< 12);
291 tc
->setMiscReg(MISCREG_CS_EFF_BASE
, vector
<< 12);
292 // This has the base value pre-added.
293 tc
->setMiscReg(MISCREG_CS_LIMIT
, 0xffff);
295 tc
->pcState(tc
->readMiscReg(MISCREG_CS_BASE
));
297 } // namespace X86ISA