/usr/src/gnu/usr.bin/binutils/gdb/f-valprint.c

Bug Summary

File:	src/gnu/usr.bin/binutils/gdb/f-valprint.c
Warning:	line 608, column 11 Null pointer passed as 2nd argument to string comparison function

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name f-valprint.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -resource-dir /usr/local/lib/clang/13.0.0 -D PIE_DEFAULT=1 -I . -I /usr/src/gnu/usr.bin/binutils/gdb -I /usr/src/gnu/usr.bin/binutils/gdb/config -D LOCALEDIR="/usr/share/locale" -D HAVE_CONFIG_H -I /usr/src/gnu/usr.bin/binutils/gdb/../include/opcode -I ../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../include -I ../intl -I /usr/src/gnu/usr.bin/binutils/gdb/../intl -D MI_OUT=1 -D TUI=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -fcommon -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils/gdb/f-valprint.c

1/* Support for printing Fortran values for GDB, the GNU debugger.
 Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2003
 Free Software Foundation, Inc.
 Contributed by Motorola.  Adapted from the C definitions by Farooq Butt
 (fmbutt@engage.sps.mot.com), additionally worked over by Stan Shebs.

 This file is part of GDB.

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */

24#include "defs.h"
25#include "gdb_string.h"
26#include "symtab.h"
27#include "gdbtypes.h"
28#include "expression.h"
29#include "value.h"
30#include "valprint.h"
31#include "language.h"
32#include "f-lang.h"
33#include "frame.h"
34#include "gdbcore.h"
35#include "command.h"
36#include "block.h"

38#if 0
39static int there_is_a_visible_common_named (char *);
40#endif

42extern void _initialize_f_valprint (void);
43static void info_common_command (char *, int);
44static void list_all_visible_commons (char *);
45static void f77_print_array (struct type *, char *, CORE_ADDR,
	     struct ui_file *, int, int, int,
	     enum val_prettyprint);
48static void f77_print_array_1 (int, int, struct type *, char *,
	       CORE_ADDR, struct ui_file *, int, int, int,
	       enum val_prettyprint,
	       int *elts);
52static void f77_create_arrayprint_offset_tbl (struct type *,
			      struct ui_file *);
54static void f77_get_dynamic_length_of_aggregate (struct type *);

56int f77_array_offset_tbl[MAX_FORTRAN_DIMS7 + 1][2];

58/* Array which holds offsets to be applied to get a row's elements
 for a given array. Array also holds the size of each subarray.  */

61/* The following macro gives us the size of the nth dimension, Where 
 n is 1 based. */

64#define F77_DIM_SIZE(n)(f77_array_offset_tbl[n][1]) (f77_array_offset_tbl[n][1])

66/* The following gives us the offset for row n where n is 1-based. */

68#define F77_DIM_OFFSET(n)(f77_array_offset_tbl[n][0]) (f77_array_offset_tbl[n][0])

70int
71f77_get_dynamic_lowerbound (struct type *type, int *lower_bound)
72{
CORE_ADDR current_frame_addr;
CORE_ADDR ptr_to_lower_bound;

switch (TYPE_ARRAY_LOWER_BOUND_TYPE (type)(type)->main_type->lower_bound_type)
  {
  case BOUND_BY_VALUE_ON_STACK:
    current_frame_addr = get_frame_base (deprecated_selected_frame);
    if (current_frame_addr > 0)
{
 *lower_bound =
   read_memory_integer (current_frame_addr +
		 TYPE_ARRAY_LOWER_BOUND_VALUE (type)(((((((((type))->main_type->fields[0]).type)))->main_type
->fields[0]).loc.bitpos)),
		 4);
}
    else
{
 *lower_bound = DEFAULT_LOWER_BOUND-999999;
 return BOUND_FETCH_ERROR-999;
}
    break;

  case BOUND_SIMPLE:
    *lower_bound = TYPE_ARRAY_LOWER_BOUND_VALUE (type)(((((((((type))->main_type->fields[0]).type)))->main_type
->fields[0]).loc.bitpos));
    break;

  case BOUND_CANNOT_BE_DETERMINED:
    error ("Lower bound may not be '*' in F77");
    break;

  case BOUND_BY_REF_ON_STACK:
    current_frame_addr = get_frame_base (deprecated_selected_frame);
    if (current_frame_addr > 0)
{
 ptr_to_lower_bound =
   read_memory_typed_address (current_frame_addr +
		       TYPE_ARRAY_LOWER_BOUND_VALUE (type)(((((((((type))->main_type->fields[0]).type)))->main_type
->fields[0]).loc.bitpos)),
		       builtin_type_void_data_ptr);
 *lower_bound = read_memory_integer (ptr_to_lower_bound, 4);
}
    else
{
 *lower_bound = DEFAULT_LOWER_BOUND-999999;
 return BOUND_FETCH_ERROR-999;
}
    break;

  case BOUND_BY_REF_IN_REG:
  case BOUND_BY_VALUE_IN_REG:
  default:
    error ("??? unhandled dynamic array bound type ???");
    break;
  }
return BOUND_FETCH_OK1;
126}

