target/arm/arm-semi.c

   1 /*
   2  *  Arm "Angel" semihosting syscalls
   3  *
   4  *  Copyright (c) 2005, 2007 CodeSourcery.
   5  *  Copyright (c) 2019 Linaro
   6  *  Written by Paul Brook.
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  20  *
  21  *  ARM Semihosting is documented in:
  22  *     Semihosting for AArch32 and AArch64 Release 2.0
  23  *     https://static.docs.arm.com/100863/0200/semihosting.pdf
  24  */
  25
  26 #include "qemu/osdep.h"
  27
  28 #include "cpu.h"
  29 #include "hw/semihosting/semihost.h"
  30 #include "hw/semihosting/console.h"
  31 #include "qemu/log.h"
  32 #ifdef CONFIG_USER_ONLY
  33 #include "qemu.h"
  34
  35 #define ARM_ANGEL_HEAP_SIZE (128 * 1024 * 1024)
  36 #else
  37 #include "exec/gdbstub.h"
  38 #include "qemu/cutils.h"
  39 #endif
  40
  41 #define TARGET_SYS_OPEN        0x01
  42 #define TARGET_SYS_CLOSE       0x02
  43 #define TARGET_SYS_WRITEC      0x03
  44 #define TARGET_SYS_WRITE0      0x04
  45 #define TARGET_SYS_WRITE       0x05
  46 #define TARGET_SYS_READ        0x06
  47 #define TARGET_SYS_READC       0x07
  48 #define TARGET_SYS_ISTTY       0x09
  49 #define TARGET_SYS_SEEK        0x0a
  50 #define TARGET_SYS_FLEN        0x0c
  51 #define TARGET_SYS_TMPNAM      0x0d
  52 #define TARGET_SYS_REMOVE      0x0e
  53 #define TARGET_SYS_RENAME      0x0f
  54 #define TARGET_SYS_CLOCK       0x10
  55 #define TARGET_SYS_TIME        0x11
  56 #define TARGET_SYS_SYSTEM      0x12
  57 #define TARGET_SYS_ERRNO       0x13
  58 #define TARGET_SYS_GET_CMDLINE 0x15
  59 #define TARGET_SYS_HEAPINFO    0x16
  60 #define TARGET_SYS_EXIT        0x18
  61 #define TARGET_SYS_SYNCCACHE   0x19
  62
  63 /* ADP_Stopped_ApplicationExit is used for exit(0),
  64  * anything else is implemented as exit(1) */
  65 #define ADP_Stopped_ApplicationExit     (0x20026)
  66
  67 #ifndef O_BINARY
  68 #define O_BINARY 0
  69 #endif
  70
  71 #define GDB_O_RDONLY  0x000
  72 #define GDB_O_WRONLY  0x001
  73 #define GDB_O_RDWR    0x002
  74 #define GDB_O_APPEND  0x008
  75 #define GDB_O_CREAT   0x200
  76 #define GDB_O_TRUNC   0x400
  77 #define GDB_O_BINARY  0
  78
  79 static int gdb_open_modeflags[12] = {
  80     GDB_O_RDONLY,
  81     GDB_O_RDONLY | GDB_O_BINARY,
  82     GDB_O_RDWR,
  83     GDB_O_RDWR | GDB_O_BINARY,
  84     GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC,
  85     GDB_O_WRONLY | GDB_O_CREAT | GDB_O_TRUNC | GDB_O_BINARY,
  86     GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC,
  87     GDB_O_RDWR | GDB_O_CREAT | GDB_O_TRUNC | GDB_O_BINARY,
  88     GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND,
  89     GDB_O_WRONLY | GDB_O_CREAT | GDB_O_APPEND | GDB_O_BINARY,
  90     GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND,
  91     GDB_O_RDWR | GDB_O_CREAT | GDB_O_APPEND | GDB_O_BINARY
  92 };
  93
  94 static int open_modeflags[12] = {
  95     O_RDONLY,
  96     O_RDONLY | O_BINARY,
  97     O_RDWR,
  98     O_RDWR | O_BINARY,
  99     O_WRONLY | O_CREAT | O_TRUNC,
 100     O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
 101     O_RDWR | O_CREAT | O_TRUNC,
 102     O_RDWR | O_CREAT | O_TRUNC | O_BINARY,
 103     O_WRONLY | O_CREAT | O_APPEND,
 104     O_WRONLY | O_CREAT | O_APPEND | O_BINARY,
 105     O_RDWR | O_CREAT | O_APPEND,
 106     O_RDWR | O_CREAT | O_APPEND | O_BINARY
 107 };
 108
 109 #ifdef CONFIG_USER_ONLY
 110 static inline uint32_t set_swi_errno(TaskState *ts, uint32_t code)
 111 {
 112     if (code == (uint32_t)-1)
 113         ts->swi_errno = errno;
 114     return code;
 115 }
 116 #else
 117 static inline uint32_t set_swi_errno(CPUARMState *env, uint32_t code)
 118 {
 119     return code;
 120 }
 121
 122 #include "exec/softmmu-semi.h"
 123 #endif
 124
 125 static target_ulong arm_semi_syscall_len;
 126
 127 #if !defined(CONFIG_USER_ONLY)
 128 static target_ulong syscall_err;
 129 #endif
 130
 131 static void arm_semi_cb(CPUState *cs, target_ulong ret, target_ulong err)
 132 {
 133     ARMCPU *cpu = ARM_CPU(cs);
 134     CPUARMState *env = &cpu->env;
 135 #ifdef CONFIG_USER_ONLY
 136     TaskState *ts = cs->opaque;
 137 #endif
 138     target_ulong reg0 = is_a64(env) ? env->xregs[0] : env->regs[0];
 139
 140     if (ret == (target_ulong)-1) {
 141 #ifdef CONFIG_USER_ONLY
 142         ts->swi_errno = err;
 143 #else
 144         syscall_err = err;
 145 #endif
 146         reg0 = ret;
 147     } else {
 148         /* Fixup syscalls that use nonstardard return conventions.  */
 149         switch (reg0) {
 150         case TARGET_SYS_WRITE:
 151         case TARGET_SYS_READ:
 152             reg0 = arm_semi_syscall_len - ret;
 153             break;
 154         case TARGET_SYS_SEEK:
 155             reg0 = 0;
 156             break;
 157         default:
 158             reg0 = ret;
 159             break;
 160         }
 161     }
 162     if (is_a64(env)) {
 163         env->xregs[0] = reg0;
 164     } else {
 165         env->regs[0] = reg0;
 166     }
 167 }
 168
 169 static target_ulong arm_flen_buf(ARMCPU *cpu)
 170 {
 171     /* Return an address in target memory of 64 bytes where the remote
 172      * gdb should write its stat struct. (The format of this structure
 173      * is defined by GDB's remote protocol and is not target-specific.)
 174      * We put this on the guest's stack just below SP.
 175      */
 176     CPUARMState *env = &cpu->env;
 177     target_ulong sp;
 178
 179     if (is_a64(env)) {
 180         sp = env->xregs[31];
 181     } else {
 182         sp = env->regs[13];
 183     }
 184
 185     return sp - 64;
 186 }
 187
 188 static void arm_semi_flen_cb(CPUState *cs, target_ulong ret, target_ulong err)
 189 {
 190     ARMCPU *cpu = ARM_CPU(cs);
 191     CPUARMState *env = &cpu->env;
 192     /* The size is always stored in big-endian order, extract
 193        the value. We assume the size always fit in 32 bits.  */
 194     uint32_t size;
 195     cpu_memory_rw_debug(cs, arm_flen_buf(cpu) + 32, (uint8_t *)&size, 4, 0);
 196     size = be32_to_cpu(size);
 197     if (is_a64(env)) {
 198         env->xregs[0] = size;
 199     } else {
 200         env->regs[0] = size;
 201     }
 202 #ifdef CONFIG_USER_ONLY
 203     ((TaskState *)cs->opaque)->swi_errno = err;
 204 #else
 205     syscall_err = err;
 206 #endif
 207 }
 208
 209 static target_ulong arm_gdb_syscall(ARMCPU *cpu, gdb_syscall_complete_cb cb,
 210                                     const char *fmt, ...)
 211 {
 212     va_list va;
 213     CPUARMState *env = &cpu->env;
 214
 215     va_start(va, fmt);
 216     gdb_do_syscallv(cb, fmt, va);
 217     va_end(va);
 218
 219     /* FIXME: we are implicitly relying on the syscall completing
 220      * before this point, which is not guaranteed. We should
 221      * put in an explicit synchronization between this and
 222      * the callback function.
 223      */
 224
 225     return is_a64(env) ? env->xregs[0] : env->regs[0];
 226 }
 227
 228 /* Read the input value from the argument block; fail the semihosting
 229  * call if the memory read fails.
 230  */
 231 #define GET_ARG(n) do {                                 \
 232     if (is_a64(env)) {                                  \
 233         if (get_user_u64(arg ## n, args + (n) * 8)) {   \
 234             return -1;                                  \
 235         }                                               \
 236     } else {                                            \
 237         if (get_user_u32(arg ## n, args + (n) * 4)) {   \
 238             return -1;                                  \
 239         }                                               \
 240     }                                                   \
 241 } while (0)
 242
 243 #define SET_ARG(n, val)                                 \
 244     (is_a64(env) ?                                      \
 245      put_user_u64(val, args + (n) * 8) :                \
 246      put_user_u32(val, args + (n) * 4))
 247
 248 /*
 249  * Do a semihosting call.
 250  *
 251  * The specification always says that the "return register" either
 252  * returns a specific value or is corrupted, so we don't need to
 253  * report to our caller whether we are returning a value or trying to
 254  * leave the register unchanged. We use 0xdeadbeef as the return value
 255  * when there isn't a defined return value for the call.
 256  */
 257 target_ulong do_arm_semihosting(CPUARMState *env)
 258 {
 259     ARMCPU *cpu = env_archcpu(env);
 260     CPUState *cs = env_cpu(env);
 261     target_ulong args;
 262     target_ulong arg0, arg1, arg2, arg3;
 263     char * s;
 264     int nr;
 265     uint32_t ret;
 266     uint32_t len;
 267 #ifdef CONFIG_USER_ONLY
 268     TaskState *ts = cs->opaque;
 269 #else
 270     CPUARMState *ts = env;
 271 #endif
 272
 273     if (is_a64(env)) {
 274         /* Note that the syscall number is in W0, not X0 */
 275         nr = env->xregs[0] & 0xffffffffU;
 276         args = env->xregs[1];
 277     } else {
 278         nr = env->regs[0];
 279         args = env->regs[1];
 280     }
 281
 282     switch (nr) {
 283     case TARGET_SYS_OPEN:
 284         GET_ARG(0);
 285         GET_ARG(1);
 286         GET_ARG(2);
 287         s = lock_user_string(arg0);
 288         if (!s) {
 289             /* FIXME - should this error code be -TARGET_EFAULT ? */
 290             return (uint32_t)-1;
 291         }
 292         if (arg1 >= 12) {
 293             unlock_user(s, arg0, 0);
 294             return (uint32_t)-1;
 295         }
 296         if (strcmp(s, ":tt") == 0) {
 297             int result_fileno = arg1 < 4 ? STDIN_FILENO : STDOUT_FILENO;
 298             unlock_user(s, arg0, 0);
 299             return result_fileno;
 300         }
 301         if (use_gdb_syscalls()) {
 302             ret = arm_gdb_syscall(cpu, arm_semi_cb, "open,%s,%x,1a4", arg0,
 303                                   (int)arg2+1, gdb_open_modeflags[arg1]);
 304         } else {
 305             ret = set_swi_errno(ts, open(s, open_modeflags[arg1], 0644));
 306         }
 307         unlock_user(s, arg0, 0);
 308         return ret;
 309     case TARGET_SYS_CLOSE:
 310         GET_ARG(0);
 311         if (use_gdb_syscalls()) {
 312             return arm_gdb_syscall(cpu, arm_semi_cb, "close,%x", arg0);
 313         } else {
 314             return set_swi_errno(ts, close(arg0));
 315         }
 316     case TARGET_SYS_WRITEC:
 317         qemu_semihosting_console_outc(env, args);
 318         return 0xdeadbeef;
 319     case TARGET_SYS_WRITE0:
 320         return qemu_semihosting_console_outs(env, args);
 321     case TARGET_SYS_WRITE:
 322         GET_ARG(0);
 323         GET_ARG(1);
 324         GET_ARG(2);
 325         len = arg2;
 326         if (use_gdb_syscalls()) {
 327             arm_semi_syscall_len = len;
 328             return arm_gdb_syscall(cpu, arm_semi_cb, "write,%x,%x,%x",
 329                                    arg0, arg1, len);
 330         } else {
 331             s = lock_user(VERIFY_READ, arg1, len, 1);
 332             if (!s) {
 333                 /* Return bytes not written on error */
 334                 return len;
 335             }
 336             ret = set_swi_errno(ts, write(arg0, s, len));
 337             unlock_user(s, arg1, 0);
 338             if (ret == (uint32_t)-1) {
 339                 ret = 0;
 340             }
 341             /* Return bytes not written */
 342             return len - ret;
 343         }
 344     case TARGET_SYS_READ:
 345         GET_ARG(0);
 346         GET_ARG(1);
 347         GET_ARG(2);
 348         len = arg2;
 349         if (use_gdb_syscalls()) {
 350             arm_semi_syscall_len = len;
 351             return arm_gdb_syscall(cpu, arm_semi_cb, "read,%x,%x,%x",
 352                                    arg0, arg1, len);
 353         } else {
 354             s = lock_user(VERIFY_WRITE, arg1, len, 0);
 355             if (!s) {
 356                 /* return bytes not read */
 357                 return len;
 358             }
 359             do {
 360                 ret = set_swi_errno(ts, read(arg0, s, len));
 361             } while (ret == -1 && errno == EINTR);
 362             unlock_user(s, arg1, len);
 363             if (ret == (uint32_t)-1) {
 364                 ret = 0;
 365             }
 366             /* Return bytes not read */
 367             return len - ret;
 368         }
 369     case TARGET_SYS_READC:
 370         qemu_log_mask(LOG_UNIMP, "%s: SYS_READC not implemented", __func__);
 371         return 0;
 372     case TARGET_SYS_ISTTY:
 373         GET_ARG(0);
 374         if (use_gdb_syscalls()) {
 375             return arm_gdb_syscall(cpu, arm_semi_cb, "isatty,%x", arg0);
 376         } else {
 377             return isatty(arg0);
 378         }
 379     case TARGET_SYS_SEEK:
 380         GET_ARG(0);
 381         GET_ARG(1);
 382         if (use_gdb_syscalls()) {
 383             return arm_gdb_syscall(cpu, arm_semi_cb, "lseek,%x,%x,0",
 384                                    arg0, arg1);
 385         } else {
 386             ret = set_swi_errno(ts, lseek(arg0, arg1, SEEK_SET));
 387             if (ret == (uint32_t)-1)
 388               return -1;
 389             return 0;
 390         }
 391     case TARGET_SYS_FLEN:
 392         GET_ARG(0);
 393         if (use_gdb_syscalls()) {
 394             return arm_gdb_syscall(cpu, arm_semi_flen_cb, "fstat,%x,%x",
 395                                    arg0, arm_flen_buf(cpu));
 396         } else {
 397             struct stat buf;
 398             ret = set_swi_errno(ts, fstat(arg0, &buf));
 399             if (ret == (uint32_t)-1)
 400                 return -1;
 401             return buf.st_size;
 402         }
 403     case TARGET_SYS_TMPNAM:
 404         qemu_log_mask(LOG_UNIMP, "%s: SYS_TMPNAM not implemented", __func__);
 405         return -1;
 406     case TARGET_SYS_REMOVE:
 407         GET_ARG(0);
 408         GET_ARG(1);
 409         if (use_gdb_syscalls()) {
 410             ret = arm_gdb_syscall(cpu, arm_semi_cb, "unlink,%s",
 411                                   arg0, (int)arg1+1);
 412         } else {
 413             s = lock_user_string(arg0);
 414             if (!s) {
 415                 /* FIXME - should this error code be -TARGET_EFAULT ? */
 416                 return (uint32_t)-1;
 417             }
 418             ret =  set_swi_errno(ts, remove(s));
 419             unlock_user(s, arg0, 0);
 420         }
 421         return ret;
 422     case TARGET_SYS_RENAME:
 423         GET_ARG(0);
 424         GET_ARG(1);
 425         GET_ARG(2);
 426         GET_ARG(3);
 427         if (use_gdb_syscalls()) {
 428             return arm_gdb_syscall(cpu, arm_semi_cb, "rename,%s,%s",
 429                                    arg0, (int)arg1+1, arg2, (int)arg3+1);
 430         } else {
 431             char *s2;
 432             s = lock_user_string(arg0);
 433             s2 = lock_user_string(arg2);
 434             if (!s || !s2)
 435                 /* FIXME - should this error code be -TARGET_EFAULT ? */
 436                 ret = (uint32_t)-1;
 437             else
 438                 ret = set_swi_errno(ts, rename(s, s2));
 439             if (s2)
 440                 unlock_user(s2, arg2, 0);
 441             if (s)
 442                 unlock_user(s, arg0, 0);
 443             return ret;
 444         }
 445     case TARGET_SYS_CLOCK:
 446         return clock() / (CLOCKS_PER_SEC / 100);
 447     case TARGET_SYS_TIME:
 448         return set_swi_errno(ts, time(NULL));
 449     case TARGET_SYS_SYSTEM:
 450         GET_ARG(0);
 451         GET_ARG(1);
 452         if (use_gdb_syscalls()) {
 453             return arm_gdb_syscall(cpu, arm_semi_cb, "system,%s",
 454                                    arg0, (int)arg1+1);
 455         } else {
 456             s = lock_user_string(arg0);
 457             if (!s) {
 458                 /* FIXME - should this error code be -TARGET_EFAULT ? */
 459                 return (uint32_t)-1;
 460             }
 461             ret = set_swi_errno(ts, system(s));
 462             unlock_user(s, arg0, 0);
 463             return ret;
 464         }
 465     case TARGET_SYS_ERRNO:
 466 #ifdef CONFIG_USER_ONLY
 467         return ts->swi_errno;
 468 #else
 469         return syscall_err;
 470 #endif
 471     case TARGET_SYS_GET_CMDLINE:
 472         {
 473             /* Build a command-line from the original argv.
 474              *
 475              * The inputs are:
 476              *     * arg0, pointer to a buffer of at least the size
 477              *               specified in arg1.
 478              *     * arg1, size of the buffer pointed to by arg0 in
 479              *               bytes.
 480              *
 481              * The outputs are:
 482              *     * arg0, pointer to null-terminated string of the
 483              *               command line.
 484              *     * arg1, length of the string pointed to by arg0.
 485              */
 486
 487             char *output_buffer;
 488             size_t input_size;
 489             size_t output_size;
 490             int status = 0;
 491 #if !defined(CONFIG_USER_ONLY)
 492             const char *cmdline;
 493 #endif
 494             GET_ARG(0);
 495             GET_ARG(1);
 496             input_size = arg1;
 497             /* Compute the size of the output string.  */
 498 #if !defined(CONFIG_USER_ONLY)
 499             cmdline = semihosting_get_cmdline();
 500             if (cmdline == NULL) {
 501                 cmdline = ""; /* Default to an empty line. */
 502             }
 503             output_size = strlen(cmdline) + 1; /* Count terminating 0. */
 504 #else
 505             unsigned int i;
 506
 507             output_size = ts->info->arg_end - ts->info->arg_start;
 508             if (!output_size) {
 509                 /*
 510                  * We special-case the "empty command line" case (argc==0).
 511                  * Just provide the terminating 0.
 512                  */
 513                 output_size = 1;
 514             }
 515 #endif
 516
 517             if (output_size > input_size) {
 518                 /* Not enough space to store command-line arguments.  */
 519                 return -1;
 520             }
 521
 522             /* Adjust the command-line length.  */
 523             if (SET_ARG(1, output_size - 1)) {
 524                 /* Couldn't write back to argument block */
 525                 return -1;
 526             }
 527
 528             /* Lock the buffer on the ARM side.  */
 529             output_buffer = lock_user(VERIFY_WRITE, arg0, output_size, 0);
 530             if (!output_buffer) {
 531                 return -1;
 532             }
 533
 534             /* Copy the command-line arguments.  */
 535 #if !defined(CONFIG_USER_ONLY)
 536             pstrcpy(output_buffer, output_size, cmdline);
 537 #else
 538             if (output_size == 1) {
 539                 /* Empty command-line.  */
 540                 output_buffer[0] = '\0';
 541                 goto out;
 542             }
 543
 544             if (copy_from_user(output_buffer, ts->info->arg_start,
 545                                output_size)) {
 546                 status = -1;
 547                 goto out;
 548             }
 549
 550             /* Separate arguments by white spaces.  */
 551             for (i = 0; i < output_size - 1; i++) {
 552                 if (output_buffer[i] == 0) {
 553                     output_buffer[i] = ' ';
 554                 }
 555             }
 556         out:
 557 #endif
 558             /* Unlock the buffer on the ARM side.  */
 559             unlock_user(output_buffer, arg0, output_size);
 560
 561             return status;
 562         }
 563     case TARGET_SYS_HEAPINFO:
 564         {
 565             target_ulong retvals[4];
 566             target_ulong limit;
 567             int i;
 568
 569             GET_ARG(0);
 570
 571 #ifdef CONFIG_USER_ONLY
 572             /*
 573              * Some C libraries assume the heap immediately follows .bss, so
 574              * allocate it using sbrk.
 575              */
 576             if (!ts->heap_limit) {
 577                 abi_ulong ret;
 578
 579                 ts->heap_base = do_brk(0);
 580                 limit = ts->heap_base + ARM_ANGEL_HEAP_SIZE;
 581                 /* Try a big heap, and reduce the size if that fails.  */
 582                 for (;;) {
 583                     ret = do_brk(limit);
 584                     if (ret >= limit) {
 585                         break;
 586                     }
 587                     limit = (ts->heap_base >> 1) + (limit >> 1);
 588                 }
 589                 ts->heap_limit = limit;
 590             }
 591
 592             retvals[0] = ts->heap_base;
 593             retvals[1] = ts->heap_limit;
 594             retvals[2] = ts->stack_base;
 595             retvals[3] = 0; /* Stack limit.  */
 596 #else
 597             limit = ram_size;
 598             /* TODO: Make this use the limit of the loaded application.  */
 599             retvals[0] = limit / 2;
 600             retvals[1] = limit;
 601             retvals[2] = limit; /* Stack base */
 602             retvals[3] = 0; /* Stack limit.  */
 603 #endif
 604
 605             for (i = 0; i < ARRAY_SIZE(retvals); i++) {
 606                 bool fail;
 607
 608                 if (is_a64(env)) {
 609                     fail = put_user_u64(retvals[i], arg0 + i * 8);
 610                 } else {
 611                     fail = put_user_u32(retvals[i], arg0 + i * 4);
 612                 }
 613
 614                 if (fail) {
 615                     /* Couldn't write back to argument block */
 616                     return -1;
 617                 }
 618             }
 619             return 0;
 620         }
 621     case TARGET_SYS_EXIT:
 622         if (is_a64(env)) {
 623             /*
 624              * The A64 version of this call takes a parameter block,
 625              * so the application-exit type can return a subcode which
 626              * is the exit status code from the application.
 627              */
 628             GET_ARG(0);
 629             GET_ARG(1);
 630
 631             if (arg0 == ADP_Stopped_ApplicationExit) {
 632                 ret = arg1;
 633             } else {
 634                 ret = 1;
 635             }
 636         } else {
 637             /*
 638              * ARM specifies only Stopped_ApplicationExit as normal
 639              * exit, everything else is considered an error
 640              */
 641             ret = (args == ADP_Stopped_ApplicationExit) ? 0 : 1;
 642         }
 643         gdb_exit(env, ret);
 644         exit(ret);
 645     case TARGET_SYS_SYNCCACHE:
 646         /*
 647          * Clean the D-cache and invalidate the I-cache for the specified
 648          * virtual address range. This is a nop for us since we don't
 649          * implement caches. This is only present on A64.
 650          */
 651         if (is_a64(env)) {
 652             return 0;
 653         }
 654         /* fall through -- invalid for A32/T32 */
 655     default:
 656         fprintf(stderr, "qemu: Unsupported SemiHosting SWI 0x%02x\n", nr);
 657         cpu_dump_state(cs, stderr, 0);
 658         abort();
 659     }
 660 }