/usr/src/gnu/usr.bin/binutils-2.17/ld/ldexp.c

Bug Summary

File:	src/gnu/usr.bin/binutils-2.17/ld/ldexp.c
Warning:	line 755, column 16 Access to field 'type' results in a dereference of a null pointer (loaded from variable 'h')

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 ldexp.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-2.17/obj/ld -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -I . -I /usr/src/gnu/usr.bin/binutils-2.17/ld -I . -D _GNU_SOURCE -I . -I /usr/src/gnu/usr.bin/binutils-2.17/ld -I ../bfd -I /usr/src/gnu/usr.bin/binutils-2.17/ld/../bfd -I /usr/src/gnu/usr.bin/binutils-2.17/ld/../include -I /usr/src/gnu/usr.bin/binutils-2.17/ld/../intl -I ../intl -D PIE_DEFAULT=1 -D LOCALEDIR="/usr/share/locale" -D PIE_DEFAULT=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-null-pointer-arithmetic -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/ld -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -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-2.17/ld/ldexp.c

1/* This module handles expression trees.
 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
 2001, 2002, 2003, 2004, 2005
 Free Software Foundation, Inc.
 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.

 This file is part of GLD, the Gnu Linker.

 GLD 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, or (at your option)
 any later version.

 GLD 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 GLD; see the file COPYING.  If not, write to the Free
 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
 02110-1301, USA.  */

24/* This module is in charge of working out the contents of expressions.

 It has to keep track of the relative/absness of a symbol etc. This
 is done by keeping all values in a struct (an etree_value_type)
 which contains a value, a section to which it is relative and a
 valid bit.  */

31#include "bfd.h"
32#include "sysdep.h"
33#include "bfdlink.h"

35#include "ld.h"
36#include "ldmain.h"
37#include "ldmisc.h"
38#include "ldexp.h"
39#include <ldgram.h>
40#include "ldlang.h"
41#include "libiberty.h"
42#include "safe-ctype.h"

44static void exp_fold_tree_1 (etree_type *);
45static void exp_fold_tree_no_dot (etree_type *);
46static bfd_vma align_n (bfd_vma, bfd_vma);

48segment_type *segments;

50struct ldexp_control expld;

52/* Print the string representation of the given token.  Surround it
 with spaces if INFIX_P is TRUE.  */

55static void
56exp_print_token (token_code_type code, int infix_p)
57{
static const struct
{
  token_code_type code;
  char * name;
}
table[] =
{
  { INT257, "int" },
  { NAME258, "NAME" },
  { PLUSEQ260, "+=" },
  { MINUSEQ261, "-=" },
  { MULTEQ262, "*=" },
  { DIVEQ263, "/=" },
  { LSHIFTEQ264, "<<=" },
  { RSHIFTEQ265, ">>=" },
  { ANDEQ266, "&=" },
  { OREQ267, "|=" },
  { OROR268, "||" },
  { ANDAND269, "&&" },
  { EQ270, "==" },
  { NE271, "!=" },
  { LE272, "<=" },
  { GE273, ">=" },
  { LSHIFT274, "<<" },
  { RSHIFT275, ">>" },
  { ALIGN_K278, "ALIGN" },
  { BLOCK279, "BLOCK" },
  { QUAD281, "QUAD" },
  { SQUAD282, "SQUAD" },
  { LONG283, "LONG" },
  { SHORT284, "SHORT" },
  { BYTE285, "BYTE" },
  { SECTIONS286, "SECTIONS" },
  { SIZEOF_HEADERS293, "SIZEOF_HEADERS" },
  { MEMORY300, "MEMORY" },
  { DEFINED307, "DEFINED" },
  { TARGET_K308, "TARGET" },
  { SEARCH_DIR309, "SEARCH_DIR" },
  { MAP310, "MAP" },
  { ENTRY311, "ENTRY" },
  { NEXT312, "NEXT" },
  { SIZEOF313, "SIZEOF" },
  { ADDR314, "ADDR" },
  { LOADADDR315, "LOADADDR" },
  { MAX_K316, "MAX_K" },
  { REL353, "relocatable" },
  { DATA_SEGMENT_ALIGN288, "DATA_SEGMENT_ALIGN" },
  { DATA_SEGMENT_RELRO_END289, "DATA_SEGMENT_RELRO_END" },
  { DATA_SEGMENT_END290, "DATA_SEGMENT_END" },
  { ORIGIN324, "ORIGIN" },
  { LENGTH326, "LENGTH" },
  { SEGMENT_START298, "SEGMENT_START" }
};
unsigned int idx;

for (idx = 0; idx < ARRAY_SIZE (table)(sizeof (table) / sizeof ((table)[0])); idx++)
  if (table[idx].code == code)
    break;

if (infix_p)
  fputc (' ', config.map_file);

if (idx < ARRAY_SIZE (table)(sizeof (table) / sizeof ((table)[0])))
  fputs (table[idx].name, config.map_file);
else if (code < 127)
  fputc (code, config.map_file);
else
  fprintf (config.map_file, "<code %d>", code);

if (infix_p)
  fputc (' ', config.map_file);
129}

