/* 

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

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

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

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

  published by the Free Software Foundation.

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

  WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

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

  free of the rightful claim of any third person regarding infringement

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

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

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

  other software, or any other product whatsoever.

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

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

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

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

  Mountain View, CA 94043, or:

  http://www.sgi.com

  For further information regarding this notice, see:

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

$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 $ */

#include "globals.h"

#include "dwarf_names.h"

#include "dwconf.h"

#include "print_frames.h"

/*

 * Print line number information:

 * 	filename

 *	new basic-block

 *	[line] [address] <new statement>

 */

static void

  print_pubname_style_entry(Dwarf_Debug dbg,

			    char *line_title,

			    char *name,

			    Dwarf_Unsigned die_off,

			    Dwarf_Unsigned cu_off,

			    Dwarf_Unsigned global_cu_off,

			    Dwarf_Unsigned maxoff);

/* referred in dwarfdump.c */

Dwarf_Die current_cu_die_for_print_frames;

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

   return an error.

   If it does the error checking in

	print_pubname_style_entry()

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

   This intended for checking pubnames-style call return

   values (for all the pubnames-style interfaces).

   In at least one gigantic executable die_off turned out wrong.

*/

static void

deal_with_name_offset_err(Dwarf_Debug dbg,

			  char *err_loc,

			  char *name, Dwarf_Unsigned die_off,

			  int nres, Dwarf_Error err)

{

    if (nres == DW_DLV_ERROR) {

	Dwarf_Unsigned myerr = dwarf_errno(err);

	if (myerr == DW_DLE_OFFSET_BAD) {

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

		   err_loc,

		   name,

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

	}

	print_error(dbg, err_loc, nres, err);

    }

}

static void

print_source_intro(Dwarf_Die cu_die)

{

    Dwarf_Off off = 0;

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

    if (ores == DW_DLV_OK) {

	printf

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

	     (unsigned long long) off);

    } else {

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

    }

}

extern void

print_line_numbers_this_cu(Dwarf_Debug dbg, Dwarf_Die cu_die)

{

    Dwarf_Signed linecount = 0;

    Dwarf_Line *linebuf = NULL;

    Dwarf_Signed i = 0;

    Dwarf_Addr pc = 0;

    Dwarf_Unsigned lineno = 0;

    Dwarf_Signed column = 0;

    string filename;

    Dwarf_Bool newstatement = 0;

    Dwarf_Bool lineendsequence = 0;

    Dwarf_Bool new_basic_block = 0;

    int lres = 0;

    int sres = 0;

    int ares = 0;

    int lires = 0;

    int cores = 0;

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

    if (verbose > 1) {

	print_source_intro(cu_die);

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

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

	lres = dwarf_print_lines(cu_die, &err);

	if (lres == DW_DLV_ERROR) {

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

	}

	return;

    }

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

    if (lres == DW_DLV_ERROR) {

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

    } else if (lres == DW_DLV_NO_ENTRY) {

	/* no line information is included */

    } else {

	print_source_intro(cu_die);

	if (verbose) {

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

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

	}

	printf

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

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

	    Dwarf_Line line = linebuf[i];

	    int nsres;

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

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

	    if (sres == DW_DLV_ERROR) {

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

	    }

	    if (sres == DW_DLV_NO_ENTRY) {

		filename = "<unknown>";

	    }

	    if (ares == DW_DLV_ERROR) {

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

	    }

	    if (ares == DW_DLV_NO_ENTRY) {

		pc = 0;

	    }

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

	    if (lires == DW_DLV_ERROR) {

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

	    }

	    if (lires == DW_DLV_NO_ENTRY) {

		lineno = -1LL;

	    }

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

	    if (cores == DW_DLV_ERROR) {

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

	    }

	    if (cores == DW_DLV_NO_ENTRY) {

		column = -1LL;

	    }

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

		   column, pc);

	    if (sres == DW_DLV_OK)

		dwarf_dealloc(dbg, filename, DW_DLA_STRING);

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

	    if (nsres == DW_DLV_OK) {

		if (newstatement) {

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

		}

	    } else if (nsres == DW_DLV_ERROR) {

		print_error(dbg, "linebeginstatment failed", nsres,

			    err);

	    }

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

	    if (nsres == DW_DLV_OK) {

		if (new_basic_block) {

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

		}

	    } else if (nsres == DW_DLV_ERROR) {

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

	    }

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

	    if (nsres == DW_DLV_OK) {

		if (lineendsequence) {

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

		}

	    } else if (nsres == DW_DLV_ERROR) {

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

	    }

	    printf("\n");

	}

	dwarf_srclines_dealloc(dbg, linebuf, linecount);

    }

}

