X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ffindvar.c;h=8f28b90c12a39ec7ab39fa834b49b87c8c1063ca;hb=c96451db277044482060eac8629154b76688af3b;hp=a8ac396bcab47b2dda35e7f6a82607a41a716b4f;hpb=4d50f90ab81c6861aaafb77672573726636a9330;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/findvar.c b/gdb/findvar.c index a8ac396bca..8f28b90c12 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -26,6 +26,233 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "inferior.h" #include "target.h" +/* Basic byte-swapping routines. GDB has needed these for a long time... + All extract a target-format integer at ADDR which is LEN bytes long. */ + +#if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8 + /* 8 bit characters are a pretty safe assumption these days, so we + assume it throughout all these swapping routines. If we had to deal with + 9 bit characters, we would need to make len be in bits and would have + to re-write these routines... */ + you lose +#endif + +LONGEST +extract_signed_integer (addr, len) + PTR addr; + int len; +{ + LONGEST retval; + unsigned char *p; + unsigned char *startaddr = (unsigned char *)addr; + unsigned char *endaddr = startaddr + len; + + if (len > sizeof (LONGEST)) + error ("\ +That operation is not available on integers of more than %d bytes.", + sizeof (LONGEST)); + + /* Start at the most significant end of the integer, and work towards + the least significant. */ +#if TARGET_BYTE_ORDER == BIG_ENDIAN + p = startaddr; +#else + p = endaddr - 1; +#endif + /* Do the sign extension once at the start. */ + retval = ((LONGEST)*p ^ 0x80) - 0x80; +#if TARGET_BYTE_ORDER == BIG_ENDIAN + for (++p; p < endaddr; ++p) +#else + for (--p; p >= startaddr; --p) +#endif + { + retval = (retval << 8) | *p; + } + return retval; +} + +unsigned LONGEST +extract_unsigned_integer (addr, len) + PTR addr; + int len; +{ + unsigned LONGEST retval; + unsigned char *p; + unsigned char *startaddr = (unsigned char *)addr; + unsigned char *endaddr = startaddr + len; + + if (len > sizeof (unsigned LONGEST)) + error ("\ +That operation is not available on integers of more than %d bytes.", + sizeof (unsigned LONGEST)); + + /* Start at the most significant end of the integer, and work towards + the least significant. */ + retval = 0; +#if TARGET_BYTE_ORDER == BIG_ENDIAN + for (p = startaddr; p < endaddr; ++p) +#else + for (p = endaddr - 1; p >= startaddr; --p) +#endif + { + retval = (retval << 8) | *p; + } + return retval; +} + +CORE_ADDR +extract_address (addr, len) + PTR addr; + int len; +{ + /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure + whether we want this to be true eventually. */ + return extract_unsigned_integer (addr, len); +} + +void +store_signed_integer (addr, len, val) + PTR addr; + int len; + LONGEST val; +{ + unsigned char *p; + unsigned char *startaddr = (unsigned char *)addr; + unsigned char *endaddr = startaddr + len; + + /* Start at the least significant end of the integer, and work towards + the most significant. */ +#if TARGET_BYTE_ORDER == BIG_ENDIAN + for (p = endaddr - 1; p >= startaddr; --p) +#else + for (p = startaddr; p < endaddr; ++p) +#endif + { + *p = val & 0xff; + val >>= 8; + } +} + +void +store_unsigned_integer (addr, len, val) + PTR addr; + int len; + unsigned LONGEST val; +{ + unsigned char *p; + unsigned char *startaddr = (unsigned char *)addr; + unsigned char *endaddr = startaddr + len; + + /* Start at the least significant end of the integer, and work towards + the most significant. */ +#if TARGET_BYTE_ORDER == BIG_ENDIAN + for (p = endaddr - 1; p >= startaddr; --p) +#else + for (p = startaddr; p < endaddr; ++p) +#endif + { + *p = val & 0xff; + val >>= 8; + } +} + +void +store_address (addr, len, val) + PTR addr; + int len; + CORE_ADDR val; +{ + /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure + whether we want this to be true eventually. */ + store_unsigned_integer (addr, len, (LONGEST)val); +} + +/* Swap LEN bytes at BUFFER between target and host byte-order. This is + the wrong way to do byte-swapping because it assumes that you have a way + to have a host variable of exactly the right size. Once extract_floating + and store_floating have been fixed, this can go away. */ +#if TARGET_BYTE_ORDER == HOST_BYTE_ORDER +#define SWAP_TARGET_AND_HOST(buffer,len) +#else /* Target and host byte order differ. */ +#define SWAP_TARGET_AND_HOST(buffer,len) \ + { \ + char tmp; \ + char *p = (char *)(buffer); \ + char *q = ((char *)(buffer)) + len - 1; \ + for (; p < q; p++, q--) \ + { \ + tmp = *q; \ + *q = *p; \ + *p = tmp; \ + } \ + } +#endif /* Target and host byte order differ. */ + +/* There are many problems with floating point cross-debugging. + + 1. These routines only handle byte-swapping, not conversion of + formats. So if host is IEEE floating and target is VAX floating, + or vice-versa, it loses. This means that we can't (yet) use these + routines for extendeds. Extendeds are handled by + REGISTER_CONVERTIBLE. What we want is a fixed version of + ieee-float.c (the current version can't deal with single or double, + and I suspect it is probably broken for some extendeds too). + + 2. We can't deal with it if there is more than one floating point + format in use. This has to be fixed at the unpack_double level. + + 3. We probably should have a LONGEST_DOUBLE or DOUBLEST or whatever + we want to call it which is long double where available. */ + +double +extract_floating (addr, len) + PTR addr; + int len; +{ + if (len == sizeof (float)) + { + float retval; + memcpy (&retval, addr, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + else if (len == sizeof (double)) + { + double retval; + memcpy (&retval, addr, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + else + { + error ("Can't deal with a floating point number of %d bytes.", len); + } +} + +void +store_floating (addr, len, val) + PTR addr; + int len; + double val; +{ + if (len == sizeof (float)) + { + float floatval = val; + SWAP_TARGET_AND_HOST (&floatval, sizeof (floatval)); + memcpy (addr, &floatval, sizeof (floatval)); + } + else if (len == sizeof (double)) + { + SWAP_TARGET_AND_HOST (&val, sizeof (val)); + memcpy (addr, &val, sizeof (val)); + } + else + { + error ("Can't deal with a floating point number of %d bytes.", len); + } +} + #if !defined (GET_SAVED_REGISTER) /* Return the address in which frame FRAME's value of register REGNUM @@ -138,9 +365,8 @@ get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval) { if (raw_buffer != NULL) { - *(CORE_ADDR *)raw_buffer = addr; - /* Put it back in target byte order. */ - SWAP_TARGET_AND_HOST (raw_buffer, sizeof (CORE_ADDR)); + /* Put it back in target format. */ + store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), addr); } if (addrp != NULL) *addrp = 0; @@ -176,8 +402,9 @@ read_relative_register_raw_bytes (regnum, myaddr) int optim; if (regnum == FP_REGNUM && selected_frame) { - memcpy (myaddr, &FRAME_FP(selected_frame), REGISTER_RAW_SIZE(FP_REGNUM)); - SWAP_TARGET_AND_HOST (myaddr, REGISTER_RAW_SIZE(FP_REGNUM)); /* in target order */ + /* Put it back in target format. */ + store_address (myaddr, REGISTER_RAW_SIZE(FP_REGNUM), + FRAME_FP(selected_frame)); return 0; } @@ -198,16 +425,25 @@ value_of_register (regnum) int optim; register value val; char raw_buffer[MAX_REGISTER_RAW_SIZE]; - char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE]; enum lval_type lval; get_saved_register (raw_buffer, &optim, &addr, selected_frame, regnum, &lval); - REGISTER_CONVERT_TO_VIRTUAL (regnum, raw_buffer, virtual_buffer); val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum)); - memcpy (VALUE_CONTENTS_RAW (val), virtual_buffer, - REGISTER_VIRTUAL_SIZE (regnum)); + + /* Convert raw data to virtual format if necessary. */ + +#ifdef REGISTER_CONVERTIBLE + if (REGISTER_CONVERTIBLE (regnum)) + { + REGISTER_CONVERT_TO_VIRTUAL (regnum, REGISTER_VIRTUAL_TYPE (regnum), + raw_buffer, VALUE_CONTENTS_RAW (val)); + } + else +#endif + memcpy (VALUE_CONTENTS_RAW (val), raw_buffer, + REGISTER_RAW_SIZE (regnum)); VALUE_LVAL (val) = lval; VALUE_ADDRESS (val) = addr; VALUE_REGNO (val) = regnum; @@ -223,7 +459,7 @@ value_of_register (regnum) the caller got the value from the last stop). */ /* Contents of the registers in target byte order. - We allocate some extra slop since we do a lot of bcopy's around `registers', + We allocate some extra slop since we do a lot of memcpy's around `registers', and failing-soft is better than failing hard. */ char registers[REGISTER_BYTES + /* SLOP */ 256]; @@ -300,57 +536,18 @@ write_register_bytes (regbyte, myaddr, len) target_store_registers (-1); } -/* Return the contents of register REGNO, regarding it as an integer. */ -/* FIXME, this loses when the REGISTER_VIRTUAL (REGNO) is true. Also, - why is the return type CORE_ADDR rather than some integer type? */ +/* Return the raw contents of register REGNO, regarding it as an integer. */ +/* This probably should be returning LONGEST rather than CORE_ADDR. */ CORE_ADDR read_register (regno) int regno; { - unsigned short sval; - unsigned int ival; - unsigned long lval; - LONGEST llval; - - int size; - if (!register_valid[regno]) target_fetch_registers (regno); - size = REGISTER_RAW_SIZE(regno); - - if (size == sizeof (unsigned char)) - return registers[REGISTER_BYTE (regno)]; - else if (size == sizeof (sval)) - { - memcpy (&sval, ®isters[REGISTER_BYTE (regno)], sizeof (sval)); - SWAP_TARGET_AND_HOST (&sval, sizeof (sval)); - return sval; - } - else if (size == sizeof (ival)) - { - memcpy (&ival, ®isters[REGISTER_BYTE (regno)], sizeof (ival)); - SWAP_TARGET_AND_HOST (&ival, sizeof (ival)); - return ival; - } - else if (size == sizeof (lval)) - { - memcpy (&lval, ®isters[REGISTER_BYTE (regno)], sizeof (lval)); - SWAP_TARGET_AND_HOST (&lval, sizeof (lval)); - return lval; - } - else if (size == sizeof (llval)) - { - memcpy (&llval, ®isters[REGISTER_BYTE (regno)], sizeof (llval)); - SWAP_TARGET_AND_HOST (&llval, sizeof (llval)); - return llval; - } - else - { - error ("GDB Internal Error in read_register() for register %d, size %d", - regno, REGISTER_RAW_SIZE(regno)); - } + return extract_address (®isters[REGISTER_BYTE (regno)], + REGISTER_RAW_SIZE(regno)); } /* Registers we shouldn't try to store. */ @@ -358,74 +555,38 @@ read_register (regno) #define CANNOT_STORE_REGISTER(regno) 0 #endif -/* Store VALUE in the register number REGNO, regarded as an integer. */ -/* FIXME, this loses when REGISTER_VIRTUAL (REGNO) is true. Also, - shouldn't the val arg be a LONGEST or something? */ +/* Store VALUE, into the raw contents of register number REGNO. */ +/* FIXME: The val arg should probably be a LONGEST. */ void write_register (regno, val) - int regno, val; + int regno; + LONGEST val; { - unsigned char cval; - unsigned short sval; - unsigned int ival; - unsigned long lval; - LONGEST llval; + PTR buf; int size; - PTR ptr; - + /* On the sparc, writing %g0 is a no-op, so we don't even want to change the registers array if something writes to this register. */ if (CANNOT_STORE_REGISTER (regno)) return; + size = REGISTER_RAW_SIZE(regno); + buf = alloca (size); + store_signed_integer (buf, size, (LONGEST) val); + /* If we have a valid copy of the register, and new value == old value, then don't bother doing the actual store. */ - size = REGISTER_RAW_SIZE(regno); - - if (size == sizeof(cval)) - { - ptr = (PTR) &cval; - cval = val; - } - else if (size == sizeof(sval)) - { - ptr = (PTR) &sval; - sval = val; - } - else if (size == sizeof(ival)) - { - ptr = (PTR) &ival; - ival = val; - } - else if (size == sizeof(lval)) - { - ptr = (PTR) &lval; - lval = val; - } - else if (size == sizeof(llval)) - { - ptr = (PTR) &llval; - llval = val; - } - else - { - error ("GDB Internal Error in write_register() for register %d, size %d", - regno, size); - } - - SWAP_TARGET_AND_HOST (ptr, size); if (register_valid [regno]) { - if (memcmp (®isters[REGISTER_BYTE (regno)], - ptr, size) == 0) + if (memcmp (®isters[REGISTER_BYTE (regno)], buf, size) == 0) return; } target_prepare_to_store (); - memcpy (®isters[REGISTER_BYTE (regno)], ptr, size); + memcpy (®isters[REGISTER_BYTE (regno)], buf, size); register_valid [regno] = 1; @@ -451,6 +612,46 @@ supply_register (regno, val) #endif } +/* Will calling read_var_value or locate_var_value on SYM end + up caring what frame it is being evaluated relative to? SYM must + be non-NULL. */ +int +symbol_read_needs_frame (sym) + struct symbol *sym; +{ + switch (SYMBOL_CLASS (sym)) + { + /* All cases listed explicitly so that gcc -Wall will detect it if + we failed to consider one. */ + case LOC_REGISTER: + case LOC_ARG: + case LOC_REF_ARG: + case LOC_REGPARM: + case LOC_REGPARM_ADDR: + case LOC_LOCAL: + case LOC_LOCAL_ARG: + case LOC_BASEREG: + case LOC_BASEREG_ARG: + return 1; + + case LOC_UNDEF: + case LOC_CONST: + case LOC_STATIC: + case LOC_TYPEDEF: + + case LOC_LABEL: + /* Getting the address of a label can be done independently of the block, + even if some *uses* of that address wouldn't work so well without + the right frame. */ + + case LOC_BLOCK: + case LOC_CONST_BYTES: + case LOC_OPTIMIZED_OUT: + return 0; + } + return 1; +} + /* Given a struct symbol for a variable, and a stack frame id, read the value of the variable and return a (pointer to a) struct value containing the value. @@ -477,15 +678,15 @@ read_var_value (var, frame) switch (SYMBOL_CLASS (var)) { case LOC_CONST: - memcpy (VALUE_CONTENTS_RAW (v), &SYMBOL_VALUE (var), len); - SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len); + /* Put the constant back in target format. */ + store_signed_integer (VALUE_CONTENTS_RAW (v), len, + (LONGEST) SYMBOL_VALUE (var)); VALUE_LVAL (v) = not_lval; return v; case LOC_LABEL: - addr = SYMBOL_VALUE_ADDRESS (var); - memcpy (VALUE_CONTENTS_RAW (v), &addr, len); - SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len); + /* Put the constant back in target format. */ + store_address (VALUE_CONTENTS_RAW (v), len, SYMBOL_VALUE_ADDRESS (var)); VALUE_LVAL (v) = not_lval; return v; @@ -503,60 +704,51 @@ read_var_value (var, frame) break; case LOC_ARG: - if (SYMBOL_BASEREG_VALID (var)) - { - addr = FRAME_GET_BASEREG_VALUE (frame, SYMBOL_BASEREG (var)); - } - else - { - fi = get_frame_info (frame); - if (fi == NULL) - return 0; - addr = FRAME_ARGS_ADDRESS (fi); - } + fi = get_frame_info (frame); + if (fi == NULL) + return 0; + addr = FRAME_ARGS_ADDRESS (fi); if (!addr) { return 0; } addr += SYMBOL_VALUE (var); break; - + case LOC_REF_ARG: - if (SYMBOL_BASEREG_VALID (var)) - { - addr = FRAME_GET_BASEREG_VALUE (frame, SYMBOL_BASEREG (var)); - } - else - { - fi = get_frame_info (frame); - if (fi == NULL) - return 0; - addr = FRAME_ARGS_ADDRESS (fi); - } + fi = get_frame_info (frame); + if (fi == NULL) + return 0; + addr = FRAME_ARGS_ADDRESS (fi); if (!addr) { return 0; } addr += SYMBOL_VALUE (var); - read_memory (addr, (char *) &addr, sizeof (CORE_ADDR)); + addr = read_memory_unsigned_integer + (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT); break; - + case LOC_LOCAL: case LOC_LOCAL_ARG: - if (SYMBOL_BASEREG_VALID (var)) - { - addr = FRAME_GET_BASEREG_VALUE (frame, SYMBOL_BASEREG (var)); - } - else - { - fi = get_frame_info (frame); - if (fi == NULL) - return 0; - addr = FRAME_LOCALS_ADDRESS (fi); - } + fi = get_frame_info (frame); + if (fi == NULL) + return 0; + addr = FRAME_LOCALS_ADDRESS (fi); addr += SYMBOL_VALUE (var); break; + case LOC_BASEREG: + case LOC_BASEREG_ARG: + { + char buf[MAX_REGISTER_RAW_SIZE]; + get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var), + NULL); + addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var))); + addr += SYMBOL_VALUE (var); + break; + } + case LOC_TYPEDEF: error ("Cannot look up value of a typedef"); break; @@ -612,7 +804,6 @@ value_from_register (type, regnum, frame) FRAME frame; { char raw_buffer [MAX_REGISTER_RAW_SIZE]; - char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE]; CORE_ADDR addr; int optim; value v = allocate_value (type); @@ -640,7 +831,7 @@ value_from_register (type, regnum, frame) int mem_stor = 0, reg_stor = 0; int mem_tracking = 1; CORE_ADDR last_addr = 0; - CORE_ADDR first_addr; + CORE_ADDR first_addr = 0; value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE); @@ -781,32 +972,17 @@ value_from_register (type, regnum, frame) VALUE_OPTIMIZED_OUT (v) = optim; VALUE_LVAL (v) = lval; VALUE_ADDRESS (v) = addr; + + /* Convert raw data to virtual format if necessary. */ - /* Convert the raw contents to virtual contents. - (Just copy them if the formats are the same.) */ - - REGISTER_CONVERT_TO_VIRTUAL (regnum, raw_buffer, virtual_buffer); - +#ifdef REGISTER_CONVERTIBLE if (REGISTER_CONVERTIBLE (regnum)) { - /* When the raw and virtual formats differ, the virtual format - corresponds to a specific data type. If we want that type, - copy the data into the value. - Otherwise, do a type-conversion. */ - - if (type != REGISTER_VIRTUAL_TYPE (regnum)) - { - /* eg a variable of type `float' in a 68881 register - with raw type `extended' and virtual type `double'. - Fetch it as a `double' and then convert to `float'. */ - v = allocate_value (REGISTER_VIRTUAL_TYPE (regnum)); - memcpy (VALUE_CONTENTS_RAW (v), virtual_buffer, len); - v = value_cast (type, v); - } - else - memcpy (VALUE_CONTENTS_RAW (v), virtual_buffer, len); + REGISTER_CONVERT_TO_VIRTUAL (regnum, type, + raw_buffer, VALUE_CONTENTS_RAW (v)); } else +#endif { /* Raw and virtual formats are the same for this register. */ @@ -818,7 +994,7 @@ value_from_register (type, regnum, frame) } #endif - memcpy (VALUE_CONTENTS_RAW (v), virtual_buffer + VALUE_OFFSET (v), len); + memcpy (VALUE_CONTENTS_RAW (v), raw_buffer + VALUE_OFFSET (v), len); } return v;