gdb: Convert language la_value_print field to a method

[deliverable/binutils-gdb.git] / sim / aarch64 / memory.c

diff --git a/sim/aarch64/memory.c b/sim/aarch64/memory.c
index 685c17375259e599d652c2e02bda37681936f912..692c22608156ff38b1c0f0371180c5c3dca46a18 100644 (file)
--- a/sim/aarch64/memory.c
+++ b/sim/aarch64/memory.c
@@ -1,6 +1,6 @@
 /* memory.c -- Memory accessor functions for the AArch64 simulator
 
-   Copyright (C) 2015-2016 Free Software Foundation, Inc.
+   Copyright (C) 2015-2020 Free Software Foundation, Inc.
 
    Contributed by Red Hat.
 
@@ -25,11 +25,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "bfd.h"
-#include "libbfd.h"
 #include "libiberty.h"
-#include "elf/internal.h"
-#include "elf/common.h"
 
 #include "memory.h"
 #include "simulator.h"
@@ -42,28 +38,41 @@ mem_error (sim_cpu *cpu, const char *message, uint64_t addr)
   TRACE_MEMORY (cpu, "ERROR: %s: %" PRIx64, message, addr);
 }
 
-/* FIXME: Aarch64 requires aligned memory access if SCTRLR_ELx.A is set,
+/* FIXME: AArch64 requires aligned memory access if SCTRLR_ELx.A is set,
    but we are not implementing that here.  */
-#define FETCH_FUNC(RETURN_TYPE, ACCESS_TYPE, NAME, N)                  \
+#define FETCH_FUNC64(RETURN_TYPE, ACCESS_TYPE, NAME, N)                        \
   RETURN_TYPE                                                          \
   aarch64_get_mem_##NAME (sim_cpu *cpu, uint64_t address)              \
   {                                                                    \
-    RETURN_TYPE val = (RETURN_TYPE) sim_core_read_unaligned_##N (cpu, 0, read_map, address); \
-    TRACE_MEMORY (cpu,                                                 \
-                 "read of %" PRIx64 " (%d bytes) from %" PRIx64,       \
-                 (uint64_t) val, N, address);                          \
+    RETURN_TYPE val = (RETURN_TYPE) (ACCESS_TYPE)                      \
+      sim_core_read_unaligned_##N (cpu, 0, read_map, address);         \
+    TRACE_MEMORY (cpu, "read of %" PRIx64 " (%d bytes) from %" PRIx64, \
+                 val, N, address);                                     \
+                                                                       \
+    return val;                                                                \
+  }
+
+FETCH_FUNC64 (uint64_t, uint64_t, u64, 8)
+FETCH_FUNC64 (int64_t,   int64_t, s64, 8)
+
+#define FETCH_FUNC32(RETURN_TYPE, ACCESS_TYPE, NAME, N)                        \
+  RETURN_TYPE                                                          \
+  aarch64_get_mem_##NAME (sim_cpu *cpu, uint64_t address)              \
+  {                                                                    \
+    RETURN_TYPE val = (RETURN_TYPE) (ACCESS_TYPE)                      \
+      sim_core_read_unaligned_##N (cpu, 0, read_map, address);         \
+    TRACE_MEMORY (cpu, "read of %8x (%d bytes) from %" PRIx64,         \
+                 val, N, address);                                     \
                                                                        \
     return val;                                                                \
   }
 
-FETCH_FUNC (uint64_t, uint64_t, u64, 8)
-FETCH_FUNC (int64_t,   int64_t, s64, 8)
-FETCH_FUNC (uint32_t, uint32_t, u32, 4)
-FETCH_FUNC (int32_t,   int32_t, s32, 4)
-FETCH_FUNC (uint32_t, uint16_t, u16, 2)
-FETCH_FUNC (int32_t,   int16_t, s16, 2)
-FETCH_FUNC (uint32_t,  uint8_t, u8, 1)
-FETCH_FUNC (int32_t,    int8_t, s8, 1)
+FETCH_FUNC32 (uint32_t, uint32_t, u32, 4)
+FETCH_FUNC32 (int32_t,   int32_t, s32, 4)
+FETCH_FUNC32 (uint32_t, uint16_t, u16, 2)
+FETCH_FUNC32 (int32_t,   int16_t, s16, 2)
+FETCH_FUNC32 (uint32_t,  uint8_t, u8, 1)
+FETCH_FUNC32 (int32_t,    int8_t, s8, 1)
 
 void
 aarch64_get_mem_long_double (sim_cpu *cpu, uint64_t address, FRegister *a)
@@ -151,10 +160,10 @@ aarch64_get_mem_ptr (sim_cpu *cpu, uint64_t address)
 uint64_t
 aarch64_get_heap_start (sim_cpu *cpu)
 {
-  uint64_t heap = aarch64_get_sym_value ("end");
+  uint64_t heap = trace_sym_value (CPU_STATE (cpu), "end");
 
   if (heap == 0)
-    heap = aarch64_get_sym_value ("_end");
+    heap = trace_sym_value (CPU_STATE (cpu), "_end");
   if (heap == 0)
     {
       heap = STACK_TOP - 0x100000;