128int
129f77_get_dynamic_upperbound (struct type *type, int *upper_bound)
130{
CORE_ADDR current_frame_addr = 0;
CORE_ADDR ptr_to_upper_bound;

switch (TYPE_ARRAY_UPPER_BOUND_TYPE (type)(type)->main_type->upper_bound_type)
  {
  case BOUND_BY_VALUE_ON_STACK:
    current_frame_addr = get_frame_base (deprecated_selected_frame);
    if (current_frame_addr > 0)
{
 *upper_bound =
   read_memory_integer (current_frame_addr +
		 TYPE_ARRAY_UPPER_BOUND_VALUE (type)(((((((((type))->main_type->fields[0]).type)))->main_type
->fields[1]).loc.bitpos)),
		 4);
}
    else
{
 *upper_bound = DEFAULT_UPPER_BOUND999999;
 return BOUND_FETCH_ERROR-999;
}
    break;

  case BOUND_SIMPLE:
    *upper_bound = TYPE_ARRAY_UPPER_BOUND_VALUE (type)(((((((((type))->main_type->fields[0]).type)))->main_type
->fields[1]).loc.bitpos));
    break;

  case BOUND_CANNOT_BE_DETERMINED:
    /* we have an assumed size array on our hands. Assume that 
       upper_bound == lower_bound so that we show at least 
       1 element.If the user wants to see more elements, let 
       him manually ask for 'em and we'll subscript the 
       array and show him */
    f77_get_dynamic_lowerbound (type, upper_bound);
    break;

  case BOUND_BY_REF_ON_STACK:
    current_frame_addr = get_frame_base (deprecated_selected_frame);
    if (current_frame_addr > 0)
{
 ptr_to_upper_bound =
   read_memory_typed_address (current_frame_addr +
		       TYPE_ARRAY_UPPER_BOUND_VALUE (type)(((((((((type))->main_type->fields[0]).type)))->main_type
->fields[1]).loc.bitpos)),
		       builtin_type_void_data_ptr);
 *upper_bound = read_memory_integer (ptr_to_upper_bound, 4);
}
    else
{
 *upper_bound = DEFAULT_UPPER_BOUND999999;
 return BOUND_FETCH_ERROR-999;
}
    break;

  case BOUND_BY_REF_IN_REG:
  case BOUND_BY_VALUE_IN_REG:
  default:
    error ("??? unhandled dynamic array bound type ???");
    break;
  }
return BOUND_FETCH_OK1;
189}

191/* Obtain F77 adjustable array dimensions */