131static void
132make_abs (void)
133{
expld.result.value += expld.result.section->vma;
expld.result.section = bfd_abs_section_ptr((asection *) &bfd_abs_section);
136}

138static void
139new_abs (bfd_vma value)
140{
expld.result.valid_p = TRUE1;
expld.result.section = bfd_abs_section_ptr((asection *) &bfd_abs_section);
expld.result.value = value;
expld.result.str = NULL((void*)0);
145}

147etree_type *
148exp_intop (bfd_vma value)
149{
etree_type *new = stat_alloc (sizeof (new->value));
new->type.node_code = INT257;
new->value.value = value;
new->value.str = NULL((void*)0);
new->type.node_class = etree_value;
return new;
156}

158etree_type *
159exp_bigintop (bfd_vma value, char *str)
160{
etree_type *new = stat_alloc (sizeof (new->value));
new->type.node_code = INT257;
new->value.value = value;
new->value.str = str;
new->type.node_class = etree_value;
return new;
167}

169/* Build an expression representing an unnamed relocatable value.  */

171etree_type *
172exp_relop (asection *section, bfd_vma value)
173{
etree_type *new = stat_alloc (sizeof (new->rel));
new->type.node_code = REL353;
new->type.node_class = etree_rel;
new->rel.section = section;
new->rel.value = value;
return new;
180}

182static void
183new_rel (bfd_vma value, char *str, asection *section)
184{
expld.result.valid_p = TRUE1;
expld.result.value = value;
expld.result.str = str;
expld.result.section = section;
189}

191static void
192new_rel_from_abs (bfd_vma value)
193{
expld.result.valid_p = TRUE1;
expld.result.value = value - expld.section->vma;
expld.result.str = NULL((void*)0);
expld.result.section = expld.section;
198}

200static void
201fold_unary (etree_type *tree)
202{
exp_fold_tree_1 (tree->unary.child);
if (expld.result.valid_p)
  {
    switch (tree->type.node_code)
{
case ALIGN_K278:
 if (expld.phase != lang_first_phase_enum)
   new_rel_from_abs (align_n (expld.dot, expld.result.value));
 else
   expld.result.valid_p = FALSE0;
 break;

case ABSOLUTE341:
 make_abs ();
 break;

case '~':
 make_abs ();
 expld.result.value = ~expld.result.value;
 break;

case '!':
 make_abs ();
 expld.result.value = !expld.result.value;
 break;

case '-':
 make_abs ();
 expld.result.value = -expld.result.value;
 break;

case NEXT312:
 /* Return next place aligned to value.  */
 if (expld.phase != lang_first_phase_enum)
   {
     make_abs ();
     expld.result.value = align_n (expld.dot, expld.result.value);
   }
 else
   expld.result.valid_p = FALSE0;
 break;

case DATA_SEGMENT_END290:
 if (expld.phase != lang_first_phase_enum
     && expld.section == bfd_abs_section_ptr((asection *) &bfd_abs_section)
     && (expld.dataseg.phase == exp_dataseg_align_seen
  || expld.dataseg.phase == exp_dataseg_relro_seen
  || expld.dataseg.phase == exp_dataseg_adjust
  || expld.dataseg.phase == exp_dataseg_relro_adjust
  || expld.phase == lang_final_phase_enum))
   {
     if (expld.dataseg.phase == exp_dataseg_align_seen
  || expld.dataseg.phase == exp_dataseg_relro_seen)
{
  expld.dataseg.phase = exp_dataseg_end_seen;
  expld.dataseg.end = expld.result.value;
}
   }
 else
   expld.result.valid_p = FALSE0;
 break;

default:
 FAIL ()do { info_assert("/usr/src/gnu/usr.bin/binutils-2.17/ld/ldexp.c"
,266); } while (0);
 break;
}
  }
270}

