1#!/usr/bin/perl
2
3my $bigend;  # little/big endian
4my $nxstack;
5
6$nxstack = 0;
7
8eval 'exec /usr/local/bin/perl -S $0 ${1+"$@"}'
9    if $running_under_some_shell;
10
11while ($ARGV[0] =~ /^-/) {
12    $_ = shift;
13  last if /^--/;
14    if (/^-n/) {
15    $nflag++;
16    next;
17    }
18    die "I don't recognize this switch: $_\\n";
19}
20$printit++ unless $nflag;
21
22$\ = "\n";      # automatically add newline on print
23$n=0;
24
25$thumb = 0;     # ARM mode by default, not Thumb.
26@proc_stack = ();
27
28LINE:
29while (<>) {
30
31    # For ADRLs we need to add a new line after the substituted one.
32    $addPadding = 0;
33
34    # First, we do not dare to touch *anything* inside double quotes, do we?
35    # Second, if you want a dollar character in the string,
36    # insert two of them -- that's how ARM C and assembler treat strings.
37    s/^([A-Za-z_]\w*)[ \t]+DCB[ \t]*\"/$1:   .ascii \"/   && do { s/\$\$/\$/g; next };
38    s/\bDCB\b[ \t]*\"/.ascii \"/                          && do { s/\$\$/\$/g; next };
39    s/^(\S+)\s+RN\s+(\S+)/$1 .req r$2/                    && do { s/\$\$/\$/g; next };
40    # If there's nothing on a line but a comment, don't try to apply any further
41    #  substitutions (this is a cheap hack to avoid mucking up the license header)
42    s/^([ \t]*);/$1@/                                     && do { s/\$\$/\$/g; next };
43    # If substituted -- leave immediately !
44
45    s/@/,:/;
46    s/;/@/;
47    while ( /@.*'/ ) {
48      s/(@.*)'/$1/g;
49    }
50    s/\{FALSE\}/0/g;
51    s/\{TRUE\}/1/g;
52    s/\{(\w\w\w\w+)\}/$1/g;
53    s/\bINCLUDE[ \t]*([^ \t\n]+)/.include \"$1\"/;
54    s/\bGET[ \t]*([^ \t\n]+)/.include \"${ my $x=$1; $x =~ s|\.s|-gnu.S|; \$x }\"/;
55    s/\bIMPORT\b/.extern/;
56    s/\bEXPORT\b/.global/;
57    s/^(\s+)\[/$1IF/;
58    s/^(\s+)\|/$1ELSE/;
59    s/^(\s+)\]/$1ENDIF/;
60    s/IF *:DEF:/ .ifdef/;
61    s/IF *:LNOT: *:DEF:/ .ifndef/;
62    s/ELSE/ .else/;
63    s/ENDIF/ .endif/;
64
65    if( /\bIF\b/ ) {
66      s/\bIF\b/ .if/;
67      s/=/==/;
68    }
69    if ( $n == 2) {
70        s/\$/\\/g;
71    }
72    if ($n == 1) {
73        s/\$//g;
74        s/label//g;
75    $n = 2;
76      }
77    if ( /MACRO/ ) {
78      s/MACRO *\n/.macro/;
79      $n=1;
80    }
81    if ( /\bMEND\b/ ) {
82      s/\bMEND\b/.endm/;
83      $n=0;
84    }
85
86    # ".rdata" doesn't work in 'as' version 2.13.2, as it is ".rodata" there.
87    #
88    if ( /\bAREA\b/ ) {
89        my $align;
90        $align = "2";
91        if ( /ALIGN=(\d+)/ ) {
92            $align = $1;
93        }
94        if ( /CODE/ ) {
95            $nxstack = 1;
96        }
97        s/^(.+)CODE(.+)READONLY(.*)/    .text/;
98        s/^(.+)DATA(.+)READONLY(.*)/    .section .rdata/;
99        s/^(.+)\|\|\.data\|\|(.+)/    .data/;
100        s/^(.+)\|\|\.bss\|\|(.+)/    .bss/;
101        s/$/;   .p2align $align/;
102        # Enable NEON instructions but don't produce a binary that requires
103        # ARMv7. RVCT does not have equivalent directives, so we just do this
104        # for all CODE areas.
105        if ( /.text/ ) {
106            # Separating .arch, .fpu, etc., by semicolons does not work (gas
107            # thinks the semicolon is part of the arch name, even when there's
108            # whitespace separating them). Sadly this means our line numbers
109            # won't match the original source file (we could use the .line
110            # directive, which is documented to be obsolete, but then gdb will
111            # show the wrong line in the translated source file).
112            s/$/;   .arch armv7-a\n   .fpu neon\n   .object_arch armv4t/;
113        }
114    }
115
116    s/\|\|\.constdata\$(\d+)\|\|/.L_CONST$1/;       # ||.constdata$3||
117    s/\|\|\.bss\$(\d+)\|\|/.L_BSS$1/;               # ||.bss$2||
118    s/\|\|\.data\$(\d+)\|\|/.L_DATA$1/;             # ||.data$2||
119    s/\|\|([a-zA-Z0-9_]+)\@([a-zA-Z0-9_]+)\|\|/@ $&/;
120    s/^(\s+)\%(\s)/    .space $1/;
121
122    s/\|(.+)\.(\d+)\|/\.$1_$2/;                     # |L80.123| -> .L80_123
123    s/\bCODE32\b/.code 32/ && do {$thumb = 0};
124    s/\bCODE16\b/.code 16/ && do {$thumb = 1};
125    if (/\bPROC\b/)
126    {
127        my $prefix;
128        my $proc;
129        /^([A-Za-z_\.]\w+)\b/;
130        $proc = $1;
131        $prefix = "";
132        if ($proc)
133        {
134            $prefix = $prefix.sprintf("\t.type\t%s, %%function; ",$proc);
135            push(@proc_stack, $proc);
136            s/^[A-Za-z_\.]\w+/$&:/;
137        }
138        $prefix = $prefix."\t.thumb_func; " if ($thumb);
139        s/\bPROC\b/@ $&/;
140        $_ = $prefix.$_;
141    }
142    s/^(\s*)(S|Q|SH|U|UQ|UH)ASX\b/$1$2ADDSUBX/;
143    s/^(\s*)(S|Q|SH|U|UQ|UH)SAX\b/$1$2SUBADDX/;
144    if (/\bENDP\b/)
145    {
146        my $proc;
147        s/\bENDP\b/@ $&/;
148        $proc = pop(@proc_stack);
149        $_ = "\t.size $proc, .-$proc".$_ if ($proc);
150    }
151    s/\bSUBT\b/@ $&/;
152    s/\bDATA\b/@ $&/;   # DATA directive is deprecated -- Asm guide, p.7-25
153    s/\bKEEP\b/@ $&/;
154    s/\bEXPORTAS\b/@ $&/;
155    s/\|\|(.)+\bEQU\b/@ $&/;
156    s/\|\|([\w\$]+)\|\|/$1/;
157    s/\bENTRY\b/@ $&/;
158    s/\bASSERT\b/@ $&/;
159    s/\bGBLL\b/@ $&/;
160    s/\bGBLA\b/@ $&/;
161    s/^\W+OPT\b/@ $&/;
162    s/:OR:/|/g;
163    s/:SHL:/<</g;
164    s/:SHR:/>>/g;
165    s/:AND:/&/g;
166    s/:LAND:/&&/g;
167    s/CPSR/cpsr/;
168    s/SPSR/spsr/;
169    s/ALIGN$/.balign 4/;
170    s/ALIGN\s+([0-9x]+)$/.balign $1/;
171    s/psr_cxsf/psr_all/;
172    s/LTORG/.ltorg/;
173    s/^([A-Za-z_]\w*)[ \t]+EQU/ .set $1,/;
174    s/^([A-Za-z_]\w*)[ \t]+SETL/ .set $1,/;
175    s/^([A-Za-z_]\w*)[ \t]+SETA/ .set $1,/;
176    s/^([A-Za-z_]\w*)[ \t]+\*/ .set $1,/;
177
178    #  {PC} + 0xdeadfeed  -->  . + 0xdeadfeed
179    s/\{PC\} \+/ \. +/;
180
181    # Single hex constant on the line !
182    #
183    # >>> NOTE <<<
184    #   Double-precision floats in gcc are always mixed-endian, which means
185    #   bytes in two words are little-endian, but words are big-endian.
186    #   So, 0x0000deadfeed0000 would be stored as 0x0000dead at low address
187    #   and 0xfeed0000 at high address.
188    #
189    s/\bDCFD\b[ \t]+0x([a-fA-F0-9]{8})([a-fA-F0-9]{8})/.long 0x$1, 0x$2/;
190    # Only decimal constants on the line, no hex !
191    s/\bDCFD\b[ \t]+([0-9\.\-]+)/.double $1/;
192
193    # Single hex constant on the line !
194#    s/\bDCFS\b[ \t]+0x([a-f0-9]{8})([a-f0-9]{8})/.long 0x$1, 0x$2/;
195    # Only decimal constants on the line, no hex !
196#    s/\bDCFS\b[ \t]+([0-9\.\-]+)/.double $1/;
197    s/\bDCFS[ \t]+0x/.word 0x/;
198    s/\bDCFS\b/.float/;
199
200    s/^([A-Za-z_]\w*)[ \t]+DCD/$1 .word/;
201    s/\bDCD\b/.word/;
202    s/^([A-Za-z_]\w*)[ \t]+DCW/$1 .short/;
203    s/\bDCW\b/.short/;
204    s/^([A-Za-z_]\w*)[ \t]+DCB/$1 .byte/;
205    s/\bDCB\b/.byte/;
206    s/^([A-Za-z_]\w*)[ \t]+\%/.comm $1,/;
207    s/^[A-Za-z_\.]\w+/$&:/;
208    s/^(\d+)/$1:/;
209    s/\%(\d+)/$1b_or_f/;
210    s/\%[Bb](\d+)/$1b/;
211    s/\%[Ff](\d+)/$1f/;
212    s/\%[Ff][Tt](\d+)/$1f/;
213    s/&([\dA-Fa-f]+)/0x$1/;
214    if ( /\b2_[01]+\b/ ) {
215      s/\b2_([01]+)\b/conv$1&&&&/g;
216      while ( /[01][01][01][01]&&&&/ ) {
217        s/0000&&&&/&&&&0/g;
218        s/0001&&&&/&&&&1/g;
219        s/0010&&&&/&&&&2/g;
220        s/0011&&&&/&&&&3/g;
221        s/0100&&&&/&&&&4/g;
222        s/0101&&&&/&&&&5/g;
223        s/0110&&&&/&&&&6/g;
224        s/0111&&&&/&&&&7/g;
225        s/1000&&&&/&&&&8/g;
226        s/1001&&&&/&&&&9/g;
227        s/1010&&&&/&&&&A/g;
228        s/1011&&&&/&&&&B/g;
229        s/1100&&&&/&&&&C/g;
230        s/1101&&&&/&&&&D/g;
231        s/1110&&&&/&&&&E/g;
232        s/1111&&&&/&&&&F/g;
233      }
234      s/000&&&&/&&&&0/g;
235      s/001&&&&/&&&&1/g;
236      s/010&&&&/&&&&2/g;
237      s/011&&&&/&&&&3/g;
238      s/100&&&&/&&&&4/g;
239      s/101&&&&/&&&&5/g;
240      s/110&&&&/&&&&6/g;
241      s/111&&&&/&&&&7/g;
242      s/00&&&&/&&&&0/g;
243      s/01&&&&/&&&&1/g;
244      s/10&&&&/&&&&2/g;
245      s/11&&&&/&&&&3/g;
246      s/0&&&&/&&&&0/g;
247      s/1&&&&/&&&&1/g;
248      s/conv&&&&/0x/g;
249    }
250
251    if ( /commandline/)
252    {
253        if( /-bigend/)
254        {
255            $bigend=1;
256        }
257    }
258
259    if ( /\bDCDU\b/ )
260    {
261        my $cmd=$_;
262        my $value;
263        my $prefix;
264        my $w1;
265        my $w2;
266        my $w3;
267        my $w4;
268
269        s/\s+DCDU\b/@ $&/;
270
271        $cmd =~ /\bDCDU\b\s+0x(\d+)/;
272        $value = $1;
273        $value =~ /(\w\w)(\w\w)(\w\w)(\w\w)/;
274        $w1 = $1;
275        $w2 = $2;
276        $w3 = $3;
277        $w4 = $4;
278
279        if( $bigend ne "")
280        {
281            # big endian
282            $prefix = "\t.byte\t0x".$w1.";".
283                      "\t.byte\t0x".$w2.";".
284                      "\t.byte\t0x".$w3.";".
285                      "\t.byte\t0x".$w4."; ";
286        }
287        else
288        {
289            # little endian
290            $prefix = "\t.byte\t0x".$w4.";".
291                      "\t.byte\t0x".$w3.";".
292                      "\t.byte\t0x".$w2.";".
293                      "\t.byte\t0x".$w1."; ";
294        }
295        $_=$prefix.$_;
296    }
297
298    if ( /\badrl\b/i )
299    {
300        s/\badrl\s+(\w+)\s*,\s*(\w+)/ldr $1,=$2/i;
301        $addPadding = 1;
302    }
303    s/\bEND\b/@ END/;
304} continue {
305    printf ("%s", $_) if $printit;
306    if ($addPadding != 0)
307    {
308        printf ("   mov r0,r0\n");
309        $addPadding = 0;
310    }
311}
312#If we had a code section, mark that this object doesn't need an executable
313# stack.
314if ($nxstack) {
315    printf ("    .section\t.note.GNU-stack,\"\",\%\%progbits\n");
316}
317