#

# Copyright (c) 2006-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: 

# efficent_rom_paging.pm

# changes the paging/unpaged configuration of binaries a generated

# OBY file

# use

# externaltool=efficient_rom_paging

# in oby file to enable

# ## TODO

# ## keyword alias isn't handled

#

package efficient_rom_paging;

use strict;

our @EXPORT=qw(

    efficient_rom_paging_info

    efficient_rom_paging_single

    efficient_rom_paging_multiple

);

require Exporter;

our @ISA = qw(Exporter);

our @EXPORT_OK = qw();

my @moved_entry; # Holds all entries that has been moved without their dependencies

my %seen; # Holds all dependencies to entries in moved_entry

use File::Basename;

# routine to provide information about the tool

sub efficient_rom_paging_info ()

{

    my %toolinfo;

    $toolinfo{'name'} = "efficient_rom_paging";

    $toolinfo{'invocation'} = "InvocationPoint2.5";

    $toolinfo{'multiple'} = \&efficient_rom_paging_multiple;

    $toolinfo{'single'} = \&efficient_rom_paging_single;

    return \%toolinfo;

}

# routine to handle multiple invocation

sub efficient_rom_paging_multiple

{

    my ($line) = @_;

    my @args=split /[=\s]/, $line;

    return "REM efficient_rom_paging.pm";

}

#

# Hash of all executables and their paged attribute

#

my %executables;

sub is_oby_statement

{

	my ($li) = @_;

	if ($li =~ /\s*data\s*=/) { return 1;}

	if ($li =~ /\s*file\s*=/) { return 1;}

	if ($li =~ /\s*dll\s*=/) { return 1;}

	if ($li =~ /\s*secondary\s*=/) { return 1;}

	return 0;

}

# Scan OBY file and move ROM_IMAGE[1] paged executables to ROM_IMAGE[0] part

sub efficient_rom_paging_single

