jcs.org / qemu
qemu with hax to log dma reads & writes jcs.org/2018/11/12/vfio
fork atom

target/m68k: Use env_cpu

Cleanup in the boilerplate that each target must define.
The combination CPU(m68k_env_get_cpu) should have used
ENV_GET_CPU to begin; use env_cpu now.

Acked-by: Laurent Vivier <laurent@vivier.eu>
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>

Richard Henderson a8d92fd8 6dd40a90

+24 -41
+1 -2
linux-user/m68k-sim.c
··· 91 91 #define ARG(x) tswap32(args[x]) 92 92 void do_m68k_simcall(CPUM68KState *env, int nr) 93 93 { 94 - M68kCPU *cpu = m68k_env_get_cpu(env); 95 94 uint32_t *args; 96 95 97 96 args = (uint32_t *)(unsigned long)(env->aregs[7] + 4); ··· 159 158 check_err(env, lseek(ARG(0), (int32_t)ARG(1), ARG(2))); 160 159 break; 161 160 default: 162 - cpu_abort(CPU(cpu), "Unsupported m68k sim syscall %d\n", nr); 161 + cpu_abort(env_cpu(env), "Unsupported m68k sim syscall %d\n", nr); 163 162 } 164 163 }
+1 -1
linux-user/m68k/cpu_loop.c
··· 23 23 24 24 void cpu_loop(CPUM68KState *env) 25 25 { 26 - CPUState *cs = CPU(m68k_env_get_cpu(env)); 26 + CPUState *cs = env_cpu(env); 27 27 int trapnr; 28 28 unsigned int n; 29 29 target_siginfo_t info;
+1 -1
linux-user/m68k/target_cpu.h
··· 31 31 32 32 static inline void cpu_set_tls(CPUM68KState *env, target_ulong newtls) 33 33 { 34 - CPUState *cs = CPU(m68k_env_get_cpu(env)); 34 + CPUState *cs = env_cpu(env); 35 35 TaskState *ts = cs->opaque; 36 36 37 37 ts->tp_value = newtls;
-5
target/m68k/cpu.h
··· 163 163 CPUM68KState env; 164 164 }; 165 165 166 - static inline M68kCPU *m68k_env_get_cpu(CPUM68KState *env) 167 - { 168 - return container_of(env, M68kCPU, env); 169 - } 170 - 171 166 #define ENV_OFFSET offsetof(M68kCPU, env) 172 167 173 168 void m68k_cpu_do_interrupt(CPUState *cpu);
+12 -21
target/m68k/helper.c
··· 168 168 169 169 void HELPER(cf_movec_to)(CPUM68KState *env, uint32_t reg, uint32_t val) 170 170 { 171 - M68kCPU *cpu = m68k_env_get_cpu(env); 172 - 173 171 switch (reg) { 174 172 case M68K_CR_CACR: 175 173 env->cacr = val; ··· 186 184 break; 187 185 /* TODO: Implement control registers. */ 188 186 default: 189 - cpu_abort(CPU(cpu), 187 + cpu_abort(env_cpu(env), 190 188 "Unimplemented control register write 0x%x = 0x%x\n", 191 189 reg, val); 192 190 } ··· 194 192 195 193 void HELPER(m68k_movec_to)(CPUM68KState *env, uint32_t reg, uint32_t val) 196 194 { 197 - M68kCPU *cpu = m68k_env_get_cpu(env); 198 - 199 195 switch (reg) { 200 196 /* MC680[1234]0 */ 201 197 case M68K_CR_SFC: ··· 248 244 env->mmu.ttr[M68K_DTTR1] = val; 249 245 return; 250 246 } 251 - cpu_abort(CPU(cpu), "Unimplemented control register write 0x%x = 0x%x\n", 247 + cpu_abort(env_cpu(env), 248 + "Unimplemented control register write 0x%x = 0x%x\n", 252 249 reg, val); 253 250 } 254 251 255 252 uint32_t HELPER(m68k_movec_from)(CPUM68KState *env, uint32_t reg) 256 253 { 257 - M68kCPU *cpu = m68k_env_get_cpu(env); 258 - 259 254 switch (reg) { 260 255 /* MC680[1234]0 */ 261 256 case M68K_CR_SFC: ··· 292 287 case M68K_CR_DTT1: 293 288 return env->mmu.ttr[M68K_DTTR1]; 294 289 } 295 - cpu_abort(CPU(cpu), "Unimplemented control register read 0x%x\n", 290 + cpu_abort(env_cpu(env), "Unimplemented control register read 0x%x\n", 296 291 reg); 297 292 } 298 293 ··· 388 383 uint32_t last_logical, last_physical; 389 384 int32_t size; 390 385 int last_attr = -1, attr = -1; 391 - M68kCPU *cpu = m68k_env_get_cpu(env); 392 - CPUState *cs = CPU(cpu); 386 + CPUState *cs = env_cpu(env); 393 387 MemTxResult txres; 394 388 395 389 if (env->mmu.tcr & M68K_TCR_PAGE_8K) { ··· 630 624 int *prot, target_ulong address, 631 625 int access_type, target_ulong *page_size) 632 626 { 633 - M68kCPU *cpu = m68k_env_get_cpu(env); 634 - CPUState *cs = CPU(cpu); 627 + CPUState *cs = env_cpu(env); 635 628 uint32_t entry; 636 629 uint32_t next; 637 630 target_ulong page_mask; ··· 1175 1168 z = n; \ 1176 1169 break; \ 1177 1170 default: \ 1178 - cpu_abort(CPU(m68k_env_get_cpu(env)), "Bad CC_OP %d", op); \ 1171 + cpu_abort(env_cpu(env), "Bad CC_OP %d", op); \ 1179 1172 } \ 1180 1173 } while (0) 1181 1174 ··· 1358 1351 #if defined(CONFIG_SOFTMMU) 1359 1352 void HELPER(ptest)(CPUM68KState *env, uint32_t addr, uint32_t is_read) 1360 1353 { 1361 - M68kCPU *cpu = m68k_env_get_cpu(env); 1362 - CPUState *cs = CPU(cpu); 1363 1354 hwaddr physical; 1364 1355 int access_type; 1365 1356 int prot; ··· 1384 1375 if (ret == 0) { 1385 1376 addr &= TARGET_PAGE_MASK; 1386 1377 physical += addr & (page_size - 1); 1387 - tlb_set_page(cs, addr, physical, 1378 + tlb_set_page(env_cpu(env), addr, physical, 1388 1379 prot, access_type & ACCESS_SUPER ? 1389 1380 MMU_KERNEL_IDX : MMU_USER_IDX, page_size); 1390 1381 } ··· 1392 1383 1393 1384 void HELPER(pflush)(CPUM68KState *env, uint32_t addr, uint32_t opmode) 1394 1385 { 1395 - M68kCPU *cpu = m68k_env_get_cpu(env); 1386 + CPUState *cs = env_cpu(env); 1396 1387 1397 1388 switch (opmode) { 1398 1389 case 0: /* Flush page entry if not global */ 1399 1390 case 1: /* Flush page entry */ 1400 - tlb_flush_page(CPU(cpu), addr); 1391 + tlb_flush_page(cs, addr); 1401 1392 break; 1402 1393 case 2: /* Flush all except global entries */ 1403 - tlb_flush(CPU(cpu)); 1394 + tlb_flush(cs); 1404 1395 break; 1405 1396 case 3: /* Flush all entries */ 1406 - tlb_flush(CPU(cpu)); 1397 + tlb_flush(cs); 1407 1398 break; 1408 1399 } 1409 1400 }
+2 -2
target/m68k/m68k-semi.c
··· 421 421 case HOSTED_INIT_SIM: 422 422 #if defined(CONFIG_USER_ONLY) 423 423 { 424 - CPUState *cs = CPU(m68k_env_get_cpu(env)); 424 + CPUState *cs = env_cpu(env); 425 425 TaskState *ts = cs->opaque; 426 426 /* Allocate the heap using sbrk. */ 427 427 if (!ts->heap_limit) { ··· 454 454 #endif 455 455 return; 456 456 default: 457 - cpu_abort(CPU(m68k_env_get_cpu(env)), "Unsupported semihosting syscall %d\n", nr); 457 + cpu_abort(env_cpu(env), "Unsupported semihosting syscall %d\n", nr); 458 458 result = 0; 459 459 } 460 460 failed:
+6 -6
target/m68k/op_helper.c
··· 196 196 197 197 static void cf_interrupt_all(CPUM68KState *env, int is_hw) 198 198 { 199 - CPUState *cs = CPU(m68k_env_get_cpu(env)); 199 + CPUState *cs = env_cpu(env); 200 200 uint32_t sp; 201 201 uint32_t sr; 202 202 uint32_t fmt; ··· 274 274 { 275 275 if (m68k_feature(env, M68K_FEATURE_QUAD_MULDIV)) { 276 276 /* all except 68000 */ 277 - CPUState *cs = CPU(m68k_env_get_cpu(env)); 277 + CPUState *cs = env_cpu(env); 278 278 switch (format) { 279 279 case 4: 280 280 *sp -= 4; ··· 299 299 300 300 static void m68k_interrupt_all(CPUM68KState *env, int is_hw) 301 301 { 302 - CPUState *cs = CPU(m68k_env_get_cpu(env)); 302 + CPUState *cs = env_cpu(env); 303 303 uint32_t sp; 304 304 uint32_t retaddr; 305 305 uint32_t vector; ··· 507 507 508 508 static void raise_exception_ra(CPUM68KState *env, int tt, uintptr_t raddr) 509 509 { 510 - CPUState *cs = CPU(m68k_env_get_cpu(env)); 510 + CPUState *cs = env_cpu(env); 511 511 512 512 cs->exception_index = tt; 513 513 cpu_loop_exit_restore(cs, raddr); ··· 1037 1037 env->cc_c = 0 <= ub ? val < 0 || val > ub : val > ub && val < 0; 1038 1038 1039 1039 if (val < 0 || val > ub) { 1040 - CPUState *cs = CPU(m68k_env_get_cpu(env)); 1040 + CPUState *cs = env_cpu(env); 1041 1041 1042 1042 /* Recover PC and CC_OP for the beginning of the insn. */ 1043 1043 cpu_restore_state(cs, GETPC(), true); ··· 1068 1068 env->cc_c = lb <= ub ? val < lb || val > ub : val > ub && val < lb; 1069 1069 1070 1070 if (env->cc_c) { 1071 - CPUState *cs = CPU(m68k_env_get_cpu(env)); 1071 + CPUState *cs = env_cpu(env); 1072 1072 1073 1073 /* Recover PC and CC_OP for the beginning of the insn. */ 1074 1074 cpu_restore_state(cs, GETPC(), true);
+1 -3
target/m68k/translate.c
··· 4777 4777 4778 4778 DISAS_INSN(wdebug) 4779 4779 { 4780 - M68kCPU *cpu = m68k_env_get_cpu(env); 4781 - 4782 4780 if (IS_USER(s)) { 4783 4781 gen_exception(s, s->base.pc_next, EXCP_PRIVILEGE); 4784 4782 return; 4785 4783 } 4786 4784 /* TODO: Implement wdebug. */ 4787 - cpu_abort(CPU(cpu), "WDEBUG not implemented"); 4785 + cpu_abort(env_cpu(env), "WDEBUG not implemented"); 4788 4786 } 4789 4787 #endif 4790 4788