1 /* Find a variable's value in memory, for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
29 /* Basic byte-swapping routines. GDB has needed these for a long time...
30 All extract a target-format integer at ADDR which is LEN bytes long. */
32 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
33 /* 8 bit characters are a pretty safe assumption these days, so we
34 assume it throughout all these swapping routines. If we had to deal with
35 9 bit characters, we would need to make len be in bits and would have
36 to re-write these routines... */
41 extract_signed_integer (addr
, len
)
47 unsigned char *startaddr
= (unsigned char *)addr
;
48 unsigned char *endaddr
= startaddr
+ len
;
50 if (len
> sizeof (LONGEST
))
52 That operation is not available on integers of more than %d bytes.",
55 /* Start at the most significant end of the integer, and work towards
56 the least significant. */
57 #if TARGET_BYTE_ORDER == BIG_ENDIAN
62 /* Do the sign extension once at the start. */
63 retval
= ((LONGEST
)*p
^ 0x80) - 0x80;
64 #if TARGET_BYTE_ORDER == BIG_ENDIAN
65 for (++p
; p
< endaddr
; ++p
)
67 for (--p
; p
>= startaddr
; --p
)
70 retval
= (retval
<< 8) | *p
;
76 extract_unsigned_integer (addr
, len
)
80 unsigned LONGEST retval
;
82 unsigned char *startaddr
= (unsigned char *)addr
;
83 unsigned char *endaddr
= startaddr
+ len
;
85 if (len
> sizeof (unsigned LONGEST
))
87 That operation is not available on integers of more than %d bytes.",
88 sizeof (unsigned LONGEST
));
90 /* Start at the most significant end of the integer, and work towards
91 the least significant. */
93 #if TARGET_BYTE_ORDER == BIG_ENDIAN
94 for (p
= startaddr
; p
< endaddr
; ++p
)
96 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
99 retval
= (retval
<< 8) | *p
;
105 extract_address (addr
, len
)
109 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
110 whether we want this to be true eventually. */
111 return extract_unsigned_integer (addr
, len
);
115 store_signed_integer (addr
, len
, val
)
121 unsigned char *startaddr
= (unsigned char *)addr
;
122 unsigned char *endaddr
= startaddr
+ len
;
124 /* Start at the least significant end of the integer, and work towards
125 the most significant. */
126 #if TARGET_BYTE_ORDER == BIG_ENDIAN
127 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
129 for (p
= startaddr
; p
< endaddr
; ++p
)
138 store_unsigned_integer (addr
, len
, val
)
141 unsigned LONGEST val
;
144 unsigned char *startaddr
= (unsigned char *)addr
;
145 unsigned char *endaddr
= startaddr
+ len
;
147 /* Start at the least significant end of the integer, and work towards
148 the most significant. */
149 #if TARGET_BYTE_ORDER == BIG_ENDIAN
150 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
152 for (p
= startaddr
; p
< endaddr
; ++p
)
161 store_address (addr
, len
, val
)
166 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
167 whether we want this to be true eventually. */
168 store_unsigned_integer (addr
, len
, (LONGEST
)val
);
171 #if !defined (GET_SAVED_REGISTER)
173 /* Return the address in which frame FRAME's value of register REGNUM
174 has been saved in memory. Or return zero if it has not been saved.
175 If REGNUM specifies the SP, the value we return is actually
176 the SP value, not an address where it was saved. */
179 find_saved_register (frame
, regnum
)
183 struct frame_info
*fi
;
184 struct frame_saved_regs saved_regs
;
186 register FRAME frame1
= 0;
187 register CORE_ADDR addr
= 0;
189 if (frame
== 0) /* No regs saved if want current frame */
192 #ifdef HAVE_REGISTER_WINDOWS
193 /* We assume that a register in a register window will only be saved
194 in one place (since the name changes and/or disappears as you go
195 towards inner frames), so we only call get_frame_saved_regs on
196 the current frame. This is directly in contradiction to the
197 usage below, which assumes that registers used in a frame must be
198 saved in a lower (more interior) frame. This change is a result
199 of working on a register window machine; get_frame_saved_regs
200 always returns the registers saved within a frame, within the
201 context (register namespace) of that frame. */
203 /* However, note that we don't want this to return anything if
204 nothing is saved (if there's a frame inside of this one). Also,
205 callers to this routine asking for the stack pointer want the
206 stack pointer saved for *this* frame; this is returned from the
210 if (REGISTER_IN_WINDOW_P(regnum
))
212 frame1
= get_next_frame (frame
);
213 if (!frame1
) return 0; /* Registers of this frame are
216 /* Get the SP from the next frame in; it will be this
218 if (regnum
!= SP_REGNUM
)
221 fi
= get_frame_info (frame1
);
222 get_frame_saved_regs (fi
, &saved_regs
);
223 return saved_regs
.regs
[regnum
]; /* ... which might be zero */
225 #endif /* HAVE_REGISTER_WINDOWS */
227 /* Note that this next routine assumes that registers used in
228 frame x will be saved only in the frame that x calls and
229 frames interior to it. This is not true on the sparc, but the
230 above macro takes care of it, so we should be all right. */
234 frame1
= get_prev_frame (frame1
);
235 if (frame1
== 0 || frame1
== frame
)
237 fi
= get_frame_info (frame1
);
238 get_frame_saved_regs (fi
, &saved_regs
);
239 if (saved_regs
.regs
[regnum
])
240 addr
= saved_regs
.regs
[regnum
];
246 /* Find register number REGNUM relative to FRAME and put its (raw,
247 target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
248 variable was optimized out (and thus can't be fetched). Set *LVAL
249 to lval_memory, lval_register, or not_lval, depending on whether
250 the value was fetched from memory, from a register, or in a strange
251 and non-modifiable way (e.g. a frame pointer which was calculated
252 rather than fetched). Set *ADDRP to the address, either in memory
253 on as a REGISTER_BYTE offset into the registers array.
255 Note that this implementation never sets *LVAL to not_lval. But
256 it can be replaced by defining GET_SAVED_REGISTER and supplying
259 The argument RAW_BUFFER must point to aligned memory. */
262 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
268 enum lval_type
*lval
;
271 /* Normal systems don't optimize out things with register numbers. */
272 if (optimized
!= NULL
)
274 addr
= find_saved_register (frame
, regnum
);
279 if (regnum
== SP_REGNUM
)
281 if (raw_buffer
!= NULL
)
283 /* Put it back in target format. */
284 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
), addr
);
290 if (raw_buffer
!= NULL
)
291 read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
296 *lval
= lval_register
;
297 addr
= REGISTER_BYTE (regnum
);
298 if (raw_buffer
!= NULL
)
299 read_register_gen (regnum
, raw_buffer
);
304 #endif /* GET_SAVED_REGISTER. */
306 /* Copy the bytes of register REGNUM, relative to the current stack frame,
307 into our memory at MYADDR, in target byte order.
308 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
310 Returns 1 if could not be read, 0 if could. */
313 read_relative_register_raw_bytes (regnum
, myaddr
)
318 if (regnum
== FP_REGNUM
&& selected_frame
)
320 /* Put it back in target format. */
321 store_address (myaddr
, REGISTER_RAW_SIZE(FP_REGNUM
),
322 FRAME_FP(selected_frame
));
326 get_saved_register (myaddr
, &optim
, (CORE_ADDR
*) NULL
, selected_frame
,
327 regnum
, (enum lval_type
*)NULL
);
331 /* Return a `value' with the contents of register REGNUM
332 in its virtual format, with the type specified by
333 REGISTER_VIRTUAL_TYPE. */
336 value_of_register (regnum
)
342 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
343 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
346 get_saved_register (raw_buffer
, &optim
, &addr
,
347 selected_frame
, regnum
, &lval
);
349 REGISTER_CONVERT_TO_VIRTUAL (regnum
, raw_buffer
, virtual_buffer
);
350 val
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
351 memcpy (VALUE_CONTENTS_RAW (val
), virtual_buffer
,
352 REGISTER_VIRTUAL_SIZE (regnum
));
353 VALUE_LVAL (val
) = lval
;
354 VALUE_ADDRESS (val
) = addr
;
355 VALUE_REGNO (val
) = regnum
;
356 VALUE_OPTIMIZED_OUT (val
) = optim
;
360 /* Low level examining and depositing of registers.
362 The caller is responsible for making
363 sure that the inferior is stopped before calling the fetching routines,
364 or it will get garbage. (a change from GDB version 3, in which
365 the caller got the value from the last stop). */
367 /* Contents of the registers in target byte order.
368 We allocate some extra slop since we do a lot of memcpy's around `registers',
369 and failing-soft is better than failing hard. */
370 char registers
[REGISTER_BYTES
+ /* SLOP */ 256];
372 /* Nonzero if that register has been fetched. */
373 char register_valid
[NUM_REGS
];
375 /* Indicate that registers may have changed, so invalidate the cache. */
380 for (i
= 0; i
< NUM_REGS
; i
++)
381 register_valid
[i
] = 0;
384 /* Indicate that all registers have been fetched, so mark them all valid. */
389 for (i
= 0; i
< NUM_REGS
; i
++)
390 register_valid
[i
] = 1;
393 /* Copy LEN bytes of consecutive data from registers
394 starting with the REGBYTE'th byte of register data
395 into memory at MYADDR. */
398 read_register_bytes (regbyte
, myaddr
, len
)
403 /* Fetch all registers. */
405 for (i
= 0; i
< NUM_REGS
; i
++)
406 if (!register_valid
[i
])
408 target_fetch_registers (-1);
412 memcpy (myaddr
, ®isters
[regbyte
], len
);
415 /* Read register REGNO into memory at MYADDR, which must be large enough
416 for REGISTER_RAW_BYTES (REGNO). Target byte-order.
417 If the register is known to be the size of a CORE_ADDR or smaller,
418 read_register can be used instead. */
420 read_register_gen (regno
, myaddr
)
424 if (!register_valid
[regno
])
425 target_fetch_registers (regno
);
426 memcpy (myaddr
, ®isters
[REGISTER_BYTE (regno
)],
427 REGISTER_RAW_SIZE (regno
));
430 /* Copy LEN bytes of consecutive data from memory at MYADDR
431 into registers starting with the REGBYTE'th byte of register data. */
434 write_register_bytes (regbyte
, myaddr
, len
)
439 /* Make sure the entire registers array is valid. */
440 read_register_bytes (0, (char *)NULL
, REGISTER_BYTES
);
441 memcpy (®isters
[regbyte
], myaddr
, len
);
442 target_store_registers (-1);
445 /* Return the raw contents of register REGNO, regarding it as an integer. */
446 /* This probably should be returning LONGEST rather than CORE_ADDR. */
449 read_register (regno
)
452 if (!register_valid
[regno
])
453 target_fetch_registers (regno
);
455 return extract_address (®isters
[REGISTER_BYTE (regno
)],
456 REGISTER_RAW_SIZE(regno
));
459 /* Registers we shouldn't try to store. */
460 #if !defined (CANNOT_STORE_REGISTER)
461 #define CANNOT_STORE_REGISTER(regno) 0
464 /* Store VALUE, into the raw contents of register number REGNO. */
465 /* FIXME: The val arg should probably be a LONGEST. */
468 write_register (regno
, val
)
475 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
476 the registers array if something writes to this register. */
477 if (CANNOT_STORE_REGISTER (regno
))
480 size
= REGISTER_RAW_SIZE(regno
);
482 store_signed_integer (buf
, size
, (LONGEST
) val
);
484 /* If we have a valid copy of the register, and new value == old value,
485 then don't bother doing the actual store. */
487 if (register_valid
[regno
])
489 if (memcmp (®isters
[REGISTER_BYTE (regno
)], buf
, size
) == 0)
493 target_prepare_to_store ();
495 memcpy (®isters
[REGISTER_BYTE (regno
)], buf
, size
);
497 register_valid
[regno
] = 1;
499 target_store_registers (regno
);
502 /* Record that register REGNO contains VAL.
503 This is used when the value is obtained from the inferior or core dump,
504 so there is no need to store the value there. */
507 supply_register (regno
, val
)
511 register_valid
[regno
] = 1;
512 memcpy (®isters
[REGISTER_BYTE (regno
)], val
, REGISTER_RAW_SIZE (regno
));
514 /* On some architectures, e.g. HPPA, there are a few stray bits in some
515 registers, that the rest of the code would like to ignore. */
516 #ifdef CLEAN_UP_REGISTER_VALUE
517 CLEAN_UP_REGISTER_VALUE(regno
, ®isters
[REGISTER_BYTE(regno
)]);
521 /* Given a struct symbol for a variable,
522 and a stack frame id, read the value of the variable
523 and return a (pointer to a) struct value containing the value.
524 If the variable cannot be found, return a zero pointer.
525 If FRAME is NULL, use the selected_frame. */
528 read_var_value (var
, frame
)
529 register struct symbol
*var
;
533 struct frame_info
*fi
;
534 struct type
*type
= SYMBOL_TYPE (var
);
538 v
= allocate_value (type
);
539 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
540 len
= TYPE_LENGTH (type
);
542 if (frame
== 0) frame
= selected_frame
;
544 switch (SYMBOL_CLASS (var
))
547 /* Put the constant back in target format. */
548 store_signed_integer (VALUE_CONTENTS_RAW (v
), len
,
549 (LONGEST
) SYMBOL_VALUE (var
));
550 VALUE_LVAL (v
) = not_lval
;
554 /* Put the constant back in target format. */
555 store_address (VALUE_CONTENTS_RAW (v
), len
, SYMBOL_VALUE_ADDRESS (var
));
556 VALUE_LVAL (v
) = not_lval
;
559 case LOC_CONST_BYTES
:
562 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
563 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
564 VALUE_LVAL (v
) = not_lval
;
569 addr
= SYMBOL_VALUE_ADDRESS (var
);
573 fi
= get_frame_info (frame
);
576 addr
= FRAME_ARGS_ADDRESS (fi
);
581 addr
+= SYMBOL_VALUE (var
);
585 fi
= get_frame_info (frame
);
588 addr
= FRAME_ARGS_ADDRESS (fi
);
593 addr
+= SYMBOL_VALUE (var
);
594 addr
= read_memory_unsigned_integer
595 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
600 fi
= get_frame_info (frame
);
603 addr
= FRAME_LOCALS_ADDRESS (fi
);
604 addr
+= SYMBOL_VALUE (var
);
608 case LOC_BASEREG_ARG
:
610 char buf
[MAX_REGISTER_RAW_SIZE
];
611 get_saved_register (buf
, NULL
, NULL
, frame
, SYMBOL_BASEREG (var
),
613 addr
= extract_address (buf
, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var
)));
614 addr
+= SYMBOL_VALUE (var
);
619 error ("Cannot look up value of a typedef");
623 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
628 case LOC_REGPARM_ADDR
:
634 b
= get_frame_block (frame
);
636 v
= value_from_register (type
, SYMBOL_VALUE (var
), frame
);
638 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
640 addr
= *(CORE_ADDR
*)VALUE_CONTENTS (v
);
641 VALUE_LVAL (v
) = lval_memory
;
648 case LOC_OPTIMIZED_OUT
:
649 VALUE_LVAL (v
) = not_lval
;
650 VALUE_OPTIMIZED_OUT (v
) = 1;
654 error ("Cannot look up value of a botched symbol.");
658 VALUE_ADDRESS (v
) = addr
;
663 /* Return a value of type TYPE, stored in register REGNUM, in frame
667 value_from_register (type
, regnum
, frame
)
672 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
673 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
676 value v
= allocate_value (type
);
677 int len
= TYPE_LENGTH (type
);
678 char *value_bytes
= 0;
679 int value_bytes_copied
= 0;
680 int num_storage_locs
;
683 VALUE_REGNO (v
) = regnum
;
685 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
686 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
689 if (num_storage_locs
> 1
690 #ifdef GDB_TARGET_IS_H8500
691 || TYPE_CODE (type
) == TYPE_CODE_PTR
695 /* Value spread across multiple storage locations. */
698 int mem_stor
= 0, reg_stor
= 0;
699 int mem_tracking
= 1;
700 CORE_ADDR last_addr
= 0;
701 CORE_ADDR first_addr
= 0;
703 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
705 /* Copy all of the data out, whereever it may be. */
707 #ifdef GDB_TARGET_IS_H8500
708 /* This piece of hideosity is required because the H8500 treats registers
709 differently depending upon whether they are used as pointers or not. As a
710 pointer, a register needs to have a page register tacked onto the front.
711 An alternate way to do this would be to have gcc output different register
712 numbers for the pointer & non-pointer form of the register. But, it
713 doesn't, so we're stuck with this. */
715 if (TYPE_CODE (type
) == TYPE_CODE_PTR
722 case R0_REGNUM
: case R1_REGNUM
: case R2_REGNUM
: case R3_REGNUM
:
723 page_regnum
= SEG_D_REGNUM
;
725 case R4_REGNUM
: case R5_REGNUM
:
726 page_regnum
= SEG_E_REGNUM
;
728 case R6_REGNUM
: case R7_REGNUM
:
729 page_regnum
= SEG_T_REGNUM
;
734 get_saved_register (value_bytes
+ 1,
741 if (lval
== lval_register
)
748 get_saved_register (value_bytes
+ 2,
755 if (lval
== lval_register
)
760 mem_tracking
= mem_tracking
&& (addr
== last_addr
);
765 #endif /* GDB_TARGET_IS_H8500 */
766 for (local_regnum
= regnum
;
767 value_bytes_copied
< len
;
768 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
771 get_saved_register (value_bytes
+ value_bytes_copied
,
778 if (regnum
== local_regnum
)
780 if (lval
== lval_register
)
788 && (regnum
== local_regnum
789 || addr
== last_addr
));
794 if ((reg_stor
&& mem_stor
)
795 || (mem_stor
&& !mem_tracking
))
796 /* Mixed storage; all of the hassle we just went through was
797 for some good purpose. */
799 VALUE_LVAL (v
) = lval_reg_frame_relative
;
800 VALUE_FRAME (v
) = FRAME_FP (frame
);
801 VALUE_FRAME_REGNUM (v
) = regnum
;
805 VALUE_LVAL (v
) = lval_memory
;
806 VALUE_ADDRESS (v
) = first_addr
;
810 VALUE_LVAL (v
) = lval_register
;
811 VALUE_ADDRESS (v
) = first_addr
;
814 fatal ("value_from_register: Value not stored anywhere!");
816 VALUE_OPTIMIZED_OUT (v
) = optim
;
818 /* Any structure stored in more than one register will always be
819 an integral number of registers. Otherwise, you'd need to do
820 some fiddling with the last register copied here for little
823 /* Copy into the contents section of the value. */
824 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
826 /* Finally do any conversion necessary when extracting this
827 type from more than one register. */
828 #ifdef REGISTER_CONVERT_TO_TYPE
829 REGISTER_CONVERT_TO_TYPE(regnum
, type
, VALUE_CONTENTS_RAW(v
));
834 /* Data is completely contained within a single register. Locate the
835 register's contents in a real register or in core;
836 read the data in raw format. */
838 get_saved_register (raw_buffer
, &optim
, &addr
, frame
, regnum
, &lval
);
839 VALUE_OPTIMIZED_OUT (v
) = optim
;
840 VALUE_LVAL (v
) = lval
;
841 VALUE_ADDRESS (v
) = addr
;
843 /* Convert the raw contents to virtual contents.
844 (Just copy them if the formats are the same.) */
846 REGISTER_CONVERT_TO_VIRTUAL (regnum
, raw_buffer
, virtual_buffer
);
848 if (REGISTER_CONVERTIBLE (regnum
))
850 /* When the raw and virtual formats differ, the virtual format
851 corresponds to a specific data type. If we want that type,
852 copy the data into the value.
853 Otherwise, do a type-conversion. */
855 if (type
!= REGISTER_VIRTUAL_TYPE (regnum
))
857 /* eg a variable of type `float' in a 68881 register
858 with raw type `extended' and virtual type `double'.
859 Fetch it as a `double' and then convert to `float'. */
860 v
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
861 memcpy (VALUE_CONTENTS_RAW (v
), virtual_buffer
, len
);
862 v
= value_cast (type
, v
);
865 memcpy (VALUE_CONTENTS_RAW (v
), virtual_buffer
, len
);
869 /* Raw and virtual formats are the same for this register. */
871 #if TARGET_BYTE_ORDER == BIG_ENDIAN
872 if (len
< REGISTER_RAW_SIZE (regnum
))
874 /* Big-endian, and we want less than full size. */
875 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
879 memcpy (VALUE_CONTENTS_RAW (v
), virtual_buffer
+ VALUE_OFFSET (v
), len
);
885 /* Given a struct symbol for a variable or function,
886 and a stack frame id,
887 return a (pointer to a) struct value containing the properly typed
891 locate_var_value (var
, frame
)
892 register struct symbol
*var
;
896 struct type
*type
= SYMBOL_TYPE (var
);
899 /* Evaluate it first; if the result is a memory address, we're fine.
900 Lazy evaluation pays off here. */
902 lazy_value
= read_var_value (var
, frame
);
904 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
906 if (VALUE_LAZY (lazy_value
)
907 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
909 addr
= VALUE_ADDRESS (lazy_value
);
910 return value_from_longest (lookup_pointer_type (type
), (LONGEST
) addr
);
913 /* Not a memory address; check what the problem was. */
914 switch (VALUE_LVAL (lazy_value
))
917 case lval_reg_frame_relative
:
918 error ("Address requested for identifier \"%s\" which is in a register.",
919 SYMBOL_SOURCE_NAME (var
));
923 error ("Can't take address of \"%s\" which isn't an lvalue.",
924 SYMBOL_SOURCE_NAME (var
));
927 return 0; /* For lint -- never reached */