193static void
194f77_get_dynamic_length_of_aggregate (struct type *type)
195{
int upper_bound = -1;
int lower_bound = 1;
int retcode;

/* Recursively go all the way down into a possibly multi-dimensional
   F77 array and get the bounds.  For simple arrays, this is pretty
   easy but when the bounds are dynamic, we must be very careful 
   to add up all the lengths correctly.  Not doing this right 
   will lead to horrendous-looking arrays in parameter lists.

   This function also works for strings which behave very 
   similarly to arrays.  */

if (TYPE_CODE (TYPE_TARGET_TYPE (type))((type)->main_type->target_type)->main_type->code == TYPE_CODE_ARRAY
    || TYPE_CODE (TYPE_TARGET_TYPE (type))((type)->main_type->target_type)->main_type->code == TYPE_CODE_STRING)
  f77_get_dynamic_length_of_aggregate (TYPE_TARGET_TYPE (type)(type)->main_type->target_type);

/* Recursion ends here, start setting up lengths.  */
retcode = f77_get_dynamic_lowerbound (type, &lower_bound);
if (retcode == BOUND_FETCH_ERROR-999)
  error ("Cannot obtain valid array lower bound");

retcode = f77_get_dynamic_upperbound (type, &upper_bound);
if (retcode == BOUND_FETCH_ERROR-999)
  error ("Cannot obtain valid array upper bound");

/* Patch in a valid length value. */

TYPE_LENGTH (type)(type)->length =
  (upper_bound - lower_bound + 1) * TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type)))(check_typedef ((type)->main_type->target_type))->length;
226}

228/* Function that sets up the array offset,size table for the array 
 type "type".  */

231static void
232f77_create_arrayprint_offset_tbl (struct type *type, struct ui_file *stream)
233{
struct type *tmp_type;
int eltlen;
int ndimen = 1;
int upper, lower, retcode;

tmp_type = type;

while ((TYPE_CODE (tmp_type)(tmp_type)->main_type->code == TYPE_CODE_ARRAY))
  {
    if (TYPE_ARRAY_UPPER_BOUND_TYPE (tmp_type)(tmp_type)->main_type->upper_bound_type == BOUND_CANNOT_BE_DETERMINED)
fprintf_filtered (stream, "<assumed size array> ");

    retcode = f77_get_dynamic_upperbound (tmp_type, &upper);
    if (retcode == BOUND_FETCH_ERROR-999)
error ("Cannot obtain dynamic upper bound");

    retcode = f77_get_dynamic_lowerbound (tmp_type, &lower);
    if (retcode == BOUND_FETCH_ERROR-999)
error ("Cannot obtain dynamic lower bound");

    F77_DIM_SIZE (ndimen)(f77_array_offset_tbl[ndimen][1]) = upper - lower + 1;

    tmp_type = TYPE_TARGET_TYPE (tmp_type)(tmp_type)->main_type->target_type;
    ndimen++;
  }

/* Now we multiply eltlen by all the offsets, so that later we 
   can print out array elements correctly.  Up till now we 
   know an offset to apply to get the item but we also 
   have to know how much to add to get to the next item */

ndimen--;
eltlen = TYPE_LENGTH (tmp_type)(tmp_type)->length;
F77_DIM_OFFSET (ndimen)(f77_array_offset_tbl[ndimen][0]) = eltlen;
while (--ndimen > 0)
  {
    eltlen *= F77_DIM_SIZE (ndimen + 1)(f77_array_offset_tbl[ndimen + 1][1]);
    F77_DIM_OFFSET (ndimen)(f77_array_offset_tbl[ndimen][0]) = eltlen;
  }
273}



277/* Actual function which prints out F77 arrays, Valaddr == address in 
 the superior.  Address == the address in the inferior.  */

280static void
281f77_print_array_1 (int nss, int ndimensions, struct type *type, char *valaddr,
   CORE_ADDR address, struct ui_file *stream, int format,
   int deref_ref, int recurse, enum val_prettyprint pretty,
   int *elts)
285{
int i;

if (nss != ndimensions)
  {
    for (i = 0; (i < F77_DIM_SIZE (nss)(f77_array_offset_tbl[nss][1]) && (*elts) < print_max); i++)
{
 fprintf_filtered (stream, "( ");
 f77_print_array_1 (nss + 1, ndimensions, TYPE_TARGET_TYPE (type)(type)->main_type->target_type,
	     valaddr + i * F77_DIM_OFFSET (nss)(f77_array_offset_tbl[nss][0]),
	     address + i * F77_DIM_OFFSET (nss)(f77_array_offset_tbl[nss][0]),
	     stream, format, deref_ref, recurse, pretty, elts);
 fprintf_filtered (stream, ") ");
}
    if (*elts >= print_max && i < F77_DIM_SIZE (nss)(f77_array_offset_tbl[nss][1])) 
fprintf_filtered (stream, "...");
  }
else
  {
    for (i = 0; i < F77_DIM_SIZE (nss)(f77_array_offset_tbl[nss][1]) && (*elts) < print_max; 
  i++, (*elts)++)
{
 val_print (TYPE_TARGET_TYPE (type)(type)->main_type->target_type,
     valaddr + i * F77_DIM_OFFSET (ndimensions)(f77_array_offset_tbl[ndimensions][0]),
     0,
     address + i * F77_DIM_OFFSET (ndimensions)(f77_array_offset_tbl[ndimensions][0]),
     stream, format, deref_ref, recurse, pretty);

 if (i != (F77_DIM_SIZE (nss)(f77_array_offset_tbl[nss][1]) - 1))
   fprintf_filtered (stream, ", ");

 if ((*elts == print_max - 1) && (i != (F77_DIM_SIZE (nss)(f77_array_offset_tbl[nss][1]) - 1)))
   fprintf_filtered (stream, "...");
}
  }
320}

