?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nand: boot code cleanup
[qemu/mini2440.git] / target-i386 / helper.c
blob7fc5366e6d61cee0afdec3d1823b125286d59ba5
1 /*
2 * i386 helpers (without register variable usage)
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA
19 */
20 #include <stdarg.h>
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <string.h>
24 #include <inttypes.h>
25 #include <signal.h>
26
27 #include "cpu.h"
28 #include "exec-all.h"
29 #include "qemu-common.h"
30 #include "kvm.h"
31
32 //#define DEBUG_MMU
33
34 /* feature flags taken from "Intel Processor Identification and the CPUID
35 * Instruction" and AMD's "CPUID Specification". In cases of disagreement
36 * about feature names, the Linux name is used. */
37 static const char *feature_name[] = {
38 "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
39 "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
40 "pat", "pse36", "pn" /* Intel psn */, "clflush" /* Intel clfsh */, NULL, "ds" /* Intel dts */, "acpi", "mmx",
41 "fxsr", "sse", "sse2", "ss", "ht" /* Intel htt */, "tm", "ia64", "pbe",
42 };
43 static const char *ext_feature_name[] = {
44 "pni" /* Intel,AMD sse3 */, NULL, NULL, "monitor", "ds_cpl", "vmx", NULL /* Linux smx */, "est",
45 "tm2", "ssse3", "cid", NULL, NULL, "cx16", "xtpr", NULL,
46 NULL, NULL, "dca", NULL, NULL, NULL, NULL, "popcnt",
47 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
48 };
49 static const char *ext2_feature_name[] = {
50 "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
51 "cx8" /* AMD CMPXCHG8B */, "apic", NULL, "syscall", "mtrr", "pge", "mca", "cmov",
52 "pat", "pse36", NULL, NULL /* Linux mp */, "nx" /* Intel xd */, NULL, "mmxext", "mmx",
53 "fxsr", "fxsr_opt" /* AMD ffxsr */, "pdpe1gb" /* AMD Page1GB */, "rdtscp", NULL, "lm" /* Intel 64 */, "3dnowext", "3dnow",
54 };
55 static const char *ext3_feature_name[] = {
56 "lahf_lm" /* AMD LahfSahf */, "cmp_legacy", "svm", "extapic" /* AMD ExtApicSpace */, "cr8legacy" /* AMD AltMovCr8 */, "abm", "sse4a", "misalignsse",
57 "3dnowprefetch", "osvw", NULL /* Linux ibs */, NULL, "skinit", "wdt", NULL, NULL,
58 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
59 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
60 };
61
62 static void add_flagname_to_bitmaps(char *flagname, uint32_t *features,
63 uint32_t *ext_features,
64 uint32_t *ext2_features,
65 uint32_t *ext3_features)
66 {
67 int i;
68 int found = 0;
69
70 for ( i = 0 ; i < 32 ; i++ )
71 if (feature_name[i] && !strcmp (flagname, feature_name[i])) {
72 *features |= 1 << i;
73 found = 1;
74 }
75 for ( i = 0 ; i < 32 ; i++ )
76 if (ext_feature_name[i] && !strcmp (flagname, ext_feature_name[i])) {
77 *ext_features |= 1 << i;
78 found = 1;
79 }
80 for ( i = 0 ; i < 32 ; i++ )
81 if (ext2_feature_name[i] && !strcmp (flagname, ext2_feature_name[i])) {
82 *ext2_features |= 1 << i;
83 found = 1;
84 }
85 for ( i = 0 ; i < 32 ; i++ )
86 if (ext3_feature_name[i] && !strcmp (flagname, ext3_feature_name[i])) {
87 *ext3_features |= 1 << i;
88 found = 1;
89 }
90 if (!found) {
91 fprintf(stderr, "CPU feature %s not found\n", flagname);
92 }
93 }
94
95 static void kvm_trim_features(uint32_t *features, uint32_t supported,
96 const char *names[])
97 {
98 int i;
99 uint32_t mask;
100
101 for (i = 0; i < 32; ++i) {
102 mask = 1U << i;
103 if ((*features & mask) && !(supported & mask)) {
104 *features &= ~mask;
105 }
106 }
107 }
108
109 typedef struct x86_def_t {
110 const char *name;
111 uint32_t level;
112 uint32_t vendor1, vendor2, vendor3;
113 int family;
114 int model;
115 int stepping;
116 uint32_t features, ext_features, ext2_features, ext3_features;
117 uint32_t xlevel;
118 char model_id[48];
119 } x86_def_t;
120
121 #define I486_FEATURES (CPUID_FP87 | CPUID_VME | CPUID_PSE)
122 #define PENTIUM_FEATURES (I486_FEATURES | CPUID_DE | CPUID_TSC | \
123 CPUID_MSR | CPUID_MCE | CPUID_CX8 | CPUID_MMX)
124 #define PENTIUM2_FEATURES (PENTIUM_FEATURES | CPUID_PAE | CPUID_SEP | \
125 CPUID_MTRR | CPUID_PGE | CPUID_MCA | CPUID_CMOV | CPUID_PAT | \
126 CPUID_PSE36 | CPUID_FXSR)
127 #define PENTIUM3_FEATURES (PENTIUM2_FEATURES | CPUID_SSE)
128 #define PPRO_FEATURES (CPUID_FP87 | CPUID_DE | CPUID_PSE | CPUID_TSC | \
129 CPUID_MSR | CPUID_MCE | CPUID_CX8 | CPUID_PGE | CPUID_CMOV | \
130 CPUID_PAT | CPUID_FXSR | CPUID_MMX | CPUID_SSE | CPUID_SSE2 | \
131 CPUID_PAE | CPUID_SEP | CPUID_APIC)
132 static x86_def_t x86_defs[] = {
133 #ifdef TARGET_X86_64
134 {
135 .name = "qemu64",
136 .level = 2,
137 .vendor1 = CPUID_VENDOR_AMD_1,
138 .vendor2 = CPUID_VENDOR_AMD_2,
139 .vendor3 = CPUID_VENDOR_AMD_3,
140 .family = 6,
141 .model = 2,
142 .stepping = 3,
143 .features = PPRO_FEATURES |
144 /* these features are needed for Win64 and aren't fully implemented */
145 CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
146 /* this feature is needed for Solaris and isn't fully implemented */
147 CPUID_PSE36,
148 .ext_features = CPUID_EXT_SSE3,
149 .ext2_features = (PPRO_FEATURES & 0x0183F3FF) |
150 CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX |
151 CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT,
152 .ext3_features = CPUID_EXT3_SVM,
153 .xlevel = 0x8000000A,
154 .model_id = "QEMU Virtual CPU version " QEMU_VERSION,
155 },
156 {
157 .name = "phenom",
158 .level = 5,
159 .vendor1 = CPUID_VENDOR_AMD_1,
160 .vendor2 = CPUID_VENDOR_AMD_2,
161 .vendor3 = CPUID_VENDOR_AMD_3,
162 .family = 16,
163 .model = 2,
164 .stepping = 3,
165 /* Missing: CPUID_VME, CPUID_HT */
166 .features = PPRO_FEATURES |
167 CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
168 CPUID_PSE36,
169 /* Missing: CPUID_EXT_CX16, CPUID_EXT_POPCNT */
170 .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR,
171 /* Missing: CPUID_EXT2_PDPE1GB, CPUID_EXT2_RDTSCP */
172 .ext2_features = (PPRO_FEATURES & 0x0183F3FF) |
173 CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX |
174 CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT | CPUID_EXT2_MMXEXT |
175 CPUID_EXT2_FFXSR,
176 /* Missing: CPUID_EXT3_LAHF_LM, CPUID_EXT3_CMP_LEG, CPUID_EXT3_EXTAPIC,
177 CPUID_EXT3_CR8LEG, CPUID_EXT3_ABM, CPUID_EXT3_SSE4A,
178 CPUID_EXT3_MISALIGNSSE, CPUID_EXT3_3DNOWPREFETCH,
179 CPUID_EXT3_OSVW, CPUID_EXT3_IBS */
180 .ext3_features = CPUID_EXT3_SVM,
181 .xlevel = 0x8000001A,
182 .model_id = "AMD Phenom(tm) 9550 Quad-Core Processor"
183 },
184 {
185 .name = "core2duo",
186 .level = 10,
187 .family = 6,
188 .model = 15,
189 .stepping = 11,
190 /* The original CPU also implements these features:
191 CPUID_VME, CPUID_DTS, CPUID_ACPI, CPUID_SS, CPUID_HT,
192 CPUID_TM, CPUID_PBE */
193 .features = PPRO_FEATURES |
194 CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
195 CPUID_PSE36,
196 /* The original CPU also implements these ext features:
197 CPUID_EXT_DTES64, CPUID_EXT_DSCPL, CPUID_EXT_VMX, CPUID_EXT_EST,
198 CPUID_EXT_TM2, CPUID_EXT_CX16, CPUID_EXT_XTPR, CPUID_EXT_PDCM */
199 .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | CPUID_EXT_SSSE3,
200 .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX,
201 /* Missing: .ext3_features = CPUID_EXT3_LAHF_LM */
202 .xlevel = 0x80000008,
203 .model_id = "Intel(R) Core(TM)2 Duo CPU T7700 @ 2.40GHz",
204 },
205 #endif
206 {
207 .name = "qemu32",
208 .level = 2,
209 .family = 6,
210 .model = 3,
211 .stepping = 3,
212 .features = PPRO_FEATURES,
213 .ext_features = CPUID_EXT_SSE3,
214 .xlevel = 0,
215 .model_id = "QEMU Virtual CPU version " QEMU_VERSION,
216 },
217 {
218 .name = "coreduo",
219 .level = 10,
220 .family = 6,
221 .model = 14,
222 .stepping = 8,
223 /* The original CPU also implements these features:
224 CPUID_DTS, CPUID_ACPI, CPUID_SS, CPUID_HT,
225 CPUID_TM, CPUID_PBE */
226 .features = PPRO_FEATURES | CPUID_VME |
227 CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA,
228 /* The original CPU also implements these ext features:
229 CPUID_EXT_VMX, CPUID_EXT_EST, CPUID_EXT_TM2, CPUID_EXT_XTPR,
230 CPUID_EXT_PDCM */
231 .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR,
232 .ext2_features = CPUID_EXT2_NX,
233 .xlevel = 0x80000008,
234 .model_id = "Genuine Intel(R) CPU T2600 @ 2.16GHz",
235 },
236 {
237 .name = "486",
238 .level = 0,
239 .family = 4,
240 .model = 0,
241 .stepping = 0,
242 .features = I486_FEATURES,
243 .xlevel = 0,
244 },
245 {
246 .name = "pentium",
247 .level = 1,
248 .family = 5,
249 .model = 4,
250 .stepping = 3,
251 .features = PENTIUM_FEATURES,
252 .xlevel = 0,
253 },
254 {
255 .name = "pentium2",
256 .level = 2,
257 .family = 6,
258 .model = 5,
259 .stepping = 2,
260 .features = PENTIUM2_FEATURES,
261 .xlevel = 0,
262 },
263 {
264 .name = "pentium3",
265 .level = 2,
266 .family = 6,
267 .model = 7,
268 .stepping = 3,
269 .features = PENTIUM3_FEATURES,
270 .xlevel = 0,
271 },
272 {
273 .name = "athlon",
274 .level = 2,
275 .vendor1 = 0x68747541, /* "Auth" */
276 .vendor2 = 0x69746e65, /* "enti" */
277 .vendor3 = 0x444d4163, /* "cAMD" */
278 .family = 6,
279 .model = 2,
280 .stepping = 3,
281 .features = PPRO_FEATURES | CPUID_PSE36 | CPUID_VME | CPUID_MTRR | CPUID_MCA,
282 .ext2_features = (PPRO_FEATURES & 0x0183F3FF) | CPUID_EXT2_MMXEXT | CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT,
283 .xlevel = 0x80000008,
284 /* XXX: put another string ? */
285 .model_id = "QEMU Virtual CPU version " QEMU_VERSION,
286 },
287 {
288 .name = "n270",
289 /* original is on level 10 */
290 .level = 5,
291 .family = 6,
292 .model = 28,
293 .stepping = 2,
294 .features = PPRO_FEATURES |
295 CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA | CPUID_VME,
296 /* Missing: CPUID_DTS | CPUID_ACPI | CPUID_SS |
297 * CPUID_HT | CPUID_TM | CPUID_PBE */
298 /* Some CPUs got no CPUID_SEP */
299 .ext_features = CPUID_EXT_MONITOR |
300 CPUID_EXT_SSE3 /* PNI */ | CPUID_EXT_SSSE3,
301 /* Missing: CPUID_EXT_DSCPL | CPUID_EXT_EST |
302 * CPUID_EXT_TM2 | CPUID_EXT_XTPR */
303 .ext2_features = (PPRO_FEATURES & 0x0183F3FF) | CPUID_EXT2_NX,
304 /* Missing: .ext3_features = CPUID_EXT3_LAHF_LM */
305 .xlevel = 0x8000000A,
306 .model_id = "Intel(R) Atom(TM) CPU N270 @ 1.60GHz",
307 },
308 };
309
310 static int cpu_x86_find_by_name(x86_def_t *x86_cpu_def, const char *cpu_model)
311 {
312 unsigned int i;
313 x86_def_t *def;
314
315 char *s = strdup(cpu_model);
316 char *featurestr, *name = strtok(s, ",");
317 uint32_t plus_features = 0, plus_ext_features = 0, plus_ext2_features = 0, plus_ext3_features = 0;
318 uint32_t minus_features = 0, minus_ext_features = 0, minus_ext2_features = 0, minus_ext3_features = 0;
319 int family = -1, model = -1, stepping = -1;
320
321 def = NULL;
322 for (i = 0; i < ARRAY_SIZE(x86_defs); i++) {
323 if (strcmp(name, x86_defs[i].name) == 0) {
324 def = &x86_defs[i];
325 break;
326 }
327 }
328 if (!def)
329 goto error;
330 memcpy(x86_cpu_def, def, sizeof(*def));
331
332 featurestr = strtok(NULL, ",");
333
334 while (featurestr) {
335 char *val;
336 if (featurestr[0] == '+') {
337 add_flagname_to_bitmaps(featurestr + 1, &plus_features, &plus_ext_features, &plus_ext2_features, &plus_ext3_features);
338 } else if (featurestr[0] == '-') {
339 add_flagname_to_bitmaps(featurestr + 1, &minus_features, &minus_ext_features, &minus_ext2_features, &minus_ext3_features);
340 } else if ((val = strchr(featurestr, '='))) {
341 *val = 0; val++;
342 if (!strcmp(featurestr, "family")) {
343 char *err;
344 family = strtol(val, &err, 10);
345 if (!*val || *err || family < 0) {
346 fprintf(stderr, "bad numerical value %s\n", val);
347 goto error;
348 }
349 x86_cpu_def->family = family;
350 } else if (!strcmp(featurestr, "model")) {
351 char *err;
352 model = strtol(val, &err, 10);
353 if (!*val || *err || model < 0 || model > 0xff) {
354 fprintf(stderr, "bad numerical value %s\n", val);
355 goto error;
356 }
357 x86_cpu_def->model = model;
358 } else if (!strcmp(featurestr, "stepping")) {
359 char *err;
360 stepping = strtol(val, &err, 10);
361 if (!*val || *err || stepping < 0 || stepping > 0xf) {
362 fprintf(stderr, "bad numerical value %s\n", val);
363 goto error;
364 }
365 x86_cpu_def->stepping = stepping;
366 } else if (!strcmp(featurestr, "vendor")) {
367 if (strlen(val) != 12) {
368 fprintf(stderr, "vendor string must be 12 chars long\n");
369 goto error;
370 }
371 x86_cpu_def->vendor1 = 0;
372 x86_cpu_def->vendor2 = 0;
373 x86_cpu_def->vendor3 = 0;
374 for(i = 0; i < 4; i++) {
375 x86_cpu_def->vendor1 |= ((uint8_t)val[i ]) << (8 * i);
376 x86_cpu_def->vendor2 |= ((uint8_t)val[i + 4]) << (8 * i);
377 x86_cpu_def->vendor3 |= ((uint8_t)val[i + 8]) << (8 * i);
378 }
379 } else if (!strcmp(featurestr, "model_id")) {
380 pstrcpy(x86_cpu_def->model_id, sizeof(x86_cpu_def->model_id),
381 val);
382 } else {
383 fprintf(stderr, "unrecognized feature %s\n", featurestr);
384 goto error;
385 }
386 } else {
387 fprintf(stderr, "feature string `%s' not in format (+feature|-feature|feature=xyz)\n", featurestr);
388 goto error;
389 }
390 featurestr = strtok(NULL, ",");
391 }
392 x86_cpu_def->features |= plus_features;
393 x86_cpu_def->ext_features |= plus_ext_features;
394 x86_cpu_def->ext2_features |= plus_ext2_features;
395 x86_cpu_def->ext3_features |= plus_ext3_features;
396 x86_cpu_def->features &= ~minus_features;
397 x86_cpu_def->ext_features &= ~minus_ext_features;
398 x86_cpu_def->ext2_features &= ~minus_ext2_features;
399 x86_cpu_def->ext3_features &= ~minus_ext3_features;
400 free(s);
401 return 0;
402
403 error:
404 free(s);
405 return -1;
406 }
407
408 void x86_cpu_list (FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...))
409 {
410 unsigned int i;
411
412 for (i = 0; i < ARRAY_SIZE(x86_defs); i++)
413 (*cpu_fprintf)(f, "x86 %16s\n", x86_defs[i].name);
414 }
415
416 static int cpu_x86_register (CPUX86State *env, const char *cpu_model)
417 {
418 x86_def_t def1, *def = &def1;
419
420 if (cpu_x86_find_by_name(def, cpu_model) < 0)
421 return -1;
422 if (def->vendor1) {
423 env->cpuid_vendor1 = def->vendor1;
424 env->cpuid_vendor2 = def->vendor2;
425 env->cpuid_vendor3 = def->vendor3;
426 } else {
427 env->cpuid_vendor1 = CPUID_VENDOR_INTEL_1;
428 env->cpuid_vendor2 = CPUID_VENDOR_INTEL_2;
429 env->cpuid_vendor3 = CPUID_VENDOR_INTEL_3;
430 }
431 env->cpuid_level = def->level;
432 if (def->family > 0x0f)
433 env->cpuid_version = 0xf00 | ((def->family - 0x0f) << 20);
434 else
435 env->cpuid_version = def->family << 8;
436 env->cpuid_version |= ((def->model & 0xf) << 4) | ((def->model >> 4) << 16);
437 env->cpuid_version |= def->stepping;
438 env->cpuid_features = def->features;
439 env->pat = 0x0007040600070406ULL;
440 env->cpuid_ext_features = def->ext_features;
441 env->cpuid_ext2_features = def->ext2_features;
442 env->cpuid_xlevel = def->xlevel;
443 env->cpuid_ext3_features = def->ext3_features;
444 {
445 const char *model_id = def->model_id;
446 int c, len, i;
447 if (!model_id)
448 model_id = "";
449 len = strlen(model_id);
450 for(i = 0; i < 48; i++) {
451 if (i >= len)
452 c = '\0';
453 else
454 c = (uint8_t)model_id[i];
455 env->cpuid_model[i >> 2] |= c << (8 * (i & 3));
456 }
457 }
458 return 0;
459 }
460
461 /* NOTE: must be called outside the CPU execute loop */
462 void cpu_reset(CPUX86State *env)
463 {
464 int i;
465
466 if (qemu_loglevel_mask(CPU_LOG_RESET)) {
467 qemu_log("CPU Reset (CPU %d)\n", env->cpu_index);
468 log_cpu_state(env, X86_DUMP_FPU | X86_DUMP_CCOP);
469 }
470
471 memset(env, 0, offsetof(CPUX86State, breakpoints));
472
473 tlb_flush(env, 1);
474
475 env->old_exception = -1;
476
477 /* init to reset state */
478
479 #ifdef CONFIG_SOFTMMU
480 env->hflags |= HF_SOFTMMU_MASK;
481 #endif
482 env->hflags2 |= HF2_GIF_MASK;
483
484 cpu_x86_update_cr0(env, 0x60000010);
485 env->a20_mask = ~0x0;
486 env->smbase = 0x30000;
487
488 env->idt.limit = 0xffff;
489 env->gdt.limit = 0xffff;
490 env->ldt.limit = 0xffff;
491 env->ldt.flags = DESC_P_MASK | (2 << DESC_TYPE_SHIFT);
492 env->tr.limit = 0xffff;
493 env->tr.flags = DESC_P_MASK | (11 << DESC_TYPE_SHIFT);
494
495 cpu_x86_load_seg_cache(env, R_CS, 0xf000, 0xffff0000, 0xffff,
496 DESC_P_MASK | DESC_S_MASK | DESC_CS_MASK | DESC_R_MASK);
497 cpu_x86_load_seg_cache(env, R_DS, 0, 0, 0xffff,
498 DESC_P_MASK | DESC_S_MASK | DESC_W_MASK);
499 cpu_x86_load_seg_cache(env, R_ES, 0, 0, 0xffff,
500 DESC_P_MASK | DESC_S_MASK | DESC_W_MASK);
501 cpu_x86_load_seg_cache(env, R_SS, 0, 0, 0xffff,
502 DESC_P_MASK | DESC_S_MASK | DESC_W_MASK);
503 cpu_x86_load_seg_cache(env, R_FS, 0, 0, 0xffff,
504 DESC_P_MASK | DESC_S_MASK | DESC_W_MASK);
505 cpu_x86_load_seg_cache(env, R_GS, 0, 0, 0xffff,
506 DESC_P_MASK | DESC_S_MASK | DESC_W_MASK);
507
508 env->eip = 0xfff0;
509 env->regs[R_EDX] = env->cpuid_version;
510
511 env->eflags = 0x2;
512
513 /* FPU init */
514 for(i = 0;i < 8; i++)
515 env->fptags[i] = 1;
516 env->fpuc = 0x37f;
517
518 env->mxcsr = 0x1f80;
519
520 memset(env->dr, 0, sizeof(env->dr));
521 env->dr[6] = DR6_FIXED_1;
522 env->dr[7] = DR7_FIXED_1;
523 cpu_breakpoint_remove_all(env, BP_CPU);
524 cpu_watchpoint_remove_all(env, BP_CPU);
525 }
526
527 void cpu_x86_close(CPUX86State *env)
528 {
529 qemu_free(env);
530 }
531
532 /***********************************************************/
533 /* x86 debug */
534
535 static const char *cc_op_str[] = {
536 "DYNAMIC",
537 "EFLAGS",
538
539 "MULB",
540 "MULW",
541 "MULL",
542 "MULQ",
543
544 "ADDB",
545 "ADDW",
546 "ADDL",
547 "ADDQ",
548
549 "ADCB",
550 "ADCW",
551 "ADCL",
552 "ADCQ",
553
554 "SUBB",
555 "SUBW",
556 "SUBL",
557 "SUBQ",
558
559 "SBBB",
560 "SBBW",
561 "SBBL",
562 "SBBQ",
563
564 "LOGICB",
565 "LOGICW",
566 "LOGICL",
567 "LOGICQ",
568
569 "INCB",
570 "INCW",
571 "INCL",
572 "INCQ",
573
574 "DECB",
575 "DECW",
576 "DECL",
577 "DECQ",
578
579 "SHLB",
580 "SHLW",
581 "SHLL",
582 "SHLQ",
583
584 "SARB",
585 "SARW",
586 "SARL",
587 "SARQ",
588 };
589
590 static void
591 cpu_x86_dump_seg_cache(CPUState *env, FILE *f,
592 int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
593 const char *name, struct SegmentCache *sc)
594 {
595 #ifdef TARGET_X86_64
596 if (env->hflags & HF_CS64_MASK) {
597 cpu_fprintf(f, "%-3s=%04x %016" PRIx64 " %08x %08x", name,
598 sc->selector, sc->base, sc->limit, sc->flags);
599 } else
600 #endif
601 {
602 cpu_fprintf(f, "%-3s=%04x %08x %08x %08x", name, sc->selector,
603 (uint32_t)sc->base, sc->limit, sc->flags);
604 }
605
606 if (!(env->hflags & HF_PE_MASK) || !(sc->flags & DESC_P_MASK))
607 goto done;
608
609 cpu_fprintf(f, " DPL=%d ", (sc->flags & DESC_DPL_MASK) >> DESC_DPL_SHIFT);
610 if (sc->flags & DESC_S_MASK) {
611 if (sc->flags & DESC_CS_MASK) {
612 cpu_fprintf(f, (sc->flags & DESC_L_MASK) ? "CS64" :
613 ((sc->flags & DESC_B_MASK) ? "CS32" : "CS16"));
614 cpu_fprintf(f, " [%c%c", (sc->flags & DESC_C_MASK) ? 'C' : '-',
615 (sc->flags & DESC_R_MASK) ? 'R' : '-');
616 } else {
617 cpu_fprintf(f, (sc->flags & DESC_B_MASK) ? "DS " : "DS16");
618 cpu_fprintf(f, " [%c%c", (sc->flags & DESC_E_MASK) ? 'E' : '-',
619 (sc->flags & DESC_W_MASK) ? 'W' : '-');
620 }
621 cpu_fprintf(f, "%c]", (sc->flags & DESC_A_MASK) ? 'A' : '-');
622 } else {
623 static const char *sys_type_name[2][16] = {
624 { /* 32 bit mode */
625 "Reserved", "TSS16-avl", "LDT", "TSS16-busy",
626 "CallGate16", "TaskGate", "IntGate16", "TrapGate16",
627 "Reserved", "TSS32-avl", "Reserved", "TSS32-busy",
628 "CallGate32", "Reserved", "IntGate32", "TrapGate32"
629 },
630 { /* 64 bit mode */
631 "<hiword>", "Reserved", "LDT", "Reserved", "Reserved",
632 "Reserved", "Reserved", "Reserved", "Reserved",
633 "TSS64-avl", "Reserved", "TSS64-busy", "CallGate64",
634 "Reserved", "IntGate64", "TrapGate64"
635 }
636 };
637 cpu_fprintf(f, sys_type_name[(env->hflags & HF_LMA_MASK) ? 1 : 0]
638 [(sc->flags & DESC_TYPE_MASK)
639 >> DESC_TYPE_SHIFT]);
640 }
641 done:
642 cpu_fprintf(f, "\n");
643 }
644
645 void cpu_dump_state(CPUState *env, FILE *f,
646 int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
647 int flags)
648 {
649 int eflags, i, nb;
650 char cc_op_name[32];
651 static const char *seg_name[6] = { "ES", "CS", "SS", "DS", "FS", "GS" };
652
653 if (kvm_enabled())
654 kvm_arch_get_registers(env);
655
656 eflags = env->eflags;
657 #ifdef TARGET_X86_64
658 if (env->hflags & HF_CS64_MASK) {
659 cpu_fprintf(f,
660 "RAX=%016" PRIx64 " RBX=%016" PRIx64 " RCX=%016" PRIx64 " RDX=%016" PRIx64 "\n"
661 "RSI=%016" PRIx64 " RDI=%016" PRIx64 " RBP=%016" PRIx64 " RSP=%016" PRIx64 "\n"
662 "R8 =%016" PRIx64 " R9 =%016" PRIx64 " R10=%016" PRIx64 " R11=%016" PRIx64 "\n"
663 "R12=%016" PRIx64 " R13=%016" PRIx64 " R14=%016" PRIx64 " R15=%016" PRIx64 "\n"
664 "RIP=%016" PRIx64 " RFL=%08x [%c%c%c%c%c%c%c] CPL=%d II=%d A20=%d SMM=%d HLT=%d\n",
665 env->regs[R_EAX],
666 env->regs[R_EBX],
667 env->regs[R_ECX],
668 env->regs[R_EDX],
669 env->regs[R_ESI],
670 env->regs[R_EDI],
671 env->regs[R_EBP],
672 env->regs[R_ESP],
673 env->regs[8],
674 env->regs[9],
675 env->regs[10],
676 env->regs[11],
677 env->regs[12],
678 env->regs[13],
679 env->regs[14],
680 env->regs[15],
681 env->eip, eflags,
682 eflags & DF_MASK ? 'D' : '-',
683 eflags & CC_O ? 'O' : '-',
684 eflags & CC_S ? 'S' : '-',
685 eflags & CC_Z ? 'Z' : '-',
686 eflags & CC_A ? 'A' : '-',
687 eflags & CC_P ? 'P' : '-',
688 eflags & CC_C ? 'C' : '-',
689 env->hflags & HF_CPL_MASK,
690 (env->hflags >> HF_INHIBIT_IRQ_SHIFT) & 1,
691 (int)(env->a20_mask >> 20) & 1,
692 (env->hflags >> HF_SMM_SHIFT) & 1,
693 env->halted);
694 } else
695 #endif
696 {
697 cpu_fprintf(f, "EAX=%08x EBX=%08x ECX=%08x EDX=%08x\n"
698 "ESI=%08x EDI=%08x EBP=%08x ESP=%08x\n"
699 "EIP=%08x EFL=%08x [%c%c%c%c%c%c%c] CPL=%d II=%d A20=%d SMM=%d HLT=%d\n",
700 (uint32_t)env->regs[R_EAX],
701 (uint32_t)env->regs[R_EBX],
702 (uint32_t)env->regs[R_ECX],
703 (uint32_t)env->regs[R_EDX],
704 (uint32_t)env->regs[R_ESI],
705 (uint32_t)env->regs[R_EDI],
706 (uint32_t)env->regs[R_EBP],
707 (uint32_t)env->regs[R_ESP],
708 (uint32_t)env->eip, eflags,
709 eflags & DF_MASK ? 'D' : '-',
710 eflags & CC_O ? 'O' : '-',
711 eflags & CC_S ? 'S' : '-',
712 eflags & CC_Z ? 'Z' : '-',
713 eflags & CC_A ? 'A' : '-',
714 eflags & CC_P ? 'P' : '-',
715 eflags & CC_C ? 'C' : '-',
716 env->hflags & HF_CPL_MASK,
717 (env->hflags >> HF_INHIBIT_IRQ_SHIFT) & 1,
718 (int)(env->a20_mask >> 20) & 1,
719 (env->hflags >> HF_SMM_SHIFT) & 1,
720 env->halted);
721 }
722
723 for(i = 0; i < 6; i++) {
724 cpu_x86_dump_seg_cache(env, f, cpu_fprintf, seg_name[i],
725 &env->segs[i]);
726 }
727 cpu_x86_dump_seg_cache(env, f, cpu_fprintf, "LDT", &env->ldt);
728 cpu_x86_dump_seg_cache(env, f, cpu_fprintf, "TR", &env->tr);
729
730 #ifdef TARGET_X86_64
731 if (env->hflags & HF_LMA_MASK) {
732 cpu_fprintf(f, "GDT= %016" PRIx64 " %08x\n",
733 env->gdt.base, env->gdt.limit);
734 cpu_fprintf(f, "IDT= %016" PRIx64 " %08x\n",
735 env->idt.base, env->idt.limit);
736 cpu_fprintf(f, "CR0=%08x CR2=%016" PRIx64 " CR3=%016" PRIx64 " CR4=%08x\n",
737 (uint32_t)env->cr[0],
738 env->cr[2],
739 env->cr[3],
740 (uint32_t)env->cr[4]);
741 for(i = 0; i < 4; i++)
742 cpu_fprintf(f, "DR%d=%016" PRIx64 " ", i, env->dr[i]);
743 cpu_fprintf(f, "\nDR6=%016" PRIx64 " DR7=%016" PRIx64 "\n",
744 env->dr[6], env->dr[7]);
745 } else
746 #endif
747 {
748 cpu_fprintf(f, "GDT= %08x %08x\n",
749 (uint32_t)env->gdt.base, env->gdt.limit);
750 cpu_fprintf(f, "IDT= %08x %08x\n",
751 (uint32_t)env->idt.base, env->idt.limit);
752 cpu_fprintf(f, "CR0=%08x CR2=%08x CR3=%08x CR4=%08x\n",
753 (uint32_t)env->cr[0],
754 (uint32_t)env->cr[2],
755 (uint32_t)env->cr[3],
756 (uint32_t)env->cr[4]);
757 for(i = 0; i < 4; i++)
758 cpu_fprintf(f, "DR%d=%08x ", i, env->dr[i]);
759 cpu_fprintf(f, "\nDR6=%08x DR7=%08x\n", env->dr[6], env->dr[7]);
760 }
761 if (flags & X86_DUMP_CCOP) {
762 if ((unsigned)env->cc_op < CC_OP_NB)
763 snprintf(cc_op_name, sizeof(cc_op_name), "%s", cc_op_str[env->cc_op]);
764 else
765 snprintf(cc_op_name, sizeof(cc_op_name), "[%d]", env->cc_op);
766 #ifdef TARGET_X86_64
767 if (env->hflags & HF_CS64_MASK) {
768 cpu_fprintf(f, "CCS=%016" PRIx64 " CCD=%016" PRIx64 " CCO=%-8s\n",
769 env->cc_src, env->cc_dst,
770 cc_op_name);
771 } else
772 #endif
773 {
774 cpu_fprintf(f, "CCS=%08x CCD=%08x CCO=%-8s\n",
775 (uint32_t)env->cc_src, (uint32_t)env->cc_dst,
776 cc_op_name);
777 }
778 }
779 if (flags & X86_DUMP_FPU) {
780 int fptag;
781 fptag = 0;
782 for(i = 0; i < 8; i++) {
783 fptag |= ((!env->fptags[i]) << i);
784 }
785 cpu_fprintf(f, "FCW=%04x FSW=%04x [ST=%d] FTW=%02x MXCSR=%08x\n",
786 env->fpuc,
787 (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11,
788 env->fpstt,
789 fptag,
790 env->mxcsr);
791 for(i=0;i<8;i++) {
792 #if defined(USE_X86LDOUBLE)
793 union {
794 long double d;
795 struct {
796 uint64_t lower;
797 uint16_t upper;
798 } l;
799 } tmp;
800 tmp.d = env->fpregs[i].d;
801 cpu_fprintf(f, "FPR%d=%016" PRIx64 " %04x",
802 i, tmp.l.lower, tmp.l.upper);
803 #else
804 cpu_fprintf(f, "FPR%d=%016" PRIx64,
805 i, env->fpregs[i].mmx.q);
806 #endif
807 if ((i & 1) == 1)
808 cpu_fprintf(f, "\n");
809 else
810 cpu_fprintf(f, " ");
811 }
812 if (env->hflags & HF_CS64_MASK)
813 nb = 16;
814 else
815 nb = 8;
816 for(i=0;i<nb;i++) {
817 cpu_fprintf(f, "XMM%02d=%08x%08x%08x%08x",
818 i,
819 env->xmm_regs[i].XMM_L(3),
820 env->xmm_regs[i].XMM_L(2),
821 env->xmm_regs[i].XMM_L(1),
822 env->xmm_regs[i].XMM_L(0));
823 if ((i & 1) == 1)
824 cpu_fprintf(f, "\n");
825 else
826 cpu_fprintf(f, " ");
827 }
828 }
829 }
830
831 /***********************************************************/
832 /* x86 mmu */
833 /* XXX: add PGE support */
834
835 void cpu_x86_set_a20(CPUX86State *env, int a20_state)
836 {
837 a20_state = (a20_state != 0);
838 if (a20_state != ((env->a20_mask >> 20) & 1)) {
839 #if defined(DEBUG_MMU)
840 printf("A20 update: a20=%d\n", a20_state);
841 #endif
842 /* if the cpu is currently executing code, we must unlink it and
843 all the potentially executing TB */
844 cpu_interrupt(env, CPU_INTERRUPT_EXITTB);
845
846 /* when a20 is changed, all the MMU mappings are invalid, so
847 we must flush everything */
848 tlb_flush(env, 1);
849 env->a20_mask = (~0x100000) | (a20_state << 20);
850 }
851 }
852
853 void cpu_x86_update_cr0(CPUX86State *env, uint32_t new_cr0)
854 {
855 int pe_state;
856
857 #if defined(DEBUG_MMU)
858 printf("CR0 update: CR0=0x%08x\n", new_cr0);
859 #endif
860 if ((new_cr0 & (CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK)) !=
861 (env->cr[0] & (CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK))) {
862 tlb_flush(env, 1);
863 }
864
865 #ifdef TARGET_X86_64
866 if (!(env->cr[0] & CR0_PG_MASK) && (new_cr0 & CR0_PG_MASK) &&
867 (env->efer & MSR_EFER_LME)) {
868 /* enter in long mode */
869 /* XXX: generate an exception */
870 if (!(env->cr[4] & CR4_PAE_MASK))
871 return;
872 env->efer |= MSR_EFER_LMA;
873 env->hflags |= HF_LMA_MASK;
874 } else if ((env->cr[0] & CR0_PG_MASK) && !(new_cr0 & CR0_PG_MASK) &&
875 (env->efer & MSR_EFER_LMA)) {
876 /* exit long mode */
877 env->efer &= ~MSR_EFER_LMA;
878 env->hflags &= ~(HF_LMA_MASK | HF_CS64_MASK);
879 env->eip &= 0xffffffff;
880 }
881 #endif
882 env->cr[0] = new_cr0 | CR0_ET_MASK;
883
884 /* update PE flag in hidden flags */
885 pe_state = (env->cr[0] & CR0_PE_MASK);
886 env->hflags = (env->hflags & ~HF_PE_MASK) | (pe_state << HF_PE_SHIFT);
887 /* ensure that ADDSEG is always set in real mode */
888 env->hflags |= ((pe_state ^ 1) << HF_ADDSEG_SHIFT);
889 /* update FPU flags */
890 env->hflags = (env->hflags & ~(HF_MP_MASK | HF_EM_MASK | HF_TS_MASK)) |
891 ((new_cr0 << (HF_MP_SHIFT - 1)) & (HF_MP_MASK | HF_EM_MASK | HF_TS_MASK));
892 }
893
894 /* XXX: in legacy PAE mode, generate a GPF if reserved bits are set in
895 the PDPT */
896 void cpu_x86_update_cr3(CPUX86State *env, target_ulong new_cr3)
897 {
898 env->cr[3] = new_cr3;
899 if (env->cr[0] & CR0_PG_MASK) {
900 #if defined(DEBUG_MMU)
901 printf("CR3 update: CR3=" TARGET_FMT_lx "\n", new_cr3);
902 #endif
903 tlb_flush(env, 0);
904 }
905 }
906
907 void cpu_x86_update_cr4(CPUX86State *env, uint32_t new_cr4)
908 {
909 #if defined(DEBUG_MMU)
910 printf("CR4 update: CR4=%08x\n", (uint32_t)env->cr[4]);
911 #endif
912 if ((new_cr4 & (CR4_PGE_MASK | CR4_PAE_MASK | CR4_PSE_MASK)) !=
913 (env->cr[4] & (CR4_PGE_MASK | CR4_PAE_MASK | CR4_PSE_MASK))) {
914 tlb_flush(env, 1);
915 }
916 /* SSE handling */
917 if (!(env->cpuid_features & CPUID_SSE))
918 new_cr4 &= ~CR4_OSFXSR_MASK;
919 if (new_cr4 & CR4_OSFXSR_MASK)
920 env->hflags |= HF_OSFXSR_MASK;
921 else
922 env->hflags &= ~HF_OSFXSR_MASK;
923
924 env->cr[4] = new_cr4;
925 }
926
927 #if defined(CONFIG_USER_ONLY)
928
929 int cpu_x86_handle_mmu_fault(CPUX86State *env, target_ulong addr,
930 int is_write, int mmu_idx, int is_softmmu)
931 {
932 /* user mode only emulation */
933 is_write &= 1;
934 env->cr[2] = addr;
935 env->error_code = (is_write << PG_ERROR_W_BIT);
936 env->error_code |= PG_ERROR_U_MASK;
937 env->exception_index = EXCP0E_PAGE;
938 return 1;
939 }
940
941 target_phys_addr_t cpu_get_phys_page_debug(CPUState *env, target_ulong addr)
942 {
943 return addr;
944 }
945
946 #else
947
948 /* XXX: This value should match the one returned by CPUID
949 * and in exec.c */
950 #if defined(CONFIG_KQEMU)
951 #define PHYS_ADDR_MASK 0xfffff000LL
952 #else
953 # if defined(TARGET_X86_64)
954 # define PHYS_ADDR_MASK 0xfffffff000LL
955 # else
956 # define PHYS_ADDR_MASK 0xffffff000LL
957 # endif
958 #endif
959
960 /* return value:
961 -1 = cannot handle fault
962 0 = nothing more to do
963 1 = generate PF fault
964 2 = soft MMU activation required for this block
965 */
966 int cpu_x86_handle_mmu_fault(CPUX86State *env, target_ulong addr,
967 int is_write1, int mmu_idx, int is_softmmu)
968 {
969 uint64_t ptep, pte;
970 target_ulong pde_addr, pte_addr;
971 int error_code, is_dirty, prot, page_size, ret, is_write, is_user;
972 target_phys_addr_t paddr;
973 uint32_t page_offset;
974 target_ulong vaddr, virt_addr;
975
976 is_user = mmu_idx == MMU_USER_IDX;
977 #if defined(DEBUG_MMU)
978 printf("MMU fault: addr=" TARGET_FMT_lx " w=%d u=%d eip=" TARGET_FMT_lx "\n",
979 addr, is_write1, is_user, env->eip);
980 #endif
981 is_write = is_write1 & 1;
982
983 if (!(env->cr[0] & CR0_PG_MASK)) {
984 pte = addr;
985 virt_addr = addr & TARGET_PAGE_MASK;
986 prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
987 page_size = 4096;
988 goto do_mapping;
989 }
990
991 if (env->cr[4] & CR4_PAE_MASK) {
992 uint64_t pde, pdpe;
993 target_ulong pdpe_addr;
994
995 #ifdef TARGET_X86_64
996 if (env->hflags & HF_LMA_MASK) {
997 uint64_t pml4e_addr, pml4e;
998 int32_t sext;
999
1000 /* test virtual address sign extension */
1001 sext = (int64_t)addr >> 47;
1002 if (sext != 0 && sext != -1) {
1003 env->error_code = 0;
1004 env->exception_index = EXCP0D_GPF;
1005 return 1;
1006 }
1007
1008 pml4e_addr = ((env->cr[3] & ~0xfff) + (((addr >> 39) & 0x1ff) << 3)) &
1009 env->a20_mask;
1010 pml4e = ldq_phys(pml4e_addr);
1011 if (!(pml4e & PG_PRESENT_MASK)) {
1012 error_code = 0;
1013 goto do_fault;
1014 }
1015 if (!(env->efer & MSR_EFER_NXE) && (pml4e & PG_NX_MASK)) {
1016 error_code = PG_ERROR_RSVD_MASK;
1017 goto do_fault;
1018 }
1019 if (!(pml4e & PG_ACCESSED_MASK)) {
1020 pml4e |= PG_ACCESSED_MASK;
1021 stl_phys_notdirty(pml4e_addr, pml4e);
1022 }
1023 ptep = pml4e ^ PG_NX_MASK;
1024 pdpe_addr = ((pml4e & PHYS_ADDR_MASK) + (((addr >> 30) & 0x1ff) << 3)) &
1025 env->a20_mask;
1026 pdpe = ldq_phys(pdpe_addr);
1027 if (!(pdpe & PG_PRESENT_MASK)) {
1028 error_code = 0;
1029 goto do_fault;
1030 }
1031 if (!(env->efer & MSR_EFER_NXE) && (pdpe & PG_NX_MASK)) {
1032 error_code = PG_ERROR_RSVD_MASK;
1033 goto do_fault;
1034 }
1035 ptep &= pdpe ^ PG_NX_MASK;
1036 if (!(pdpe & PG_ACCESSED_MASK)) {
1037 pdpe |= PG_ACCESSED_MASK;
1038 stl_phys_notdirty(pdpe_addr, pdpe);
1039 }
1040 } else
1041 #endif
1042 {
1043 /* XXX: load them when cr3 is loaded ? */
1044 pdpe_addr = ((env->cr[3] & ~0x1f) + ((addr >> 27) & 0x18)) &
1045 env->a20_mask;
1046 pdpe = ldq_phys(pdpe_addr);
1047 if (!(pdpe & PG_PRESENT_MASK)) {
1048 error_code = 0;
1049 goto do_fault;
1050 }
1051 ptep = PG_NX_MASK | PG_USER_MASK | PG_RW_MASK;
1052 }
1053
1054 pde_addr = ((pdpe & PHYS_ADDR_MASK) + (((addr >> 21) & 0x1ff) << 3)) &
1055 env->a20_mask;
1056 pde = ldq_phys(pde_addr);
1057 if (!(pde & PG_PRESENT_MASK)) {
1058 error_code = 0;
1059 goto do_fault;
1060 }
1061 if (!(env->efer & MSR_EFER_NXE) && (pde & PG_NX_MASK)) {
1062 error_code = PG_ERROR_RSVD_MASK;
1063 goto do_fault;
1064 }
1065 ptep &= pde ^ PG_NX_MASK;
1066 if (pde & PG_PSE_MASK) {
1067 /* 2 MB page */
1068 page_size = 2048 * 1024;
1069 ptep ^= PG_NX_MASK;
1070 if ((ptep & PG_NX_MASK) && is_write1 == 2)
1071 goto do_fault_protect;
1072 if (is_user) {
1073 if (!(ptep & PG_USER_MASK))
1074 goto do_fault_protect;
1075 if (is_write && !(ptep & PG_RW_MASK))
1076 goto do_fault_protect;
1077 } else {
1078 if ((env->cr[0] & CR0_WP_MASK) &&
1079 is_write && !(ptep & PG_RW_MASK))
1080 goto do_fault_protect;
1081 }
1082 is_dirty = is_write && !(pde & PG_DIRTY_MASK);
1083 if (!(pde & PG_ACCESSED_MASK) || is_dirty) {
1084 pde |= PG_ACCESSED_MASK;
1085 if (is_dirty)
1086 pde |= PG_DIRTY_MASK;
1087 stl_phys_notdirty(pde_addr, pde);
1088 }
1089 /* align to page_size */
1090 pte = pde & ((PHYS_ADDR_MASK & ~(page_size - 1)) | 0xfff);
1091 virt_addr = addr & ~(page_size - 1);
1092 } else {
1093 /* 4 KB page */
1094 if (!(pde & PG_ACCESSED_MASK)) {
1095 pde |= PG_ACCESSED_MASK;
1096 stl_phys_notdirty(pde_addr, pde);
1097 }
1098 pte_addr = ((pde & PHYS_ADDR_MASK) + (((addr >> 12) & 0x1ff) << 3)) &
1099 env->a20_mask;
1100 pte = ldq_phys(pte_addr);
1101 if (!(pte & PG_PRESENT_MASK)) {
1102 error_code = 0;
1103 goto do_fault;
1104 }
1105 if (!(env->efer & MSR_EFER_NXE) && (pte & PG_NX_MASK)) {
1106 error_code = PG_ERROR_RSVD_MASK;
1107 goto do_fault;
1108 }
1109 /* combine pde and pte nx, user and rw protections */
1110 ptep &= pte ^ PG_NX_MASK;
1111 ptep ^= PG_NX_MASK;
1112 if ((ptep & PG_NX_MASK) && is_write1 == 2)
1113 goto do_fault_protect;
1114 if (is_user) {
1115 if (!(ptep & PG_USER_MASK))
1116 goto do_fault_protect;
1117 if (is_write && !(ptep & PG_RW_MASK))
1118 goto do_fault_protect;
1119 } else {
1120 if ((env->cr[0] & CR0_WP_MASK) &&
1121 is_write && !(ptep & PG_RW_MASK))
1122 goto do_fault_protect;
1123 }
1124 is_dirty = is_write && !(pte & PG_DIRTY_MASK);
1125 if (!(pte & PG_ACCESSED_MASK) || is_dirty) {
1126 pte |= PG_ACCESSED_MASK;
1127 if (is_dirty)
1128 pte |= PG_DIRTY_MASK;
1129 stl_phys_notdirty(pte_addr, pte);
1130 }
1131 page_size = 4096;
1132 virt_addr = addr & ~0xfff;
1133 pte = pte & (PHYS_ADDR_MASK | 0xfff);
1134 }
1135 } else {
1136 uint32_t pde;
1137
1138 /* page directory entry */
1139 pde_addr = ((env->cr[3] & ~0xfff) + ((addr >> 20) & 0xffc)) &
1140 env->a20_mask;
1141 pde = ldl_phys(pde_addr);
1142 if (!(pde & PG_PRESENT_MASK)) {
1143 error_code = 0;
1144 goto do_fault;
1145 }
1146 /* if PSE bit is set, then we use a 4MB page */
1147 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1148 page_size = 4096 * 1024;
1149 if (is_user) {
1150 if (!(pde & PG_USER_MASK))
1151 goto do_fault_protect;
1152 if (is_write && !(pde & PG_RW_MASK))
1153 goto do_fault_protect;
1154 } else {
1155 if ((env->cr[0] & CR0_WP_MASK) &&
1156 is_write && !(pde & PG_RW_MASK))
1157 goto do_fault_protect;
1158 }
1159 is_dirty = is_write && !(pde & PG_DIRTY_MASK);
1160 if (!(pde & PG_ACCESSED_MASK) || is_dirty) {
1161 pde |= PG_ACCESSED_MASK;
1162 if (is_dirty)
1163 pde |= PG_DIRTY_MASK;
1164 stl_phys_notdirty(pde_addr, pde);
1165 }
1166
1167 pte = pde & ~( (page_size - 1) & ~0xfff); /* align to page_size */
1168 ptep = pte;
1169 virt_addr = addr & ~(page_size - 1);
1170 } else {
1171 if (!(pde & PG_ACCESSED_MASK)) {
1172 pde |= PG_ACCESSED_MASK;
1173 stl_phys_notdirty(pde_addr, pde);
1174 }
1175
1176 /* page directory entry */
1177 pte_addr = ((pde & ~0xfff) + ((addr >> 10) & 0xffc)) &
1178 env->a20_mask;
1179 pte = ldl_phys(pte_addr);
1180 if (!(pte & PG_PRESENT_MASK)) {
1181 error_code = 0;
1182 goto do_fault;
1183 }
1184 /* combine pde and pte user and rw protections */
1185 ptep = pte & pde;
1186 if (is_user) {
1187 if (!(ptep & PG_USER_MASK))
1188 goto do_fault_protect;
1189 if (is_write && !(ptep & PG_RW_MASK))
1190 goto do_fault_protect;
1191 } else {
1192 if ((env->cr[0] & CR0_WP_MASK) &&
1193 is_write && !(ptep & PG_RW_MASK))
1194 goto do_fault_protect;
1195 }
1196 is_dirty = is_write && !(pte & PG_DIRTY_MASK);
1197 if (!(pte & PG_ACCESSED_MASK) || is_dirty) {
1198 pte |= PG_ACCESSED_MASK;
1199 if (is_dirty)
1200 pte |= PG_DIRTY_MASK;
1201 stl_phys_notdirty(pte_addr, pte);
1202 }
1203 page_size = 4096;
1204 virt_addr = addr & ~0xfff;
1205 }
1206 }
1207 /* the page can be put in the TLB */
1208 prot = PAGE_READ;
1209 if (!(ptep & PG_NX_MASK))
1210 prot |= PAGE_EXEC;
1211 if (pte & PG_DIRTY_MASK) {
1212 /* only set write access if already dirty... otherwise wait
1213 for dirty access */
1214 if (is_user) {
1215 if (ptep & PG_RW_MASK)
1216 prot |= PAGE_WRITE;
1217 } else {
1218 if (!(env->cr[0] & CR0_WP_MASK) ||
1219 (ptep & PG_RW_MASK))
1220 prot |= PAGE_WRITE;
1221 }
1222 }
1223 do_mapping:
1224 pte = pte & env->a20_mask;
1225
1226 /* Even if 4MB pages, we map only one 4KB page in the cache to
1227 avoid filling it too fast */
1228 page_offset = (addr & TARGET_PAGE_MASK) & (page_size - 1);
1229 paddr = (pte & TARGET_PAGE_MASK) + page_offset;
1230 vaddr = virt_addr + page_offset;
1231
1232 ret = tlb_set_page_exec(env, vaddr, paddr, prot, mmu_idx, is_softmmu);
1233 return ret;
1234 do_fault_protect:
1235 error_code = PG_ERROR_P_MASK;
1236 do_fault:
1237 error_code |= (is_write << PG_ERROR_W_BIT);
1238 if (is_user)
1239 error_code |= PG_ERROR_U_MASK;
1240 if (is_write1 == 2 &&
1241 (env->efer & MSR_EFER_NXE) &&
1242 (env->cr[4] & CR4_PAE_MASK))
1243 error_code |= PG_ERROR_I_D_MASK;
1244 if (env->intercept_exceptions & (1 << EXCP0E_PAGE)) {
1245 /* cr2 is not modified in case of exceptions */
1246 stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_2),
1247 addr);
1248 } else {
1249 env->cr[2] = addr;
1250 }
1251 env->error_code = error_code;
1252 env->exception_index = EXCP0E_PAGE;
1253 return 1;
1254 }
1255
1256 target_phys_addr_t cpu_get_phys_page_debug(CPUState *env, target_ulong addr)
1257 {
1258 target_ulong pde_addr, pte_addr;
1259 uint64_t pte;
1260 target_phys_addr_t paddr;
1261 uint32_t page_offset;
1262 int page_size;
1263
1264 if (env->cr[4] & CR4_PAE_MASK) {
1265 target_ulong pdpe_addr;
1266 uint64_t pde, pdpe;
1267
1268 #ifdef TARGET_X86_64
1269 if (env->hflags & HF_LMA_MASK) {
1270 uint64_t pml4e_addr, pml4e;
1271 int32_t sext;
1272
1273 /* test virtual address sign extension */
1274 sext = (int64_t)addr >> 47;
1275 if (sext != 0 && sext != -1)
1276 return -1;
1277
1278 pml4e_addr = ((env->cr[3] & ~0xfff) + (((addr >> 39) & 0x1ff) << 3)) &
1279 env->a20_mask;
1280 pml4e = ldq_phys(pml4e_addr);
1281 if (!(pml4e & PG_PRESENT_MASK))
1282 return -1;
1283
1284 pdpe_addr = ((pml4e & ~0xfff) + (((addr >> 30) & 0x1ff) << 3)) &
1285 env->a20_mask;
1286 pdpe = ldq_phys(pdpe_addr);
1287 if (!(pdpe & PG_PRESENT_MASK))
1288 return -1;
1289 } else
1290 #endif
1291 {
1292 pdpe_addr = ((env->cr[3] & ~0x1f) + ((addr >> 27) & 0x18)) &
1293 env->a20_mask;
1294 pdpe = ldq_phys(pdpe_addr);
1295 if (!(pdpe & PG_PRESENT_MASK))
1296 return -1;
1297 }
1298
1299 pde_addr = ((pdpe & ~0xfff) + (((addr >> 21) & 0x1ff) << 3)) &
1300 env->a20_mask;
1301 pde = ldq_phys(pde_addr);
1302 if (!(pde & PG_PRESENT_MASK)) {
1303 return -1;
1304 }
1305 if (pde & PG_PSE_MASK) {
1306 /* 2 MB page */
1307 page_size = 2048 * 1024;
1308 pte = pde & ~( (page_size - 1) & ~0xfff); /* align to page_size */
1309 } else {
1310 /* 4 KB page */
1311 pte_addr = ((pde & ~0xfff) + (((addr >> 12) & 0x1ff) << 3)) &
1312 env->a20_mask;
1313 page_size = 4096;
1314 pte = ldq_phys(pte_addr);
1315 }
1316 if (!(pte & PG_PRESENT_MASK))
1317 return -1;
1318 } else {
1319 uint32_t pde;
1320
1321 if (!(env->cr[0] & CR0_PG_MASK)) {
1322 pte = addr;
1323 page_size = 4096;
1324 } else {
1325 /* page directory entry */
1326 pde_addr = ((env->cr[3] & ~0xfff) + ((addr >> 20) & 0xffc)) & env->a20_mask;
1327 pde = ldl_phys(pde_addr);
1328 if (!(pde & PG_PRESENT_MASK))
1329 return -1;
1330 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1331 pte = pde & ~0x003ff000; /* align to 4MB */
1332 page_size = 4096 * 1024;
1333 } else {
1334 /* page directory entry */
1335 pte_addr = ((pde & ~0xfff) + ((addr >> 10) & 0xffc)) & env->a20_mask;
1336 pte = ldl_phys(pte_addr);
1337 if (!(pte & PG_PRESENT_MASK))
1338 return -1;
1339 page_size = 4096;
1340 }
1341 }
1342 pte = pte & env->a20_mask;
1343 }
1344
1345 page_offset = (addr & TARGET_PAGE_MASK) & (page_size - 1);
1346 paddr = (pte & TARGET_PAGE_MASK) + page_offset;
1347 return paddr;
1348 }
1349
1350 void hw_breakpoint_insert(CPUState *env, int index)
1351 {
1352 int type, err = 0;
1353
1354 switch (hw_breakpoint_type(env->dr[7], index)) {
1355 case 0:
1356 if (hw_breakpoint_enabled(env->dr[7], index))
1357 err = cpu_breakpoint_insert(env, env->dr[index], BP_CPU,
1358 &env->cpu_breakpoint[index]);
1359 break;
1360 case 1:
1361 type = BP_CPU | BP_MEM_WRITE;
1362 goto insert_wp;
1363 case 2:
1364 /* No support for I/O watchpoints yet */
1365 break;
1366 case 3:
1367 type = BP_CPU | BP_MEM_ACCESS;
1368 insert_wp:
1369 err = cpu_watchpoint_insert(env, env->dr[index],
1370 hw_breakpoint_len(env->dr[7], index),
1371 type, &env->cpu_watchpoint[index]);
1372 break;
1373 }
1374 if (err)
1375 env->cpu_breakpoint[index] = NULL;
1376 }
1377
1378 void hw_breakpoint_remove(CPUState *env, int index)
1379 {
1380 if (!env->cpu_breakpoint[index])
1381 return;
1382 switch (hw_breakpoint_type(env->dr[7], index)) {
1383 case 0:
1384 if (hw_breakpoint_enabled(env->dr[7], index))
1385 cpu_breakpoint_remove_by_ref(env, env->cpu_breakpoint[index]);
1386 break;
1387 case 1:
1388 case 3:
1389 cpu_watchpoint_remove_by_ref(env, env->cpu_watchpoint[index]);
1390 break;
1391 case 2:
1392 /* No support for I/O watchpoints yet */
1393 break;
1394 }
1395 }
1396
1397 int check_hw_breakpoints(CPUState *env, int force_dr6_update)
1398 {
1399 target_ulong dr6;
1400 int reg, type;
1401 int hit_enabled = 0;
1402
1403 dr6 = env->dr[6] & ~0xf;
1404 for (reg = 0; reg < 4; reg++) {
1405 type = hw_breakpoint_type(env->dr[7], reg);
1406 if ((type == 0 && env->dr[reg] == env->eip) ||
1407 ((type & 1) && env->cpu_watchpoint[reg] &&
1408 (env->cpu_watchpoint[reg]->flags & BP_WATCHPOINT_HIT))) {
1409 dr6 |= 1 << reg;
1410 if (hw_breakpoint_enabled(env->dr[7], reg))
1411 hit_enabled = 1;
1412 }
1413 }
1414 if (hit_enabled || force_dr6_update)
1415 env->dr[6] = dr6;
1416 return hit_enabled;
1417 }
1418
1419 static CPUDebugExcpHandler *prev_debug_excp_handler;
1420
1421 void raise_exception(int exception_index);
1422
1423 static void breakpoint_handler(CPUState *env)
1424 {
1425 CPUBreakpoint *bp;
1426
1427 if (env->watchpoint_hit) {
1428 if (env->watchpoint_hit->flags & BP_CPU) {
1429 env->watchpoint_hit = NULL;
1430 if (check_hw_breakpoints(env, 0))
1431 raise_exception(EXCP01_DB);
1432 else
1433 cpu_resume_from_signal(env, NULL);
1434 }
1435 } else {
1436 TAILQ_FOREACH(bp, &env->breakpoints, entry)
1437 if (bp->pc == env->eip) {
1438 if (bp->flags & BP_CPU) {
1439 check_hw_breakpoints(env, 1);
1440 raise_exception(EXCP01_DB);
1441 }
1442 break;
1443 }
1444 }
1445 if (prev_debug_excp_handler)
1446 prev_debug_excp_handler(env);
1447 }
1448 #endif /* !CONFIG_USER_ONLY */
1449
1450 static void host_cpuid(uint32_t function, uint32_t count,
1451 uint32_t *eax, uint32_t *ebx,
1452 uint32_t *ecx, uint32_t *edx)
1453 {
1454 #if defined(CONFIG_KVM)
1455 uint32_t vec[4];
1456
1457 #ifdef __x86_64__
1458 asm volatile("cpuid"
1459 : "=a"(vec[0]), "=b"(vec[1]),
1460 "=c"(vec[2]), "=d"(vec[3])
1461 : "0"(function), "c"(count) : "cc");
1462 #else
1463 asm volatile("pusha \n\t"
1464 "cpuid \n\t"
1465 "mov %%eax, 0(%2) \n\t"
1466 "mov %%ebx, 4(%2) \n\t"
1467 "mov %%ecx, 8(%2) \n\t"
1468 "mov %%edx, 12(%2) \n\t"
1469 "popa"
1470 : : "a"(function), "c"(count), "S"(vec)
1471 : "memory", "cc");
1472 #endif
1473
1474 if (eax)
1475 *eax = vec[0];
1476 if (ebx)
1477 *ebx = vec[1];
1478 if (ecx)
1479 *ecx = vec[2];
1480 if (edx)
1481 *edx = vec[3];
1482 #endif
1483 }
1484
1485 void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count,
1486 uint32_t *eax, uint32_t *ebx,
1487 uint32_t *ecx, uint32_t *edx)
1488 {
1489 /* test if maximum index reached */
1490 if (index & 0x80000000) {
1491 if (index > env->cpuid_xlevel)
1492 index = env->cpuid_level;
1493 } else {
1494 if (index > env->cpuid_level)
1495 index = env->cpuid_level;
1496 }
1497
1498 switch(index) {
1499 case 0:
1500 *eax = env->cpuid_level;
1501 *ebx = env->cpuid_vendor1;
1502 *edx = env->cpuid_vendor2;
1503 *ecx = env->cpuid_vendor3;
1504
1505 /* sysenter isn't supported on compatibility mode on AMD. and syscall
1506 * isn't supported in compatibility mode on Intel. so advertise the
1507 * actuall cpu, and say goodbye to migration between different vendors
1508 * is you use compatibility mode. */
1509 if (kvm_enabled())
1510 host_cpuid(0, 0, NULL, ebx, ecx, edx);
1511 break;
1512 case 1:
1513 *eax = env->cpuid_version;
1514 *ebx = (env->cpuid_apic_id << 24) | 8 << 8; /* CLFLUSH size in quad words, Linux wants it. */
1515 *ecx = env->cpuid_ext_features;
1516 *edx = env->cpuid_features;
1517
1518 /* "Hypervisor present" bit required for Microsoft SVVP */
1519 if (kvm_enabled())
1520 *ecx |= (1 << 31);
1521 break;
1522 case 2:
1523 /* cache info: needed for Pentium Pro compatibility */
1524 *eax = 1;
1525 *ebx = 0;
1526 *ecx = 0;
1527 *edx = 0x2c307d;
1528 break;
1529 case 4:
1530 /* cache info: needed for Core compatibility */
1531 switch (count) {
1532 case 0: /* L1 dcache info */
1533 *eax = 0x0000121;
1534 *ebx = 0x1c0003f;
1535 *ecx = 0x000003f;
1536 *edx = 0x0000001;
1537 break;
1538 case 1: /* L1 icache info */
1539 *eax = 0x0000122;
1540 *ebx = 0x1c0003f;
1541 *ecx = 0x000003f;
1542 *edx = 0x0000001;
1543 break;
1544 case 2: /* L2 cache info */
1545 *eax = 0x0000143;
1546 *ebx = 0x3c0003f;
1547 *ecx = 0x0000fff;
1548 *edx = 0x0000001;
1549 break;
1550 default: /* end of info */
1551 *eax = 0;
1552 *ebx = 0;
1553 *ecx = 0;
1554 *edx = 0;
1555 break;
1556 }
1557 break;
1558 case 5:
1559 /* mwait info: needed for Core compatibility */
1560 *eax = 0; /* Smallest monitor-line size in bytes */
1561 *ebx = 0; /* Largest monitor-line size in bytes */
1562 *ecx = CPUID_MWAIT_EMX | CPUID_MWAIT_IBE;
1563 *edx = 0;
1564 break;
1565 case 6:
1566 /* Thermal and Power Leaf */
1567 *eax = 0;
1568 *ebx = 0;
1569 *ecx = 0;
1570 *edx = 0;
1571 break;
1572 case 9:
1573 /* Direct Cache Access Information Leaf */
1574 *eax = 0; /* Bits 0-31 in DCA_CAP MSR */
1575 *ebx = 0;
1576 *ecx = 0;
1577 *edx = 0;
1578 break;
1579 case 0xA:
1580 /* Architectural Performance Monitoring Leaf */
1581 *eax = 0;
1582 *ebx = 0;
1583 *ecx = 0;
1584 *edx = 0;
1585 break;
1586 case 0x80000000:
1587 *eax = env->cpuid_xlevel;
1588 *ebx = env->cpuid_vendor1;
1589 *edx = env->cpuid_vendor2;
1590 *ecx = env->cpuid_vendor3;
1591 break;
1592 case 0x80000001:
1593 *eax = env->cpuid_features;
1594 *ebx = 0;
1595 *ecx = env->cpuid_ext3_features;
1596 *edx = env->cpuid_ext2_features;
1597
1598 if (kvm_enabled()) {
1599 uint32_t h_eax, h_edx;
1600
1601 host_cpuid(index, 0, &h_eax, NULL, NULL, &h_edx);
1602
1603 /* disable CPU features that the host does not support */
1604
1605 /* long mode */
1606 if ((h_edx & 0x20000000) == 0 /* || !lm_capable_kernel */)
1607 *edx &= ~0x20000000;
1608 /* syscall */
1609 if ((h_edx & 0x00000800) == 0)
1610 *edx &= ~0x00000800;
1611 /* nx */
1612 if ((h_edx & 0x00100000) == 0)
1613 *edx &= ~0x00100000;
1614
1615 /* disable CPU features that KVM cannot support */
1616
1617 /* svm */
1618 *ecx &= ~4UL;
1619 /* 3dnow */
1620 *edx &= ~0xc0000000;
1621 }
1622 break;
1623 case 0x80000002:
1624 case 0x80000003:
1625 case 0x80000004:
1626 *eax = env->cpuid_model[(index - 0x80000002) * 4 + 0];
1627 *ebx = env->cpuid_model[(index - 0x80000002) * 4 + 1];
1628 *ecx = env->cpuid_model[(index - 0x80000002) * 4 + 2];
1629 *edx = env->cpuid_model[(index - 0x80000002) * 4 + 3];
1630 break;
1631 case 0x80000005:
1632 /* cache info (L1 cache) */
1633 *eax = 0x01ff01ff;
1634 *ebx = 0x01ff01ff;
1635 *ecx = 0x40020140;
1636 *edx = 0x40020140;
1637 break;
1638 case 0x80000006:
1639 /* cache info (L2 cache) */
1640 *eax = 0;
1641 *ebx = 0x42004200;
1642 *ecx = 0x02008140;
1643 *edx = 0;
1644 break;
1645 case 0x80000008:
1646 /* virtual & phys address size in low 2 bytes. */
1647 /* XXX: This value must match the one used in the MMU code. */
1648 if (env->cpuid_ext2_features & CPUID_EXT2_LM) {
1649 /* 64 bit processor */
1650 #if defined(CONFIG_KQEMU)
1651 *eax = 0x00003020; /* 48 bits virtual, 32 bits physical */
1652 #else
1653 /* XXX: The physical address space is limited to 42 bits in exec.c. */
1654 *eax = 0x00003028; /* 48 bits virtual, 40 bits physical */
1655 #endif
1656 } else {
1657 #if defined(CONFIG_KQEMU)
1658 *eax = 0x00000020; /* 32 bits physical */
1659 #else
1660 if (env->cpuid_features & CPUID_PSE36)
1661 *eax = 0x00000024; /* 36 bits physical */
1662 else
1663 *eax = 0x00000020; /* 32 bits physical */
1664 #endif
1665 }
1666 *ebx = 0;
1667 *ecx = 0;
1668 *edx = 0;
1669 break;
1670 case 0x8000000A:
1671 *eax = 0x00000001; /* SVM Revision */
1672 *ebx = 0x00000010; /* nr of ASIDs */
1673 *ecx = 0;
1674 *edx = 0; /* optional features */
1675 break;
1676 default:
1677 /* reserved values: zero */
1678 *eax = 0;
1679 *ebx = 0;
1680 *ecx = 0;
1681 *edx = 0;
1682 break;
1683 }
1684 }
1685
1686 CPUX86State *cpu_x86_init(const char *cpu_model)
1687 {
1688 CPUX86State *env;
1689 static int inited;
1690
1691 env = qemu_mallocz(sizeof(CPUX86State));
1692 cpu_exec_init(env);
1693 env->cpu_model_str = cpu_model;
1694
1695 /* init various static tables */
1696 if (!inited) {
1697 inited = 1;
1698 optimize_flags_init();
1699 #ifndef CONFIG_USER_ONLY
1700 prev_debug_excp_handler =
1701 cpu_set_debug_excp_handler(breakpoint_handler);
1702 #endif
1703 }
1704 if (cpu_x86_register(env, cpu_model) < 0) {
1705 cpu_x86_close(env);
1706 return NULL;
1707 }
1708 cpu_reset(env);
1709 #ifdef CONFIG_KQEMU
1710 kqemu_init(env);
1711 #endif
1712
1713 qemu_init_vcpu(env);
1714
1715 if (kvm_enabled()) {
1716 kvm_trim_features(&env->cpuid_features,
1717 kvm_arch_get_supported_cpuid(env, 1, R_EDX),
1718 feature_name);
1719 kvm_trim_features(&env->cpuid_ext_features,
1720 kvm_arch_get_supported_cpuid(env, 1, R_ECX),
1721 ext_feature_name);
1722 kvm_trim_features(&env->cpuid_ext2_features,
1723 kvm_arch_get_supported_cpuid(env, 0x80000001, R_EDX),
1724 ext2_feature_name);
1725 kvm_trim_features(&env->cpuid_ext3_features,
1726 kvm_arch_get_supported_cpuid(env, 0x80000001, R_ECX),
1727 ext3_feature_name);
1728 }
1729
1730 return env;
1731 }
Samsung s3c2440 and arm920t support for the mini2440 dev board