272static void
273fold_binary (etree_type *tree)
274{
exp_fold_tree_1 (tree->binary.lhs);

/* The SEGMENT_START operator is special because its first
   operand is a string, not the name of a symbol.  */
if (expld.result.valid_p && tree->type.node_code == SEGMENT_START298)
  {
    const char *segment_name;
    segment_type *seg;
    /* Check to see if the user has overridden the default
value.  */
    segment_name = tree->binary.rhs->name.name;
    for (seg = segments; seg; seg = seg->next) 
if (strcmp (seg->name, segment_name) == 0)
 {
   seg->used = TRUE1;
   expld.result.value = seg->value;
   expld.result.str = NULL((void*)0);
   expld.result.section = NULL((void*)0);
   break;
 }
  }
else if (expld.result.valid_p)
  {
    etree_value_type lhs = expld.result;

    exp_fold_tree_1 (tree->binary.rhs);
    if (expld.result.valid_p)
{
 /* If the values are from different sections, or this is an
    absolute expression, make both the source arguments
    absolute.  However, adding or subtracting an absolute
    value from a relative value is meaningful, and is an
    exception.  */
 if (expld.section != bfd_abs_section_ptr((asection *) &bfd_abs_section)
     && lhs.section == bfd_abs_section_ptr((asection *) &bfd_abs_section)
     && tree->type.node_code == '+')
   {
     /* Keep the section of the rhs term.  */
     expld.result.value = lhs.value + expld.result.value;
     return;
   }
 else if (expld.section != bfd_abs_section_ptr((asection *) &bfd_abs_section)
     && expld.result.section == bfd_abs_section_ptr((asection *) &bfd_abs_section)
     && (tree->type.node_code == '+'
  || tree->type.node_code == '-'))
   {
     /* Keep the section of the lhs term.  */
     expld.result.section = lhs.section;
   }
 else if (expld.result.section != lhs.section
   || expld.section == bfd_abs_section_ptr((asection *) &bfd_abs_section))
   {
     make_abs ();
     lhs.value += lhs.section->vma;
   }

 switch (tree->type.node_code)
   {
   case '%':
     if (expld.result.value != 0)
expld.result.value = ((bfd_signed_vma) lhs.value
		      % (bfd_signed_vma) expld.result.value);
     else if (expld.phase != lang_mark_phase_enum)
einfo (_("%F%S %% by zero\n")("%F%S %% by zero\n"));
     break;

   case '/':
     if (expld.result.value != 0)
expld.result.value = ((bfd_signed_vma) lhs.value
		      / (bfd_signed_vma) expld.result.value);
     else if (expld.phase != lang_mark_phase_enum)
einfo (_("%F%S / by zero\n")("%F%S / by zero\n"));
     break;

349#define BOP(x, y)case x: expld.result.value = lhs.value y expld.result.value; break
; \
   case x:							\
     expld.result.value = lhs.value y expld.result.value;	\
     break;

     BOP ('+', +)case '+': expld.result.value = lhs.value + expld.result.value
; break;;
     BOP ('*', *)case '*': expld.result.value = lhs.value * expld.result.value
; break;;
     BOP ('-', -)case '-': expld.result.value = lhs.value - expld.result.value
; break;;
     BOP (LSHIFT, <<)case 274: expld.result.value = lhs.value << expld.result
.value; break;;
     BOP (RSHIFT, >>)case 275: expld.result.value = lhs.value >> expld.result
.value; break;;
     BOP (EQ, ==)case 270: expld.result.value = lhs.value == expld.result.value
; break;;
     BOP (NE, !=)case 271: expld.result.value = lhs.value != expld.result.value
; break;;
     BOP ('<', <)case '<': expld.result.value = lhs.value < expld.result
.value; break;;
     BOP ('>', >)case '>': expld.result.value = lhs.value > expld.result
.value; break;;
     BOP (LE, <=)case 272: expld.result.value = lhs.value <= expld.result.value
; break;;
     BOP (GE, >=)case 273: expld.result.value = lhs.value >= expld.result.value
; break;;
     BOP ('&', &)case '&': expld.result.value = lhs.value & expld.result
.value; break;;
     BOP ('^', ^)case '^': expld.result.value = lhs.value ^ expld.result.value
; break;;
     BOP ('|', |)case '|': expld.result.value = lhs.value | expld.result.value
; break;;
     BOP (ANDAND, &&)case 269: expld.result.value = lhs.value && expld.result
.value; break;;
     BOP (OROR, ||)case 268: expld.result.value = lhs.value || expld.result.value
; break;;

   case MAX_K316:
     if (lhs.value > expld.result.value)
expld.result.value = lhs.value;
     break;

   case MIN_K317:
     if (lhs.value < expld.result.value)
expld.result.value = lhs.value;
     break;

   case ALIGN_K278:
     expld.result.value = align_n (lhs.value, expld.result.value);
     break;

   case DATA_SEGMENT_ALIGN288:
     if (expld.phase != lang_first_phase_enum
  && expld.section == bfd_abs_section_ptr((asection *) &bfd_abs_section)
  && (expld.dataseg.phase == exp_dataseg_none
      || expld.dataseg.phase == exp_dataseg_adjust
      || expld.dataseg.phase == exp_dataseg_relro_adjust
      || expld.phase == lang_final_phase_enum))
{
  bfd_vma maxpage = lhs.value;
  bfd_vma commonpage = expld.result.value;

  expld.result.value = align_n (expld.dot, maxpage);
  if (expld.dataseg.phase == exp_dataseg_relro_adjust)
    expld.result.value = expld.dataseg.base;
  else if (expld.dataseg.phase != exp_dataseg_adjust)
    {
      expld.result.value += expld.dot & (maxpage - 1);
      if (expld.phase == lang_allocating_phase_enum)
	{
	  expld.dataseg.phase = exp_dataseg_align_seen;
	  expld.dataseg.min_base = align_n (expld.dot, maxpage);
	  expld.dataseg.base = expld.result.value;
	  expld.dataseg.pagesize = commonpage;
	  expld.dataseg.maxpagesize = maxpage;
	  expld.dataseg.relro_end = 0;
	}
    }
  else if (commonpage < maxpage)
    expld.result.value += ((expld.dot + commonpage - 1)
			   & (maxpage - commonpage));
}
     else
expld.result.valid_p = FALSE0;
     break;

   case DATA_SEGMENT_RELRO_END289:
     if (expld.phase != lang_first_phase_enum
  && (expld.dataseg.phase == exp_dataseg_align_seen
      || expld.dataseg.phase == exp_dataseg_adjust
      || expld.dataseg.phase == exp_dataseg_relro_adjust
      || expld.phase == lang_final_phase_enum))
{
  if (expld.dataseg.phase == exp_dataseg_align_seen
      || expld.dataseg.phase == exp_dataseg_relro_adjust)
    expld.dataseg.relro_end = lhs.value + expld.result.value;

  if (expld.dataseg.phase == exp_dataseg_relro_adjust
      && (expld.dataseg.relro_end
	  & (expld.dataseg.pagesize - 1)))
    {
      expld.dataseg.relro_end += expld.dataseg.pagesize - 1;
      expld.dataseg.relro_end &= ~(expld.dataseg.pagesize - 1);
      expld.result.value = (expld.dataseg.relro_end
			    - expld.result.value);
    }
  else
    expld.result.value = lhs.value;

  if (expld.dataseg.phase == exp_dataseg_align_seen)
    expld.dataseg.phase = exp_dataseg_relro_seen;
}
     else
expld.result.valid_p = FALSE0;
     break;

   default:
     FAIL ()do { info_assert("/usr/src/gnu/usr.bin/binutils-2.17/ld/ldexp.c"
,451); } while (0);
   }
}
    else
expld.result.valid_p = FALSE0;
  }
457}