/*

A strcpy which ensures NUL terminated string

and never overruns the output.

*/

static void

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

{

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

	strncpy(out, in, outlen - 1);

	out[outlen - 1] = 0;

    } else {

	strcpy(out, in);

    }

}

/*

	Returns 1 if a proc with this low_pc found.

	Else returns 0.

*/

static int

get_proc_name(Dwarf_Debug dbg, Dwarf_Die die, Dwarf_Addr low_pc,

	      char *proc_name_buf, int proc_name_buf_len)

{

    Dwarf_Signed atcnt = 0;

    Dwarf_Signed i = 0;

    Dwarf_Attribute *atlist = NULL;

    Dwarf_Addr low_pc_die = 0;

    int atres = 0;

    int funcres = 1;

    int funcpcfound = 0;

    int funcnamefound = 1;

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

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

    if (atres == DW_DLV_ERROR) {

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

	return 0;

    }

    if (atres == DW_DLV_NO_ENTRY) {

	return 0;

    }

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

	Dwarf_Half attr;

	int ares;

	string temps;

	int sres;

	int dres;

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

	    /* stop as soon as both found */

	    break;

	}

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

	if (ares == DW_DLV_ERROR) {

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

	} else if (ares == DW_DLV_OK) {

	    switch (attr) {

	    case DW_AT_name:

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

		if (sres == DW_DLV_ERROR) {

		    print_error(dbg,

				"formstring in get_proc_name failed",

				sres, err);

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

		       actual string */

		    safe_strcpy(proc_name_buf, proc_name_buf_len,

				"ERROR in dwarf_formstring!", 50);

		} else if (sres == DW_DLV_NO_ENTRY) {

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

		       actual string */

		    safe_strcpy(proc_name_buf, proc_name_buf_len,

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

		} else {

		    long len = (long) strlen(temps);

		    safe_strcpy(proc_name_buf, proc_name_buf_len, temps,

				len);

		}

		funcnamefound = 1;	/* FOUND THE NAME */

		break;

	    case DW_AT_low_pc:

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

		if (dres == DW_DLV_ERROR) {

		    print_error(dbg, "formaddr in get_proc_name failed",

				dres, err);

		    low_pc_die = ~low_pc;

		    /* ensure no match */

		}

		funcpcfound = 1;

		break;

	    default:

		break;

	    }

	}

    }

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

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

    }

    dwarf_dealloc(dbg, atlist, DW_DLA_LIST);

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

	funcres = 0;

    }

    return (funcres);

}

/*

	Modified Depth First Search looking for the procedure:

	a) only looks for children of subprogram.

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

	   for a child.

	Needed since some languages, including MP Fortran,

	have nested functions.

	Return 0 on failure, 1 on success.

*/

static int

get_nested_proc_name(Dwarf_Debug dbg, Dwarf_Die die, Dwarf_Addr low_pc,

		     char *ret_name_buf, int ret_name_buf_len)