322/* This function gets called to print an F77 array, we set up some 
 stuff and then immediately call f77_print_array_1() */

325static void
326f77_print_array (struct type *type, char *valaddr, CORE_ADDR address,
 struct ui_file *stream, int format, int deref_ref, int recurse,
 enum val_prettyprint pretty)
329{
int ndimensions;
int elts = 0;

ndimensions = calc_f77_array_dims (type);

if (ndimensions > MAX_FORTRAN_DIMS7 || ndimensions < 0)
  error ("Type node corrupt! F77 arrays cannot have %d subscripts (%d Max)",
  ndimensions, MAX_FORTRAN_DIMS7);

/* Since F77 arrays are stored column-major, we set up an 
   offset table to get at the various row's elements. The 
   offset table contains entries for both offset and subarray size. */

f77_create_arrayprint_offset_tbl (type, stream);

f77_print_array_1 (1, ndimensions, type, valaddr, address, stream, format,
     deref_ref, recurse, pretty, &elts);
347}
348

350/* Print data of type TYPE located at VALADDR (within GDB), which came from
 the inferior at address ADDRESS, onto stdio stream STREAM according to
 FORMAT (a letter or 0 for natural format).  The data at VALADDR is in
 target byte order.

 If the data are a string pointer, returns the number of string characters
 printed.

 If DEREF_REF is nonzero, then dereference references, otherwise just print
 them like pointers.

 The PRETTY parameter controls prettyprinting.  */

363int
364f_val_print (struct type *type, char *valaddr, int embedded_offset,
    CORE_ADDR address, struct ui_file *stream, int format,
    int deref_ref, int recurse, enum val_prettyprint pretty)