459static void
460fold_trinary (etree_type *tree)
461{
exp_fold_tree_1 (tree->trinary.cond);
if (expld.result.valid_p)
  exp_fold_tree_1 (expld.result.value
     ? tree->trinary.lhs
     : tree->trinary.rhs);
467}

469static void
470fold_name (etree_type *tree)
471{
memset (&expld.result, 0, sizeof (expld.result));
14
←
Value assigned to 'expld.result.valid_p', which participates in a condition later→

switch (tree->type.node_code)
15
←
Control jumps to 'case 315:'  at line 570→
  {
  case SIZEOF_HEADERS293:
    if (expld.phase != lang_first_phase_enum)
{
 bfd_vma hdr_size = 0;
 /* Don't find the real header size if only marking sections;
    The bfd function may cache incorrect data.  */
 if (expld.phase != lang_mark_phase_enum)
   hdr_size = bfd_sizeof_headers (output_bfd, link_info.relocatable)((*((output_bfd)->xvec->_bfd_sizeof_headers)) (output_bfd
, link_info.relocatable));
 new_abs (hdr_size);
}
    break;
  case DEFINED307:
    if (expld.phase == lang_first_phase_enum)
lang_track_definedness (tree->name.name);
    else
{
 struct bfd_link_hash_entry *h;
 int def_iteration
   = lang_symbol_definition_iteration (tree->name.name);

 h = bfd_wrapped_link_hash_lookup (output_bfd, &link_info,
			    tree->name.name,
			    FALSE0, FALSE0, TRUE1);
 expld.result.value = (h != NULL((void*)0)
		&& (h->type == bfd_link_hash_defined
		    || h->type == bfd_link_hash_defweak
		    || h->type == bfd_link_hash_common)
		&& (def_iteration == lang_statement_iteration
		    || def_iteration == -1));
 expld.result.section = bfd_abs_section_ptr((asection *) &bfd_abs_section);
 expld.result.valid_p = TRUE1;
}
    break;
  case NAME258:
    if (expld.phase == lang_first_phase_enum)
;
    else if (tree->name.name[0] == '.' && tree->name.name[1] == 0)
new_rel_from_abs (expld.dot);
    else
{
 struct bfd_link_hash_entry *h;

 h = bfd_wrapped_link_hash_lookup (output_bfd, &link_info,
			    tree->name.name,
			    TRUE1, FALSE0, TRUE1);
 if (!h)
   einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")("%P%F: bfd_link_hash_lookup failed: %E\n"));
 else if (h->type == bfd_link_hash_defined
   || h->type == bfd_link_hash_defweak)
   {
     if (bfd_is_abs_section (h->u.def.section)((h->u.def.section) == ((asection *) &bfd_abs_section)
))
new_abs (h->u.def.value);
     else
{
  asection *output_section;

  output_section = h->u.def.section->output_section;
  if (output_section == NULL((void*)0))
    {
      if (expld.phase != lang_mark_phase_enum)
	einfo (_("%X%S: unresolvable symbol `%s'"("%X%S: unresolvable symbol `%s'" " referenced in expression\n"
)
		 " referenced in expression\n")("%X%S: unresolvable symbol `%s'" " referenced in expression\n"
),
	       tree->name.name);
    }
  else
    new_rel (h->u.def.value + h->u.def.section->output_offset,
	     NULL((void*)0), output_section);
}
   }
 else if (expld.phase == lang_final_phase_enum
   || expld.assigning_to_dot)
   einfo (_("%F%S: undefined symbol `%s' referenced in expression\n")("%F%S: undefined symbol `%s' referenced in expression\n"),
   tree->name.name);
 else if (h->type == bfd_link_hash_new)
   {
     h->type = bfd_link_hash_undefined;
     h->u.undef.abfd = NULL((void*)0);
     if (h->u.undef.next == NULL((void*)0) && h != link_info.hash->undefs_tail)
bfd_link_add_undef (link_info.hash, h);
   }
}
    break;

  case ADDR314:
    if (expld.phase != lang_first_phase_enum)
{
 lang_output_section_statement_type *os;

 os = lang_output_section_find (tree->name.name);
 if (os != NULL((void*)0) && os->processed)
   new_rel (0, NULL((void*)0), os->bfd_section);
}
    break;

  case LOADADDR315:
    if (expld.phase != lang_first_phase_enum)
16
←
Assuming field 'phase' is equal to lang_first_phase_enum→
17
←
Taking false branch→
{
 lang_output_section_statement_type *os;

 os = lang_output_section_find (tree->name.name);
 if (os != NULL((void*)0) && os->processed)
   {
     if (os->load_base == NULL((void*)0))
new_rel (0, NULL((void*)0), os->bfd_section);
     else
exp_fold_tree_1 (os->load_base);
   }
}
    break;
18
←
 Execution continues on line 571→

  case SIZEOF313:
    if (expld.phase != lang_first_phase_enum)
{
 int opb = bfd_octets_per_byte (output_bfd);
 lang_output_section_statement_type *os;

 os = lang_output_section_find (tree->name.name);
 if (os == NULL((void*)0))
   new_abs (0);
 else if (os->processed)
   new_abs (os->bfd_section->size / opb);
}
    break;

  case LENGTH326:
    {
      lang_memory_region_type *mem;
      
      mem = lang_memory_region_lookup (tree->name.name, FALSE0);  
      if (mem != NULL((void*)0)) 
        new_abs (mem->length);
      else          
        einfo (_("%F%S: undefined MEMORY region `%s'"("%F%S: undefined MEMORY region `%s'" " referenced in expression\n"
)
   " referenced in expression\n")("%F%S: undefined MEMORY region `%s'" " referenced in expression\n"
), tree->name.name);
    }
    break;

  case ORIGIN324:
    {
      lang_memory_region_type *mem;
      
      mem = lang_memory_region_lookup (tree->name.name, FALSE0);  
      if (mem != NULL((void*)0)) 
        new_abs (mem->origin);
      else          
        einfo (_("%F%S: undefined MEMORY region `%s'"("%F%S: undefined MEMORY region `%s'" " referenced in expression\n"
)
   " referenced in expression\n")("%F%S: undefined MEMORY region `%s'" " referenced in expression\n"
), tree->name.name);
    }
    break;

  default:
    FAIL ()do { info_assert("/usr/src/gnu/usr.bin/binutils-2.17/ld/ldexp.c"
,627); } while (0);
    break;
  }
630}