{

	my ($oby) = @_;

	print "efficient_rom_paging.pm: Making paging more efficient.\n";

	my $rofs_start = 0;

	#Find ROFS partition

	foreach my $line (@$oby)

	{

		if ($line =~ /ROM_IMAGE\[1\]/i)

		{

			last;

		}

		$rofs_start++;

	}

	my @rom_core_partition = @$oby[0 .. $rofs_start-1];

	my @rofs_partition = @$oby[$rofs_start .. $#$oby];

	if (is_pagingoverride_nopaged($oby))

	{

		move_all_paged_and_default_nonexecutables_to_core(\@rom_core_partition, \@rofs_partition);

		move_all_aliases_to_core(\@rom_core_partition, \@rofs_partition);

		@$oby = (@rom_core_partition, @rofs_partition);

		print "\n";

		return;

	}

	setup_pageable_attribute_array(\@rofs_partition);

	if (is_pagingoverride_defaultpaged($oby))

	{

		move_all_default_executables_to_core(\@rom_core_partition, \@rofs_partition);

	}

	move_all_paged_and_default_nonexecutables_to_core(\@rom_core_partition, \@rofs_partition);

	if (is_pagingoverride_alwayspage($oby))

	{

		move_all_executables_to_core(\@rom_core_partition, \@rofs_partition);

		move_all_aliases_to_core(\@rom_core_partition, \@rofs_partition);

		@$oby = (@rom_core_partition, @rofs_partition);

		print "\n";

		return;

	}

	move_all_paged_executables_to_core(\@rom_core_partition, \@rofs_partition);

	move_all_dependencies_to_core(\@rom_core_partition, \@rofs_partition, $oby);

	move_all_aliases_to_core(\@rom_core_partition, \@rofs_partition);

	move_all_renames_to_core(\@rom_core_partition, \@rofs_partition);

	move_all_patchdata_to_core(\@rom_core_partition, \@rofs_partition);

	@$oby = (@rom_core_partition, @rofs_partition);

	print "\n";

}

sub is_pagingoverride_nopaged

{

	my ($oby) = @_;

	for my $line (@$oby)

	{

		if ($line =~ /pagingoverride\s+nopaging/i)

		{

			return 1;

		}

	}

	return 0;

}

sub is_pagingoverride_defaultpaged

{

	my ($oby) = @_;

	for my $line (@$oby)

	{

		if ($line =~ /pagingoverride\s+defaultpaged/i)

		{

			return 1;

		}

	}

	return 0;

}

sub is_pagingoverride_alwayspage

{

	my ($oby) = @_;

	for my $line (@$oby)

	{

		if ($line =~ /pagingoverride\s+alwayspage/i)

		{

			return 1;

		}

	}

	return 0;

}

sub setup_pageable_attribute_array

{

	my ($rofs_partition) = @_;

	my $counter = 0;

	for my $line (@$rofs_partition)

	{

		if (is_oby_statement($line))

		{

			my $executable;

			$line =~ /file=(\S+)/i;

			$executable = $1;

			open DUMP, "ELFTRAN -dump h $executable |" or die "Can't execute ELFTRAN\n";

			while (my $line=<DUMP>)

			{

				if ($line =~ /pageability : (\S+)/i)

				{

					$executables{$executable} = $1;

					print "." if (($counter++ % 10) == 0);

				}

			}

			close DUMP;

		}

	}

}

sub move_all_paged_executables_to_core

{

	my ($rom_core, $rofs) = @_;

	my @rofs_execs = grep {$_ =~ /file\s*=/i} @$rofs;

	for my $line (@rofs_execs)

	{

		my $executable;

		$line =~ /file=(\S+) /;

		$executable = $1;

		if ($line =~ /\s+paged$/i || ($line !~ /\s+unpaged$/i && lc($executables{$executable}) eq 'paged'))

		{

			push @$rom_core, $line; # Add line to rom core.

			# Save the executables in a list. Will be used as a cache when dependencies are searched for.

			push @moved_entry, $executable; 

			@$rofs = grep {$_ ne $line} @$rofs; # Remove line from rofs partition

		}

	}

}

sub move_all_paged_nonexecutables_to_core

{

	my ($rom_core_partition, $rofs_partition) = @_;

	my @rofs_data = grep {$_ =~ /data\s*=\s*\S+\s+\S*\s+paged/i} @$rofs_partition;

	for my $line (@rofs_data)

	{

		push @$rom_core_partition, $line;

		@$rofs_partition = grep {$_ ne $line} @$rofs_partition;

	}

}

sub move_all_paged_and_default_nonexecutables_to_core

{

	my ($rom_core_partition, $rofs_partition) = @_;

	move_all_paged_nonexecutables_to_core($rom_core_partition, $rofs_partition);

	my @rofs_data = grep {$_ =~ /data=\s*/} @$rofs_partition;

	@rofs_data = grep {$_ !~ /unpaged/ } @rofs_data;

	for my $line (@rofs_data)

	{

		push @$rom_core_partition, $line;

		@$rofs_partition = grep {$_ ne $line} @$rofs_partition;

	}

}

sub move_all_default_executables_to_core

{

	my ($rom_core_partition, $rofs_partition) = @_;

	my @rofs_execs = grep {$_ =~ /file\s*=/i} @$rofs_partition;

	# If they have been set to unpaged in the oby file, they shouldn't be moved over.

	for my $executable (sort keys %executables)

	{

		if ($executables{$executable} =~ /default/i)

		{

			for my $line (@rofs_execs)

			{

				if ($line !~ /unpaged\s*$/i)

				{

					my $rofs_executable = $line;

					$rofs_executable =~ /file\s*=\s*(\S+)/i;

					$rofs_executable = $1;

					if ($rofs_executable eq $executable)

					{

						push @moved_entry, $executable; 

						push @$rom_core_partition, $line;

						@$rofs_partition = grep {$_ ne $line} @$rofs_partition;

						last;

					}

				}

			}

		}

	}

}

sub move_all_executables_to_core

{

	my ($rom_core_partition, $rofs_partition) = @_;

	my @all_executables = grep {$_ =~ /file\s*=/i} @$rofs_partition;

	for my $line (@all_executables)

	{

		push @$rom_core_partition, $line;

		push @moved_entry, $line;

		@$rofs_partition = grep {$_ ne $line} @$rofs_partition;

	}

}

sub move_all_aliases_to_core

{

	my ($rom_core_partition, $rofs_partition) = @_;

	my @all_aliases = grep {$_ =~ /^alias\s+\S+\s+\S+/i} @$rofs_partition;

	for my $line (@all_aliases)

	{

		$line =~ /^alias\s+(\S+)\s+\S+/i;

		my $alias = $1;

		$alias = basename($alias);

		my @file_stmt = grep {$_ =~ /^\s*(extension|device|file|data)(\[\S+\])?\s*=\s*\S+\s+\S*($alias)(\")?[\s+|\r](\s+\S+)*\s*$/i} @$rom_core_partition;

 		if(scalar @file_stmt)

		{

			push @$rom_core_partition, $line;

			@$rofs_partition = grep {$_ ne $line} @$rofs_partition;

		}

	}

}

sub move_all_renames_to_core

{

	my ($rom_core_partition, $rofs_partition) = @_;

	my @all_renames = grep {$_ =~ /^rename\s+\S+\s+\S+/i} @$rofs_partition;

	for my $line (@all_renames)

	{

		$line =~ /^rename\s+(\S+)\s+\S+/i;

		my $rename = $1;

		$rename = basename($rename);

		for (my $i=0; $i < scalar @$rom_core_partition; $i++)

		{

			if ($rename =~ $$rom_core_partition[$i])

			{

				splice(@$rom_core_partition, $i+1, 0, $line);

				@$rofs_partition = grep {$_ ne $line} @$rofs_partition;

				last;

			}

		}

	}

}

sub move_all_patchdata_to_core

{

	my ($rom_core_partition, $rofs_partition) = @_;

	my @all_patchdata = grep {$_ =~ /^patchdata\s+\S+\s+\S+\s+/i} @$rofs_partition;

	for my $line (@all_patchdata)

	{

		$line =~ /^patchdata\s+(\S+)\s+\S+\s+/i;

		my $patchdata = $1;

		$patchdata = basename($patchdata);

		if (grep($patchdata, @$rom_core_partition))

		{

			push @$rom_core_partition, $line;

			@$rofs_partition = grep {$_ ne $line} @$rofs_partition;

		}

	}

}

sub move_all_dependencies_to_core

{

	my ($rom_core_partition, $rofs_partition, $oby) = @_;

	my $counter = 0;

	for my $d (@moved_entry) 

	{

		if (!exists $seen{$d})

		{

			$seen{$d}=();

			listcomp("", $d, $oby);

			$counter++;

			print "." if (($counter % 10) == 0);

		}

	}

	# delete all dependencies that have already been moved to core rom.		

	for my $exec (@moved_entry)

	{

		if (exists $seen{$exec})

		{

			delete $seen{$exec};

		}

	}

	# move all dependencies to rom core

	my @rofs_execs = grep {$_ =~/file\s*=/i} @$rofs_partition;

	for my $exec (keys %seen)

	{

		for my $line (@rofs_execs)

		{

			my $rofs_exec = $line;

			$rofs_exec =~ /file\s*=\s*\S+\s+(\S+)/i;

			$rofs_exec = $1;

			$rofs_exec =~ s/"//g;

			if (basename(lc($exec)) eq basename(lc($rofs_exec)))

			{

				push @$rom_core_partition, $line;

				push @moved_entry, $line;

				@$rofs_partition = grep {$_ ne $line} @$rofs_partition;

				last;

			}

		}

	}

}

# for each exe, list the dependencies

sub listcomp

{

	my ($deps, $comp, $oby) = @_;

	# find dependencies of comp

	my @ar=getdeps($comp, $oby);

	# recurse over new dependencies

	foreach my $d (@ar)

	{

		$d=lc($d);

		if (!exists $seen{$d})

		{

 			# recurse

			$seen{$d}=();

			listcomp($deps, $d, $oby);

		}

	}

}

sub getdeps

{

	my ($comp, $oby) = @_;

	my @list=();

	my $hw_base_name = basename($comp);

	for my $line (@$oby)

	{

		if (is_oby_statement($line))

		{

			if ($line =~ /\\$hw_base_name/i)

			{

				$line =~ /\s*=\s*(\S+)\s*/;

				$comp = $1;

				last;

			}

		}

	}

	open DUMP, "ELFTRAN -dump i $comp |" or die "Can't execute ELFTRAN\n";

	while (my $line=<DUMP>)

	{

		if ($line =~ /imports from (\S+)/i)

		{

			my $d = $1;

			$d =~ s/\{\S{8}\}//; # remove {00000000}

			$d =~ s/\[\S{8}\]//; # remove [00000000]

			push @list, "$d";

		}

	}

	close DUMP;

	return @list;

}

1;