367{
unsigned int i = 0;	/* Number of characters printed */
struct type *elttype;
LONGESTlong val;
CORE_ADDR addr;

CHECK_TYPEDEF (type)(type) = check_typedef (type);
switch (TYPE_CODE (type)(type)->main_type->code)
  {
  case TYPE_CODE_STRING:
    f77_get_dynamic_length_of_aggregate (type);
    LA_PRINT_STRING (stream, valaddr, TYPE_LENGTH (type), 1, 0)(current_language->la_printstr(stream, valaddr, (type)->
length, 1, 0));
    break;

  case TYPE_CODE_ARRAY:
    fprintf_filtered (stream, "(");
    f77_print_array (type, valaddr, address, stream, format,
       deref_ref, recurse, pretty);
    fprintf_filtered (stream, ")");
    break;

  case TYPE_CODE_PTR:
    if (format && format != 's')
{
 print_scalar_formatted (valaddr, type, format, 0, stream);
 break;
}
    else
{
 addr = unpack_pointer (type, valaddr);
 elttype = check_typedef (TYPE_TARGET_TYPE (type)(type)->main_type->target_type);

 if (TYPE_CODE (elttype)(elttype)->main_type->code == TYPE_CODE_FUNC)
   {
     /* Try to print what function it points to.  */
     print_address_demangle (addr, stream, demangle);
     /* Return value is irrelevant except for string pointers.  */
     return 0;
   }

 if (addressprint && format != 's')
   print_address_numeric (addr, 1, stream);

 /* For a pointer to char or unsigned char, also print the string
    pointed to, unless pointer is null.  */
 if (TYPE_LENGTH (elttype)(elttype)->length == 1
     && TYPE_CODE (elttype)(elttype)->main_type->code == TYPE_CODE_INT
     && (format == 0 || format == 's')
     && addr != 0)
   i = val_print_string (addr, -1, TYPE_LENGTH (elttype)(elttype)->length, stream);

 /* Return number of characters printed, including the terminating
    '\0' if we reached the end.  val_print_string takes care including
    the terminating '\0' if necessary.  */
 return i;
}
    break;

  case TYPE_CODE_REF:
    elttype = check_typedef (TYPE_TARGET_TYPE (type)(type)->main_type->target_type);
    if (addressprint)
{
 CORE_ADDR addr
   = extract_typed_address (valaddr + embedded_offset, type);
 fprintf_filtered (stream, "@");
 print_address_numeric (addr, 1, stream);
 if (deref_ref)
   fputs_filtered (": ", stream);
}
    /* De-reference the reference.  */
    if (deref_ref)
{
 if (TYPE_CODE (elttype)(elttype)->main_type->code != TYPE_CODE_UNDEF)
   {
     struct value *deref_val =
     value_at
     (TYPE_TARGET_TYPE (type)(type)->main_type->target_type,
      unpack_pointer (lookup_pointer_type (builtin_type_void),
	       valaddr + embedded_offset),
      NULL((void*)0));
     val_print (VALUE_TYPE (deref_val)(deref_val)->type,
	 VALUE_CONTENTS (deref_val)((void)((deref_val)->lazy && value_fetch_lazy(deref_val
)), ((char *) (deref_val)->aligner.contents + (deref_val)->
embedded_offset)),
	 0,
	 VALUE_ADDRESS (deref_val)(deref_val)->location.address,
	 stream,
	 format,
	 deref_ref,
	 recurse,
	 pretty);
   }
 else
   fputs_filtered ("???", stream);
}
    break;

  case TYPE_CODE_FUNC:
    if (format)
{
 print_scalar_formatted (valaddr, type, format, 0, stream);
 break;
}
    /* FIXME, we should consider, at least for ANSI C language, eliminating
       the distinction made between FUNCs and POINTERs to FUNCs.  */
    fprintf_filtered (stream, "{");
    type_print (type, "", stream, -1);
    fprintf_filtered (stream, "} ");
    /* Try to print what function it points to, and its address.  */
    print_address_demangle (address, stream, demangle);
    break;

  case TYPE_CODE_INT:
    format = format ? format : output_format;
    if (format)
print_scalar_formatted (valaddr, type, format, 0, stream);
    else
{
 val_print_type_code_int (type, valaddr, stream);
 /* C and C++ has no single byte int type, char is used instead.
    Since we don't know whether the value is really intended to
    be used as an integer or a character, print the character
    equivalent as well. */
 if (TYPE_LENGTH (type)(type)->length == 1)
   {
     fputs_filtered (" ", stream);
     LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr),(current_language->la_printchar((unsigned char) unpack_long
 (type, valaddr), stream))
	     stream)(current_language->la_printchar((unsigned char) unpack_long
 (type, valaddr), stream));
   }
}
    break;

  case TYPE_CODE_FLT:
    if (format)
print_scalar_formatted (valaddr, type, format, 0, stream);
    else
print_floating (valaddr, type, stream);
    break;

  case TYPE_CODE_VOID:
    fprintf_filtered (stream, "VOID");
    break;

  case TYPE_CODE_ERROR:
    fprintf_filtered (stream, "<error type>");
    break;

  case TYPE_CODE_RANGE:
    /* FIXME, we should not ever have to print one of these yet.  */
    fprintf_filtered (stream, "<range type>");
    break;

  case TYPE_CODE_BOOL:
    format = format ? format : output_format;
    if (format)