632static void
633exp_fold_tree_1 (etree_type *tree)
634{
if (tree4.1
'tree' is not equal to NULL
 == NULL((void*)0))
5
←
Taking false branch→
10
←
Assuming 'tree' is not equal to NULL→
11
←
Taking false branch→
  {
    memset (&expld.result, 0, sizeof (expld.result));
    return;
  }

switch (tree->type.node_class)
6
←
Control jumps to 'case etree_assign:'  at line 676→
12
←
Control jumps to 'case etree_name:'  at line 764→
  {
  case etree_value:
    new_rel (tree->value.value, tree->value.str, expld.section);
    break;

  case etree_rel:
    if (expld.phase != lang_first_phase_enum)
{
 asection *output_section = tree->rel.section->output_section;
 new_rel (tree->rel.value + tree->rel.section->output_offset,
   NULL((void*)0), output_section);
}
    else
memset (&expld.result, 0, sizeof (expld.result));
    break;

  case etree_assert:
    exp_fold_tree_1 (tree->assert_s.child);
    if (expld.phase == lang_final_phase_enum && !expld.result.value)
einfo ("%X%P: %s\n", tree->assert_s.message);
    break;

  case etree_unary:
    fold_unary (tree);
    break;

  case etree_binary:
    fold_binary (tree);
    break;

  case etree_trinary:
    fold_trinary (tree);
    break;

  case etree_assign:
  case etree_provide:
  case etree_provided:
    if (tree->assign.dst[0] == '.' && tree->assign.dst[1] == 0)
7
←
Assuming the condition is false→
{
 /* Assignment to dot can only be done during allocation.  */
 if (tree->type.node_class != etree_assign)
   einfo (_("%F%S can not PROVIDE assignment to location counter\n")("%F%S can not PROVIDE assignment to location counter\n"));
 if (expld.phase == lang_mark_phase_enum
     || expld.phase == lang_allocating_phase_enum
     || (expld.phase == lang_final_phase_enum
  && expld.section == bfd_abs_section_ptr((asection *) &bfd_abs_section)))
   {
     /* Notify the folder that this is an assignment to dot.  */
     expld.assigning_to_dot = TRUE1;
     exp_fold_tree_1 (tree->assign.src);
     expld.assigning_to_dot = FALSE0;

     if (!expld.result.valid_p)
{
  if (expld.phase != lang_mark_phase_enum)
    einfo (_("%F%S invalid assignment to location counter\n")("%F%S invalid assignment to location counter\n"));
}
     else if (expld.dotp == NULL((void*)0))
einfo (_("%F%S assignment to location counter"("%F%S assignment to location counter" " invalid outside of SECTION\n"
)
	 " invalid outside of SECTION\n")("%F%S assignment to location counter" " invalid outside of SECTION\n"
));
     else
{
  bfd_vma nextdot;

  nextdot = expld.result.value + expld.section->vma;
  if (nextdot < expld.dot
      && expld.section != bfd_abs_section_ptr((asection *) &bfd_abs_section))
    einfo (_("%F%S cannot move location counter backwards"("%F%S cannot move location counter backwards" " (from %V to %V)\n"
)
	     " (from %V to %V)\n")("%F%S cannot move location counter backwards" " (from %V to %V)\n"
), expld.dot, nextdot);
  else
    {
      expld.dot = nextdot;
      *expld.dotp = nextdot;
    }
}
   }
 else
   memset (&expld.result, 0, sizeof (expld.result));
}
    else
{
 struct bfd_link_hash_entry *h = NULL((void*)0);

 if (tree->type.node_class7.1
Field 'node_class' is not equal to etree_provide
 == etree_provide)
8
←
Taking false branch→
   {
     h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
			FALSE0, FALSE0, TRUE1);
     if (h == NULL((void*)0)
  || (h->type != bfd_link_hash_new
      && h->type != bfd_link_hash_undefined
      && h->type != bfd_link_hash_common))
{
  /* Do nothing.  The symbol was never referenced, or was
     defined by some object.  */
  break;
}
   }

 exp_fold_tree_1 (tree->assign.src);
9
←
Calling 'exp_fold_tree_1'→
21
←
Returning from 'exp_fold_tree_1'→
 if (expld.result.valid_p)
22
←
Assuming field 'valid_p' is not equal to 0→
23
←
Taking true branch→
   {
     if (h23.1
'h' is equal to NULL
 == NULL((void*)0))
24
←
Taking true branch→
{
  h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
25
←
Value assigned to 'h'→
			    TRUE1, FALSE0, TRUE1);
  if (h == NULL((void*)0))
26
←
Assuming 'h' is equal to NULL→
27
←
Assuming pointer value is null→
28
←
Taking true branch→
    einfo (_("%P%F:%s: hash creation failed\n")("%P%F:%s: hash creation failed\n"),
	   tree->assign.dst);
}

     /* FIXME: Should we worry if the symbol is already
 defined?  */
     lang_update_definedness (tree->assign.dst, h);
     h->type = bfd_link_hash_defined;
29
←
Access to field 'type' results in a dereference of a null pointer (loaded from variable 'h')
     h->u.def.value = expld.result.value;
     h->u.def.section = expld.result.section;
     if (tree->type.node_class == etree_provide)
tree->type.node_class = etree_provided;
   }
}
    break;

  case etree_name:
    fold_name (tree);
