mcu/tools/ldsInfo.pm

#!/usr/bin/perl
#
#  Copyright Statement:
#  --------------------
#  This software is protected by Copyright and the information contained
#  herein is confidential. The software may not be copied and the information
#  contained herein may not be used or disclosed except with the written
#  permission of MediaTek Inc. (C) 2006
#
#  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
#  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
#  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
#  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
#  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
#  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
#  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
#  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
#  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
#  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
#  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
#  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
#
#  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
#  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
#  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
#  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
#  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
#
#  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
#  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
#  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
#  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
#  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
#
#*****************************************************************************
#*
#* Filename:
#* ---------
#*   ldsInfo.pm
#*
#* Project:
#* --------
#*
#*
#* Description:
#* ------------
#*   This script is to parse LinkerScript
#*
#* Author:
#* -------
#*   Qmei Yang (mtk03726)
#*
#****************************************************************************/
#****************************************************************************
# Included Modules
#****************************************************************************
use strict;
BEGIN { push @INC, './pcore/tools/' }  # add additional library path
use CommonUtility;
use sysGenUtility;
#****************************************************************************
# Constants
#****************************************************************************
package Region;
use constant Base         => 0;
use constant MaxSize      => 1;
use constant Attribute    => 2;
use constant Offset       => 3;

package InfoIndex;
use constant Base         => 1;
use constant MaxSize      => 3;
use constant Attribute    => 4;
use constant Offset       => 2;

package ldsInfo;
#****************************************************************************
# Global Variables
#****************************************************************************
#****************************************************************************
# oo >>>  Finished
#****************************************************************************
return 1;

#****************************************************************************
# ldsInfo Version
#****************************************************************************
sub ldsInfo_verno
{
    return " u0.02";
           # u0.02 , 20160621 by Tero, Memory parsing modified
           # u0.01 , 20150806 by carl, Avoid taking linker symbol with postfix "_LENGTH" as a section
           # m0.11 , 20130605 by mei, Support to strip comments in MEMORY
           # m0.10 , 20130503 by mei, Add GetMEMORYInfoByName()
           # m0.09 , 20121125 by mei, Support ParseSECTIONS() to skip other kinds of ASSERT
           # m0.08 , 20121029 by mei, Support more flexible MEMORY format
           # m0.07 , 20121002 by mei, Support ORIGIN
           # m0.06 , 20120921 by mei, Support parsing hidden execution regions(the regions aint shown in linker symbol)
           # m0.05 , 20120724 by mei, Support parsing MaxSize by ASSERT in linker script
           # m0.04 , 20120528 by mei, Support path and filename case sensitive on Linux
           # m0.03 , 20120522 by mei, support sysgen2
           # m0.02 , 20120513 by mei, support partially parsing Linker Script
           # m0.01 , 20120504 by mei, initial version
}