print_scalar_formatted (valaddr, type, format, 0, stream);
    else
{
 val = 0;
 switch (TYPE_LENGTH (type)(type)->length)
   {
   case 1:
     val = unpack_long (builtin_type_f_logical_s1, valaddr);
     break;

   case 2:
     val = unpack_long (builtin_type_f_logical_s2, valaddr);
     break;

   case 4:
     val = unpack_long (builtin_type_f_logical, valaddr);
     break;

   default:
     error ("Logicals of length %d bytes not supported",
     TYPE_LENGTH (type)(type)->length);

   }

 if (val == 0)
   fprintf_filtered (stream, ".FALSE.");
 else if (val == 1)
   fprintf_filtered (stream, ".TRUE.");
 else
   /* Not a legitimate logical type, print as an integer.  */
   {
     /* Bash the type code temporarily.  */
     TYPE_CODE (type)(type)->main_type->code = TYPE_CODE_INT;
     f_val_print (type, valaddr, 0, address, stream, format,
	   deref_ref, recurse, pretty);
     /* Restore the type code so later uses work as intended. */
     TYPE_CODE (type)(type)->main_type->code = TYPE_CODE_BOOL;
   }
}
    break;

  case TYPE_CODE_COMPLEX:
    switch (TYPE_LENGTH (type)(type)->length)
{
case 8:
 type = builtin_type_f_real;
 break;
case 16:
 type = builtin_type_f_real_s8;
 break;
case 32:
 type = builtin_type_f_real_s16;
 break;
default:
 error ("Cannot print out complex*%d variables", TYPE_LENGTH (type)(type)->length);
}
    fputs_filtered ("(", stream);
    print_floating (valaddr, type, stream);
    fputs_filtered (",", stream);
    print_floating (valaddr + TYPE_LENGTH (type)(type)->length, type, stream);
    fputs_filtered (")", stream);
    break;

  case TYPE_CODE_UNDEF:
    /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
       dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
       and no complete type for struct foo in that file.  */
    fprintf_filtered (stream, "<incomplete type>");
    break;

  default:
    error ("Invalid F77 type code %d in symbol table.", TYPE_CODE (type)(type)->main_type->code);
  }
gdb_flush (stream);
return 0;
595}

597static void
598list_all_visible_commons (char *funname)
599{
SAVED_F77_COMMON_PTR tmp;

tmp = head_common_list;

printf_filtered ("All COMMON blocks visible at this level:\n\n");

while (tmp != NULL((void*)0))
12
←
Assuming 'tmp' is not equal to NULL→
13
←
Loop condition is true.  Entering loop body→
  {
    if (strcmp (tmp->owning_function, funname) == 0)
14
←
Null pointer passed as 2nd argument to string comparison function
printf_filtered ("%s\n", tmp->name);

    tmp = tmp->next;
  }
613}

615/* This function is used to print out the values in a given COMMON 
 block. It will always use the most local common block of the 
 given name */

619static void
620info_common_command (char *comname, int from_tty)
621{
SAVED_F77_COMMON_PTR the_common;
COMMON_ENTRY_PTR entry;
struct frame_info *fi;
char *funname = 0;
1
'funname' initialized to a null pointer value→
struct symbol *func;

/* We have been told to display the contents of F77 COMMON 
   block supposedly visible in this function.  Let us 
   first make sure that it is visible and if so, let 
   us display its contents */

fi = deprecated_selected_frame;

if (fi == NULL((void*)0))
2
←
Assuming 'fi' is not equal to NULL→
3
←
Taking false branch→
  error ("No frame selected");

/* The following is generally ripped off from stack.c's routine 
   print_frame_info() */

func = find_pc_function (get_frame_pc (fi));
if (func)
4
←
Assuming 'func' is null→
5
←
Taking false branch→
  {
    /* In certain pathological cases, the symtabs give the wrong
       function (when we are in the first function in a file which
       is compiled without debugging symbols, the previous function
       is compiled with debugging symbols, and the "foo.o" symbol
       that is supposed to tell us where the file with debugging symbols
       ends has been truncated by ar because it is longer than 15
       characters).

       So look in the minimal symbol tables as well, and if it comes
       up with a larger address for the function use that instead.
       I don't think this can ever cause any problems; there shouldn't
       be any minimal symbols in the middle of a function.
       FIXME:  (Not necessarily true.  What about text labels) */

    struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));

    if (msymbol != NULL((void*)0)
 && (SYMBOL_VALUE_ADDRESS (msymbol)(msymbol)->ginfo.value.address
     > BLOCK_START (SYMBOL_BLOCK_VALUE (func))((func)->ginfo.value.block)->startaddr))