13
←
Calling 'fold_name'→
19
←
Returning from 'fold_name'→
    break;
20
←
 Execution continues on line 765→

  default:
    FAIL ()do { info_assert("/usr/src/gnu/usr.bin/binutils-2.17/ld/ldexp.c"
,769); } while (0);
    memset (&expld.result, 0, sizeof (expld.result));
    break;
  }
773}

775void
776exp_fold_tree (etree_type *tree, asection *current_section, bfd_vma *dotp)
777{
expld.dot = *dotp;
expld.dotp = dotp;
expld.section = current_section;
exp_fold_tree_1 (tree);
782}

784static void
785exp_fold_tree_no_dot (etree_type *tree)
786{
expld.dot = 0;
expld.dotp = NULL((void*)0);
expld.section = bfd_abs_section_ptr((asection *) &bfd_abs_section);
exp_fold_tree_1 (tree);
4
←
Calling 'exp_fold_tree_1'→
791}

793etree_type *
794exp_binop (int code, etree_type *lhs, etree_type *rhs)
795{
etree_type value, *new;

value.type.node_code = code;
value.binary.lhs = lhs;
value.binary.rhs = rhs;
value.type.node_class = etree_binary;
exp_fold_tree_no_dot (&value);
if (expld.result.valid_p)
  return exp_intop (expld.result.value);

new = stat_alloc (sizeof (new->binary));
memcpy (new, &value, sizeof (new->binary));
return new;
809}