sub ParseSECTIONS
{
    my $self = shift;
    my ($strInput) = @_;
    my @lines = split(/\n/, $strInput);
    map {$self->parse_linker_symbol($_)} @lines;
    my ($strPrvRegionName, $strPrvBase, $nOVERLAYLine) = (undef, undef, 0);
    my @OVERLAY;
    foreach my $strLine (@lines) 
    {
        next if($strLine =~ /PROVIDE/);
        if($strLine =~ /ASSERT/ and $strLine =~ /Sizes\s*of\s*(\S+)\s*exceed\s*(\w+)/ )
        {
            my ($strRegionName, $nMaxSize) = ($1, hex($2));
            my $nIndex = $self->{ExeRegionLookUpTable}{$strRegionName};
            $self->{ExeRegion}->{$nIndex}[3] = $nMaxSize;
        }
        elsif($strLine =~ /ASSERT/)
        {
            next;
        }
        elsif(($strLine =~ /(\S+)\s+(\S+)*\s*\(NOLOAD\)\s*\:(.*)/ 
          or $strLine =~ /(\S+)\s+(\S+)*\s*\:(.*)/)
          and $strLine !~ /OVERLAY/)
        {
            my ($strRegionName, $strBase, $strLast) = ($1, $2, $3);
            if($strPrvRegionName eq "OVERLAY")
            {
                $self->parse_overlay(\@OVERLAY);
                $nOVERLAYLine = 0;
                @OVERLAY = ();
            }
            if($strBase =~ /ALIGN|\d+/)
            {
                my $nIndex = $self->{ExeRegionLookUpTable}{$strRegionName};
                $self->{ExeRegion}->{$nIndex}[1] = $strBase;
                $self->{ExeRegion}->{$nIndex}[2] = undef;
            }
            elsif($strBase =~ /ORIGIN\(\s*(\S+)\s*\)/)
            {
                my $nIndex = $self->{ExeRegionLookUpTable}{$strRegionName};
                my $ORIGIN;
                foreach my $aref (@{$self->{MEMORYInfo}})
                {
                    if($1 eq $aref->[0])
                    {
                        $ORIGIN = $aref->[1];
                        last;    
                    }    
                }
                $self->{ExeRegion}->{$nIndex}[1] = $ORIGIN;
                $self->{ExeRegion}->{$nIndex}[2] = undef;
            }
            else
            {   # used in set_hiddenERs()
                $strRegionName =~ s/\///g;
                my $nIndex = $self->{ExeRegionLookUpTable}{$strPrvRegionName};
                $self->{HiddenExeRegion}->{$strRegionName} = [$nIndex, $strPrvRegionName];
            }
            if($strLast =~ /\{/)
            {
                $strLast =~ s/.*\{//;
                $self->parse_input_section($strLast, $strRegionName);
            }
            $strPrvRegionName = $strRegionName;
        }
        elsif($strLine =~ /OVERLAY/ or ($nOVERLAYLine >0 and $strPrvRegionName eq "OVERLAY"))
        {# parse overlay
            $strPrvRegionName = "OVERLAY";
            push(@OVERLAY, $strLine);
            $nOVERLAYLine++ if($strLine =~ /OVERLAY/);
            $nOVERLAYLine++ if($strLine =~/\{/);
            $nOVERLAYLine-- if($strLine =~/\}/);
            next;
        }
        elsif($strLine !~ /\=|\;/)
        {# parse input section
            $self->parse_input_section($strLine, $strPrvRegionName);
        }
        $self->parse_memory_view($strLine, $strPrvRegionName);
    }
    $self->set_hiddenERs();
}
sub parse_overlay  #ParseSECTIONS
{
    my $self = shift;
    my ($lines_aref) = @_;
    my $strCurRegionName = undef;
    my $strOVERLAYBase;
    my @OverlayRegion;
    foreach my $strLine (@$lines_aref)
    {
        if($strLine =~ /OVERLAY\s*(\S*)\s*:/)
        {
            $strOVERLAYBase = $1;
            next;
        }
        elsif($strLine =~ /^\s*(\S+)\s*\{/ or ($strLine =~ /^\s*(\S+)/ and $strLine !~ /\{|\}|\*|\(|\)|\=|\;/))
        {
            my $strRegionName = $1;
            $strRegionName =~ s/\s|\{|\}//g;
            next if($strRegionName eq "");
            $strCurRegionName = $strRegionName;
            if(exists $self->{ExeRegionLookUpTable}{$strRegionName})
            {
                my $nIndex = $self->{ExeRegionLookUpTable}{$strRegionName};
                $self->{ExeRegion}->{$nIndex}[1] = $strOVERLAYBase;
                $self->{ExeRegion}->{$nIndex}[2] = undef;
                $self->{ExeRegion}->{$nIndex}[4] = ["OVERLAY"];
                push (@OverlayRegion, $strRegionName);
            }
        }
        elsif($strLine =~ /\>/)
        {
            map{ $self->parse_memory_view($strLine, $_);}@OverlayRegion;
        }
        elsif($strLine !~ /\=|\;/ and defined $strCurRegionName)
        {
            $self->parse_input_section($strLine, $strCurRegionName);
        }
    }
}
sub parse_input_section #used by ParseSECTIONS and parse_overlay
{
    my $self = shift;
    my ($strLine, $strRegionName)= @_;
    $strLine =~ s/.*\{|\}.*//;
    
    #remove empty string
    my $temp = $strLine;
    $temp =~ s/\s//g; 
    return if($temp eq "");
    
    if($strLine =~ /\{*\s*(\S+)\s*\((.+)\)(\}*)/)
    {
        push(@{$self->{InputSection}{$strRegionName}}, "$1 ($2)");
    }
    elsif( $strLine !~/\;|\=/)
    {
        push(@{$self->{InputSection}{$strRegionName}}, $strLine);
    }
}
sub parse_linker_symbol #used by ParseSECTIONS
{
    my $self = shift;
    my ($strLine) = @_;

    #DRDI/L2CACHE_LOCK/MCURO_HWRW etc. are dummy output sections, thus strip them.
    my %dummySection = ( DRDI => 0,
                         L2CACHE_LOCK => 0,
                         MCURO_HWRW => 0,
                         DUMMY_END => 0,
                         KTEST => 0,
                         LOAD_VIEW_END => 0,
                         EXECUTION_VIEW_END => 0,
                       );

    if( $strLine =~ /Image\$\$(\S+)\$\$ZI\$\$(\S+)\s*\=\s*(\S+|\.)\s*\;/ or
        $strLine =~ /Image\$\$(\S+)\$\$(\S+)\s*\=\s*\s*(\S+|\.)\s*\;/)
    {
        my ($strRegionName, $strBase, $strOffset, $nMaxSize, @Attr) = ($1, undef, "+0x0", undef, ());
        my ($strIndexName, $strInput) = ($2, $3);

        return if ($strRegionName =~ /LENGTH/ or exists $dummySection{$strRegionName}); # should not add any LENGTH in section name
        if($strIndexName =~ /Base/ and $strInput !~ /\s+|\./)
        {
            $strBase = $strInput;
            $strOffset = undef;
        }
        if($strIndexName =~ /Length/ and $strInput =~ /\d+/)
        {
            $nMaxSize = hex($strInput) ;
        }
        if(!exists $self->{ExeRegionLookUpTable}{$strRegionName})
        {
            $self->{ExeRegion}->{++$self->{ExeRegionCount}} = [$strRegionName, $strBase, $strOffset, $nMaxSize, \@Attr];
            $self->{ExeRegionLookUpTable}{$strRegionName} = $self->{ExeRegionCount};
        }
        else
        {
            if(defined $nMaxSize)
            {
                my $nIndex = $self->{ExeRegionLookUpTable}{$strRegionName};
                $self->{ExeRegion}->{$nIndex}[3] = $nMaxSize;
            }
        }
    }
}
sub parse_memory_view  #used by ParseSECTIONS and parse_overlay
{
    my $self = shift;
    my ($strLine, $strRegionName) = @_;
    if($strLine =~ /\>\s*(\S+)\s*AT\s*\>\s*(\S+)/)
    {
        $self->{MemoryView}{$strRegionName} = [$1, $2];
    }
    elsif($strLine =~ /AT\s*\>\s*(\S+)/)
    {
        $self->{MemoryView}{$strRegionName} = ["", $1];
    }
    elsif($strLine =~ /\>\s*(\S+)/)
    {
        $self->{MemoryView}{$strRegionName} = [$1, ""];
    }
}
sub set_hiddenERs
{
    my $self = shift;
    foreach my $key (keys %{$self->{HiddenExeRegion}})
    {
        if(exists $self->{ExeRegionLookUpTable}->{$key})
        {
            delete $self->{HiddenExeRegion}->{$key};
        }    
    }
}

sub ParseMEMORY
{
    my ($strMEMORY) = @_;
    #strip comments
    $strMEMORY =~s#/\*[^*]*\*+([^/*][^*]*\*+)*/|([^/"']*("[^"\\]*(\\[\d\D][^"\\]*)*"[^/"']*|'[^'\\]*(\\[\d\D][^'\\]*)*'[^/"']*|/+[^*/][^/"']*)*)#$2#g;
    my @MemoryInfo;
    my @lines = split(/\n/, $strMEMORY);
    foreach my $line (@lines) 
    {
        my ($strName, $strBase, $strLength) = &ParseMEMORYLine($line);
        push @MemoryInfo, [$strName, $strBase, $strLength] if(defined $strName);
    }
    return \@MemoryInfo;
}
sub ParseMEMORYLine
{
    my ($strLine) = @_;
    my ($strName, $strBase, $strLength) = (undef, undef, undef);
    my @org = ("ORIGIN", "org", "o");
    my @len = ("LENGTH", "len", "l");
    my $bFind = 0;
    foreach my $o (@org)
    {
        foreach my $l (@len)
        {
            if($strLine =~ /\s*(\S+)\s*:\s*$o\s*\=\s*(.+)\s*,\s*$l\s*\=\s*(.+)/)
            {
                ($strName, $strBase, $strLength) = ($1, $2, $3);
                $bFind = 1; last;
	      } elsif ($strLine =~ /^\s*#/) {
		$strName = $strLine;
	      }
        }
        last if($bFind==1);
    }
    return ($strName, $strBase, $strLength);
}
sub new
{
    my $class = shift;
    my $self = {};
    #default value
    $self->{ldsPath} = undef;
    $self->{MEMORY} = undef;   #=string
    $self->{SECTIONS} = undef; #=string
    $self->{MEMORYInfo} = undef; #aref: [$strName, $strBase, $strLength]
    
    $self->{ExeRegion} = {};            #%g_ExeRegion; (start from 1) 
                                        # nIndex => [$1=Region name, $2=strBaseAddress, $3=strOffset, $4=nMaxSize, $5=\@Attribute]
    $self->{ExeRegionCount} = 0;        #$g_ExeRegionCount = 0;
    $self->{ExeRegionLookUpTable} = {}; #%g_ExeRegionLookUpTable; # RegionName -> Index
    $self->{HiddenExeRegion} = {};        #%HiddenExeRegion = RegionName => [$nPrvERIndex, $strPrvERName];

    $self->{MemoryView} = {};      # %g_MemoryView; (start from 1)
                                   # $RegionName => [$ExecutionView, $LoadView];
    $self->{InputSection} = {}; # $self->{InputSection}{$strRegionName} = @InputSections;
    #$self->{EXCLUDE_FILE} = {}; # $self->{EXCLUDE_FILE}{$strInputSection} = @files;
    bless $self, $class;
    return $self;
}

sub ParseLinkerScript
{
    my $self = shift;
    my ($ldsPath) = @_;
    if(defined $ldsPath and -e $ldsPath)
    {
        open (FILE_HANDLE, "<$ldsPath") or &lds_die("$ldsPath: file error!", __FILE__, __LINE__);
        my $strStart = undef;
        while (<FILE_HANDLE>) 
        {
            if(/^MEMORY/)
            {
                $strStart = "MEMORY";
            }
            elsif(/^SECTIONS/)
            {
                $strStart = "SECTIONS";
            }
            elsif(/^}/)
            {
                undef $strStart;    
            }
            elsif($_ !~ /^{/ and defined $strStart)
            {
                $self->{$strStart} .= $_;
            }
        }
        close FILE_HANDLE;
        #strip comments
        $self->{MEMORY} =~s#/\*[^*]*\*+([^/*][^*]*\*+)*/|([^/"']*("[^"\\]*(\\[\d\D][^"\\]*)*"[^/"']*|'[^'\\]*(\\[\d\D][^'\\]*)*'[^/"']*|/+[^*/][^/"']*)*)#$2#g;
        $self->{SECTIONS} =~s#/\*[^*]*\*+([^/*][^*]*\*+)*/|([^/"']*("[^"\\]*(\\[\d\D][^"\\]*)*"[^/"']*|'[^'\\]*(\\[\d\D][^'\\]*)*'[^/"']*|/+[^*/][^/"']*)*)#$2#g;
        $self->{MEMORYInfo} = &ParseMEMORY($self->{MEMORY});
        &EvalMemory($self->{MEMORYInfo});
        $self->ParseSECTIONS($self->{SECTIONS});
    }
    else
    {
        &lds_die("LinkerScript Path($ldsPath) doesn't exist", __FILE__, __LINE__);   
    }
}

sub EvalMemory
{
    my ($MEMORYInfo_aref) = @_;
    foreach my $item (@$MEMORYInfo_aref)
    {
        my $nBase = eval($item->[1]);
        my $nLen = eval($item->[2]);
        $item->[1] = &CommonUtil::Dec2Hex($nBase);
        $item->[2] = &CommonUtil::Dec2Hex($nLen);
    }
}

sub GetMEMROYInfo
{
    my $self = shift;
    return $self->{MEMORYInfo};
}

sub GetMEMORYInfoByName
{
    my $self = shift;
    my ($strRegionName) = @_;
    my ($strBase, $strLen) = (undef, undef);
    my $MEMORYInfo_aref = $self->{MEMORYInfo};
    foreach my $aref (@$MEMORYInfo_aref)
    {
        if($strRegionName eq $aref->[0])
        {
            $strBase = $aref->[1];
            $strLen = $aref->[2];
            last;
        }    
    }
    return ($strBase, $strLen);
}

sub ListMemoryView
{
    my $self = shift;
    foreach my $item (keys %{$self->{MemoryView}})
    {
        print "[$item]\n";
        map {print "$_  "}@{$self->{MemoryView}{$item}};
        print "\n";
    }
}
sub ListInputSections
{
    my $self = shift;
    foreach my $item (keys %{$self->{InputSection}})
    {
        print "[$item]\n";
        map {print "$_\n"}@{$self->{InputSection}{$item}};
        print "\n\n";
    }
}

#****************************************************************************
# subroutine:  GetAllExeRegion
# input:       x
# output:      an array reference of execution region 
#****************************************************************************
sub GetAllExeRegion
{
    my $self = shift;
    my @ExeRegions;
    foreach my $i (1 .. $self->{ExeRegionCount})
    {
        push(@ExeRegions, $self->{ExeRegion}{$i}->[0]);
    }
    return \@ExeRegions;
}
#****************************************************************************
# subroutine:  GetAllHiddenExeRegion
# purpose:     To get hidden 
# input:       x
# output:      an array reference of execution region 
#****************************************************************************
sub GetAllHiddenExeRegion
{
    my $self = shift;
    my $href = $self->{HiddenExeRegion};
    my @ExeRegions = sort { $href->{$a}->[0] <=> $href->{$b}->[0]} keys %$href;
    #map{print "[$_]".$href->{$_}->[0]."\n";} @ExeRegions;
    return \@ExeRegions;
}
#****************************************************************************
# subroutine:  GetRegionInfo - Get Region information from ExecutionRegions
# input:       $strRegionName: Execution Name (Case sensitive)
#              $nOption= Region::Base, Region::MaxSize, Region::Attribute, Region::Offset
# output:      $strInfo may be base, maxsize, attribute, and offset
#****************************************************************************
sub GetRegionInfo
{
    my $self = shift;
    my ($strRegionName, $nOption) = @_;
    my $strInfo = undef;
    my $Info_ref = $self->GetExeRegionInfo($strRegionName);

    if(defined $Info_ref->[Region::Attribute])
    {
        if($nOption >  Region::Offset || $nOption <  Region::Base)
        { # report error - $nOption must have a value
            &lds_die("GetRegionInfo must have Option value($nOption)");
        }
        else
        {
            $strInfo = $Info_ref->[$nOption];
        }
    }
    return $strInfo;
}
#****************************************************************************
# subroutine:  GetExeRegionInfo - Get Execution Region information
# input:       $strRegionName: Execution Name (Case sensitive)
# output:      an Array contains 
#              [0]$strBase=Region Base address, 
#              [1]$strMaxSize=Region MaxSize, 
#              [2]$strAttribute=Attribute, 
#              [3]$strOffset(undef= no offset , others=start with +0x.. or ALIGN)
#****************************************************************************
sub GetExeRegionInfo
{
    my $self = shift;
    my ($strRegionName) = @_;
    my ($strBase, $nMaxSize, $strAttribute, $strOffset) = (undef, undef, undef, undef);
    my $nIndex = $self->{ExeRegionLookUpTable}{$strRegionName};
    if(defined $nIndex)
    {
        $strOffset = $self->{ExeRegion}{$nIndex}->[2];
        $strBase = $self->{ExeRegion}{$nIndex}->[1]; 
        $nMaxSize = (defined $self->{ExeRegion}{$nIndex}->[3]) ? $self->{ExeRegion}{$nIndex}->[3] : 0xFFFFFFFF;
        $strAttribute = $self->{ExeRegion}{$nIndex}->[4];
    }
    my @Info = ($strBase, &CommonUtil::Dec2Hex($nMaxSize), $strAttribute, $strOffset);
    return \@Info;
}

#****************************************************************************
# subroutine:  lds_die
# sample code: (message, __FILE__, __LINE__)
# input:       $error_msg, $file, $line_no
#****************************************************************************
sub lds_die
{
    my ($error_msg, $file, $line_no) = (@_);
    &CommonUtil::error_handler($error_msg, $file, $line_no, 'ldsInfo');    
}