funname = DEPRECATED_SYMBOL_NAME (msymbol)(msymbol)->ginfo.name;
    else
funname = DEPRECATED_SYMBOL_NAME (func)(func)->ginfo.name;
  }
else
  {
    struct minimal_symbol *msymbol =
    lookup_minimal_symbol_by_pc (get_frame_pc (fi));

    if (msymbol != NULL((void*)0))
6
←
Assuming 'msymbol' is equal to NULL→
7
←
Taking false branch→
funname = DEPRECATED_SYMBOL_NAME (msymbol)(msymbol)->ginfo.name;
  }

/* If comname is NULL, we assume the user wishes to see the 
   which COMMON blocks are visible here and then return */

if (comname == 0)
8
←
Assuming 'comname' is equal to null→
9
←
Taking true branch→
  {
    list_all_visible_commons (funname);
10
←
Passing null pointer value via 1st parameter 'funname'→
11
←
Calling 'list_all_visible_commons'→
    return;
  }

the_common = find_common_for_function (comname, funname);

if (the_common)
  {
    if (strcmp (comname, BLANK_COMMON_NAME_LOCAL"__BLANK") == 0)
printf_filtered ("Contents of blank COMMON block:\n");
    else
printf_filtered ("Contents of F77 COMMON block '%s':\n", comname);

    printf_filtered ("\n");
    entry = the_common->entries;

    while (entry != NULL((void*)0))
{
 printf_filtered ("%s = ", DEPRECATED_SYMBOL_NAME (entry->symbol)(entry->symbol)->ginfo.name);
 print_variable_value (entry->symbol, fi, gdb_stdout);
 printf_filtered ("\n");
 entry = entry->next;
}
  }
else
  printf_filtered ("Cannot locate the common block %s in function '%s'\n",
     comname, funname);
708}

710/* This function is used to determine whether there is a
 F77 common block visible at the current scope called 'comname'. */

713#if 0
714static int
715there_is_a_visible_common_named (char *comname)
716{
SAVED_F77_COMMON_PTR the_common;
struct frame_info *fi;
char *funname = 0;
struct symbol *func;

if (comname == NULL((void*)0))
  error ("Cannot deal with NULL common name!");

fi = deprecated_selected_frame;

if (fi == NULL((void*)0))
  error ("No frame selected");

/* The following is generally ripped off from stack.c's routine 
   print_frame_info() */

func = find_pc_function (fi->pc);
if (func)
  {
    /* In certain pathological cases, the symtabs give the wrong
       function (when we are in the first function in a file which
       is compiled without debugging symbols, the previous function
       is compiled with debugging symbols, and the "foo.o" symbol
       that is supposed to tell us where the file with debugging symbols
       ends has been truncated by ar because it is longer than 15
       characters).

       So look in the minimal symbol tables as well, and if it comes
       up with a larger address for the function use that instead.
       I don't think this can ever cause any problems; there shouldn't
       be any minimal symbols in the middle of a function.
       FIXME:  (Not necessarily true.  What about text labels) */

    struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);

    if (msymbol != NULL((void*)0)
 && (SYMBOL_VALUE_ADDRESS (msymbol)(msymbol)->ginfo.value.address
     > BLOCK_START (SYMBOL_BLOCK_VALUE (func))((func)->ginfo.value.block)->startaddr))
funname = DEPRECATED_SYMBOL_NAME (msymbol)(msymbol)->ginfo.name;
    else
funname = DEPRECATED_SYMBOL_NAME (func)(func)->ginfo.name;
  }
else
  {
    struct minimal_symbol *msymbol =
    lookup_minimal_symbol_by_pc (fi->pc);

    if (msymbol != NULL((void*)0))
funname = DEPRECATED_SYMBOL_NAME (msymbol)(msymbol)->ginfo.name;
  }

the_common = find_common_for_function (comname, funname);

return (the_common ? 1 : 0);
771}
772#endif

774void
775_initialize_f_valprint (void)
776{
add_info ("common", info_common_command,
   "Print out the values contained in a Fortran COMMON block.");
if (xdb_commands)
  add_com ("lc", class_info, info_common_command,
    "Print out the values contained in a Fortran COMMON block.");
782}