811etree_type *
812exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
813{
etree_type value, *new;

value.type.node_code = code;
value.trinary.lhs = lhs;
value.trinary.cond = cond;
value.trinary.rhs = rhs;
value.type.node_class = etree_trinary;
exp_fold_tree_no_dot (&value);
if (expld.result.valid_p)
  return exp_intop (expld.result.value);

new = stat_alloc (sizeof (new->trinary));
memcpy (new, &value, sizeof (new->trinary));
return new;
828}

830etree_type *
831exp_unop (int code, etree_type *child)
832{
etree_type value, *new;

value.unary.type.node_code = code;
value.unary.child = child;
value.unary.type.node_class = etree_unary;
exp_fold_tree_no_dot (&value);
if (expld.result.valid_p)
  return exp_intop (expld.result.value);

new = stat_alloc (sizeof (new->unary));
memcpy (new, &value, sizeof (new->unary));
return new;
845}

847etree_type *
848exp_nameop (int code, const char *name)
849{
etree_type value, *new;

value.name.type.node_code = code;
value.name.name = name;
value.name.type.node_class = etree_name;

exp_fold_tree_no_dot (&value);
if (expld.result.valid_p)
  return exp_intop (expld.result.value);

new = stat_alloc (sizeof (new->name));
memcpy (new, &value, sizeof (new->name));
return new;

864}

866etree_type *
867exp_assop (int code, const char *dst, etree_type *src)
868{
etree_type *new;

new = stat_alloc (sizeof (new->assign));
new->type.node_code = code;
new->type.node_class = etree_assign;
new->assign.src = src;
new->assign.dst = dst;
return new;
877}

879/* Handle PROVIDE.  */

881etree_type *
882exp_provide (const char *dst, etree_type *src, bfd_boolean hidden)
883{
etree_type *n;

n = stat_alloc (sizeof (n->assign));
n->assign.type.node_code = '=';
n->assign.type.node_class = etree_provide;
n->assign.src = src;
n->assign.dst = dst;
n->assign.hidden = hidden;
return n;
893}

895/* Handle ASSERT.  */

897etree_type *
898exp_assert (etree_type *exp, const char *message)
899{
etree_type *n;

n = stat_alloc (sizeof (n->assert_s));
n->assert_s.type.node_code = '!';
n->assert_s.type.node_class = etree_assert;
n->assert_s.child = exp;
n->assert_s.message = message;
return n;
908}

