#

# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of the License "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description:

#

# Perl script to decode ROM symbols

#

# Usage: perl printsym.pl symbolfile

#

# Converts various forms of text from STDIN and write to stdout

use strict;

add_object(0xF8000000,0xFFF00000, "ROM");

die "Usage: printsym.pl romsymbolfile\n" unless @ARGV;

my %addresslist;

my %address;

read_rom_symbols($ARGV[0]);

shift;

## need to add more file types here... especially .map files

# We've accumulated the ranges of objects indexed by start address,

# with a companion list of addresses subdivided by the leading byte

# Now sort them numerically...

sub numerically { $a <=> $b }

foreach my $key (keys %addresslist)

{

	@{$addresslist{$key}} = sort numerically @{$addresslist{$key}};

}

# read lines from STDIN and decode them

print "Please enter data to be decoded\n";

while (my $line=<STDIN>)

	{

	next if ($line =~ /^\s+$/);		# skip blank lines

	print "\n";

	if ($line =~ /(?:^|\s)(([0-9A-Fa-f]{2} ){4,})/)	# pairs of hex digits separated by spaces = hex dump?

		{

		hexbytes($1);

		print "\n";

		next;

		}

	if ($line =~ /[0-9A-Fa-f]{8}\s+/)	# groups of hex words

		{

		hexwords($line);

		print "\n";

		next;

		}

	print "???\n";

	}

#############################################################################

sub add_object

	{

	my ($base, $max, $name) = @_;

	$address{$base} = [ $base, $max, $name ];

	my $key=$base>>20;

	my $maxkey=$max>>20;

	while ($key <= $maxkey)		# allowing for objects that span the boundary

		{

		push @{$addresslist{$key}}, $base;

		$key+=1;

		}

	}

sub match_addr

#

# Try matching one of the named areas in the addresslist

#

	{

	my ($word) = @_;

	if ($word < 1024*1024)

		{

		return 0;

		}

	# Optimization - try looking up the address directly

	my $base;

	my $max;

	my $name;

	if(defined $address{$word}) {

		($base, $max, $name) = @{$address{$word}};

	}

	if (!(defined $base))

		{

		my $key=$word>>20;

		my $regionbase;

		foreach $base (@{$addresslist{$key}})

			{

			if ($base <= $word)

				{

				$regionbase = $base;

				next;

				}

			if ($base > $word)

				{

				last;

				}

			}

		if(defined $regionbase)

			{

			($base, $max, $name) = @{$address{$regionbase}};

			}

		}

	if (defined $base && defined $max && $base <= $word && $max >= $word)

		{

		printf "%s + 0x%x", $name, $word - $base;

		return 1;

		}

	return 0;

	}

# Handle a MAKSYM.LOG file for a ROM

#

# NB. Wanted to do 

#

#   open ROMIMAGE, "cxxfilt <$romimage |" or open ROMIMAGE, $romimage or die

#

# but this uses "/bin/sh cxxfilt <$romimage" which works up to the point where the

# shell can't load cxxfilt.

#

sub read_rom_symbols

	{

	my ($romimage)=@_;

	open ROMSYMBOLS, $romimage or print "Can't open $romimage\n" and return;

	my $a;

	my $b;

	while (my $line = <ROMSYMBOLS>)

		{

		if(!($line =~ /^[0-9A-Fa-f]{8}/))

			{

			next;

			}

		# 8 bytes for the address

		$a = substr $line,0,8;

		if(!($a =~ /[0-9A-Fa-f]{8}/))

			{

			next;

			}

		# 4 bytes for the length

		$b = substr $line,12,4;

		if(!($b =~ /[0-9A-Fa-f]{4}/))

			{

			next;

			}

		# rest of line is symbol

		my $symbol = substr $line,20;

		chomp $symbol;

		my $base=hex($a);

		my $length=hex($b);

		if ($base < 0x50000000) 

			{

			next;	# skip this line

			}

		if ($length==0xffffffff)

			{

			$length=100;	# MAKSYM bug? choose a rational length

			}

		add_object($base, $base+$length-1, $symbol);

		}

	print "ROM Symbols from $romimage\n";

	}

sub dumpword

	{

	my ($word) = @_;

	my $data = pack "V", @_[0];

	$data =~ tr [\040-\177]/./c;

	printf "= %08x %4s  ", $word, $data;

	match_addr($word);

	printf "\n";

	}

sub hexbytes

	{

	my @bytes = split /\s+/, @_[0];

	my $wordcount = @bytes/4;

	map { dumpword($_) } (unpack "V$wordcount", (pack "H2"x($wordcount*4), @bytes));

	}

sub hexwords

	{

	my @words = grep /[0-9A-Fa-f]{8}/, split( /[^0-9A-Fa-f]+/, @_[0]);

	my $wordcount = @words;

	map { dumpword($_) } (unpack "N$wordcount", (pack "H8"x($wordcount), @words));

	}