1 /* 

     2   Copyright (C) 2000,2003,2004,2005,2006 Silicon Graphics, Inc.  All Rights Reserved.

     3   Portions Copyright 2007 Sun Microsystems, Inc. All rights reserved.

     4 

     5   This program is free software; you can redistribute it and/or modify it

     6   under the terms of version 2 of the GNU General Public License as

     7   published by the Free Software Foundation.

     8 

     9   This program is distributed in the hope that it would be useful, but

    10   WITHOUT ANY WARRANTY; without even the implied warranty of

    11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

    12 

    13   Further, this software is distributed without any warranty that it is

    14   free of the rightful claim of any third person regarding infringement

    15   or the like.  Any license provided herein, whether implied or

    16   otherwise, applies only to this software file.  Patent licenses, if

    17   any, provided herein do not apply to combinations of this program with

    18   other software, or any other product whatsoever.

    19 

    20   You should have received a copy of the GNU General Public License along

    21   with this program; if not, write the Free Software Foundation, Inc., 51

    22   Franklin Street - Fifth Floor, Boston MA 02110-1301, USA.

    23 

    24   Contact information:  Silicon Graphics, Inc., 1500 Crittenden Lane,

    25   Mountain View, CA 94043, or:

    26 

    27   http://www.sgi.com

    28 

    29   For further information regarding this notice, see:

    30 

    31   http://oss.sgi.com/projects/GenInfo/NoticeExplan

    32 

    33 

    34 

    35 $Header: /plroot/cmplrs.src/v7.4.5m/.RCS/PL/dwarfdump/RCS/print_sections.c,v 1.69 2006/04/17 00:09:56 davea Exp $ */

    36 #include "globals.h"

    37 #include "dwarf_names.h"

    38 #include "dwconf.h"

    39 

    40 #include "print_frames.h"

    41 /*

    42  * Print line number information:

    43  * 	filename

    44  *	new basic-block

    45  *	[line] [address] <new statement>

    46  */

    47 

    48 

    49 static void

    50   print_pubname_style_entry(Dwarf_Debug dbg,

    51 			    char *line_title,

    52 			    char *name,

    53 			    Dwarf_Unsigned die_off,

    54 			    Dwarf_Unsigned cu_off,

    55 			    Dwarf_Unsigned global_cu_off,

    56 			    Dwarf_Unsigned maxoff);

    57 

    58 

    59 /* referred in dwarfdump.c */

    60 Dwarf_Die current_cu_die_for_print_frames;

    61 

    62 /* If an offset is bad, libdwarf will notice it and

    63    return an error.

    64    If it does the error checking in

    65 	print_pubname_style_entry()

    66    will be useless as we give up here on an error.

    67 

    68    This intended for checking pubnames-style call return

    69    values (for all the pubnames-style interfaces).

    70 

    71    In at least one gigantic executable die_off turned out wrong.

    72 */

    73 

    74 static void

    75 deal_with_name_offset_err(Dwarf_Debug dbg,

    76 			  char *err_loc,

    77 			  char *name, Dwarf_Unsigned die_off,

    78 			  int nres, Dwarf_Error err)

    79 {

    80     if (nres == DW_DLV_ERROR) {

    81 	Dwarf_Unsigned myerr = dwarf_errno(err);

    82 

    83 	if (myerr == DW_DLE_OFFSET_BAD) {

    84 	    printf("Error: bad offset %s, %s %lld (0x%llx)\n",

    85 		   err_loc,

    86 		   name,

    87 		   (long long) die_off, (unsigned long long) die_off);

    88 	}

    89 	print_error(dbg, err_loc, nres, err);

    90     }

    91 }

    92 

    93 static void

    94 print_source_intro(Dwarf_Die cu_die)

    95 {

    96     Dwarf_Off off = 0;

    97     int ores = dwarf_dieoffset(cu_die, &off, &err);

    98 

    99     if (ores == DW_DLV_OK) {

   100 	printf

   101 	    ("Source lines (from CU-DIE at .debug_info offset %llu):\n",

   102 	     (unsigned long long) off);

   103     } else {

   104 	printf("Source lines (for the CU-DIE at unknown location):\n");

   105     }

   106 }

   107 

   108 

   109 extern void

   110 print_line_numbers_this_cu(Dwarf_Debug dbg, Dwarf_Die cu_die)

   111 {

   112     Dwarf_Signed linecount = 0;

   113     Dwarf_Line *linebuf = NULL;

   114     Dwarf_Signed i = 0;

   115     Dwarf_Addr pc = 0;

   116     Dwarf_Unsigned lineno = 0;

   117     Dwarf_Signed column = 0;

   118     string filename;

   119     Dwarf_Bool newstatement = 0;

   120     Dwarf_Bool lineendsequence = 0;

   121     Dwarf_Bool new_basic_block = 0;

   122     int lres = 0;

   123     int sres = 0;

   124     int ares = 0;

   125     int lires = 0;

   126     int cores = 0;

   127 

   128     printf("\n.debug_line: line number info for a single cu\n");

   129     if (verbose > 1) {

   130 	print_source_intro(cu_die);

   131 	print_one_die(dbg, cu_die, /* print_information= */ 1,

   132 		      /* srcfiles= */ 0, /* cnt= */ 0);

   133 

   134 	lres = dwarf_print_lines(cu_die, &err);

   135 	if (lres == DW_DLV_ERROR) {

   136 	    print_error(dbg, "dwarf_srclines details", lres, err);

   137 	}

   138 	return;

   139     }

   140     lres = dwarf_srclines(cu_die, &linebuf, &linecount, &err);

   141     if (lres == DW_DLV_ERROR) {

   142 	print_error(dbg, "dwarf_srclines", lres, err);

   143     } else if (lres == DW_DLV_NO_ENTRY) {

   144 	/* no line information is included */

   145     } else {

   146 	print_source_intro(cu_die);

   147 	if (verbose) {

   148 	    print_one_die(dbg, cu_die, /* print_information= */ 1,

   149 			  /* srcfiles= */ 0, /* cnt= */ 0);

   150 	}

   151 	printf

   152 	    ("<source>\t[row,column]\t<pc>\t//<new statement or basic block\n");

   153 

   154 	for (i = 0; i < linecount; i++) {

   155 	    Dwarf_Line line = linebuf[i];

   156 	    int nsres;

   157 

   158 	    sres = dwarf_linesrc(line, &filename, &err);

   159 	    ares = dwarf_lineaddr(line, &pc, &err);

   160 	    if (sres == DW_DLV_ERROR) {

   161 		print_error(dbg, "dwarf_linesrc", sres, err);

   162 	    }

   163 	    if (sres == DW_DLV_NO_ENTRY) {

   164 		filename = "<unknown>";

   165 	    }

   166 	    if (ares == DW_DLV_ERROR) {

   167 		print_error(dbg, "dwarf_lineaddr", ares, err);

   168 	    }

   169 	    if (ares == DW_DLV_NO_ENTRY) {

   170 		pc = 0;

   171 	    }

   172 	    lires = dwarf_lineno(line, &lineno, &err);

   173 	    if (lires == DW_DLV_ERROR) {

   174 		print_error(dbg, "dwarf_lineno", lires, err);

   175 	    }

   176 	    if (lires == DW_DLV_NO_ENTRY) {

   177 		lineno = -1LL;

   178 	    }

   179 	    cores = dwarf_lineoff(line, &column, &err);

   180 	    if (cores == DW_DLV_ERROR) {

   181 		print_error(dbg, "dwarf_lineoff", cores, err);

   182 	    }

   183 	    if (cores == DW_DLV_NO_ENTRY) {

   184 		column = -1LL;

   185 	    }

   186 	    printf("%s:\t[%3llu,%2lld]\t%#llx", filename, lineno,

   187 		   column, pc);

   188 	    if (sres == DW_DLV_OK)

   189 		dwarf_dealloc(dbg, filename, DW_DLA_STRING);

   190 

   191 	    nsres = dwarf_linebeginstatement(line, &newstatement, &err);

   192 	    if (nsres == DW_DLV_OK) {

   193 		if (newstatement) {

   194 		    printf("\t// new statement");

   195 		}

   196 	    } else if (nsres == DW_DLV_ERROR) {

   197 		print_error(dbg, "linebeginstatment failed", nsres,

   198 			    err);

   199 	    }

   200 	    nsres = dwarf_lineblock(line, &new_basic_block, &err);

   201 	    if (nsres == DW_DLV_OK) {

   202 		if (new_basic_block) {

   203 		    printf("\t// new basic block");

   204 		}

   205 	    } else if (nsres == DW_DLV_ERROR) {

   206 		print_error(dbg, "lineblock failed", nsres, err);

   207 	    }

   208 	    nsres = dwarf_lineendsequence(line, &lineendsequence, &err);

   209 	    if (nsres == DW_DLV_OK) {

   210 		if (lineendsequence) {

   211 		    printf("\t// end of text sequence");

   212 		}

   213 	    } else if (nsres == DW_DLV_ERROR) {

   214 		print_error(dbg, "lineblock failed", nsres, err);

   215 	    }

   216 	    printf("\n");

   217 

   218 	}

   219 	dwarf_srclines_dealloc(dbg, linebuf, linecount);

   220     }

   221 }

   222 

   223 /*

   224 

   225 A strcpy which ensures NUL terminated string

   226 and never overruns the output.

   227 

   228 */

   229 static void

   230 safe_strcpy(char *out, long outlen, char *in, long inlen)

   231 {

   232     if (inlen >= (outlen - 1)) {

   233 	strncpy(out, in, outlen - 1);

   234 	out[outlen - 1] = 0;

   235     } else {

   236 	strcpy(out, in);

   237     }

   238 }

   239 

   240 /*

   241 	Returns 1 if a proc with this low_pc found.

   242 	Else returns 0.

   243 

   244 

   245 */

   246 static int

   247 get_proc_name(Dwarf_Debug dbg, Dwarf_Die die, Dwarf_Addr low_pc,

   248 	      char *proc_name_buf, int proc_name_buf_len)

   249 {

   250     Dwarf_Signed atcnt = 0;

   251     Dwarf_Signed i = 0;

   252     Dwarf_Attribute *atlist = NULL;

   253     Dwarf_Addr low_pc_die = 0;

   254     int atres = 0;

   255     int funcres = 1;

   256     int funcpcfound = 0;

   257     int funcnamefound = 1;

   258 

   259     proc_name_buf[0] = 0;	/* always set to something */

   260     atres = dwarf_attrlist(die, &atlist, &atcnt, &err);

   261     if (atres == DW_DLV_ERROR) {

   262 	print_error(dbg, "dwarf_attrlist", atres, err);

   263 	return 0;

   264     }

   265     if (atres == DW_DLV_NO_ENTRY) {

   266 	return 0;

   267     }

   268     for (i = 0; i < atcnt; i++) {

   269 	Dwarf_Half attr;

   270 	int ares;

   271 	string temps;

   272 	int sres;

   273 	int dres;

   274 

   275 	if (funcnamefound == 1 && funcpcfound == 1) {

   276 	    /* stop as soon as both found */

   277 	    break;

   278 	}

   279 	ares = dwarf_whatattr(atlist[i], &attr, &err);

   280 	if (ares == DW_DLV_ERROR) {

   281 	    print_error(dbg, "get_proc_name whatattr error", ares, err);

   282 	} else if (ares == DW_DLV_OK) {

   283 	    switch (attr) {

   284 	    case DW_AT_name:

   285 		sres = dwarf_formstring(atlist[i], &temps, &err);

   286 		if (sres == DW_DLV_ERROR) {

   287 		    print_error(dbg,

   288 				"formstring in get_proc_name failed",

   289 				sres, err);

   290 		    /* 50 is safe wrong length since is bigger than the 

   291 		       actual string */

   292 		    safe_strcpy(proc_name_buf, proc_name_buf_len,

   293 				"ERROR in dwarf_formstring!", 50);

   294 		} else if (sres == DW_DLV_NO_ENTRY) {

   295 		    /* 50 is safe wrong length since is bigger than the 

   296 		       actual string */

   297 		    safe_strcpy(proc_name_buf, proc_name_buf_len,

   298 				"NO ENTRY on dwarf_formstring?!", 50);

   299 		} else {

   300 		    long len = (long) strlen(temps);

   301 

   302 		    safe_strcpy(proc_name_buf, proc_name_buf_len, temps,

   303 				len);

   304 		}

   305 		funcnamefound = 1;	/* FOUND THE NAME */

   306 		break;

   307 	    case DW_AT_low_pc:

   308 		dres = dwarf_formaddr(atlist[i], &low_pc_die, &err);

   309 		if (dres == DW_DLV_ERROR) {

   310 		    print_error(dbg, "formaddr in get_proc_name failed",

   311 				dres, err);

   312 		    low_pc_die = ~low_pc;

   313 		    /* ensure no match */

   314 		}

   315 		funcpcfound = 1;

   316 

   317 		break;

   318 	    default:

   319 		break;

   320 	    }

   321 	}

   322     }

   323     for (i = 0; i < atcnt; i++) {

   324 	dwarf_dealloc(dbg, atlist[i], DW_DLA_ATTR);

   325     }

   326     dwarf_dealloc(dbg, atlist, DW_DLA_LIST);

   327     if (funcnamefound == 0 || funcpcfound == 0 || low_pc != low_pc_die) {

   328 	funcres = 0;

   329     }

   330     return (funcres);

   331 }

   332 

   333 /*

   334 	Modified Depth First Search looking for the procedure:

   335 	a) only looks for children of subprogram.

   336 	b) With subprogram looks at current die *before* looking

   337 	   for a child.

   338 	

   339 	Needed since some languages, including MP Fortran,

   340 	have nested functions.

   341 	Return 0 on failure, 1 on success.

   342 */

   343 static int

   344 get_nested_proc_name(Dwarf_Debug dbg, Dwarf_Die die, Dwarf_Addr low_pc,

   345 		     char *ret_name_buf, int ret_name_buf_len)

   346 {

   347     char name_buf[BUFSIZ];

   348     Dwarf_Die curdie = die;

   349     int die_locally_gotten = 0;

   350     Dwarf_Die prev_child = 0;

   351     Dwarf_Die newchild = 0;

   352     Dwarf_Die newsibling = 0;

   353     Dwarf_Half tag;

   354     Dwarf_Error err = 0;

   355     int chres = DW_DLV_OK;

   356 

   357     ret_name_buf[0] = 0;

   358     while (chres == DW_DLV_OK) {

   359 	int tres;

   360 

   361 	tres = dwarf_tag(curdie, &tag, &err);

   362 	newchild = 0;

   363 	err = 0;

   364 	if (tres == DW_DLV_OK) {

   365 	    int lchres;

   366 

   367 	    if (tag == DW_TAG_subprogram) {

   368 		int proc_name_v;

   369 

   370 		proc_name_v = get_proc_name(dbg, curdie, low_pc,

   371 					    name_buf, BUFSIZ);

   372 		if (proc_name_v) {

   373 		    /* this is it */

   374 		    safe_strcpy(ret_name_buf, ret_name_buf_len,

   375 				name_buf, (long) strlen(name_buf));

   376 		    if (die_locally_gotten) {

   377 			/* If we got this die from the parent, we do

   378 			   not want to dealloc here! */

   379 			dwarf_dealloc(dbg, curdie, DW_DLA_DIE);

   380 		    }

   381 		    return 1;

   382 		}

   383 		/* check children of subprograms recursively should

   384 		   this really be check children of anything? */

   385 

   386 		lchres = dwarf_child(curdie, &newchild, &err);

   387 		if (lchres == DW_DLV_OK) {

   388 		    /* look for inner subprogram */

   389 		    int newprog =

   390 			get_nested_proc_name(dbg, newchild, low_pc,

   391 					     name_buf, BUFSIZ);

   392 

   393 		    dwarf_dealloc(dbg, newchild, DW_DLA_DIE);

   394 		    if (newprog) {

   395 			/* Found it.  We could just take this name or

   396 			   we could concatenate names together For now, 

   397 			   just take name */

   398 			if (die_locally_gotten) {

   399 			    /* If we got this die from the parent, we

   400 			       do not want to dealloc here! */

   401 			    dwarf_dealloc(dbg, curdie, DW_DLA_DIE);

   402 			}

   403 			safe_strcpy(ret_name_buf, ret_name_buf_len,

   404 				    name_buf, (long) strlen(name_buf));

   405 			return 1;

   406 		    }

   407 		} else if (lchres == DW_DLV_NO_ENTRY) {

   408 		    /* nothing to do */

   409 		} else {

   410 		    print_error(dbg,

   411 				"get_nested_proc_name dwarf_child() failed ",

   412 				chres, err);

   413 		    if (die_locally_gotten) {

   414 			/* If we got this die from the parent, we do

   415 			   not want to dealloc here! */

   416 			dwarf_dealloc(dbg, curdie, DW_DLA_DIE);

   417 		    }

   418 		    return 0;

   419 		}

   420 	    }			/* end if TAG_subprogram */

   421 	} else {

   422 	    print_error(dbg, "no tag on child read ", tres, err);

   423 	    if (die_locally_gotten) {

   424 		/* If we got this die from the parent, we do not want

   425 		   to dealloc here! */

   426 		dwarf_dealloc(dbg, curdie, DW_DLA_DIE);

   427 	    }

   428 	    return 0;

   429 	}

   430 	/* try next sibling */

   431 	prev_child = curdie;

   432 	chres = dwarf_siblingof(dbg, curdie, &newsibling, &err);

   433 	if (chres == DW_DLV_ERROR) {

   434 	    print_error(dbg, "dwarf_cu_header On Child read ", chres,

   435 			err);

   436 	    if (die_locally_gotten) {

   437 		/* If we got this die from the parent, we do not want

   438 		   to dealloc here! */

   439 		dwarf_dealloc(dbg, curdie, DW_DLA_DIE);

   440 	    }

   441 	    return 0;

   442 	} else if (chres == DW_DLV_NO_ENTRY) {

   443 	    if (die_locally_gotten) {

   444 		/* If we got this die from the parent, we do not want

   445 		   to dealloc here! */

   446 		dwarf_dealloc(dbg, prev_child, DW_DLA_DIE);

   447 	    }

   448 	    return 0;		/* proc name not at this level */

   449 	} else {		/* DW_DLV_OK */

   450 	    curdie = newsibling;

   451 	    if (die_locally_gotten) {

   452 		/* If we got this die from the parent, we do not want

   453 		   to dealloc here! */

   454 		dwarf_dealloc(dbg, prev_child, DW_DLA_DIE);

   455 	    }

   456 	    prev_child = 0;

   457 	    die_locally_gotten = 1;

   458 	}

   459 

   460     }

   461     if (die_locally_gotten) {

   462 	/* If we got this die from the parent, we do not want to

   463 	   dealloc here! */

   464 	dwarf_dealloc(dbg, curdie, DW_DLA_DIE);

   465     }

   466     return 0;

   467 }

   468 

   469 /*

   470   For MP Fortran and possibly other languages, functions 

   471   nest!  As a result, we must dig thru all functions, 

   472   not just the top level.

   473 

   474 

   475   This remembers the CU die and restarts each search at the start

   476   of  the current cu.

   477 

   478   

   479 */

   480 string

   481 get_fde_proc_name(Dwarf_Debug dbg, Dwarf_Addr low_pc)

   482 {

   483     static char proc_name[BUFSIZ];

   484     Dwarf_Unsigned cu_header_length;

   485     Dwarf_Unsigned abbrev_offset;

   486     Dwarf_Half version_stamp;

   487     Dwarf_Half address_size;

   488     Dwarf_Unsigned next_cu_offset = 0;

   489     int cures = DW_DLV_OK;

   490     int dres = DW_DLV_OK;

   491     int chres = DW_DLV_OK;

   492     int looping = 0;

   493 

   494     if (current_cu_die_for_print_frames == NULL) {

   495 	cures

   496 	    = dwarf_next_cu_header(dbg, &cu_header_length,

   497 				   &version_stamp, &abbrev_offset,

   498 				   &address_size, &next_cu_offset,

   499 				   &err);

   500 	if (cures == DW_DLV_ERROR) {

   501 	    return NULL;

   502 	} else if (cures == DW_DLV_NO_ENTRY) {

   503 	    /* loop thru the list again */

   504 	    current_cu_die_for_print_frames = 0;

   505 	    ++looping;

   506 	} else {		/* DW_DLV_OK */

   507 	    dres = dwarf_siblingof(dbg, NULL,

   508 				   &current_cu_die_for_print_frames,

   509 				   &err);

   510 	    if (dres == DW_DLV_ERROR) {

   511 		return NULL;

   512 	    }

   513 	}

   514     }

   515     if (dres == DW_DLV_OK) {

   516 	Dwarf_Die child = 0;

   517 

   518 	if (current_cu_die_for_print_frames == 0) {

   519 	    /* no information. Possibly a stripped file */

   520 	    return NULL;

   521 	}

   522 	chres =

   523 	    dwarf_child(current_cu_die_for_print_frames, &child, &err);

   524 	if (chres == DW_DLV_ERROR) {

   525 	    print_error(dbg, "dwarf_cu_header on child read ", chres,

   526 			err);

   527 	} else if (chres == DW_DLV_NO_ENTRY) {

   528 	} else {		/* DW_DLV_OK */

   529 	    int gotname =

   530 		get_nested_proc_name(dbg, child, low_pc, proc_name,

   531 				     BUFSIZ);

   532 

   533 	    dwarf_dealloc(dbg, child, DW_DLA_DIE);

   534 	    if (gotname) {

   535 		return (proc_name);

   536 	    }

   537 	    child = 0;

   538 	}

   539     }

   540     for (;;) {

   541 	Dwarf_Die ldie;

   542 

   543 	cures = dwarf_next_cu_header(dbg, &cu_header_length,

   544 				     &version_stamp, &abbrev_offset,

   545 				     &address_size, &next_cu_offset,

   546 				     &err);

   547 

   548 	if (cures != DW_DLV_OK) {

   549 	    break;

   550 	}

   551 

   552 

   553 	dres = dwarf_siblingof(dbg, NULL, &ldie, &err);

   554 

   555 	if (current_cu_die_for_print_frames) {

   556 	    dwarf_dealloc(dbg, current_cu_die_for_print_frames,

   557 			  DW_DLA_DIE);

   558 	}

   559 	current_cu_die_for_print_frames = 0;

   560 	if (dres == DW_DLV_ERROR) {

   561 	    print_error(dbg,

   562 			"dwarf_cu_header Child Read finding proc name for .debug_frame",

   563 			chres, err);

   564 	    continue;

   565 	} else if (dres == DW_DLV_NO_ENTRY) {

   566 	    ++looping;

   567 	    if (looping > 1) {

   568 		print_error(dbg, "looping  on cu headers!", dres, err);

   569 		return NULL;

   570 	    }

   571 	    continue;

   572 	}

   573 	/* DW_DLV_OK */

   574 	current_cu_die_for_print_frames = ldie;

   575 	{

   576 	    int chres;

   577 	    Dwarf_Die child;

   578 

   579 	    chres =

   580 		dwarf_child(current_cu_die_for_print_frames, &child,

   581 			    &err);

   582 	    if (chres == DW_DLV_ERROR) {

   583 		print_error(dbg, "dwarf Child Read ", chres, err);

   584 	    } else if (chres == DW_DLV_NO_ENTRY) {

   585 

   586 		;		/* do nothing, loop on cu */

   587 	    } else {		/* DW_DLV_OK) */

   588 

   589 		int gotname =

   590 		    get_nested_proc_name(dbg, child, low_pc, proc_name,

   591 					 BUFSIZ);

   592 

   593 		dwarf_dealloc(dbg, child, DW_DLA_DIE);

   594 		if (gotname) {

   595 		    return (proc_name);

   596 		}

   597 	    }

   598 	}

   599     }

   600     return (NULL);

   601 }

   602 

   603 /* get all the data in .debug_frame (or .eh_frame). 

   604  The '3' versions mean print using the dwarf3 new interfaces.

   605  The non-3 mean use the old interfaces.

   606  All combinations of requests are possible.

   607 */

   608 extern void

   609 print_frames(Dwarf_Debug dbg, int print_debug_frame, int print_eh_frame,

   610 	     struct dwconf_s *config_data)

   611 {

   612     Dwarf_Cie *cie_data = NULL;

   613     Dwarf_Signed cie_element_count = 0;

   614     Dwarf_Fde *fde_data = NULL;

   615     Dwarf_Signed fde_element_count = 0;

   616     Dwarf_Signed i;

   617     int fres = 0;

   618     Dwarf_Half address_size = 0;

   619     int framed = 0;

   620 

   621     fres = dwarf_get_address_size(dbg, &address_size, &err);

   622     if (fres != DW_DLV_OK) {

   623 	print_error(dbg, "dwarf_get_address_size", fres, err);

   624     }

   625     for (framed = 0; framed < 2; ++framed) {

   626 	char *framename = 0;

   627 	int silent_if_missing = 0;

   628 	int is_eh = 0;

   629 

   630 	if (framed == 0) {

   631 	    if (!print_debug_frame) {

   632 		continue;

   633 	    }

   634 	    framename = ".debug_frame";

   635 	    /* 

   636 	     * Big question here is how to print all the info?

   637 	     * Can print the logical matrix, but that is huge,

   638 	     * though could skip lines that don't change.

   639 	     * Either that, or print the instruction statement program

   640 	     * that describes the changes.

   641 	     */

   642 	    fres =

   643 		dwarf_get_fde_list(dbg, &cie_data, &cie_element_count,

   644 				   &fde_data, &fde_element_count, &err);

   645 	} else {

   646 	    if (!print_eh_frame) {

   647 		continue;

   648 	    }

   649 	    is_eh = 1;

   650 	    /* This is gnu g++ exceptions in a .eh_frame section. Which 

   651 	       is just like .debug_frame except that the empty, or

   652 	       'special' CIE_id is 0, not -1 (to distinguish fde from

   653 	       cie). And the augmentation is "eh". As of egcs-1.1.2

   654 	       anyway. A non-zero cie_id is in a fde and is the

   655 	       difference between the fde address and the beginning of

   656 	       the cie it belongs to. This makes sense as this is

   657 	       intended to be referenced at run time, and is part of

   658 	       the running image. For more on augmentation strings, see 

   659 	       libdwarf/dwarf_frame.c.  */

   660 

   661 	    /* 

   662 	     * Big question here is how to print all the info?

   663 	     * Can print the logical matrix, but that is huge,

   664 	     * though could skip lines that don't change.

   665 	     * Either that, or print the instruction statement program

   666 	     * that describes the changes.

   667 	     */

   668 	    silent_if_missing = 1;

   669 	    framename = ".eh_frame";

   670 	    fres =

   671 		dwarf_get_fde_list_eh(dbg, &cie_data,

   672 				      &cie_element_count, &fde_data,

   673 				      &fde_element_count, &err);

   674 	}

   675 	if (fres == DW_DLV_ERROR) {

   676 	    printf("\n%s\n", framename);

   677 	    print_error(dbg, "dwarf_get_fde_list", fres, err);

   678 	} else if (fres == DW_DLV_NO_ENTRY) {

   679 	    if (!silent_if_missing)

   680 		printf("\n%s\n", framename);

   681 	    /* no frame information */

   682 	} else {		/* DW_DLV_OK */

   683 

   684 	    printf("\n%s\n", framename);

   685 	    printf("\nfde:\n");

   686 

   687 	    for (i = 0; i < fde_element_count; i++) {

   688 		print_one_fde(dbg, fde_data[i],

   689 			      i, cie_data, cie_element_count,

   690 			      address_size, is_eh, config_data);

   691 	    }

   692 	    /* 

   693 	       Print the cie set. */

   694 	    if (verbose) {

   695 		printf("\ncie:\n");

   696 		for (i = 0; i < cie_element_count; i++) {

   697 		    print_one_cie(dbg, cie_data[i], i, address_size,

   698 				  config_data);

   699 		}

   700 	    }

   701 	    dwarf_fde_cie_list_dealloc(dbg, cie_data, cie_element_count,

   702 				       fde_data, fde_element_count);

   703 	}

   704     }

   705     if (current_cu_die_for_print_frames) {

   706 	dwarf_dealloc(dbg, current_cu_die_for_print_frames, DW_DLA_DIE);

   707 	current_cu_die_for_print_frames = 0;

   708     }

   709 }

   710 

   711 

   712 

   713 

   714 int

   715   dwarf_get_section_max_offsets(Dwarf_Debug /* dbg */ ,

   716 				Dwarf_Unsigned *	/* debug_info_size 

   717 							 */ ,

   718 				Dwarf_Unsigned *	/* debug_abbrev_size 

   719 							 */

   720 				, Dwarf_Unsigned *	/* debug_line_size 

   721 							 */ ,

   722 				Dwarf_Unsigned *	/* debug_loc_size 

   723 							 */ ,

   724 				Dwarf_Unsigned *

   725 				/* debug_aranges_size */ ,

   726 				Dwarf_Unsigned *

   727 				/* debug_macinfo_size */ ,

   728 				Dwarf_Unsigned *

   729 				/* debug_pubnames_size */ ,

   730 				Dwarf_Unsigned *	/* debug_str_size 

   731 							 */ ,

   732 				Dwarf_Unsigned *	/* debug_frame_size 

   733 							 */

   734 				, Dwarf_Unsigned *	/* debug_ranges_size 

   735 							 */

   736 				, Dwarf_Unsigned *

   737 				/* debug_pubtypes_size */ );

   738 

   739 /* The new (April 2005) dwarf_get_section_max_offsets()

   740    in libdwarf returns all max-offsets, but we only

   741    want one of those offsets. This function returns 

   742    the one we want from that set,

   743    making functions needing this offset as readable as possible.

   744    (avoiding code duplication).

   745 */

   746 static Dwarf_Unsigned

   747 get_info_max_offset(Dwarf_Debug dbg)

   748 {

   749     Dwarf_Unsigned debug_info_size = 0;

   750     Dwarf_Unsigned debug_abbrev_size = 0;

   751     Dwarf_Unsigned debug_line_size = 0;

   752     Dwarf_Unsigned debug_loc_size = 0;

   753     Dwarf_Unsigned debug_aranges_size = 0;

   754     Dwarf_Unsigned debug_macinfo_size = 0;

   755     Dwarf_Unsigned debug_pubnames_size = 0;

   756     Dwarf_Unsigned debug_str_size = 0;

   757     Dwarf_Unsigned debug_frame_size = 0;

   758     Dwarf_Unsigned debug_ranges_size = 0;

   759     Dwarf_Unsigned debug_pubtypes_size = 0;

   760 

   761     dwarf_get_section_max_offsets(dbg,

   762 				  &debug_info_size,

   763 				  &debug_abbrev_size,

   764 				  &debug_line_size,

   765 				  &debug_loc_size,

   766 				  &debug_aranges_size,

   767 				  &debug_macinfo_size,

   768 				  &debug_pubnames_size,

   769 				  &debug_str_size,

   770 				  &debug_frame_size,

   771 				  &debug_ranges_size,

   772 				  &debug_pubtypes_size);

   773 

   774     return debug_info_size;

   775 }

   776 

   777 /* This unifies the code for some error checks to

   778    avoid code duplication.

   779 */

   780 static void

   781 check_info_offset_sanity(char *sec,

   782 			 char *field,

   783 			 char *global,

   784 			 Dwarf_Unsigned offset, Dwarf_Unsigned maxoff)

   785 {

   786     if (maxoff == 0) {

   787 	/* Lets make a heuristic check. */

   788 	if (offset > 0xffffffff) {

   789 	    printf("Warning: section %s %s %s offset 0x%llx "

   790 		   "exceptionally large \n",

   791 		   sec, field, global, (unsigned long long) offset);

   792 	}

   793     }

   794     if (offset >= maxoff) {

   795 	printf("Warning: section %s %s %s offset 0x%llx "

   796 	       "larger than max of 0x%llx\n",

   797 	       sec, field, global, (unsigned long long) offset,

   798 	       (unsigned long long) maxoff);

   799     }

   800 }

   801 

   802 /* Unified pubnames style output.

   803    The error checking here against maxoff may be useless

   804    (in that libdwarf may return an error if the offset is bad

   805    and we will not get called here).

   806    But we leave it in nonetheless as it looks sensible.

   807    In at least one gigantic executable such offsets turned out wrong.

   808 */

   809 static void

   810 print_pubname_style_entry(Dwarf_Debug dbg,

   811 			  char *line_title,

   812 			  char *name,

   813 			  Dwarf_Unsigned die_off,

   814 			  Dwarf_Unsigned cu_off,

   815 			  Dwarf_Unsigned global_cu_offset,

   816 			  Dwarf_Unsigned maxoff)

   817 {

   818     Dwarf_Die die = NULL;

   819     Dwarf_Die cu_die = NULL;

   820     Dwarf_Off die_CU_off = 0;

   821     int dres = 0;

   822     int ddres = 0;

   823     int cudres = 0;

   824 

   825     /* get die at die_off */

   826     dres = dwarf_offdie(dbg, die_off, &die, &err);

   827     if (dres != DW_DLV_OK)

   828 	print_error(dbg, "dwarf_offdie", dres, err);

   829 

   830     /* get offset of die from its cu-header */

   831     ddres = dwarf_die_CU_offset(die, &die_CU_off, &err);

   832     if (ddres != DW_DLV_OK) {

   833 	print_error(dbg, "dwarf_die_CU_offset", ddres, err);

   834     }

   835 

   836     /* get die at offset cu_off */

   837     cudres = dwarf_offdie(dbg, cu_off, &cu_die, &err);

   838     if (cudres != DW_DLV_OK) {

   839 	dwarf_dealloc(dbg, die, DW_DLA_DIE);

   840 	print_error(dbg, "dwarf_offdie", cudres, err);

   841     }

   842     printf("%s %-15s die-in-sect %lld, cu-in-sect %lld,"

   843 	   " die-in-cu %lld, cu-header-in-sect %lld",

   844 	   line_title, name, (long long) die_off, (long long) cu_off,

   845 	   /* the cu die offset */

   846 	   (long long) die_CU_off,

   847 	   /* following is absolute offset of the ** beginning of the

   848 	      cu */

   849 	   (long long) (die_off - die_CU_off));

   850 

   851     if ((die_off - die_CU_off) != global_cu_offset) {

   852 	printf(" error: real cuhdr %llu", global_cu_offset);

   853 	exit(1);

   854     }

   855     if (verbose) {

   856 	printf(" cuhdr %llu", global_cu_offset);

   857     }

   858 

   859 

   860     dwarf_dealloc(dbg, die, DW_DLA_DIE);

   861     dwarf_dealloc(dbg, cu_die, DW_DLA_DIE);

   862 

   863 

   864     printf("\n");

   865 

   866     check_info_offset_sanity(line_title,

   867 			     "die offset", name, die_off, maxoff);

   868     check_info_offset_sanity(line_title,

   869 			     "die cu offset", name, die_CU_off, maxoff);

   870     check_info_offset_sanity(line_title,

   871 			     "cu offset", name,

   872 			     (die_off - die_CU_off), maxoff);

   873 

   874 }

   875 

   876 

   877 /* get all the data in .debug_pubnames */

   878 extern void

   879 print_pubnames(Dwarf_Debug dbg)

   880 {

   881     Dwarf_Global *globbuf = NULL;

   882     Dwarf_Signed count = 0;

   883     Dwarf_Signed i = 0;

   884     Dwarf_Off die_off = 0;

   885     Dwarf_Off cu_off = 0;

   886     char *name = 0;

   887     int res = 0;

   888 

   889     printf("\n.debug_pubnames\n");

   890     res = dwarf_get_globals(dbg, &globbuf, &count, &err);

   891     if (res == DW_DLV_ERROR) {

   892 	print_error(dbg, "dwarf_get_globals", res, err);

   893     } else if (res == DW_DLV_NO_ENTRY) {

   894 	/* (err == 0 && count == DW_DLV_NOCOUNT) means there are no

   895 	   pubnames.  */

   896     } else {

   897 	Dwarf_Unsigned maxoff = get_info_max_offset(dbg);

   898 

   899 	for (i = 0; i < count; i++) {

   900 	    int nres;

   901 	    int cures3;

   902 	    Dwarf_Off global_cu_off = 0;

   903 

   904 	    nres = dwarf_global_name_offsets(globbuf[i],

   905 					     &name, &die_off, &cu_off,

   906 					     &err);

   907 	    deal_with_name_offset_err(dbg, "dwarf_global_name_offsets",

   908 				      name, die_off, nres, err);

   909 

   910 	    cures3 = dwarf_global_cu_offset(globbuf[i],

   911 					    &global_cu_off, &err);

   912 	    if (cures3 != DW_DLV_OK) {

   913 		print_error(dbg, "dwarf_global_cu_offset", cures3, err);

   914 	    }

   915 

   916 	    print_pubname_style_entry(dbg,

   917 				      "global",

   918 				      name, die_off, cu_off,

   919 				      global_cu_off, maxoff);

   920 

   921 	    /* print associated die too? */

   922 

   923 	    if (check_pubname_attr) {

   924 		Dwarf_Bool has_attr;

   925 		int ares;

   926 		int dres;

   927 		Dwarf_Die die;

   928 

   929 		/* get die at die_off */

   930 		dres = dwarf_offdie(dbg, die_off, &die, &err);

   931 		if (dres != DW_DLV_OK) {

   932 		    print_error(dbg, "dwarf_offdie", dres, err);

   933 		}

   934 

   935 

   936 		ares =

   937 		    dwarf_hasattr(die, DW_AT_external, &has_attr, &err);

   938 		if (ares == DW_DLV_ERROR) {

   939 		    print_error(dbg, "hassattr on DW_AT_external", ares,

   940 				err);

   941 		}

   942 		pubname_attr_result.checks++;

   943 		if (ares == DW_DLV_OK && has_attr) {

   944 		    /* Should the value of flag be examined? */

   945 		} else {

   946 		    pubname_attr_result.errors++;

   947 		    DWARF_CHECK_ERROR2(name,

   948 				       "pubname does not have DW_AT_external")

   949 		}

   950 		dwarf_dealloc(dbg, die, DW_DLA_DIE);

   951 	    }

   952 	}

   953 	dwarf_globals_dealloc(dbg, globbuf, count);

   954     }

   955 }				/* print_pubnames() */

   956 

   957 

   958 struct macro_counts_s {

   959     long mc_start_file;

   960     long mc_end_file;

   961     long mc_define;

   962     long mc_undef;

   963     long mc_extension;

   964     long mc_code_zero;

   965     long mc_unknown;

   966 };

   967 

   968 static void

   969 print_one_macro_entry_detail(long i,

   970 			     char *type,

   971 			     struct Dwarf_Macro_Details_s *mdp)

   972 {

   973     /* "DW_MACINFO_*: section-offset file-index [line] string\n" */

   974     if (mdp->dmd_macro) {

   975 	printf("%3ld %s: %6llu %2lld [%4lld] \"%s\" \n",

   976 	       i,

   977 	       type,

   978 	       mdp->dmd_offset,

   979 	       mdp->dmd_fileindex, mdp->dmd_lineno, mdp->dmd_macro);

   980     } else {

   981 	printf("%3ld %s: %6llu %2lld [%4lld] 0\n",

   982 	       i,

   983 	       type,

   984 	       mdp->dmd_offset, mdp->dmd_fileindex, mdp->dmd_lineno);

   985     }

   986 

   987 }

   988 

   989 static void

   990 print_one_macro_entry(long i,

   991 		      struct Dwarf_Macro_Details_s *mdp,

   992 		      struct macro_counts_s *counts)

   993 {

   994 

   995     switch (mdp->dmd_type) {

   996     case 0:

   997 	counts->mc_code_zero++;

   998 	print_one_macro_entry_detail(i, "DW_MACINFO_type-code-0", mdp);

   999 	break;

  1000 

  1001     case DW_MACINFO_start_file:

  1002 	counts->mc_start_file++;

  1003 	print_one_macro_entry_detail(i, "DW_MACINFO_start_file", mdp);

  1004 	break;

  1005 

  1006     case DW_MACINFO_end_file:

  1007 	counts->mc_end_file++;

  1008 	print_one_macro_entry_detail(i, "DW_MACINFO_end_file  ", mdp);

  1009 	break;

  1010 

  1011     case DW_MACINFO_vendor_ext:

  1012 	counts->mc_extension++;

  1013 	print_one_macro_entry_detail(i, "DW_MACINFO_vendor_ext", mdp);

  1014 	break;

  1015 

  1016     case DW_MACINFO_define:

  1017 	counts->mc_define++;

  1018 	print_one_macro_entry_detail(i, "DW_MACINFO_define    ", mdp);

  1019 	break;

  1020 

  1021     case DW_MACINFO_undef:

  1022 	counts->mc_undef++;

  1023 	print_one_macro_entry_detail(i, "DW_MACINFO_undef     ", mdp);

  1024 	break;

  1025 

  1026     default:

  1027 	{

  1028 	    char create_type[50];	/* More than large enough. */

  1029 

  1030 	    counts->mc_unknown++;

  1031 	    snprintf(create_type, sizeof(create_type),

  1032 		     "DW_MACINFO_0x%x", mdp->dmd_type);

  1033 	    print_one_macro_entry_detail(i, create_type, mdp);

  1034 	}

  1035 	break;

  1036     }

  1037 }

  1038 

  1039 /* print data in .debug_macinfo */

  1040 /* FIXME: should print name of file whose index is in macro data

  1041    here  --  somewhere.

  1042 */

  1043  /*ARGSUSED*/ extern void

  1044 print_macinfo(Dwarf_Debug dbg)

  1045 {

  1046     Dwarf_Off offset = 0;

  1047     Dwarf_Unsigned max = 0;

  1048     Dwarf_Signed count = 0;

  1049     long group = 0;

  1050     Dwarf_Macro_Details *maclist = NULL;

  1051     int lres = 0;

  1052 

  1053     printf("\n.debug_macinfo\n");

  1054 

  1055     while ((lres = dwarf_get_macro_details(dbg, offset,

  1056 					   max, &count, &maclist,

  1057 					   &err)) == DW_DLV_OK) {

  1058 	long i;

  1059 	struct macro_counts_s counts;

  1060 

  1061 

  1062 	memset(&counts, 0, sizeof(counts));

  1063 

  1064 	printf("\n");

  1065 	printf("compilation-unit .debug_macinfo # %ld\n", group);

  1066 	printf

  1067 	    ("num name section-offset file-index [line] \"string\"\n");

  1068 	for (i = 0; i < count; i++) {

  1069 	    struct Dwarf_Macro_Details_s *mdp = &maclist[i];

  1070 

  1071 	    print_one_macro_entry(i, mdp, &counts);

  1072 	}

  1073 

  1074 	if (counts.mc_start_file == 0) {

  1075 	    printf

  1076 		("DW_MACINFO file count of zero is invalid DWARF2/3\n");

  1077 	}

  1078 	if (counts.mc_start_file != counts.mc_end_file) {

  1079 	    printf("Counts of DW_MACINFO file (%ld) end_file (%ld) "

  1080 		   "do not match!.\n",

  1081 		   counts.mc_start_file, counts.mc_end_file);

  1082 	}

  1083 	if (counts.mc_code_zero < 1) {

  1084 	    printf("Count of zeros in macro group should be non-zero "

  1085 		   "(1 preferred), count is %ld\n",

  1086 		   counts.mc_code_zero);

  1087 	}

  1088 	printf("Macro counts: start file %ld, "

  1089 	       "end file %ld, "

  1090 	       "define %ld, "

  1091 	       "undef %ld "

  1092 	       "ext %ld, "

  1093 	       "code-zero %ld, "

  1094 	       "unknown %ld\n",

  1095 	       counts.mc_start_file,

  1096 	       counts.mc_end_file,

  1097 	       counts.mc_define,

  1098 	       counts.mc_undef,

  1099 	       counts.mc_extension,

  1100 	       counts.mc_code_zero, counts.mc_unknown);

  1101 

  1102 

  1103 	/* int type= maclist[count - 1].dmd_type; */

  1104 	/* ASSERT: type is zero */

  1105 

  1106 	offset = maclist[count - 1].dmd_offset + 1;

  1107 	dwarf_dealloc(dbg, maclist, DW_DLA_STRING);

  1108 	++group;

  1109     }

  1110     if (lres == DW_DLV_ERROR) {

  1111 	print_error(dbg, "dwarf_get_macro_details", lres, err);

  1112     }

  1113 }

  1114 

  1115 /* print data in .debug_loc */

  1116 extern void

  1117 print_locs(Dwarf_Debug dbg)

  1118 {

  1119     Dwarf_Unsigned offset = 0;

  1120     Dwarf_Addr hipc_offset = 0;

  1121     Dwarf_Addr lopc_offset = 0;

  1122     Dwarf_Ptr data = 0;

  1123     Dwarf_Unsigned entry_len = 0;

  1124     Dwarf_Unsigned next_entry = 0;

  1125     int lres = 0;

  1126 

  1127     printf("\n.debug_loc format <o b e l> means "

  1128 	   "section-offset begin-addr end-addr length-of-block-entry\n");

  1129     while ((lres = dwarf_get_loclist_entry(dbg, offset,

  1130 					   &hipc_offset, &lopc_offset,

  1131 					   &data, &entry_len,

  1132 					   &next_entry,

  1133 					   &err)) == DW_DLV_OK) {

  1134 	printf("\t <obel> 0x%08llx 0x%09llx " "0x%08llx " "%8lld\n",

  1135 	       (long long) offset, (long long) lopc_offset,