910void
911exp_print_tree (etree_type *tree)
912{
if (config.map_file == NULL((void*)0))
  config.map_file = stderr(&__sF[2]);

if (tree == NULL((void*)0))
  {
    minfo ("NULL TREE\n");
    return;
  }

switch (tree->type.node_class)
  {
  case etree_value:
    minfo ("0x%v", tree->value.value);
    return;
  case etree_rel:
    if (tree->rel.section->owner != NULL((void*)0))
minfo ("%B:", tree->rel.section->owner);
    minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
    return;
  case etree_assign:
    fprintf (config.map_file, "%s", tree->assign.dst);
    exp_print_token (tree->type.node_code, TRUE1);
    exp_print_tree (tree->assign.src);
    break;
  case etree_provide:
  case etree_provided:
    fprintf (config.map_file, "PROVIDE (%s, ", tree->assign.dst);
    exp_print_tree (tree->assign.src);
    fprintf (config.map_file, ")");
    break;
  case etree_binary:
    fprintf (config.map_file, "(");
    exp_print_tree (tree->binary.lhs);
    exp_print_token (tree->type.node_code, TRUE1);
    exp_print_tree (tree->binary.rhs);
    fprintf (config.map_file, ")");
    break;
  case etree_trinary:
    exp_print_tree (tree->trinary.cond);
    fprintf (config.map_file, "?");
    exp_print_tree (tree->trinary.lhs);
    fprintf (config.map_file, ":");
    exp_print_tree (tree->trinary.rhs);
    break;
  case etree_unary:
    exp_print_token (tree->unary.type.node_code, FALSE0);
    if (tree->unary.child)
{
 fprintf (config.map_file, " (");
 exp_print_tree (tree->unary.child);
 fprintf (config.map_file, ")");
}
    break;

  case etree_assert:
    fprintf (config.map_file, "ASSERT (");
    exp_print_tree (tree->assert_s.child);
    fprintf (config.map_file, ", %s)", tree->assert_s.message);
    break;

  case etree_name:
    if (tree->type.node_code == NAME258)
{
 fprintf (config.map_file, "%s", tree->name.name);
}
    else
{
 exp_print_token (tree->type.node_code, FALSE0);
 if (tree->name.name)
   fprintf (config.map_file, " (%s)", tree->name.name);
}
    break;
  default:
    FAIL ()do { info_assert("/usr/src/gnu/usr.bin/binutils-2.17/ld/ldexp.c"
,986); } while (0);
    break;
  }
989}

991bfd_vma
992exp_get_vma (etree_type *tree, bfd_vma def, char *name)
993{
if (tree != NULL((void*)0))
  {
    exp_fold_tree_no_dot (tree);
    if (expld.result.valid_p)
return expld.result.value;
    else if (name != NULL((void*)0) && expld.phase != lang_mark_phase_enum)
einfo (_("%F%S nonconstant expression for %s\n")("%F%S nonconstant expression for %s\n"), name);
  }
return def;
1003}

1005int
1006exp_get_value_int (etree_type *tree, int def, char *name)
1007{
return exp_get_vma (tree, def, name);
1009}

1011fill_type *
1012exp_get_fill (etree_type *tree, fill_type *def, char *name)
1013{
fill_type *fill;
size_t len;
unsigned int val;

if (tree == NULL((void*)0))
  return def;

exp_fold_tree_no_dot (tree);
if (!expld.result.valid_p)
  {
    if (name != NULL((void*)0) && expld.phase != lang_mark_phase_enum)
einfo (_("%F%S nonconstant expression for %s\n")("%F%S nonconstant expression for %s\n"), name);
    return def;
  }

if (expld.result.str != NULL((void*)0) && (len = strlen (expld.result.str)) != 0)
  {
    unsigned char *dst;
    unsigned char *s;
    fill = xmalloc ((len + 1) / 2 + sizeof (*fill) - 1);
    fill->size = (len + 1) / 2;
    dst = fill->data;
    s = (unsigned char *) expld.result.str;
    val = 0;
    do
{
 unsigned int digit;

 digit = *s++ - '0';
 if (digit > 9)
   digit = (digit - 'A' + '0' + 10) & 0xf;
 val <<= 4;
 val += digit;
 --len;
 if ((len & 1) == 0)
   {
     *dst++ = val;
     val = 0;
   }
}
    while (len != 0);
  }
else
  {
    fill = xmalloc (4 + sizeof (*fill) - 1);
    val = expld.result.value;
    fill->data[0] = (val >> 24) & 0xff;
    fill->data[1] = (val >> 16) & 0xff;
    fill->data[2] = (val >>  8) & 0xff;
    fill->data[3] = (val >>  0) & 0xff;
    fill->size = 4;
  }
return fill;
1067}

1069bfd_vma
1070exp_get_abs_int (etree_type *tree, int def, char *name)
1071{
if (tree != NULL((void*)0))
1
Assuming 'tree' is not equal to NULL→
2
←
Taking true branch→
  {
    exp_fold_tree_no_dot (tree);
3
←
Calling 'exp_fold_tree_no_dot'→

    if (expld.result.valid_p)
{
 expld.result.value += expld.result.section->vma;
 return expld.result.value;
}
    else if (name != NULL((void*)0) && expld.phase != lang_mark_phase_enum)
einfo (_("%F%S non constant expression for %s\n")("%F%S non constant expression for %s\n"), name);
  }
return def;
1085}

1087static bfd_vma
1088align_n (bfd_vma value, bfd_vma align)
1089{
if (align <= 1)
  return value;

value = (value + align - 1) / align;
return value * align;
1095}