#
# Copyright (c) 1999-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:
# Relinks the debug exe/dlls in a ROM if the make file is present
#
require 5.003_07;
use strict;
no strict 'vars';
use English;
use Cwd;
use FindBin; # for FindBin::Bin
my $PerlLibPath; # fully qualified pathname of the directory containing our Perl modules
BEGIN {
# check user has a version of perl that will cope
require 5.005_03;
# establish the path to the Perl libraries: currently the same directory as this script
$PerlLibPath = $FindBin::Bin; # X:/epoc32/tools
$PerlLibPath =~ s/\//\\/g; # X:\epoc32\tools
$PerlLibPath .= "\\";
}
use lib $PerlLibPath;
use Modload;
Load_SetModulePath($PerlLibPath);
# Globals
my $debug = 0;
my $rombuild;
my @executables = ( 'euser' );
cwd =~ /^(.:)/o;
my $drive = $1;
# get EPOCROOT for searching directories
my $epocroot = lc $ENV{EPOCROOT};
&args;
&main;
exit 0;
#
# main
#
sub main
{
my $file;
my $text;
my $data;
my $bss;
my $textlen;
my $datalen;
my $bsslen;
open (ROM, "<$rombuild")
or die "ERROR: Can't open rombuild log file \"$rombuild\"\n";
die "ERROR: \"$rombuild\" isn't a rombuild log file\n"
unless ((<ROM> =~ /^ROMBUILD/) || (<ROM> =~ /^ROMBUILD/));
# build up a hash of all the make files indexed by build and exe name
#
# do this in a more directed way based on the map files for the
# executables we are interested in.
%map = ();
&dirsearch($epocroot . "EPOC32\\", "BUILD");
while (<ROM>)
{
if (/^Writing Rom image/)
{
# stop at end of first ROM, ignoring any extension ROMs
# This is necessary because the same file could appear
# at different places in different extensions.
#
last;
}
if (/^Processing file (.*)/)
{
my $datalen;
my $skip;
$file = lc $1;
$text = $bss = $data = $datalen = 0;
# Work out final addresses of sections
while (defined($_=<ROM>) && !/^$/)
{
if (/^Code start addr:\s+(\w+)/)
{
$text = hex($1);
}
elsif (/^DataBssLinearBase:\s+(\w+)/)
{
$data = hex($1);
}
elsif (/^Code size:\s+(\w+)/)
{
$textlen = hex($1);
}
elsif (/^Data size:\s+(\w+)/)
{
$datalen = hex($1);
$bss = $data + $datalen;
}
elsif (/^BssSize:\s+(\w+)/)
{
$bsslen = hex($1);
}
}
# Sanity check - text section can't be zero (other sections may be)
die "ERROR: Can't find rombuild info for \"$file\"\n"
if (!$text);
# get the build and exe name
# protect $epocroot with \Q and \E to stop it
# using \ as a special character
if ($file =~ /^\Q$epocroot\Eepoc32\\release\\(.*)\\(.*)\\(.*)$/o)
{
$build = lc $1;
$debrel = uc $2;
$executablefile = lc $3;
}
# Only relink this file if it's kernel-side or matches the regexp
if ($build =~ /^(M|S)/i)
{
$skip = 0;
}
else
{
$skip = 1;
foreach $re (@executables)
{
$skip = 0 if ($file =~ /$re/i);
}
}
print "$file - skipped\n" if ($skip && $debug);
next if ($skip);
if (! defined $map{"$build $executablefile"})
{
print "$file - no makefile\n";
next;
}
if ($debrel ne "UDEB")
{
print "$file - can't fixup $debrel\n";
next;
}
# relink this file
print "$file";
# lookup the makefile name
($makepath, $workdir) = @{$map{"$build $executablefile"}};
# only relink if we have a makefile
if ($makepath && $workdir)
{
# optimisation: don't relink if already at correct address
$file =~ /(.+\.)[^\.]+/;
my $symfile = $drive.$1."sym";
my $buf;
my $elffile;
open SYMFILE, $symfile or print"\nCannot open $symfile\n";
read SYMFILE, $buf, 4;
if ($buf =~/^\x7F\x45\x4C\x46/){
$elffile = $buf;
}
close SYMFILE;
if ($elffile){
if ((-e $file) && (-e $symfile) &&
open (CHILD, "fromelf -v $symfile |"))
{
my $oldtext;
my $olddata;
my $foundcode = 0;
my $founddata = 0;
while (<CHILD>)
{
if (/ER_RO/)
{
$foundcode = 1;
}
if (/ER_RW/)
{
$founddata = 1;
}
if (/Addr : 0x\w+/)
{
$_=~tr/0-9//dc;
if ($founddata == 1)
{
$founddata = 0;
$olddata = hex($_);
}
if ($foundcode == 1)
{
$foundcode = 0;
$oldtext = hex($_);
}
}
}
close CHILD;
$skip = 1 if ((!$textlen || ($text == $oldtext)) && (!$datalen || ($data == $olddata)));
}
}
else {
if ((-e $file) && (-e $symfile) &&
open (CHILD, "objdump --headers $symfile |"))
{
my $oldtext;
my $olddata;
my $oldbss;
while (<CHILD>)
{
if (/^\s+\d+\s+(\.\w+)\s+[0-9a-fA-F]+\s+([0-9a-fA-F]+)\s/)
{
if ($1 eq '.text')
{
$oldtext = hex($2);
}
elsif ($1 eq '.data')
{
$olddata = hex($2);
}
elsif ($1 eq '.bss')
{
$oldbss = hex($2);
}
}
}
close CHILD;
$skip = 1 if ((!$textlen || ($text == $oldtext)) &&
(!$datalen || ($data == $olddata)) &&
(!$bsslen || ($bss == $oldbss)));
print " - current" if ($skip && $debug);
}
}
if (!$skip)
{
chdir $workdir
or die "Can't cd to build directory \"$workdir\"\n";
# save executable in case relink fails
rename $file, "$file.bak"
or die "Can't rename \"$file\": $ERRNO\n"
if -e $file;
$makepath = &fixMakefile($makepath);
my $command;
if ($elffile){
if($makepath =~ /\.gcce/i){
$command =
sprintf ("make -r -s -f \"$makepath\" $debrel " .
"USERLDFLAGS=\"-Ttext 0x%lx -Tdata 0x%lx\"", $text, $data);
}
else {
$command =
sprintf ("make -r -s -f \"$makepath\" $debrel " .
"USERLDFLAGS=\"--ro-base 0x%lx --rw-base 0x%lx\"", $text, $data);
}
}
else {
$command =
sprintf ("make -r -s -f \"$makepath\" $debrel " .
"USERLDFLAGS=\"--image-base 0 -Ttext 0x%lx " .
"-Tdata 0x%lx -Tbss 0x%lx\"",
$text, $data, $bss);
}
print "\n\"$command\"" if ($debug);
open (CHILD, "$command |")
or die "\nERROR: Can't run \"$command\": $ERRNO\n";
close CHILD;
unlink $makepath;
if (-e $file)
{
unlink "$file.bak";
}
else # relink failed for some reason - restore saved
{
rename "$file.bak", $file;
}
}
print "\n";
}
else
{
print " - can't fixup\n";
}
}
}
close ROM;
}
#
# args - get command line args
#
sub args
{
my $arg;
my @args;
my $flag;
&help if (!@ARGV);
while (@ARGV)
{
$arg = shift @ARGV;
if ($arg=~/^[\-\/](\S*)$/)
{
$flag=$1;
if ($flag=~/^[\?h]$/i)
{
&help;
}
else
{
print "\nERROR: Unknown flag \"-$flag\"\n";
&usage;
exit 1;
}
}
else
{
push @args,$arg;
}
}
$rombuild = shift @args;
if (@args)
{
foreach $file (@args)
{
push @executables, quotemeta($file);
}
}
}
# recursive directory search
sub dirsearch
{
my ($input_path, $dir) = @_;
my $searchpath = "$input_path$dir\\";
my $workdir;
return unless (opendir DIRHANDLE, $searchpath);
my @allfiles = grep !/^\.\.?$/, readdir DIRHANDLE;
closedir DIRHANDLE;
# Breadth first search: scan files and collect list of subdirectories
my @dirlist;
foreach $entry (@allfiles)
{
my $entrypath = "$searchpath$entry";
if (-d $entrypath)
{
# don't look in udeb & urel directories which contain objects and binaries
push @dirlist, $entry unless ($entry =~ /(deb|rel)$/i);
}
elsif ($entry =~ /$dir$/i)
{
# ARM4/xxx.ARM4 => generated makefile
my $liney;
open (FILE, "<$entrypath");
while ($liney=<FILE>)
{
if ($liney =~ /^\# CWD\s(.+)\\/)
{
$workdir = lc $1;
}
if ($liney =~ /^\# Target\s(.*)$/)
{
my $target = lc $1;
# add to the hash table
my $build = lc $dir;
$map{"$build $target"} = [lc "$entrypath", $workdir];
$workdir = undef;
last;
}
}
close FILE;
}
}
undef @allfiles;
# Now process the subdirectories...
foreach $entry (@dirlist)
{
&dirsearch ($searchpath,$entry);
}
undef @dirlist;
}
sub help ()
{
my $build;
&Load_ModuleL('E32TPVER');
print "\nfixupsym - " .
"Fix up executables with locations taken from a ROM image (Build ",
&E32tpver, ")\n";
&usage;
exit 0;
}
sub usage ()
{
print <<EOF
Usage:
fixupsym <logfile> [<executables>]
Where:
<logfile> Log file from rombuild tool.
<executables> Names of additional executables to fix up.
ASSP-specific executables and EUSER are always included.
Example:
fixupsym rombuild.log efile efsrv .fsy
EOF
;
exit 0;
}
sub fixMakefile()
{
my $makefile = shift @_;
my $tmpMakfile = $makefile.".TMP";
open (FILEIN, $makefile) or die "Can't open file \"$makefile\" \n";
open (FILEOUT, ">".$tmpMakfile) or die "Can't create file \"$tmpMakfile\" \n";
while(<FILEIN>) {
if ($_ =~ /^\s*elf2e32/){
print FILEOUT "#".$_;
}
else {
print FILEOUT $_;
}
}
close FILEIN;
close FILEOUT;
$tmpMakfile;
}