#

 # 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));

 	}