Upload Tizen:Base source
[external/binutils.git] / bfd / mep-relocs.pl
1 #!/usr/bin/perl
2 # -*- perl -*-
3 #
4 # Toshiba MeP Media Engine Relocation Generator
5 # Copyright (C) 2001, 2007 Free Software Foundation, Inc.
6 # This file is part of BFD.
7 # Originally written by DJ Delorie <dj@redhat.com>
8 #
9 # This program is free software; you can redistribute it and/or modify
10 # it under the terms of the GNU General Public License as published by
11 # the Free Software Foundation; either version 3 of the License, or
12 # (at your option) any later version.
13
14 # This program is distributed in the hope that it will be useful,
15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 # GNU General Public License for more details.
18
19 # You should have received a copy of the GNU General Public License
20 # along with this program; if not, write to the Free Software
21 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
22 # MA 02110-1301, USA.
23
24
25 # Usage: Run this anywhere inside your source tree.  It will read
26 # include/elf/mep.h and scan the comments therein.  It will renumber
27 # the relocs to be sequential (this is needed so that bfd/elf32-mep.h
28 # works) if needed.  It will then update the reloc list in bfd/reloc.c
29 # and the howto, mapping, and apply routines in bfd/elf32-mep.c.  You
30 # can then regenerate bfd-in2.h and check everything in.
31
32 # FIXME: After the relocation list is finalized, change this to
33 # *verify* the reloc list, rather than resequence it.
34
35 while (! -f "include/elf/mep.h" && ! -f "bfd/reloc.c") {
36     chdir "..";
37     $pwd = `pwd`;
38     if ($pwd !~ m@/.*/@) {
39         print STDERR "Cannot find include/elf/mep.h or bfd/reloc.h\n";
40         exit 1;
41     }
42 }
43 $pwd = `pwd`;
44 print "srctop is $pwd";
45
46 printf "Reading include/elf/mep.h ...\n";
47 open(MEPH, "include/elf/mep.h");
48 open(MEPHO, "> include/elf/mep.h.new") || die("mep.h.new create: $!");
49 $val = 0;
50 while (<MEPH>) {
51     if (($pre,$rel,$rest) = /(.*RELOC_NUMBER \()([^,]+), *\d+(.*)/) {
52         $rest =~ s/[\r\n]+$//;
53         print (MEPHO "$pre$rel, $val$rest\n") || die("mep.h.new write: $!");
54         $val ++;
55         $rel =~ s/R_MEP_//;
56         push(@relocs, $rel);
57
58         $rest =~ s@.*/\* @@;
59         ($pattern, $sign, $attrs) = $rest =~ m@(.*) ([US]) (.*)\*/@;
60         $pattern =~ s/ //g;
61         push(@pattern, $pattern);
62         push(@sign, $sign);
63         push(@attrs, $attrs);
64
65         printf "%4d $rel p=`$pattern' s=`$sign' a=`$attrs'\n", $#pattern;
66
67     } else {
68         print(MEPHO) || die("mep.h.new write: $!");
69     }
70 }
71 close(MEPH);
72 close(MEPHO) || die("mep.h.new close: $!");
73
74 &swapfile("include/elf/mep.h");
75
76 redo_file ("bfd/reloc.c",
77            "",
78            "ENUMDOC\n  Toshiba Media Processor Relocations.\n\nCOMMENT\n",
79            "ENUM\n  BFD_RELOC_MEP_%s\n",
80            "");
81
82 $autogen = "    /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h.  */\n";
83
84 redo_file ("bfd/elf32-mep.c",
85            "MEPRELOC:HOWTO",
86            $autogen,
87            "MEPRELOC:END",
88            "",
89            "&emit_howto();",
90            "MEPRELOC:MAP",
91            $autogen,
92            "MEPRELOC:END",
93            "",
94            "    MAP(%s);\n",
95            "MEPRELOC:APPLY",
96            $autogen,
97            "MEPRELOC:END",
98            "",
99            "&emit_apply();",
100            );
101
102 sub mask2shifts {
103     my ($mask) = @_;
104     my ($bits, $left, $right, $ci, $c, $cv);
105     $bits = 0;
106     $left = 0;
107     $right = 32;
108     for ($ci=0; $ci<length($mask); $ci++) {
109         $c = substr($mask, $ci, 1);
110         $left++;
111         next if $c eq '-';
112         $left = 0;
113         $cv = ord($c) - ord('0');
114         $cv -= ord('a') - ord('9') - 1 if $cv > 9;
115         $right = $cv unless $right < $cv;
116         $bits = $cv+1 unless $bits > $cv+1;
117     }
118     $mask =~ tr/-/1/c;
119     $mask =~ tr/-/0/;
120     ($rmask = $mask) =~ tr/01/10/;
121     $mask = unpack("H*", pack("B*", $mask));
122     $rmask = unpack("H*", pack("B*", $rmask));
123     return ($bits, $left, $right, $mask, $rmask);
124 }
125
126 sub emit_howto {
127     for ($i=2; $i<=$#relocs; $i++) {
128         $mask = $pattern[$i];
129
130         if (length($mask) == 8)     { $bytesize = 0; }
131         elsif (length($mask) == 16) { $bytesize = 1; }
132         elsif (length($mask) == 32) { $bytesize = 2; }
133
134         ($bits, $left, $right, $mask) = mask2shifts ($mask);
135         $bits[$i] = $bits;
136         $pcrel = 0;
137         $pcrel = 1 if $attrs[$i] =~ /pc-rel/i;
138         $overflow = $sign[$i];
139         $overflow = 'N' if $attrs[$i] =~ /no-overflow/;
140
141         $c = "$relocs[$i],";
142         printf(NEW "  MEPREL (R_MEP_%-10s%d,%3d,%2d,%2d,%2d,%2s, 0x%s),\n",
143                $c, $bytesize, $bits, $left, $right, $pcrel, $overflow, $mask);
144     }
145 }
146
147 sub emit_apply {
148     for ($i=2; $i<=$#relocs; $i++) {
149         $v = "u";
150         $v = "s" if $sign[$i] =~ /S/;
151         if (length($pattern[$i]) == 8) {
152             $e = ''; # no endian swap for bytes
153         } elsif ($pattern[$i] =~ /-/ || length($pattern[$i]) == 16) {
154             $e = '^e2'; # endian swap - 2byte words only
155         } else {
156             $e = '^e4' # endian swap for data
157         }
158         print NEW "    case R_MEP_$relocs[$i]: /* $pattern[$i] */\n";
159         if ($attrs[$i] =~ /tp-rel/i) {
160             print NEW "      $v -= mep_tpoff_base(rel->r_offset);\n";
161         }
162         if ($attrs[$i] =~ /gp-rel/i) {
163             print NEW "      $v -= mep_sdaoff_base(rel->r_offset);\n";
164         }
165         if ($attrs[$i] !~ /no-overflow/ && $bits[$i] < 32) {
166             if ($v eq "u") {
167                 $max = (1 << $bits[$i]) - 1;
168                 print NEW "      if (u > $max) r = bfd_reloc_overflow;\n";
169             } else {
170                 $min = -(1 << ($bits[$i]-1));
171                 $max = (1 << ($bits[$i]-1)) - 1;
172                 print NEW "      if ($min > s || s > $max) r = bfd_reloc_overflow;\n";
173             }
174         }
175         for ($b=0; $b<length($pattern[$i]); $b += 8) {
176             $mask = substr($pattern[$i], $b, 8);
177             ($bits, $left, $right, $mask, $rmask) = mask2shifts ($mask);
178             if ($left > $right) { $left -= $right; $right = 0; }
179             else { $right -= $left; $left = 0; }
180
181             if ($mask ne "00") {
182                 $bb = $b / 8;
183                 print NEW "      byte[$bb$e] = ";
184                 print NEW "(byte[$bb$e] & 0x$rmask) | " if $rmask ne "00";
185                 if ($left) {
186                     print NEW "(($v << $left) & 0x$mask)";
187                 } elsif ($right) {
188                     print NEW "(($v >> $right) & 0x$mask)";
189                 } else {
190                     print NEW "($v & 0x$mask)";
191                 }
192                 print NEW ";\n";
193             }
194         }
195         print NEW "      break;\n";
196     }
197 }
198
199
200 #-----------------------------------------------------------------------------
201
202 sub redo_file {
203     my ($file, @control) = @_;
204     open(OLD, $file);
205     open(NEW, "> $file.new") || die("$file.new create: $!");
206
207     print "Scanning file $file ...\n";
208
209     while (1) {
210         $start = shift @control;
211         $prefix = shift @control;
212         $end = shift @control;
213         $suffix = shift @control;
214         $pattern = shift @control;
215
216         if (!$start) {
217             print NEW while <OLD>;
218             last;
219         }
220
221         print "  looking for $start\n";
222         while (<OLD>) {
223             print NEW;
224             last if /\Q$start\E/;
225         }
226         print "can't find $start\n" unless $_;
227         last unless $_;
228
229         print NEW $prefix;
230         if ($pattern =~ /^\&/) {
231             eval $pattern;
232             die("$pattern: $@") if $@;
233         } else {
234             for $i (2..$#relocs) {
235                 printf (NEW "$pattern", $relocs[$i]) || die("$file.new write: $!");
236                 $pattern =~ s/^ENUM\n/ENUMX\n/;
237             }
238         }
239         print NEW $suffix;
240         while (<OLD>) {
241             last if /\Q$end\E/;
242         }
243         print NEW;
244     }
245
246     close(OLD);
247     close(NEW) || die("$file.new close: $!");
248     &swapfile($file);
249 }
250
251 #-----------------------------------------------------------------------------
252
253 sub swapfile {
254     my ($f) = @_;
255     if ( ! -f "$f.save") {
256         system "cp $f $f.save";
257     }
258     open(ORIG, $f);
259     open(NEW, "$f.new");
260     while (<ORIG>) {
261         $n = <NEW>;
262         if ($n ne $_) {
263             close(ORIG);
264             close(NEW);
265             print "  Updating $f\n";
266             rename "$f", "$f.old";
267             rename "$f.new", "$f";
268             return;
269         }
270     }
271     close(ORIG);
272     close(NEW);
273     print "  No change to $f\n";
274     unlink "$f.new";
275 }