Gitiles
Code Review Sign In
192.168.1.100 / T800_MD / 1eb8f53f94c145708b5ea2c6b9b96ea3d613f607 / . / mcu / tools / scatInfo.pm
blob: 0a575557821554a2f13b33d947cefafa881f7598 [file] [log] [blame]
rjw6c1fd8f2022-11-30 14:33:01 +0800[diff] [blame]1#!/usr/bin/perl
2#
3# Copyright Statement:
4# --------------------
5# This software is protected by Copyright and the information contained
6# herein is confidential. The software may not be copied and the information
7# contained herein may not be used or disclosed except with the written
8# permission of MediaTek Inc. (C) 2006
9#
10# BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
11# THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
12# RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
13# AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
14# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
15# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
16# NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
17# SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
18# SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
19# THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
20# NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
21# SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
22#
23# BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
24# LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
25# AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
26# OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
27# MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
28#
29# THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
30# WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
31# LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
32# RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
33# THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
34#
35#*****************************************************************************
36#*
37#* Filename:
38#* ---------
39#* scatInfo.pm
40#*
41#* Project:
42#* --------
43#*
44#*
45#* Description:
46#* ------------
47#* This module collects the subroutines for common utility.
48#*
49#*
50#* Author:
51#* -------
52#* Carl Kao (mtk08237)
53#*
54#****************************************************************************/
55use strict;
56#use warnings;
57BEGIN { push @INC, './pcore/tools/' } # add additional library path
58use sysGenUtility; #pm file name without case sensitivity
59use ldsInfoWrap;
60use CommonUtility;
61use FileInfoParser;
62#****************************************************************************
63# Constants
64#****************************************************************************
65package Region;
66use constant Base => 0;
67use constant MaxSize => 1;
68use constant Attribute => 2;
69use constant Offset => 3;
70
71package scatInfo;
72#****************************************************************************
73# Verno
74#****************************************************************************
75my $SCATINFO_VERNO = " v0.01";
76 # v0.01 by Tero , 20180817, Refine memory dump for USPRAM
77 # a0.04 by Carl , 20170616, Support overlapped ROM region
78 # a0.03 by Tero , 20170608, L1DSP removed from memory dump
79 # a0.02 by Tero , 20170322, Dynamic code load area dump support
80 # a0.01 by Tero , 20161128, IOCU2 and L2CLOCK sections added to ClassifyRegions and GetDumpExeRegions
81 # u0.23 by Tero , 20160801, Removed LR11 support
82 # u0.22 by Tero , 20160628, Added AUROM dump support
83 # u0.21 by Tero , 20160204, Set ROM section to CACHED_RO and UROM to UNCACHED_RO region group
84 # u0.20 by Tero , 20160203, Added L2SRAM L2NC and L2C groups
85 # u0.19 by Carl , 20160126, Avoid dump sections with name "PHYSICAL_BOUNDARY" (for SPRAM physical name)
86 # u0.18 by Tero , 20160113, Added core spesific cacheable data region info groups
87 # u0.17 by Tero , 20160111, Refine ClassifyRegions abd GetDumpExeRegions
88 # u0.16 by Tero , 20160108, Refine ClassifyRegions abd GetDumpExeRegions
89 # u0.15 by Carl , 20150709, Group L2SRAM section for DSM
90 # u0.14 by Carl , 20150415, Refine setting for (MCU RO, MDHW RW) DNC+NC, (MCU RW, MDHW RW) DNC+NC
91 # u0.13 by Carl , 20150223, Backout u0.12 and refactor parsing rule for L2SRAM linker symbol
92 # u0.12 by Carl , 20150122, Remove L2SRAM from dump region to avoid memory dump fail
93 # u0.11 by Carl , 20141222, Support L2SRAM section (in L1CORE)
94 # u0.10 by Carl , 20141217, Support multiple overlap section
95 # u0.09 by Carl , 20141125, Merge ATCM and BTCM as a single TCM
96 # u0.08 by Carl , 20140120, Remove shared memory output sections from RAM memory region view
97 # u0.07 by Carl , 20140826, Refine memory dump for l1core
98 # u0.06 by Carl , 20140801, Refine GetL1COREDumpExeRegions() for dump L1CORE TCM
99 # u0.05 by Carl , 20140731, Refine for memory dump and "DSP_SECTION"
100 # u0.04 by Carl , 20140407, Rename "l1dsp" to "l1core", "L1DSP" to "L1CORE"
101 # u0.03 by Carl , 20140402, Pcore sysGen2
102 # u0.02 by BM , 20140303, Change folder path
103 # u0.01 by BM , 20140220, Branch from MOLY
104 # m0.16 by mei , 20131024, Support dump regions in order
105 # m0.15 by mei , 20130905, Dump nc in CACHED_EXTSRAM only on MOLY
106 # m0.14 by mei , 20130527, Fix SearchExeRegionName() for sym using region_ZI's naming
107 # m0.13 by mei , 20121117, Suppport to dump code region
108 # m0.12 by mei , 20130212, Add GetAllLoadRegion()
109 # m0.11 by mei , 20121218, Not to dump INTSRAM_DATA_B1 if it doesn't exist in sym
110 # m0.10 by mei , 20121002, Support LTE TCM dump
111 # m0.09 by mei , 20120911, New function: GetRegionMap()
112 # m0.08 by mei , 20120827, Modify combined ROM for memory dump due to layout change
113 # m0.07 by mei , 20120817, Support GetChip()
114 # m0.06 by mei , 20120807, Move sysUtil::Dec2Hex to CommonUtil::Dec2Hex
115 # m0.05 by mei , 20120712, Move booting type query from sysGenUtility to FileInfoParser
116 # m0.04 by mei , 20120712, Support dump ROM1 on MT6280
117 # m0.03 by mei , 20120710, Support dump ROM related region on MT6280
118 # v0.09 by mei , 20120606, Dump INTSRAM_DATA$ instead of INTSRAM_DATA
119 # m0.02 by mei , 2012/05/28, Support path and filename case sensitive on Linux
120 # m0.01 by mei , 2012/05/28, Support lds_new
121 # v0.08 by mei , 2012/05/19, backward support #define ALIGN
122 # v0.07 by mei , 2012/05/13, Support attribute list in Execution Region
123 # v0.06 by mei , 2012/05/13, Rename ALIGN to SetAddress and fix typo
124 # v0.05 , 2012/04/17, support dump ALICE and compressed ALICE
125 # v0.04 , 2012/03/19, Fix Multirom region names
126 # v0.03 , 2012/02/20, Support MBA not generated in original combination
127 # v0.02 , 2012/02/15, Support memory dump
128 # v0.01 , 2012/01/30, Initial revision
129
130#****************************************************************************
131# global variable
132#****************************************************************************
133my $DebugPrint = 1;
134
135#****************************************************************************
136# oo >>> Finished
137#****************************************************************************
138return 1;
139sub new
140{
141 my $class = shift;
142 my $self = {};
143 #default value
144 $self->{SCATPath} = undef; #$g_SCATPath;
145 $self->{LoadRegion} = {}; #$g_LoadRegionCountIndex(start from 1)
146 #=> [$1=Region name, $2=ImageLimit(Previous region) or strBaseAddress, $3=strOffset, $4=nMaxSize, $5=\@Attribute]
147 $self->{LoadRegionCount} = 0; #$g_LoadRegionCount = 0;
148 $self->{LoadRegionLookUpTable} = {}; #%g_LoadRegionLookUpTable; # RegionName -> Index
149
150 $self->{ExeRegion} = {}; #%g_ExeRegion; (start from 1)
151 # nIndex => [$1=Region name, $2=ImageLimit(Previous region) or strBaseAddress, $3=strOffset, $4=nMaxSize, $5=\@Attribute]
152 $self->{ExeRegionCount} = 0; #$g_ExeRegionCount = 0;
153 $self->{ExeRegionLookUpTable} = {}; #%g_ExeRegionLookUpTable; # RegionName -> Index
154
155 $self->{RegionMap} = {}; # %g_RegionMap; # {Load Region Name => [Execution Region Name, ... in order]}
156 $self->{ExeRegionMap} = {}; # %g_RegionMap; # {Exe Region Name => Load Region Name}
157 $self->{InputSection} = {}; # $self->{InputSection}{$strRegionName} = @InputSections;
158 $self->{RegionGroup} = {}; # %g_RegionGroup; # {GroupName} => [RegionName, ... sorted by Index]
159 bless $self, $class;
160 return $self;
161}
162sub LIS_new
163{
164 my $class = shift;
165 my $self = {};
166 my ( $LoadRegion_ref, $LoadRegionCount, $LoadRegionLookUpTable_ref,
167 $ExeRegion_ref, $ExeRegionCount, $ExeRegionLookUpTable_ref,
168 $RegionGroup_ref, $RegionMap_ref) = @_;
169
170 #Change to corresponding hash
171 my (%LoadRegion, %ExeRegion);
172 map { $LoadRegion{$_} = [&CommonUtil::Dec2Hex($LoadRegion_ref->{$_}[0]),
173 &CommonUtil::Dec2Hex($LoadRegion_ref->{$_}[1]),
174 undef,
175 &CommonUtil::Dec2Hex($LoadRegion_ref->{$_}[3]),
176 [&CommonUtil::Dec2Hex($LoadRegion_ref->{$_}[4])]]; } keys %$LoadRegion_ref;
177 map { $ExeRegion{$_} = [&CommonUtil::Dec2Hex($ExeRegion_ref->{$_}[0]),
178 &CommonUtil::Dec2Hex($ExeRegion_ref->{$_}[1]),
179 undef,
180 &CommonUtil::Dec2Hex($ExeRegion_ref->{$_}[3]),
181 [&CommonUtil::Dec2Hex($ExeRegion_ref->{$_}[4])]]; } keys %$ExeRegion_ref;
182
183 #default value
184 $self->{SCATPath} = undef;
185 $self->{LoadRegion} = $LoadRegion_ref;
186 $self->{LoadRegionCount} = $LoadRegionCount;
187 $self->{LoadRegionLookUpTable} = $LoadRegionLookUpTable_ref;
188
189 $self->{ExeRegion} = $ExeRegion_ref;
190 $self->{ExeRegionCount} = $ExeRegionCount;
191 $self->{ExeRegionLookUpTable} = $ExeRegionLookUpTable_ref;
192
193 $self->{RegionMap} = $RegionMap_ref;
194 $self->{ExeRegionMap} = undef; # %g_RegionMap; # {Exe Region Name => Load Region Name}
195 $self->{InputSection} = {};
196 $self->{RegionGroup} = $RegionGroup_ref;
197 bless $self, $class;
198 return $self;
199}
200sub lds_new
201{
202 my $class = shift;
203 my $self = {};
204 my ($ldsPath, $strFakeLoadRegionName) = @_;
205 $self->{ldsInfo} = new ldsInfoWrap($strFakeLoadRegionName);
206 $self->{ldsInfo}->ParseLinkerScript($ldsPath);
207 my ( $ExeRegion_ref, $ExeRegionCount, $ExeRegionLookUpTable_ref,
208 $RegionGroup_ref, $RegionMap_ref) = (undef, undef, undef, undef, undef);
209
210 #default value
211 $self->{SCATPath} = undef;
212 $self->{LoadRegion} = $self->{ldsInfo}->{LoadRegion};
213 $self->{LoadRegionCount} = $self->{ldsInfo}->{LoadRegionCount};
214 $self->{LoadRegionLookUpTable} = $self->{ldsInfo}->{LoadRegionLookUpTable};
215
216 $self->{ExeRegion} = $self->{ldsInfo}->{ExeRegion};
217 $self->{ExeRegionCount} = $self->{ldsInfo}->{ExeRegionCount};
218 $self->{ExeRegionLookUpTable} = $self->{ldsInfo}->{ExeRegionLookUpTable};
219 $self->{RegionMap} = $self->{ldsInfo}->{RegionMap};
220 # %g_RegionMap; # {Load Region Name => [Execution Region Name, ... in order]}
221
222
223 $self->{ExeRegionMap} = undef; # %g_RegionMap; # {Exe Region Name => Load Region Name}
224 $self->{InputSection} = {};
225 $self->{RegionGroup} = undef;
226 bless $self, $class;
227 return $self;
228}
229
230#****************************************************************************
231# subroutine: ParseScatterFile
232# input: Scatter file Path string
233# output: x
234#****************************************************************************
235sub ParseScatterFile
236{
237 my $self = shift;
238 my ($SCATPath) = @_;
239 $self->{SCATPath} = $SCATPath;
240 if(defined $SCATPath and -e $SCATPath)
241 {
242 open (FILE_HANDLE, "<$SCATPath") or &SCAT_die("$SCATPath: file error!", __FILE__, __LINE__);
243 my %Scat_Content;
244 while (<FILE_HANDLE>) {
245 #print "$. - $_ ";
246 if (/#define/ or /^#/ or /ScatterAssert/) {next;}
247 if ((/SetAddress/ and /ImageLimit/) or (/ALIGN/ and /ImageLimit/)) { $Scat_Content{$.} = $_; next;}
248 if (/;/) {s/;.*//;}
249 if (/\(.+\)/) { $Scat_Content{$.} = $_; next;} # input section
250 if (/{/ or /}/ or /\S+/) { $Scat_Content{$.} = $_; next;}
251 }
252 $self->parse_scatter_file_structure(\%Scat_Content);
253 close FILE_HANDLE;
254 $self->reorder();
255 }
256 else
257 {
258 &SCAT_die("ScatterFile Path($SCATPath) doesn't exist", __FILE__, __LINE__);
259 }
260}
261
262
263#****************************************************************************
264# subroutine: parse_scatter_file_structure
265# return:
266#****************************************************************************
267sub parse_scatter_file_structure
268{
269 my $self = shift;
270 my ($scat_content_href) = @_;
271 my $SCATPath = $self->{SCATPath};
272 my $last_line_no;
273 my $text_line;
274
275 my $view=0; #counter , 1 = load view , 2 = exec view
276 my $nInputSectionStart = 0;
277 my $strLoadRegionName;
278 foreach my $file_line_no (sort {$a <=> $b} keys %$scat_content_href)
279 {
280 $text_line = $scat_content_href->{$file_line_no};
281 if($text_line =~ m/{/)
282 {
283 &SCAT_die("$SCATPath: un-recognisable view(more than 2 '{') at Line $file_line_no!", __FILE__, __LINE__) if ($view > 1);
284 &SCAT_die("$SCATPath: no region name detected before Line $file_line_no!", __FILE__, __LINE__) if (not defined $last_line_no);
285 $view++;
286 $nInputSectionStart = $file_line_no+1 if ($view == 2);
287 my $strRegionName = $self->parse_region_string( $scat_content_href->{$last_line_no} , $view );
288 #-------------------collect Map: LoadRegion => Execution Region----------------
289 if($view ==1)
290 {
291 $strLoadRegionName = $strRegionName;
292 $self->{RegionMap}{$strLoadRegionName} = [];
293 }
294 push(@{$self->{RegionMap}{$strLoadRegionName}}, $strRegionName) if($view == 2);
295 $self->{ExeRegionMap}{$strRegionName} = $strLoadRegionName if($view == 2);
296 # ----------------------------------------------------------
297 }
298 elsif ($text_line =~ m/}/)
299 {
300 #-------------------collect input sections----------------
301 if($view == 2)
302 {
303 my @InputSections;
304 while ( $nInputSectionStart < $file_line_no )
305 {
306 if( exists $scat_content_href->{$nInputSectionStart})
307 {
308 my $inputsection = $scat_content_href->{$nInputSectionStart};
309 chomp($inputsection);
310 $inputsection =~ s/^\s+|\t//;
311 #print "$nInputSectionStart: $inputsection\n";
312 push(@InputSections, $inputsection);
313 }
314 $nInputSectionStart++;
315 }
316 my $strRegionName = $self->{ExeRegion}{$self->{ExeRegionCount}}[0];
317 $self->{InputSection}{$strRegionName} = @InputSections;
318 }
319 # ----------------------------------------------------------
320 $view--;
321 &SCAT_die("$SCATPath: un-recognisable view at Line $file_line_no !\n", __FILE__, __LINE__) if ($view < 0);
322 }
323 $last_line_no = $file_line_no;
324 }
325}
326#****************************************************************************
327# subroutine: parse_region_string
328# input: reference to %LoadView or %ExecView ; Region Name start address string ; View (1: LoadView; 2: ExecView)
329# return: %LoadView ; key = RegionName , value = hash ref , begin , attr , length
330#****************************************************************************
331sub parse_region_string
332{
333 my $self = shift;
334 my ($string, $view) = @_;
335 chomp($string);
336 my ($strRegionName, $strBaseAddress, $strOffset, $nMaxSize, @Attr) = ("UNKNOWN", undef, undef, 0xFFFFFFFF, ());
337 if ($string =~ m/(\S+)\s+[SetAddress|ALIGN]\(ImageLimit\((\S+)\)\s*(\+\s*0x\w+)*,\s*\S+\s*\)\s+([ABSOLUTE|FIXED|OVERLAY|EMPTY]*)\s*(0x\w+)*/)
338 {
339 #[$1=Region name, $2=ALIGN(Previous region), $3=strOffset, $4=nMaxSize, $5=strAttribute]
340 $strRegionName = $1;
341 my ($temp2, $temp3, $temp4, $temp5) = ($2, $3, $4, $5);
342 $strBaseAddress = "ImageLimit($temp2)";
343 $strOffset = $temp3 if( defined $temp3 and $temp3 =~ /\+/ );
344 push(@Attr, $temp3) if(defined $temp3 and $temp3 =~/ABSOLUTE|FIXED|OVERLAY|EMPTY/);
345 push(@Attr, $temp4) if(defined $temp4 and $temp4 =~/ABSOLUTE|FIXED|OVERLAY|EMPTY/);
346 $nMaxSize = hex($temp3) if(defined $temp3 and $temp3 =~ /^0x/);
347 $nMaxSize = hex($temp4) if(defined $temp4 and $temp4 =~ /^0x/);
348 $nMaxSize = hex($temp5) if(defined $temp5 and $temp5 =~ /^0x/);
349 }
350 else
351 {
352 ($strRegionName, $strBaseAddress, $strOffset, $nMaxSize) = &parse_normal_region($string, \@Attr);
353 }
354 if($view == 1)
355 {
356 #[$1=Region name, $2=strBaseAddress, $3=strOffset, $4=nMaxSize, $5=Attribute_aref]
357 $self->{LoadRegion}{++$self->{LoadRegionCount}}= [$strRegionName, $strBaseAddress, $strOffset, $nMaxSize, \@Attr];
358 $self->{LoadRegionLookUpTable}{$strRegionName} = $self->{LoadRegionCount};
359 }
360 elsif($view ==2)
361 {
362 $self->{ExeRegion}{++$self->{ExeRegionCount}}= [$strRegionName, $strBaseAddress, $strOffset, $nMaxSize, \@Attr];
363 $self->{ExeRegionLookUpTable}{$strRegionName} = $self->{ExeRegionCount};
364 }
365 return $strRegionName;
366}
367#****************************************************************************
368# subroutine: parse_normal_region
369# used by parse_region_string() to parse normal region
370# e.g. RegionName (0x100|+0x100) [attribute list] [max size]
371# or RegionName ImageLimit(xxxRegion) [attribute list] [max size]
372# or RegionName ImageLimit(xxx)Region + offset [attribute list] [max size]
373# input: 1. $string to be parsed 2. \@Attr to be fileed in
374# return: $strRegionName, $strBaseAddress, $strOffset, $nMaxSize
375#****************************************************************************
376sub parse_normal_region
377{
378 my ($string, $Attr_aref) = @_;
379 my ($strRegionName, $strBaseAddress, $strOffset, $nMaxSize) = ("UNKNOWN", undef, undef, 0xFFFFFFFF);
380 my @Description = split(/\s+/, $string); # split by space
381 my @Temp;
382 map {push(@Temp, $_) if($_ ne "")} @Description;
383
384 my @ConnectedToken;
385 &ConnectBuiltin(\@Temp,\@ConnectedToken);
386 my ($nIndex, $bConnect, $strPrevItem) = (0, 0 , undef);
387 foreach my $item (@ConnectedToken)
388 {
389 $item = $strPrevItem ." ". $item if($bConnect == 1);
390 $strRegionName = $item if($nIndex == 0);
391 if($nIndex == 1)
392 {
393 if($item =~/Image(\S+)\(\s*(\S+)\s*\)/)
394 {
395 $strBaseAddress = "Image$1($2)";
396 }
397 if($item =~ /\+\s*(\S+)/)
398 {
399 $strOffset = "+$1";;
400 }
401 else
402 {
403 $strBaseAddress = $item;
404 }
405 }
406 push(@$Attr_aref, $item) if($item =~ /ABSOLUTE|FIXED|OVERLAY|EMPTY|PI|ZEROPAD/);
407 $bConnect = 1 if($item =~ /ALIGN$|FILL$|PADVALUE$/);
408 if($item =~ /[ALIGN|FILL|PADVALUE]\s+(\w+)/)
409 {
410 push(@$Attr_aref, $item);
411 $bConnect = 0;
412 }
413 else
414 {
415 $nMaxSize = hex($1) if($item =~ /(0x\w+)/ and $nIndex > 1);
416 }
417 $nIndex++;
418 $strPrevItem = $item;
419 }
420# print "[Name]$strRegionName, [Base]$strBaseAddress, [Offset]$strOffset, [Max]".&CommonUtil::Dec2Hex($nMaxSize).", [Attr]". join("::", @$Attr_aref)."\n";
421 return ($strRegionName, $strBaseAddress, $strOffset, $nMaxSize);
422}
423sub ConnectBuiltin #used by parse_normal_region
424{
425 my ($BeforeConnect_aref, $AfterConnect_aref) = @_;
426 my $item = undef;
427 for(my $i=0; $i<=$#$BeforeConnect_aref; $i++)
428 {
429 if(!defined $item)
430 {
431 $item = $BeforeConnect_aref->[$i];
432 }
433 else
434 {
435 $item .= $BeforeConnect_aref->[$i];
436 }
437 if($item =~ /ImageLimit|ImageBase/)
438 {
439 next if($item !~/\)/);
440 next if($item =~/\)/ and $BeforeConnect_aref->[$i+1] =~/\+/);
441 next if($item =~/\)/ and $BeforeConnect_aref->[$i] eq "+" ); #RegionName ImageLimit(xxx)Region+(offset)
442 }
443 push(@$AfterConnect_aref, $item);
444 $item = undef;
445 }
446}
447
448sub reorder
449{
450 my $self = shift;
451 for(my $i=1; $i<=$self->{ExeRegionCount}; $i++)
452 {
453 if($self->{ExeRegion}{$i}->[1] =~ /[ImageLimit|ImageBase]\(\s*(\S+)\s*\)/)
454 {
455 my $nMyNewIndex = $self->{ExeRegionLookUpTable}{$1}+1;
456 next if($nMyNewIndex == $i);
457 my $iNext = $i;
458 my $nMove = 1;
459 while(($self->{ExeRegion}{++$iNext}->[2] =~ /\+/)
460 and ($self->{ExeRegionMap}{$self->{ExeRegion}{$i}->[0]} eq $self->{ExeRegionMap}{$self->{ExeRegion}{$iNext}->[0]} ))
461 {
462 $nMove++;
463 }
464 for(my $j=0; $j<$nMove; $j++) #save temp
465 {
466 $self->move($i+$j, $self->{ExeRegionCount}+1+$j, "Exe");
467 }
468 if($nMyNewIndex > $i)
469 { #move down, shift up
470 for(my $j=$i+$nMove; $j<=$nMyNewIndex; $j++)
471 {
472 $self->move($j, $j-$nMove, "Exe");
473 }
474 }
475 else
476 { #move up, shift down
477 for(my $j=$i-1; $j>=$nMyNewIndex ; $j--)
478 {
479 $self->move($j, $j+$nMove, "Exe");
480 }
481 }
482 #move temp back
483 for(my $j=0; $j<$nMove; $j++)
484 {
485 $self->move($self->{ExeRegionCount}+1+$j, $nMyNewIndex+$j , "Exe");
486 my $nIndex = $self->{ExeRegionCount}+1+$j;
487 delete $self->{ExeRegion}{$nIndex};
488 }
489 }
490 }
491# for(my $i=1; $i<=$self->{ExeRegionCount}; $i++)
492# {
493# print "$i\n";
494# print "[Name]".$self->{ExeRegion}{$i}->[0]." ";
495# print "[Index] $self->{ExeRegionLookUpTable}{$self->{ExeRegion}{$i}->[0]}\n";
496# }
497# print "========================================================================\n";
498# foreach my $item (keys %{$self->{ExeRegionLookUpTable}})
499# {
500# print "$self->{ExeRegionLookUpTable}{$item}\n";
501# print "[Name]".$item."\n";
502# }
503}
504
505sub move
506{ # move nIndex 1 -> nIndex2 wihtout saving
507 my $self = shift;
508 my ($nIndex1, $nIndex2, $strView) = @_;
509 my $strRegionName1 = $self->{$strView."Region"}{$nIndex1}->[0];
510 $self->{$strView."Region"}{$nIndex2} = $self->{$strView."Region"}{$nIndex1};
511 $self->{$strView."RegionLookUpTable"}{$strRegionName1} = $nIndex2;
512}
513#****************************************************************************
514# subroutine: ClassifyRegionType
515# input: $MAKEFILE_ref
516# return: x
517#RegionType = INTSRAM, DYNAMIC_DNC, DYNAMIC_DC, CACHED_RO, CACHED_RW, NONCACHED_RO, NONCACHED_RW, IOCU2
518#****************************************************************************
519sub ClassifyRegionType
520{
521 my $self = shift;
522 my ($MAKEFILE_ref) = @_;
523 my $bb = &FileInfo::GetChip();
524 my $bNOR = &FileInfo::is_NOR($MAKEFILE_ref);
525 my $DEMAND_PAGING = $self->SearchLoadRegionName("DEMAND_PAGING");
526
527 my %DCM_Regions; # BaseAddress <-> RegionName
528 foreach (keys %{$self->{ExeRegionLookUpTable}})
529 {
530 #if-else order is important
531 if(/PHYSICAL_BOUNDARY/)
532 {
533 next; # for linker symbol Image$$ISPRAM0_PHYSICAL_BOUNDARY$$Base, Image$$ISPRAM0_PHYSICAL_BOUNDARY$$Length, ... etc
534 }
535 elsif(/L2SRAM_/)
536 {
537 $self->add_region_into_group("L2SRAM", $_);
538 $self->add_region_into_group("L2SRAM_L2NC", $_) if(/L2SRAM_L2NC/);
539 $self->add_region_into_group("L2SRAM_L2C", $_) if(/L2SRAM_L2C/);
540 next;
541 }
542 elsif(/CODE/)
543 {
544 $self->add_region_into_group("ROM", $_);
545 next;
546 }
547 elsif(/L2CACHE/)
548 {
549 $self->add_region_into_group("L2LOCK", $_);
550 next;
551 }
552 elsif(/IOCU2/)
553 {
554 $self->add_region_into_group("IOCU2", $_);
555 next;
556 }
557 elsif(/IOCU3/)
558 {
559 $self->add_region_into_group("IOCU3", $_);
560 next;
561 }
562 elsif(/USPRAM/)
563 {
564 $self->add_region_into_group("USPRAM", $_);
565 $self->add_region_into_group("LOAD_AREA", $_) if(/USPRAM_CODE/);
566 next;
567 }
568 elsif(/MCURO_HWRW|MCURW_HWRW/i)
569 {
570 if(/DYNAMIC_CACHEABLE_EXTSRAM_DEFAULT_NONCACHEABLE/) {
571 $self->add_region_into_group("DEFAULT_DYNAMIC_DNC", $_);
572 $self->add_region_into_group("DYNAMIC_DNC", $_);
573 }elsif(/DYNAMIC_CACHEABLE_EXTSRAM_DEFAULT_CACHEABLE/) {
574 $self->add_region_into_group("DEFAULT_DYNAMIC_DC", $_);
575 $self->add_region_into_group("DYNAMIC_DC", $_);
576 }elsif(/^EXTSRAM/) {
577 $self->add_region_into_group("DEFAULT_NONCACHED_RW", $_) if(! /TX|RX/);
578 $self->add_region_into_group("NONCACHED_RW", $_) if(/MCURW_HWRW/);
579 $self->add_region_into_group("NONCACHED_RO", $_) if(/MCURO_HWRW/);
580 }elsif(/^CACHED_EXTSRAM/) {
581 if(/DRDI/) { # $self->IsOverlappedRegion($_) is not workable
582 $self->add_region_into_group("DRDI_SET", $_); # for dump (exec view)
583 $self->add_region_into_group("LOAD_AREA", $_); # for dump (load view)
584 if(0){ # reserve for stage 4
585 $self->add_region_into_group("DRDI_2G", $_) if(/DRDI_2G/); # for dump
586 $self->add_region_into_group("DRDI_3GFDD", $_) if(/DRDI_3GFDD/); # for dump
587 $self->add_region_into_group("DRDI_3GTDD", $_) if(/DRDI_3GTDD/); # for dump
588 $self->add_region_into_group("DRDI_MMRF", $_) if(/DRDI_MMRF/); # for dump
589 $self->add_region_into_group("DRDI_C2K", $_) if(/DRDI_C2K/); # for dump
590 $self->add_region_into_group("DRDI_LTE", $_) if(/DRDI_LTE/); # for dump
591 }
592 $self->add_region_into_group("CACHED_RW_INCLUDE_DRDI", $_); # for custom_mk_ram_info. NO DUMP
593 }else{
594 $self->add_region_into_group("CACHED_RW_WT", $_) if(/MCURW_HWRW/); # for dump
595 $self->add_region_into_group("CACHED_RO_DATA", $_) if(/MCURO_HWRW/);
596 }
597 }
598 next;
599 }
600 elsif(/DYNAMIC_CACHEABLE_EXTSRAM_DEFAULT_NONCACHEABLE/)
601 {
602 $self->add_region_into_group("CORE0_C", $_) if(/CORE0/);
603 $self->add_region_into_group("CORE1_C", $_) if(/CORE1/);
604 $self->add_region_into_group("CORE2_C", $_) if(/CORE2/);
605 $self->add_region_into_group("DEFAULT_DYNAMIC_DNC", $_);
606 $self->add_region_into_group("DYNAMIC_DNC", $_); next;
607 }
608 elsif(/DYNAMIC_CACHEABLE_EXTSRAM_DEFAULT_CACHEABLE|DSP_SECTION/)
609 {
610 $self->add_region_into_group("CORE0_C", $_) if(/CORE0/);
611 $self->add_region_into_group("CORE1_C", $_) if(/CORE1/);
612 $self->add_region_into_group("CORE2_C", $_) if(/CORE2/);
613 $self->add_region_into_group("DEFAULT_DYNAMIC_DC", $_);
614 $self->add_region_into_group("DYNAMIC_DC", $_); next;
615 }
616 elsif(/DUMMY_END|EXTSRAM_TMP_PAGE_TABLE/)
617 {
618 next;
619 }
620 elsif(/CACHED|^PAGE_TABLE$|MCU_C|GADGET/)
621 {
622 if(0 == &sysUtil::is_mmu($bb))
623 {
624 $self->add_region_into_group("NONCACHED_RW", $_);
625 }
626 elsif(/WT|NVRAM/)
627 {
628 $self->add_region_into_group("CACHED_RW_WT", $_);
629 }
630 else
631 {
632 $self->add_region_into_group("CACHED_RW", $_); # for dump
633 $self->add_region_into_group("CACHED_RW_INCLUDE_DRDI", $_); # for custom_mk_ram_info. NO DUMP
634 }
635 $self->add_region_into_group("CORE0_C", $_) if(/CORE0/);
636 $self->add_region_into_group("CORE1_C", $_) if(/CORE1/);
637 $self->add_region_into_group("CORE2_C", $_) if(/CORE2/);
638 next;
639 }
640 elsif(/EXTSRAM/)
641 {
642 $self->add_region_into_group("DEFAULT_NONCACHED_RW", $_) if(! /TX|RX|EXTSRAM_L1DSP_ZI/);
643 $self->add_region_into_group("NONCACHED_RW", $_);
644 next;
645 }
646 elsif(/EMIINIT|INTSRAM|^[ID]SPRAM[0-1]/)
647 {
648 $self->add_region_into_group("INTSRAM", $_);
649 $self->add_region_into_group("LOAD_AREA", $_) if(/^ISPRAM[0-1]$/);
650 next;
651 }
652 elsif(/^DYNAMIC_SECTION_ISPRAM/)
653 {
654 $self->add_region_into_group("LOAD_AREA", $_); next;
655 }
656 elsif(/^ROM/)
657 {
658 next if($_ =~/GFH|SIGNATURE_SECTION/);
659 $self->add_region_into_group("CACHED_RO", $_);
660 $self->add_region_into_group("ROM", $_); next;
661 }
662 elsif(/^UROM/)
663 {
664 $self->add_region_into_group("NONCACHED_RO", $_);
665 $self->add_region_into_group("UROM", $_); next;
666 }
667 elsif(/^AUROM/)
668 {
669 $self->add_region_into_group("AUROM", $_); next;
670 }
671
672 }
673}
674sub add_region_into_group #used by ClassifyRegionType
675{
676 my $self = shift;
677 my ($strKey, $strRegionName) = @_;
678 if(exists $self->{RegionGroup}{$strKey})
679 {
680 my $temp_ref = $self->{RegionGroup}{$strKey};
681 push(@$temp_ref, $strRegionName);
682 #print $_ ."\n" foreach (@$temp_ref);
683 }
684 else
685 {
686 $self->{RegionGroup}{$strKey}= [$strRegionName];
687 }
688}
689#****************************************************************************
690# subroutine: GetGroupedRegions
691# input: $strKey:
692# RegionType = INTSRAM, DYNAMIC_DNC, DYNAMIC_DC, CACHED_RO, CACHED_RW, NONCACHED_RO, NONCACHED_RW;
693# output: array_ref: #[[Region1], [Region3, Region4], [Region6]] in order
694#****************************************************************************
695sub GetGroupedRegions
696{
697 my $self = shift;
698 #RegionType = INTSRAM, DYNAMIC_DNC, DYNAMIC_DC, CACHED_RO, CACHED_RW, NONCACHED_RO, NONCACHED_RW;
699 my ($strKey) = @_;
700 my @CombinedRegions = (); #[[Region1], [Region3, Region4], [Region6]]
701
702 #NoMergeRegion indicates which regions can't be merged because gap exists.
703 my %NoMergeRegion = ( NONCACHED_RO => 0, );
704
705 if(exists $self->{RegionGroup}{$strKey})
706 {
707 my $OptionString = ($strKey eq "MBA") ? "Load" : "Exe";
708 my $LookupTable = $self->{$OptionString."RegionLookUpTable"};
709 my $Regions = $self->{$OptionString."Region"};
710
711 my $temp_ref = $self->{RegionGroup}{$strKey};
712 my @temp = map{ $LookupTable->{$_} } @$temp_ref ;
713 my @Sort_temp = sort {$a <=> $b} @temp;
714
715 my ($nPreviousIndex, $nIndex) = (-1,0);
716 foreach(@Sort_temp)
717 {
718 my $strRegionName = $Regions->{$_}->[0];
719 my ($bIsFixed, $strFixedLength) = $self->IsFixedLengthRegion($strRegionName);
720
721 if((not exists $NoMergeRegion{$strKey} and !exists $self->{LoadRegionLookUpTable}{$strRegionName})
722 and ($nPreviousIndex+1 == $_ and $bIsFixed == 0)) #non fixed region or not load region
723 {
724 my $array = $CombinedRegions[$nIndex-1];
725 push(@$array , $strRegionName);
726 }
727 else
728 {
729 push(@CombinedRegions, [ $strRegionName ]);
730 $nIndex++;
731 }
732 $nPreviousIndex = $_;
733 }
734 }
735 #map {print "[$strKey]Combination:".$_->[0]."\n"} @CombinedRegions;
736 return \@CombinedRegions;
737}
738
739#****************************************************************************
740# subroutine: GetExeRegionsByLoadRegion
741# input: $strLoadRegionName
742# output: array_ref: #in order
743#****************************************************************************
744sub GetExeRegionsByLoadRegion
745{
746 my $self = shift;
747 my ($strLoadRegionName) = @_;
748 my $array_ref = undef;
749 if(exists $self->{RegionMap}{$strLoadRegionName})
750 {
751 $array_ref = $self->{RegionMap}{$strLoadRegionName};
752 }
753 return $array_ref;
754}
755
756#****************************************************************************
757# subroutine: GetFirstExeRegionNameByLoadRegion
758# input: $strLoadRegionName
759# output: $strExeRegionName
760#****************************************************************************
761sub GetFirstExeRegionNameByLoadRegion
762{
763 my $self = shift;
764 my ($strLoadRegionName) = @_;
765 my $strExeRegionName = undef;
766 my $array_ref = undef;
767
768 if(exists $self->{RegionMap}{$strLoadRegionName})
769 {
770 $array_ref = $self->{RegionMap}{$strLoadRegionName};
771 $strExeRegionName = $array_ref->[0];
772 }
773 return $strExeRegionName;
774}
775
776#****************************************************************************
777# subroutine: GetExeRegionsInRAMByLoadRegion
778# input: $strLoadRegionName
779# output: array_ref: #in order
780# by filtering EXTSRAM|CACHED|DYNAMIC and "NOT" EXTSRAM_DSP since they are located in shared memory
781#****************************************************************************
782sub GetExeRegionsInRAMByLoadRegion
783{
784 my $self = shift;
785 my ($strLoadRegionName) = @_;
786 my $array_ref = $self->GetExeRegionsInKeyWordByLoadRegion($strLoadRegionName, "EXTSRAM|CACHED|DYNAMIC", "DYNAMIC_SECTION|DUMMY");
787 return $array_ref;
788}
789#****************************************************************************
790# subroutine: GetExeRegionsInROMByLoadRegion
791# input: $strLoadRegionName
792# output: array_ref: #in order
793# by filtering ROM and not SIGNATURE_SECTION
794#****************************************************************************
795sub GetExeRegionsInROMByLoadRegion
796{
797 my $self = shift;
798 my ($strLoadRegionName) = @_;
799 my $array_ref = $self->GetExeRegionsInKeyWordByLoadRegion($strLoadRegionName, "ROM", "SIGNATURE_SECTION");
800 return $array_ref;
801}
802
803sub IsFixedLengthDumpGroup # for dump region usage
804{
805 my $self = shift;
806 my ($strKey) = @_; # VECTOR_TABLE, INTSRAM, DYNAMIC_DNC, DYNAMIC_DNC_VA, DYNAMIC_DC, DYNAMIC_DC_PA,
807 # CACHED_RW, NONCACHED_RW, OTHERS
808 my %Fixed_Table =
809 (
810 "VECTOR_TABLE" => 1,
811 "INTSRAM" => 1,
812 );
813 return $Fixed_Table{$strKey};
814}
815use constant COMPRESSED_ALICE => "COMPRESSED_ALICE";
816use constant DUMP_VECTOR_TABLE => "DUMP_VECTOR_TABLE";
817sub GetDumpExeRegions
818{ #
819 my $self = shift;
820 my ($bb) = @_;
821 my %DumpRegions;
822 my @DumpOrder;
823
824 # ROM related
825 # if(!&FileInfo::is_NonSPNOR()) # it is 90 rule
826 {
827 $DumpRegions{ROM_PA} = $self->GetGroupedRegions("ROM"); push(@DumpOrder, "ROM_PA");
828 $DumpRegions{ROM} = $self->GetGroupedRegions("ROM"); push(@DumpOrder, "ROM");
829 $DumpRegions{UROM} = $self->GetGroupedRegions("UROM"); push(@DumpOrder, "UROM");
830 $DumpRegions{AUROM} = $self->GetGroupedRegions("AUROM"); push(@DumpOrder, "AUROM");
831 $DumpRegions{LOAD_AREA} = $self->GetGroupedRegions("LOAD_AREA");push(@DumpOrder, "LOAD_AREA");
832 }
833 # TCM
834 $DumpRegions{INTSRAM} = $self->GetGroupedRegions("INTSRAM");push(@DumpOrder, "INTSRAM");
835
836 # L2SRAM
837 $DumpRegions{L2SRAM}= $self->GetGroupedRegions("L2SRAM"); push(@DumpOrder, "L2SRAM");
838 # USPRAM
839 $DumpRegions{USPRAM}= $self->GetGroupedRegions("USPRAM"); push(@DumpOrder, "USPRAM");
840
841 #L2LOCK
842 $DumpRegions{L2LOCK} = $self->GetGroupedRegions("L2LOCK"); push(@DumpOrder, "L2LOCK");
843
844 # DYNAMIC_CACHED_EXTSRAM_DNC_REGION
845 $DumpRegions{DEFAULT_DYNAMIC_DNC} = $self->GetGroupedRegions("DEFAULT_DYNAMIC_DNC"); push(@DumpOrder, "DEFAULT_DYNAMIC_DNC");
846 $DumpRegions{DEFAULT_DYNAMIC_DNC_VA} = $self->GetGroupedRegions("DEFAULT_DYNAMIC_DNC"); push(@DumpOrder, "DEFAULT_DYNAMIC_DNC_VA");
847
848 $DumpRegions{CACHED_RO_DATA_PA} = $self->GetGroupedRegions("CACHED_RO_DATA"); push(@DumpOrder, "CACHED_RO_DATA_PA");
849 $DumpRegions{CACHED_RO_DATA} = $self->GetGroupedRegions("CACHED_RO_DATA"); push(@DumpOrder, "CACHED_RO_DATA");
850
851
852 $DumpRegions{DRDI_SET_PA} = $self->GetGroupedRegions("DRDI_SET"); push(@DumpOrder, "DRDI_SET_PA");
853 $DumpRegions{DRDI_SET} = $self->GetGroupedRegions("DRDI_SET"); push(@DumpOrder, "DRDI_SET");
854 if(0){ # reserve for stage 4
855 $DumpRegions{DRDI_2G_PA} = $self->GetGroupedRegions("DRDI_2G"); push(@DumpOrder, "DRDI_2G_PA");
856 $DumpRegions{DRDI_2G} = $self->GetGroupedRegions("DRDI_2G"); push(@DumpOrder, "DRDI_2G");
857 $DumpRegions{DRDI_3GFDD_PA} = $self->GetGroupedRegions("DRDI_3GFDD"); push(@DumpOrder, "DRDI_3GFDD_PA");
858 $DumpRegions{DRDI_3GFDD} = $self->GetGroupedRegions("DRDI_3GFDD"); push(@DumpOrder, "DRDI_3GFDD");
859 $DumpRegions{DRDI_3GTDD_PA} = $self->GetGroupedRegions("DRDI_3GTDD"); push(@DumpOrder, "DRDI_3GTDD_PA");
860 $DumpRegions{DRDI_3GTDD} = $self->GetGroupedRegions("DRDI_3GTDD"); push(@DumpOrder, "DRDI_3GTDD");
861 $DumpRegions{DRDI_MMRF_PA} = $self->GetGroupedRegions("DRDI_MMRF"); push(@DumpOrder, "DRDI_MMRF_PA");
862 $DumpRegions{DRDI_MMRF} = $self->GetGroupedRegions("DRDI_MMRF"); push(@DumpOrder, "DRDI_MMRF");
863 $DumpRegions{DRDI_C2K_PA} = $self->GetGroupedRegions("DRDI_C2K"); push(@DumpOrder, "DRDI_C2K_PA");
864 $DumpRegions{DRDI_C2K} = $self->GetGroupedRegions("DRDI_C2K"); push(@DumpOrder, "DRDI_C2K");
865 $DumpRegions{DRDI_LTE_PA} = $self->GetGroupedRegions("DRDI_LTE"); push(@DumpOrder, "DRDI_LTE_PA");
866 $DumpRegions{DRDI_LTE} = $self->GetGroupedRegions("DRDI_LTE"); push(@DumpOrder, "DRDI_LTE");
867 }
868
869 # DYNAMIC_CACHED_EXTSRAM_DC_REGION
870 $DumpRegions{DEFAULT_DYNAMIC_DC_PA} = $self->GetGroupedRegions("DEFAULT_DYNAMIC_DC"); push(@DumpOrder, "DEFAULT_DYNAMIC_DC_PA");
871 $DumpRegions{DEFAULT_DYNAMIC_DC} = $self->GetGroupedRegions("DEFAULT_DYNAMIC_DC"); push(@DumpOrder, "DEFAULT_DYNAMIC_DC");
872
873 # CACHED_EXTSRAM_REGION
874 $DumpRegions{CACHED_RW_PA} = $self->GetGroupedRegions("CACHED_RW"); push(@DumpOrder, "CACHED_RW_PA");
875 $DumpRegions{CACHED_RW} = $self->GetGroupedRegions("CACHED_RW"); push(@DumpOrder, "CACHED_RW");
876 $DumpRegions{CACHED_RW_WT_PA} = $self->GetGroupedRegions("CACHED_RW_WT"); push(@DumpOrder, "CACHED_RW_WT_PA");
877 $DumpRegions{CACHED_RW_WT} = $self->GetGroupedRegions("CACHED_RW_WT"); push(@DumpOrder, "CACHED_RW_WT");
878
879 # NONCACHED_EXTSRAM_REGION
880 $DumpRegions{DEFAULT_NONCACHED_RW} = $self->GetGroupedRegions("DEFAULT_NONCACHED_RW"); push(@DumpOrder, "DEFAULT_NONCACHED_RW");
881
882 # IOCU2
883 $DumpRegions{IOCU2_PA} = $self->GetGroupedRegions("IOCU2"); push(@DumpOrder, "IOCU2_PA");
884 $DumpRegions{IOCU2} = $self->GetGroupedRegions("IOCU2"); push(@DumpOrder, "IOCU2");
885 $DumpRegions{IOCU3_PA} = $self->GetGroupedRegions("IOCU3"); push(@DumpOrder, "IOCU3_PA");
886 $DumpRegions{IOCU3} = $self->GetGroupedRegions("IOCU3"); push(@DumpOrder, "IOCU3");
887 return (\%DumpRegions, \@DumpOrder);
888}
889
890#****************************************************************************
891# subroutine: GetExeRegionsInKeyWordByLoadRegion
892# used by GetExeRegionsInROMByLoadRegion() and GetExeRegionsInRAMByLoadRegion()
893# input: $strLoadRegionName
894# filter $List but not $Unlist
895# output: array_ref: #in order
896#****************************************************************************
897sub GetExeRegionsInKeyWordByLoadRegion
898{
899 my $self = shift;
900 my ($strLoadRegionName, $List, $UnList) = @_;
901 my @RegionIndexsInRAM;
902 my @RegionsInRAM;
903 if(exists $self->{RegionMap}{$strLoadRegionName})
904 {
905 my $array_ref = $self->{RegionMap}{$strLoadRegionName};
906 foreach(@$array_ref)
907 {
908 if($_ =~ /$List/ and $_ !~ /$UnList/)
909 {
910 push(@RegionIndexsInRAM, $self->{ExeRegionLookUpTable}{$_});
911 }
912 }
913 sort {$a<=>$b} @RegionIndexsInRAM;
914 foreach(@RegionIndexsInRAM)
915 {
916 push(@RegionsInRAM, $self->{ExeRegion}{$_}->[0]);
917 }
918 }
919 return \@RegionsInRAM;
920}
921#****************************************************************************
922# subroutine: GetAllExeRegion
923# input: x
924# output: an array reference of execution region
925#****************************************************************************
926sub GetAllExeRegion
927{
928 my $self = shift;
929 my @ExeRegions;
930 foreach my $i (1 .. $self->{ExeRegionCount})
931 {
932 push(@ExeRegions, $self->{ExeRegion}{$i}->[0]);
933 }
934 return \@ExeRegions;
935}
936
937#****************************************************************************
938# subroutine: GetAllLoadRegion
939# input: x
940# output: an array reference of load region
941#****************************************************************************
942sub GetAllLoadRegion
943{
944 my $self = shift;
945 my @Regions;
946 foreach my $i (1 .. $self->{LoadRegionCount})
947 {
948 push(@Regions, $self->{LoadRegion}{$i}->[0]);
949 }
950 return \@Regions;
951}
952#****************************************************************************
953# subroutine: IsFixedLengthRegion
954# to see if its size needs to be fixed
955# input: RegionName
956# output: 1. $bIsFixed: 0=not fixed, 1= fixed
957# 2. $strFixedLength: no matter it's fixed or not, return its MaxSize
958#****************************************************************************
959sub IsFixedLengthRegion
960{
961 my $self = shift;
962 my ($strRegionName) = @_;
963 my $bIsFixed = 0;
964 my $strFixedLength;
965 my @FixedLenPattern = ("DSP_TX", "DSP_RX", "^[ID]SPRAM[0-2]", "USPRAM",
966 # old section
967 "jblend_ram", "DSP_RW_MCU_RW_TX1",
968 "CODE_PATCH_CODE", "DSP_RW_MCU_RW_DMA_RW_TX2_AND_RX", "DSP_RW_DSPONLY", "DSP_DMA_RX", "DYNAMIC_SECTION_ISPRAM",
969 "LANG_PACK", "CUSTPACK");
970 foreach my $strPattern (@FixedLenPattern)
971 {
972 if($strRegionName =~ /$strPattern/)
973 {
974 $bIsFixed = 1;
975 last;
976 }
977 }
978 $strFixedLength = $self->GetRegionInfo($strRegionName, Region::MaxSize);
979 return ($bIsFixed, $strFixedLength);
980}
981
982#****************************************************************************
983# subroutine: IsOverlappedRegion
984# to see if its overlap sections
985# input: RegionName
986# output: 1. $bIsFixed: 0=not fixed, 1= fixed
987# 2. $strFixedLength: no matter it's fixed or not, return its MaxSize
988#****************************************************************************
989sub IsOverlappedRegion
990{
991 my $self = shift;
992 my ($strRegionName) = @_;
993 my $bIsOverlapped = 0;
994 my $strOverlappedLength;
995 my @OverlappedLenPattern = ("DRDI"); # not for DSM in UMOLYA
996 foreach my $strPattern (@OverlappedLenPattern)
997 {
998 if($strRegionName =~ /$strPattern/)
999 {
1000 $bIsOverlapped = 1;
1001 last;
1002 }
1003 }
1004 $strOverlappedLength = $self->GetRegionInfo($strRegionName, Region::MaxSize);
1005 return ($bIsOverlapped, $strOverlappedLength);
1006}
1007
1008#****************************************************************************
1009# subroutine: IsRegionExistent
1010# to see if this Region exists in Load Regions or Execution Regions
1011# input: RegionName
1012# output: $bExistent=undef: not existent, 1= existent
1013#****************************************************************************
1014sub IsRegionExistent
1015{
1016 my $self = shift;
1017 my ($strRegionName) = @_;
1018 my $bExistent = undef;
1019 if(exists $self->{LoadRegionLookUpTable}{$strRegionName} or exists $self->{ExeRegionLookUpTable}{$strRegionName})
1020 {
1021 $bExistent = 1;
1022 }
1023 return $bExistent;
1024}
1025#****************************************************************************
1026# subroutine: GetPreviousExeRegionName
1027# to get the input region's previous execution region name
1028# input: RegionName
1029# output: $strPreviousRegion: undef means it's not existent
1030#****************************************************************************
1031sub GetPreviousExeRegionName
1032{
1033 my $self = shift;
1034 my ($strCurrentRegion) = @_;
1035 my $nIndex = $self->{ExeRegionLookUpTable}{$strCurrentRegion};
1036 my $strPreviousRegion = $self->{ExeRegion}{$nIndex-1}->[0] if(exists $self->{ExeRegion}{$nIndex-1});
1037 return $strPreviousRegion;
1038}
1039#****************************************************************************
1040# subroutine: GetNextExeRegionName
1041# to get the input region's next execution region name
1042# input: RegionName
1043# output: $strNextRegion: undef means it's not existent
1044#****************************************************************************
1045sub GetNextExeRegionName
1046{
1047 my $self = shift;
1048 my ($strCurrentRegion) = @_;
1049 my $nIndex = $self->{ExeRegionLookUpTable}{$strCurrentRegion};
1050 my $strNextRegion = $self->{ExeRegion}{$nIndex+1}->[0] if(exists $self->{ExeRegion}{$nIndex+1});
1051 return $strNextRegion;
1052}
1053#****************************************************************************
1054# subroutine: SearchExeRegionName
1055# to get the first execution region name by keyword searching
1056# input: Keyword
1057# output: RegionName: undef means it's not existent
1058#****************************************************************************
1059sub SearchExeRegionName
1060{
1061 my $self = shift;
1062 my ($strKey) = @_;
1063 my $strRegion = undef;
1064 foreach my $strTemp (keys %{$self->{ExeRegionLookUpTable}})
1065 {
1066 if($strTemp =~ /$strKey/)
1067 {
1068 $strRegion = $strTemp;
1069 last;
1070 }
1071 }
1072 if(!defined $strRegion)
1073 {
1074 $strKey =~ s/\$//;
1075 foreach my $strTemp (keys %{$self->{ExeRegionLookUpTable}})
1076 {
1077 if($strTemp =~ /$strKey\_ZI$/i)
1078 {
1079 $strRegion = $strTemp;
1080 last;
1081 }
1082 }
1083 }
1084 return $strRegion;
1085}
1086#****************************************************************************
1087# subroutine: SearchExeRegionName
1088# to get the first load region name by keyword searching
1089# input: Keyword
1090# output: RegionName: undef means it's not existent
1091#****************************************************************************
1092sub SearchLoadRegionName
1093{
1094 my $self = shift;
1095 my ($strKey) = @_;
1096 my $strRegion = undef;
1097 foreach my $strTemp (keys %{$self->{LoadRegionLookUpTable}})
1098 {
1099 if($strTemp =~ /$strKey/)
1100 {
1101 $strRegion = $strTemp;
1102 last;
1103 }
1104 }
1105 return $strRegion;
1106}
1107#****************************************************************************
1108# subroutine: GetRegionInfo - Get Region information from LoadRegions and ExecutionRegions
1109# Search Execution Region First, then Load Region
1110# input: $strRegionName: Execution Name (Case sensitive)
1111# $nOption= Region::Base, Region::MaxSize, Region::Attribute, Region::Offset
1112# output: $strInfo may be base, maxsize, attribute, and offset
1113#****************************************************************************
1114sub GetRegionInfo
1115{
1116 my $self = shift;
1117 my ($strRegionName, $nOption) = @_;
1118 my $strInfo = undef;
1119 my $Info_ref = $self->GetExeRegionInfo($strRegionName);
1120 if(!defined $Info_ref->[Region::Attribute])
1121 {
1122 $Info_ref = $self->GetLoadRegionInfo($strRegionName);
1123 }
1124 if(defined $Info_ref->[Region::Attribute])
1125 {
1126 if($nOption > Region::Offset || $nOption < Region::Base)
1127 { # report error - $nOption must have a value
1128 &SCAT_die("GetRegionInfo must have Option value($nOption)");
1129 }
1130 else
1131 {
1132 $strInfo = $Info_ref->[$nOption];
1133 }
1134 }
1135 return $strInfo;
1136}
1137
1138#****************************************************************************
1139# subroutine: GetExeRegionInfo - Get Execution Region information
1140# input: $strRegionName: Execution Name (Case sensitive)
1141# output: an Array contains
1142# [0]$strBase=Region Base address,
1143# [1]$strMaxSize=Region MaxSize,
1144# [2]$strAttribute=Attribute,
1145# [3]$strOffset(undef= no offset , others=start with +0x.. or ALIGN)
1146#****************************************************************************
1147sub GetExeRegionInfo
1148{
1149 my $self = shift;
1150 my ($strRegionName) = @_;
1151 my ($strBase, $nMaxSize, $strAttribute, $strOffset) = (undef, undef, undef, undef);
1152 my $nIndex = $self->{ExeRegionLookUpTable}{$strRegionName};
1153 if(defined $nIndex)
1154 {
1155 $strOffset = $self->{ExeRegion}{$nIndex}->[2];
1156 $strBase = $self->{ExeRegion}{$nIndex}->[1];
1157 $nMaxSize = (defined $self->{ExeRegion}{$nIndex}->[3]) ? $self->{ExeRegion}{$nIndex}->[3] : 0xFFFFFFFF;
1158 $strAttribute = $self->{ExeRegion}{$nIndex}->[4];
1159 }
1160 my @Info = ($strBase, &CommonUtil::Dec2Hex($nMaxSize), $strAttribute, $strOffset);
1161 return \@Info;
1162}
1163#****************************************************************************
1164# subroutine: GetLoadRegionInfo - Get Load Region information
1165# input: $strRegionName: Load Name (Case sensitive)
1166# output: an Array contains
1167# [0]$strBase=Region Base address,
1168# [1]$strMaxSize=Region MaxSize,
1169# [2]$attr_aref= (\@Attribte):attribute list,
1170# [3]$strOffset(undef= no offset , others=start with +0x.. or ALIGN)
1171#****************************************************************************
1172sub GetLoadRegionInfo
1173{
1174 my $self = shift;
1175 my ($strRegionName) = (@_);
1176 my ($strBase, $nMaxSize, $attr_aref, $strOffset) = (undef, undef, undef, undef);
1177 my $nIndex = $self->{LoadRegionLookUpTable}{$strRegionName};
1178 if(defined $nIndex)
1179 {
1180 $strOffset = $self->{LoadRegion}{$nIndex}->[2];
1181 $strBase = $self->{LoadRegion}{$nIndex}->[1] if(!defined $strOffset);
1182 $nMaxSize = (defined $self->{LoadRegion}{$nIndex}->[3]) ? $self->{LoadRegion}{$nIndex}->[3] : 0xFFFFFFFF;
1183 $attr_aref = $self->{LoadRegion}{$nIndex}->[4];
1184 }
1185 my @Info = ($strBase, &CommonUtil::Dec2Hex($nMaxSize), $attr_aref, $strOffset);
1186 return \@Info;
1187}
1188#****************************************************************************
1189# subroutine: GetRegionMap - Get Load Region-Execution Region mapping
1190# input: N/A
1191# output: # \%g_RegionMap; # {Load Region Name => [Execution Region Name, ... in order]}
1192#****************************************************************************
1193sub GetRegionMap
1194{
1195 my $self = shift;
1196 return $self->{RegionMap}; # %g_RegionMap; # {Load Region Name => [Execution Region Name, ... in order]}
1197}
1198
1199#****************************************************************************
1200# subroutine: SCAT_die
1201# sample code: (message, __FILE__, __LINE__)
1202# input: $error_msg, $file, $line_no
1203#****************************************************************************
1204sub SCAT_die
1205{
1206 my ($error_msg, $file, $line_no) = (@_);
1207 &sysUtil::error_handler($error_msg, $file, $line_no, 'SCATINFO');
1208}
1209
1210sub GetSCATINFO_VERNO
1211{
1212 return $SCATINFO_VERNO;
1213}
1214sub GetldsInfoWrap_VERNO
1215{
1216 return "ldsInfoWrap.pm".&ldsInfoWrap::ldsInfoWrap_verno();
1217}