xref: /netbsd-src/external/gpl3/gdb.old/dist/gdb/findvar.c (revision bdc22b2e01993381dcefeff2bc9b56ca75a4235c)
1 /* Find a variable's value in memory, for GDB, the GNU debugger.
2 
3    Copyright (C) 1986-2016 Free Software Foundation, Inc.
4 
5    This file is part of GDB.
6 
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11 
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16 
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19 
20 #include "defs.h"
21 #include "symtab.h"
22 #include "gdbtypes.h"
23 #include "frame.h"
24 #include "value.h"
25 #include "gdbcore.h"
26 #include "inferior.h"
27 #include "target.h"
28 #include "floatformat.h"
29 #include "symfile.h"		/* for overlay functions */
30 #include "regcache.h"
31 #include "user-regs.h"
32 #include "block.h"
33 #include "objfiles.h"
34 #include "language.h"
35 #include "dwarf2loc.h"
36 
37 /* Basic byte-swapping routines.  All 'extract' functions return a
38    host-format integer from a target-format integer at ADDR which is
39    LEN bytes long.  */
40 
41 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
42   /* 8 bit characters are a pretty safe assumption these days, so we
43      assume it throughout all these swapping routines.  If we had to deal with
44      9 bit characters, we would need to make len be in bits and would have
45      to re-write these routines...  */
46 you lose
47 #endif
48 
49 LONGEST
50 extract_signed_integer (const gdb_byte *addr, int len,
51 			enum bfd_endian byte_order)
52 {
53   LONGEST retval;
54   const unsigned char *p;
55   const unsigned char *startaddr = addr;
56   const unsigned char *endaddr = startaddr + len;
57 
58   if (len > (int) sizeof (LONGEST))
59     error (_("\
60 That operation is not available on integers of more than %d bytes."),
61 	   (int) sizeof (LONGEST));
62 
63   /* Start at the most significant end of the integer, and work towards
64      the least significant.  */
65   if (byte_order == BFD_ENDIAN_BIG)
66     {
67       p = startaddr;
68       /* Do the sign extension once at the start.  */
69       retval = ((LONGEST) * p ^ 0x80) - 0x80;
70       for (++p; p < endaddr; ++p)
71 	retval = (retval << 8) | *p;
72     }
73   else
74     {
75       p = endaddr - 1;
76       /* Do the sign extension once at the start.  */
77       retval = ((LONGEST) * p ^ 0x80) - 0x80;
78       for (--p; p >= startaddr; --p)
79 	retval = (retval << 8) | *p;
80     }
81   return retval;
82 }
83 
84 ULONGEST
85 extract_unsigned_integer (const gdb_byte *addr, int len,
86 			  enum bfd_endian byte_order)
87 {
88   ULONGEST retval;
89   const unsigned char *p;
90   const unsigned char *startaddr = addr;
91   const unsigned char *endaddr = startaddr + len;
92 
93   if (len > (int) sizeof (ULONGEST))
94     error (_("\
95 That operation is not available on integers of more than %d bytes."),
96 	   (int) sizeof (ULONGEST));
97 
98   /* Start at the most significant end of the integer, and work towards
99      the least significant.  */
100   retval = 0;
101   if (byte_order == BFD_ENDIAN_BIG)
102     {
103       for (p = startaddr; p < endaddr; ++p)
104 	retval = (retval << 8) | *p;
105     }
106   else
107     {
108       for (p = endaddr - 1; p >= startaddr; --p)
109 	retval = (retval << 8) | *p;
110     }
111   return retval;
112 }
113 
114 /* Sometimes a long long unsigned integer can be extracted as a
115    LONGEST value.  This is done so that we can print these values
116    better.  If this integer can be converted to a LONGEST, this
117    function returns 1 and sets *PVAL.  Otherwise it returns 0.  */
118 
119 int
120 extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
121 			       enum bfd_endian byte_order, LONGEST *pval)
122 {
123   const gdb_byte *p;
124   const gdb_byte *first_addr;
125   int len;
126 
127   len = orig_len;
128   if (byte_order == BFD_ENDIAN_BIG)
129     {
130       for (p = addr;
131 	   len > (int) sizeof (LONGEST) && p < addr + orig_len;
132 	   p++)
133 	{
134 	  if (*p == 0)
135 	    len--;
136 	  else
137 	    break;
138 	}
139       first_addr = p;
140     }
141   else
142     {
143       first_addr = addr;
144       for (p = addr + orig_len - 1;
145 	   len > (int) sizeof (LONGEST) && p >= addr;
146 	   p--)
147 	{
148 	  if (*p == 0)
149 	    len--;
150 	  else
151 	    break;
152 	}
153     }
154 
155   if (len <= (int) sizeof (LONGEST))
156     {
157       *pval = (LONGEST) extract_unsigned_integer (first_addr,
158 						  sizeof (LONGEST),
159 						  byte_order);
160       return 1;
161     }
162 
163   return 0;
164 }
165 
166 
167 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
168    address it represents.  */
169 CORE_ADDR
170 extract_typed_address (const gdb_byte *buf, struct type *type)
171 {
172   if (TYPE_CODE (type) != TYPE_CODE_PTR
173       && TYPE_CODE (type) != TYPE_CODE_REF)
174     internal_error (__FILE__, __LINE__,
175 		    _("extract_typed_address: "
176 		    "type is not a pointer or reference"));
177 
178   return gdbarch_pointer_to_address (get_type_arch (type), type, buf);
179 }
180 
181 /* All 'store' functions accept a host-format integer and store a
182    target-format integer at ADDR which is LEN bytes long.  */
183 
184 void
185 store_signed_integer (gdb_byte *addr, int len,
186 		      enum bfd_endian byte_order, LONGEST val)
187 {
188   gdb_byte *p;
189   gdb_byte *startaddr = addr;
190   gdb_byte *endaddr = startaddr + len;
191 
192   /* Start at the least significant end of the integer, and work towards
193      the most significant.  */
194   if (byte_order == BFD_ENDIAN_BIG)
195     {
196       for (p = endaddr - 1; p >= startaddr; --p)
197 	{
198 	  *p = val & 0xff;
199 	  val >>= 8;
200 	}
201     }
202   else
203     {
204       for (p = startaddr; p < endaddr; ++p)
205 	{
206 	  *p = val & 0xff;
207 	  val >>= 8;
208 	}
209     }
210 }
211 
212 void
213 store_unsigned_integer (gdb_byte *addr, int len,
214 			enum bfd_endian byte_order, ULONGEST val)
215 {
216   unsigned char *p;
217   unsigned char *startaddr = (unsigned char *) addr;
218   unsigned char *endaddr = startaddr + len;
219 
220   /* Start at the least significant end of the integer, and work towards
221      the most significant.  */
222   if (byte_order == BFD_ENDIAN_BIG)
223     {
224       for (p = endaddr - 1; p >= startaddr; --p)
225 	{
226 	  *p = val & 0xff;
227 	  val >>= 8;
228 	}
229     }
230   else
231     {
232       for (p = startaddr; p < endaddr; ++p)
233 	{
234 	  *p = val & 0xff;
235 	  val >>= 8;
236 	}
237     }
238 }
239 
240 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
241    form.  */
242 void
243 store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
244 {
245   if (TYPE_CODE (type) != TYPE_CODE_PTR
246       && TYPE_CODE (type) != TYPE_CODE_REF)
247     internal_error (__FILE__, __LINE__,
248 		    _("store_typed_address: "
249 		    "type is not a pointer or reference"));
250 
251   gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr);
252 }
253 
254 
255 
256 /* Return a `value' with the contents of (virtual or cooked) register
257    REGNUM as found in the specified FRAME.  The register's type is
258    determined by register_type().  */
259 
260 struct value *
261 value_of_register (int regnum, struct frame_info *frame)
262 {
263   struct gdbarch *gdbarch = get_frame_arch (frame);
264   struct value *reg_val;
265 
266   /* User registers lie completely outside of the range of normal
267      registers.  Catch them early so that the target never sees them.  */
268   if (regnum >= gdbarch_num_regs (gdbarch)
269 		+ gdbarch_num_pseudo_regs (gdbarch))
270     return value_of_user_reg (regnum, frame);
271 
272   reg_val = value_of_register_lazy (frame, regnum);
273   value_fetch_lazy (reg_val);
274   return reg_val;
275 }
276 
277 /* Return a `value' with the contents of (virtual or cooked) register
278    REGNUM as found in the specified FRAME.  The register's type is
279    determined by register_type().  The value is not fetched.  */
280 
281 struct value *
282 value_of_register_lazy (struct frame_info *frame, int regnum)
283 {
284   struct gdbarch *gdbarch = get_frame_arch (frame);
285   struct value *reg_val;
286 
287   gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
288 			+ gdbarch_num_pseudo_regs (gdbarch)));
289 
290   /* We should have a valid (i.e. non-sentinel) frame.  */
291   gdb_assert (frame_id_p (get_frame_id (frame)));
292 
293   reg_val = allocate_value_lazy (register_type (gdbarch, regnum));
294   VALUE_LVAL (reg_val) = lval_register;
295   VALUE_REGNUM (reg_val) = regnum;
296   VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
297   return reg_val;
298 }
299 
300 /* Given a pointer of type TYPE in target form in BUF, return the
301    address it represents.  */
302 CORE_ADDR
303 unsigned_pointer_to_address (struct gdbarch *gdbarch,
304 			     struct type *type, const gdb_byte *buf)
305 {
306   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
307 
308   return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
309 }
310 
311 CORE_ADDR
312 signed_pointer_to_address (struct gdbarch *gdbarch,
313 			   struct type *type, const gdb_byte *buf)
314 {
315   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
316 
317   return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
318 }
319 
320 /* Given an address, store it as a pointer of type TYPE in target
321    format in BUF.  */
322 void
323 unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type,
324 			     gdb_byte *buf, CORE_ADDR addr)
325 {
326   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
327 
328   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
329 }
330 
331 void
332 address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
333 			   gdb_byte *buf, CORE_ADDR addr)
334 {
335   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
336 
337   store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
338 }
339 
340 /* See value.h.  */
341 
342 enum symbol_needs_kind
343 symbol_read_needs (struct symbol *sym)
344 {
345   if (SYMBOL_COMPUTED_OPS (sym) != NULL)
346     return SYMBOL_COMPUTED_OPS (sym)->get_symbol_read_needs (sym);
347 
348   switch (SYMBOL_CLASS (sym))
349     {
350       /* All cases listed explicitly so that gcc -Wall will detect it if
351          we failed to consider one.  */
352     case LOC_COMPUTED:
353       gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
354 
355     case LOC_REGISTER:
356     case LOC_ARG:
357     case LOC_REF_ARG:
358     case LOC_REGPARM_ADDR:
359     case LOC_LOCAL:
360       return SYMBOL_NEEDS_FRAME;
361 
362     case LOC_UNDEF:
363     case LOC_CONST:
364     case LOC_STATIC:
365     case LOC_TYPEDEF:
366 
367     case LOC_LABEL:
368       /* Getting the address of a label can be done independently of the block,
369          even if some *uses* of that address wouldn't work so well without
370          the right frame.  */
371 
372     case LOC_BLOCK:
373     case LOC_CONST_BYTES:
374     case LOC_UNRESOLVED:
375     case LOC_OPTIMIZED_OUT:
376       return SYMBOL_NEEDS_NONE;
377     }
378   return SYMBOL_NEEDS_FRAME;
379 }
380 
381 /* See value.h.  */
382 
383 int
384 symbol_read_needs_frame (struct symbol *sym)
385 {
386   return symbol_read_needs (sym) == SYMBOL_NEEDS_FRAME;
387 }
388 
389 /* Private data to be used with minsym_lookup_iterator_cb.  */
390 
391 struct minsym_lookup_data
392 {
393   /* The name of the minimal symbol we are searching for.  */
394   const char *name;
395 
396   /* The field where the callback should store the minimal symbol
397      if found.  It should be initialized to NULL before the search
398      is started.  */
399   struct bound_minimal_symbol result;
400 };
401 
402 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
403    It searches by name for a minimal symbol within the given OBJFILE.
404    The arguments are passed via CB_DATA, which in reality is a pointer
405    to struct minsym_lookup_data.  */
406 
407 static int
408 minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data)
409 {
410   struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data;
411 
412   gdb_assert (data->result.minsym == NULL);
413 
414   data->result = lookup_minimal_symbol (data->name, NULL, objfile);
415 
416   /* The iterator should stop iff a match was found.  */
417   return (data->result.minsym != NULL);
418 }
419 
420 /* Given static link expression and the frame it lives in, look for the frame
421    the static links points to and return it.  Return NULL if we could not find
422    such a frame.   */
423 
424 static struct frame_info *
425 follow_static_link (struct frame_info *frame,
426 		    const struct dynamic_prop *static_link)
427 {
428   CORE_ADDR upper_frame_base;
429 
430   if (!dwarf2_evaluate_property (static_link, frame, NULL, &upper_frame_base))
431     return NULL;
432 
433   /* Now climb up the stack frame until we reach the frame we are interested
434      in.  */
435   for (; frame != NULL; frame = get_prev_frame (frame))
436     {
437       struct symbol *framefunc = get_frame_function (frame);
438 
439       /* Stacks can be quite deep: give the user a chance to stop this.  */
440       QUIT;
441 
442       /* If we don't know how to compute FRAME's base address, don't give up:
443 	 maybe the frame we are looking for is upper in the stace frame.  */
444       if (framefunc != NULL
445 	  && SYMBOL_BLOCK_OPS (framefunc) != NULL
446 	  && SYMBOL_BLOCK_OPS (framefunc)->get_frame_base != NULL
447 	  && (SYMBOL_BLOCK_OPS (framefunc)->get_frame_base (framefunc, frame)
448 	      == upper_frame_base))
449 	break;
450     }
451 
452   return frame;
453 }
454 
455 /* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical
456    rules, look for the frame that is actually hosting VAR and return it.  If,
457    for some reason, we found no such frame, return NULL.
458 
459    This kind of computation is necessary to correctly handle lexically nested
460    functions.
461 
462    Note that in some cases, we know what scope VAR comes from but we cannot
463    reach the specific frame that hosts the instance of VAR we are looking for.
464    For backward compatibility purposes (with old compilers), we then look for
465    the first frame that can host it.  */
466 
467 static struct frame_info *
468 get_hosting_frame (struct symbol *var, const struct block *var_block,
469 		   struct frame_info *frame)
470 {
471   const struct block *frame_block = NULL;
472 
473   if (!symbol_read_needs_frame (var))
474     return NULL;
475 
476   /* Some symbols for local variables have no block: this happens when they are
477      not produced by a debug information reader, for instance when GDB creates
478      synthetic symbols.  Without block information, we must assume they are
479      local to FRAME. In this case, there is nothing to do.  */
480   else if (var_block == NULL)
481     return frame;
482 
483   /* We currently assume that all symbols with a location list need a frame.
484      This is true in practice because selecting the location description
485      requires to compute the CFA, hence requires a frame.  However we have
486      tests that embed global/static symbols with null location lists.
487      We want to get <optimized out> instead of <frame required> when evaluating
488      them so return a frame instead of raising an error.  */
489   else if (var_block == block_global_block (var_block)
490 	   || var_block == block_static_block (var_block))
491     return frame;
492 
493   /* We have to handle the "my_func::my_local_var" notation.  This requires us
494      to look for upper frames when we find no block for the current frame: here
495      and below, handle when frame_block == NULL.  */
496   if (frame != NULL)
497     frame_block = get_frame_block (frame, NULL);
498 
499   /* Climb up the call stack until reaching the frame we are looking for.  */
500   while (frame != NULL && frame_block != var_block)
501     {
502       /* Stacks can be quite deep: give the user a chance to stop this.  */
503       QUIT;
504 
505       if (frame_block == NULL)
506 	{
507 	  frame = get_prev_frame (frame);
508 	  if (frame == NULL)
509 	    break;
510 	  frame_block = get_frame_block (frame, NULL);
511 	}
512 
513       /* If we failed to find the proper frame, fallback to the heuristic
514 	 method below.  */
515       else if (frame_block == block_global_block (frame_block))
516 	{
517 	  frame = NULL;
518 	  break;
519 	}
520 
521       /* Assuming we have a block for this frame: if we are at the function
522 	 level, the immediate upper lexical block is in an outer function:
523 	 follow the static link.  */
524       else if (BLOCK_FUNCTION (frame_block))
525 	{
526 	  const struct dynamic_prop *static_link
527 	    = block_static_link (frame_block);
528 	  int could_climb_up = 0;
529 
530 	  if (static_link != NULL)
531 	    {
532 	      frame = follow_static_link (frame, static_link);
533 	      if (frame != NULL)
534 		{
535 		  frame_block = get_frame_block (frame, NULL);
536 		  could_climb_up = frame_block != NULL;
537 		}
538 	    }
539 	  if (!could_climb_up)
540 	    {
541 	      frame = NULL;
542 	      break;
543 	    }
544 	}
545 
546       else
547 	/* We must be in some function nested lexical block.  Just get the
548 	   outer block: both must share the same frame.  */
549 	frame_block = BLOCK_SUPERBLOCK (frame_block);
550     }
551 
552   /* Old compilers may not provide a static link, or they may provide an
553      invalid one.  For such cases, fallback on the old way to evaluate
554      non-local references: just climb up the call stack and pick the first
555      frame that contains the variable we are looking for.  */
556   if (frame == NULL)
557     {
558       frame = block_innermost_frame (var_block);
559       if (frame == NULL)
560 	{
561 	  if (BLOCK_FUNCTION (var_block)
562 	      && !block_inlined_p (var_block)
563 	      && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)))
564 	    error (_("No frame is currently executing in block %s."),
565 		   SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)));
566 	  else
567 	    error (_("No frame is currently executing in specified"
568 		     " block"));
569 	}
570     }
571 
572   return frame;
573 }
574 
575 /* A default implementation for the "la_read_var_value" hook in
576    the language vector which should work in most situations.  */
577 
578 struct value *
579 default_read_var_value (struct symbol *var, const struct block *var_block,
580 			struct frame_info *frame)
581 {
582   struct value *v;
583   struct type *type = SYMBOL_TYPE (var);
584   CORE_ADDR addr;
585   enum symbol_needs_kind sym_need;
586 
587   /* Call check_typedef on our type to make sure that, if TYPE is
588      a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
589      instead of zero.  However, we do not replace the typedef type by the
590      target type, because we want to keep the typedef in order to be able to
591      set the returned value type description correctly.  */
592   check_typedef (type);
593 
594   sym_need = symbol_read_needs (var);
595   if (sym_need == SYMBOL_NEEDS_FRAME)
596     gdb_assert (frame != NULL);
597   else if (sym_need == SYMBOL_NEEDS_REGISTERS && !target_has_registers)
598     error (_("Cannot read `%s' without registers"), SYMBOL_PRINT_NAME (var));
599 
600   if (frame != NULL)
601     frame = get_hosting_frame (var, var_block, frame);
602 
603   if (SYMBOL_COMPUTED_OPS (var) != NULL)
604     return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
605 
606   switch (SYMBOL_CLASS (var))
607     {
608     case LOC_CONST:
609       if (is_dynamic_type (type))
610 	{
611 	  /* Value is a constant byte-sequence and needs no memory access.  */
612 	  type = resolve_dynamic_type (type, NULL, /* Unused address.  */ 0);
613 	}
614       /* Put the constant back in target format. */
615       v = allocate_value (type);
616       store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
617 			    gdbarch_byte_order (get_type_arch (type)),
618 			    (LONGEST) SYMBOL_VALUE (var));
619       VALUE_LVAL (v) = not_lval;
620       return v;
621 
622     case LOC_LABEL:
623       /* Put the constant back in target format.  */
624       v = allocate_value (type);
625       if (overlay_debugging)
626 	{
627 	  CORE_ADDR addr
628 	    = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
629 					SYMBOL_OBJ_SECTION (symbol_objfile (var),
630 							    var));
631 
632 	  store_typed_address (value_contents_raw (v), type, addr);
633 	}
634       else
635 	store_typed_address (value_contents_raw (v), type,
636 			      SYMBOL_VALUE_ADDRESS (var));
637       VALUE_LVAL (v) = not_lval;
638       return v;
639 
640     case LOC_CONST_BYTES:
641       if (is_dynamic_type (type))
642 	{
643 	  /* Value is a constant byte-sequence and needs no memory access.  */
644 	  type = resolve_dynamic_type (type, NULL, /* Unused address.  */ 0);
645 	}
646       v = allocate_value (type);
647       memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
648 	      TYPE_LENGTH (type));
649       VALUE_LVAL (v) = not_lval;
650       return v;
651 
652     case LOC_STATIC:
653       if (overlay_debugging)
654 	addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
655 					 SYMBOL_OBJ_SECTION (symbol_objfile (var),
656 							     var));
657       else
658 	addr = SYMBOL_VALUE_ADDRESS (var);
659       break;
660 
661     case LOC_ARG:
662       addr = get_frame_args_address (frame);
663       if (!addr)
664 	error (_("Unknown argument list address for `%s'."),
665 	       SYMBOL_PRINT_NAME (var));
666       addr += SYMBOL_VALUE (var);
667       break;
668 
669     case LOC_REF_ARG:
670       {
671 	struct value *ref;
672 	CORE_ADDR argref;
673 
674 	argref = get_frame_args_address (frame);
675 	if (!argref)
676 	  error (_("Unknown argument list address for `%s'."),
677 		 SYMBOL_PRINT_NAME (var));
678 	argref += SYMBOL_VALUE (var);
679 	ref = value_at (lookup_pointer_type (type), argref);
680 	addr = value_as_address (ref);
681 	break;
682       }
683 
684     case LOC_LOCAL:
685       addr = get_frame_locals_address (frame);
686       addr += SYMBOL_VALUE (var);
687       break;
688 
689     case LOC_TYPEDEF:
690       error (_("Cannot look up value of a typedef `%s'."),
691 	     SYMBOL_PRINT_NAME (var));
692       break;
693 
694     case LOC_BLOCK:
695       if (overlay_debugging)
696 	addr = symbol_overlayed_address
697 	  (BLOCK_START (SYMBOL_BLOCK_VALUE (var)),
698 	   SYMBOL_OBJ_SECTION (symbol_objfile (var), var));
699       else
700 	addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
701       break;
702 
703     case LOC_REGISTER:
704     case LOC_REGPARM_ADDR:
705       {
706 	int regno = SYMBOL_REGISTER_OPS (var)
707 		      ->register_number (var, get_frame_arch (frame));
708 	struct value *regval;
709 
710 	if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
711 	  {
712 	    regval = value_from_register (lookup_pointer_type (type),
713 					  regno,
714 					  frame);
715 
716 	    if (regval == NULL)
717 	      error (_("Value of register variable not available for `%s'."),
718 	             SYMBOL_PRINT_NAME (var));
719 
720 	    addr = value_as_address (regval);
721 	  }
722 	else
723 	  {
724 	    regval = value_from_register (type, regno, frame);
725 
726 	    if (regval == NULL)
727 	      error (_("Value of register variable not available for `%s'."),
728 	             SYMBOL_PRINT_NAME (var));
729 	    return regval;
730 	  }
731       }
732       break;
733 
734     case LOC_COMPUTED:
735       gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
736 
737     case LOC_UNRESOLVED:
738       {
739 	struct minsym_lookup_data lookup_data;
740 	struct minimal_symbol *msym;
741 	struct obj_section *obj_section;
742 
743 	memset (&lookup_data, 0, sizeof (lookup_data));
744 	lookup_data.name = SYMBOL_LINKAGE_NAME (var);
745 
746 	gdbarch_iterate_over_objfiles_in_search_order
747 	  (symbol_arch (var),
748 	   minsym_lookup_iterator_cb, &lookup_data,
749 	   symbol_objfile (var));
750 	msym = lookup_data.result.minsym;
751 
752 	/* If we can't find the minsym there's a problem in the symbol info.
753 	   The symbol exists in the debug info, but it's missing in the minsym
754 	   table.  */
755 	if (msym == NULL)
756 	  {
757 	    const char *flavour_name
758 	      = objfile_flavour_name (symbol_objfile (var));
759 
760 	    /* We can't get here unless we've opened the file, so flavour_name
761 	       can't be NULL.  */
762 	    gdb_assert (flavour_name != NULL);
763 	    error (_("Missing %s symbol \"%s\"."),
764 		   flavour_name, SYMBOL_LINKAGE_NAME (var));
765 	  }
766 	obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym);
767 	/* Relocate address, unless there is no section or the variable is
768 	   a TLS variable. */
769 	if (obj_section == NULL
770 	    || (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
771 	   addr = MSYMBOL_VALUE_RAW_ADDRESS (msym);
772 	else
773 	   addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result);
774 	if (overlay_debugging)
775 	  addr = symbol_overlayed_address (addr, obj_section);
776 	/* Determine address of TLS variable. */
777 	if (obj_section
778 	    && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
779 	  addr = target_translate_tls_address (obj_section->objfile, addr);
780       }
781       break;
782 
783     case LOC_OPTIMIZED_OUT:
784       return allocate_optimized_out_value (type);
785 
786     default:
787       error (_("Cannot look up value of a botched symbol `%s'."),
788 	     SYMBOL_PRINT_NAME (var));
789       break;
790     }
791 
792   v = value_at_lazy (type, addr);
793   return v;
794 }
795 
796 /* Calls VAR's language la_read_var_value hook with the given arguments.  */
797 
798 struct value *
799 read_var_value (struct symbol *var, const struct block *var_block,
800 		struct frame_info *frame)
801 {
802   const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var));
803 
804   gdb_assert (lang != NULL);
805   gdb_assert (lang->la_read_var_value != NULL);
806 
807   return lang->la_read_var_value (var, var_block, frame);
808 }
809 
810 /* Install default attributes for register values.  */
811 
812 struct value *
813 default_value_from_register (struct gdbarch *gdbarch, struct type *type,
814                              int regnum, struct frame_id frame_id)
815 {
816   int len = TYPE_LENGTH (type);
817   struct value *value = allocate_value (type);
818 
819   VALUE_LVAL (value) = lval_register;
820   VALUE_FRAME_ID (value) = frame_id;
821   VALUE_REGNUM (value) = regnum;
822 
823   /* Any structure stored in more than one register will always be
824      an integral number of registers.  Otherwise, you need to do
825      some fiddling with the last register copied here for little
826      endian machines.  */
827   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
828       && len < register_size (gdbarch, regnum))
829     /* Big-endian, and we want less than full size.  */
830     set_value_offset (value, register_size (gdbarch, regnum) - len);
831   else
832     set_value_offset (value, 0);
833 
834   return value;
835 }
836 
837 /* VALUE must be an lval_register value.  If regnum is the value's
838    associated register number, and len the length of the values type,
839    read one or more registers in FRAME, starting with register REGNUM,
840    until we've read LEN bytes.
841 
842    If any of the registers we try to read are optimized out, then mark the
843    complete resulting value as optimized out.  */
844 
845 void
846 read_frame_register_value (struct value *value, struct frame_info *frame)
847 {
848   struct gdbarch *gdbarch = get_frame_arch (frame);
849   LONGEST offset = 0;
850   LONGEST reg_offset = value_offset (value);
851   int regnum = VALUE_REGNUM (value);
852   int len = type_length_units (check_typedef (value_type (value)));
853 
854   gdb_assert (VALUE_LVAL (value) == lval_register);
855 
856   /* Skip registers wholly inside of REG_OFFSET.  */
857   while (reg_offset >= register_size (gdbarch, regnum))
858     {
859       reg_offset -= register_size (gdbarch, regnum);
860       regnum++;
861     }
862 
863   /* Copy the data.  */
864   while (len > 0)
865     {
866       struct value *regval = get_frame_register_value (frame, regnum);
867       int reg_len = type_length_units (value_type (regval)) - reg_offset;
868 
869       /* If the register length is larger than the number of bytes
870          remaining to copy, then only copy the appropriate bytes.  */
871       if (reg_len > len)
872 	reg_len = len;
873 
874       value_contents_copy (value, offset, regval, reg_offset, reg_len);
875 
876       offset += reg_len;
877       len -= reg_len;
878       reg_offset = 0;
879       regnum++;
880     }
881 }
882 
883 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
884 
885 struct value *
886 value_from_register (struct type *type, int regnum, struct frame_info *frame)
887 {
888   struct gdbarch *gdbarch = get_frame_arch (frame);
889   struct type *type1 = check_typedef (type);
890   struct value *v;
891 
892   if (gdbarch_convert_register_p (gdbarch, regnum, type1))
893     {
894       int optim, unavail, ok;
895 
896       /* The ISA/ABI need to something weird when obtaining the
897          specified value from this register.  It might need to
898          re-order non-adjacent, starting with REGNUM (see MIPS and
899          i386).  It might need to convert the [float] register into
900          the corresponding [integer] type (see Alpha).  The assumption
901          is that gdbarch_register_to_value populates the entire value
902          including the location.  */
903       v = allocate_value (type);
904       VALUE_LVAL (v) = lval_register;
905       VALUE_FRAME_ID (v) = get_frame_id (frame);
906       VALUE_REGNUM (v) = regnum;
907       ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
908 				      value_contents_raw (v), &optim,
909 				      &unavail);
910 
911       if (!ok)
912 	{
913 	  if (optim)
914 	    mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type));
915 	  if (unavail)
916 	    mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
917 	}
918     }
919   else
920     {
921       /* Construct the value.  */
922       v = gdbarch_value_from_register (gdbarch, type,
923 				       regnum, get_frame_id (frame));
924 
925       /* Get the data.  */
926       read_frame_register_value (v, frame);
927     }
928 
929   return v;
930 }
931 
932 /* Return contents of register REGNUM in frame FRAME as address.
933    Will abort if register value is not available.  */
934 
935 CORE_ADDR
936 address_from_register (int regnum, struct frame_info *frame)
937 {
938   struct gdbarch *gdbarch = get_frame_arch (frame);
939   struct type *type = builtin_type (gdbarch)->builtin_data_ptr;
940   struct value *value;
941   CORE_ADDR result;
942   int regnum_max_excl = (gdbarch_num_regs (gdbarch)
943 			 + gdbarch_num_pseudo_regs (gdbarch));
944 
945   if (regnum < 0 || regnum >= regnum_max_excl)
946     error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum,
947 	   regnum_max_excl);
948 
949   /* This routine may be called during early unwinding, at a time
950      where the ID of FRAME is not yet known.  Calling value_from_register
951      would therefore abort in get_frame_id.  However, since we only need
952      a temporary value that is never used as lvalue, we actually do not
953      really need to set its VALUE_FRAME_ID.  Therefore, we re-implement
954      the core of value_from_register, but use the null_frame_id.  */
955 
956   /* Some targets require a special conversion routine even for plain
957      pointer types.  Avoid constructing a value object in those cases.  */
958   if (gdbarch_convert_register_p (gdbarch, regnum, type))
959     {
960       gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
961       int optim, unavail, ok;
962 
963       ok = gdbarch_register_to_value (gdbarch, frame, regnum, type,
964 				      buf, &optim, &unavail);
965       if (!ok)
966 	{
967 	  /* This function is used while computing a location expression.
968 	     Complain about the value being optimized out, rather than
969 	     letting value_as_address complain about some random register
970 	     the expression depends on not being saved.  */
971 	  error_value_optimized_out ();
972 	}
973 
974       return unpack_long (type, buf);
975     }
976 
977   value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
978   read_frame_register_value (value, frame);
979 
980   if (value_optimized_out (value))
981     {
982       /* This function is used while computing a location expression.
983 	 Complain about the value being optimized out, rather than
984 	 letting value_as_address complain about some random register
985 	 the expression depends on not being saved.  */
986       error_value_optimized_out ();
987     }
988 
989   result = value_as_address (value);
990   release_value (value);
991   value_free (value);
992 
993   return result;
994 }
995 
996