{

    char name_buf[BUFSIZ];

    Dwarf_Die curdie = die;

    int die_locally_gotten = 0;

    Dwarf_Die prev_child = 0;

    Dwarf_Die newchild = 0;

    Dwarf_Die newsibling = 0;

    Dwarf_Half tag;

    Dwarf_Error err = 0;

    int chres = DW_DLV_OK;

    ret_name_buf[0] = 0;

    while (chres == DW_DLV_OK) {

	int tres;

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

	newchild = 0;

	err = 0;

	if (tres == DW_DLV_OK) {

	    int lchres;

	    if (tag == DW_TAG_subprogram) {

		int proc_name_v;

		proc_name_v = get_proc_name(dbg, curdie, low_pc,

					    name_buf, BUFSIZ);

		if (proc_name_v) {

		    /* this is it */

		    safe_strcpy(ret_name_buf, ret_name_buf_len,

				name_buf, (long) strlen(name_buf));

		    if (die_locally_gotten) {

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

			   not want to dealloc here! */

			dwarf_dealloc(dbg, curdie, DW_DLA_DIE);

		    }

		    return 1;

		}

		/* check children of subprograms recursively should

		   this really be check children of anything? */

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

		if (lchres == DW_DLV_OK) {

		    /* look for inner subprogram */

		    int newprog =

			get_nested_proc_name(dbg, newchild, low_pc,

					     name_buf, BUFSIZ);

		    dwarf_dealloc(dbg, newchild, DW_DLA_DIE);

		    if (newprog) {

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

			   we could concatenate names together For now, 

			   just take name */

			if (die_locally_gotten) {

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

			       do not want to dealloc here! */

			    dwarf_dealloc(dbg, curdie, DW_DLA_DIE);

			}

			safe_strcpy(ret_name_buf, ret_name_buf_len,

				    name_buf, (long) strlen(name_buf));

			return 1;

		    }

		} else if (lchres == DW_DLV_NO_ENTRY) {

		    /* nothing to do */

		} else {

		    print_error(dbg,

				"get_nested_proc_name dwarf_child() failed ",

				chres, err);

		    if (die_locally_gotten) {

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

			   not want to dealloc here! */

			dwarf_dealloc(dbg, curdie, DW_DLA_DIE);

		    }

		    return 0;

		}

	    }			/* end if TAG_subprogram */

	} else {

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

	    if (die_locally_gotten) {

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

		   to dealloc here! */

		dwarf_dealloc(dbg, curdie, DW_DLA_DIE);

	    }

	    return 0;

	}

	/* try next sibling */

	prev_child = curdie;

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

	if (chres == DW_DLV_ERROR) {

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

			err);

	    if (die_locally_gotten) {

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

		   to dealloc here! */

		dwarf_dealloc(dbg, curdie, DW_DLA_DIE);

	    }

	    return 0;

	} else if (chres == DW_DLV_NO_ENTRY) {

	    if (die_locally_gotten) {

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

		   to dealloc here! */

		dwarf_dealloc(dbg, prev_child, DW_DLA_DIE);

	    }

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

	} else {		/* DW_DLV_OK */

	    curdie = newsibling;

	    if (die_locally_gotten) {

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

		   to dealloc here! */

		dwarf_dealloc(dbg, prev_child, DW_DLA_DIE);

	    }

	    prev_child = 0;

	    die_locally_gotten = 1;

	}

    }

    if (die_locally_gotten) {

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

	   dealloc here! */

	dwarf_dealloc(dbg, curdie, DW_DLA_DIE);

    }

    return 0;

}

/*

  For MP Fortran and possibly other languages, functions 

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

  not just the top level.

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

  of  the current cu.

*/

string

get_fde_proc_name(Dwarf_Debug dbg, Dwarf_Addr low_pc)

{

    static char proc_name[BUFSIZ];

    Dwarf_Unsigned cu_header_length;

    Dwarf_Unsigned abbrev_offset;

    Dwarf_Half version_stamp;

    Dwarf_Half address_size;

    Dwarf_Unsigned next_cu_offset = 0;

    int cures = DW_DLV_OK;

    int dres = DW_DLV_OK;

    int chres = DW_DLV_OK;

    int looping = 0;

    if (current_cu_die_for_print_frames == NULL) {

	cures

	    = dwarf_next_cu_header(dbg, &cu_header_length,

				   &version_stamp, &abbrev_offset,

				   &address_size, &next_cu_offset,

				   &err);

	if (cures == DW_DLV_ERROR) {

	    return NULL;

	} else if (cures == DW_DLV_NO_ENTRY) {

	    /* loop thru the list again */

	    current_cu_die_for_print_frames = 0;

	    ++looping;

	} else {		/* DW_DLV_OK */

	    dres = dwarf_siblingof(dbg, NULL,

				   &current_cu_die_for_print_frames,

				   &err);

	    if (dres == DW_DLV_ERROR) {

		return NULL;

	    }

	}

    }

    if (dres == DW_DLV_OK) {

	Dwarf_Die child = 0;

	if (current_cu_die_for_print_frames == 0) {

	    /* no information. Possibly a stripped file */

	    return NULL;

	}

	chres =

	    dwarf_child(current_cu_die_for_print_frames, &child, &err);

	if (chres == DW_DLV_ERROR) {

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

			err);

	} else if (chres == DW_DLV_NO_ENTRY) {

	} else {		/* DW_DLV_OK */