Skip to content
GitLab
Select Git revision
  • v1.14.0-linphone default
  • v1.12.0-linphone
  • v1.9.0-linphone
  • v1.7.0-linphone
  • feature/update_to_v1.9.0-linphone
  • feature/uwp_nuget
  • m68-3440
  • m66-3359
  • sandbox/luoyi@google.com/convolve
  • mandarinduck
  • sandbox/wangch@google.com/vp9
  • v1.6.1_linphone
  • linphone-android
  • longtailedduck
  • m56-2924
  • nextgenv2
  • m54-2840
  • sandbox/yaowu@google.com/mergeaom
  • khakicampbell
  • m52-2743
  • v1.9.0
  • v1.9.0-rc1
  • v1.8.2
  • v1.8.1
  • v1.8.0
  • v1.7.0
  • v1.6.1
  • v1.6.0
  • v1.5.0
  • v1.4.0
  • v1.3.0
  • v1.2.0
  • v1.1.0
  • v1.0.0
  • v0.9.7-p1
  • v0.9.7
  • v0.9.6
  • v0.9.5
  • v0.9.2
  • v0.9.1
Find file BlameHistoryPermalink
  • Martin Storsjo's avatar
    ads2gas: Allow converting code to thumb mode · 644587cf
    Martin Storsjo authored 
    Currently this only supports thumb2.

This involves rewriting certain instructions that can't be expressed
in thumb2 into equivalent instruction sequences. The regexps for
rewriting are currently written pretty narrowly, only covering the
exact cases currently encountered in the code base.

No IT instructions are added (since that would require more logic than
plain regexps), so using the thumb mode requires enabling
-mimplicit-it=always/thumb.

Change-Id: I1f676ad1d351381f02bcf00105102aa8dd7ae364
    644587cf
ads2gas.pl 8.49 KiB
1 
#!/usr/bin/perl
2 
##
3 
##  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
4 
##
5 
##  Use of this source code is governed by a BSD-style license
6 
##  that can be found in the LICENSE file in the root of the source
7 
##  tree. An additional intellectual property rights grant can be found
8 
##  in the file PATENTS.  All contributing project authors may
9 
##  be found in the AUTHORS file in the root of the source tree.
10 
##
11
12
13 
# ads2gas.pl
14 
# Author: Eric Fung (efung (at) acm.org)
15 
#
16 
# Convert ARM Developer Suite 1.0.1 syntax assembly source to GNU as format
17 
#
18 
# Usage: cat inputfile | perl ads2gas.pl > outputfile
19 
#
20
21 
my $thumb = 0;
22
23 
foreach my $arg (@ARGV) {
24 
    $thumb = 1 if ($arg == "-thumb");
25 
}
26
27 
print "@ This file was created from a .asm file\n";
28 
print "@  using the ads2gas.pl script.\n";
29 
print "\t.equ DO1STROUNDING, 0\n";
30 
if ($thumb) {
31 
    print "\t.syntax unified\n";
32 
    print "\t.thumb\n";
33 
}
34
35 
# Stack of procedure names.
36 
@proc_stack = ();
37
38 
while (<STDIN>)
39 
{
40 
    undef $comment;
41 
    undef $line;
42 
    $comment_char = ";";
43 
    $comment_sub = "@";
44
45 
    # Handle comments.
46 
    if (/$comment_char/)
47 
    {
48 
      $comment = "";
49 
      ($line, $comment) = /(.*?)$comment_char(.*)/;
50 
      $_ = $line;
51 
    }
52
53 
    # Load and store alignment
54 
    s/@/,:/g;
55
56 
    # Hexadecimal constants prefaced by 0x
57 
    s/#&/#0x/g;
58
59 
    # Convert :OR: to |
60 
    s/:OR:/ | /g;
61
62 
    # Convert :AND: to &
63 
    s/:AND:/ & /g;
64
65 
    # Convert :NOT: to ~
66 
    s/:NOT:/ ~ /g;
67
68 
    # Convert :SHL: to <<
69 
    s/:SHL:/ << /g;
70
7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
# Convert :SHR: to >> s/:SHR:/ >> /g; # Convert ELSE to .else s/\bELSE\b/.else/g; # Convert ENDIF to .endif s/\bENDIF\b/.endif/g; # Convert ELSEIF to .elseif s/\bELSEIF\b/.elseif/g; # Convert LTORG to .ltorg s/\bLTORG\b/.ltorg/g; # Convert endfunc to nothing. s/\bendfunc\b//ig; # Convert FUNCTION to nothing. s/\bFUNCTION\b//g; s/\bfunction\b//g; s/\bENTRY\b//g; s/\bMSARMASM\b/0/g; s/^\s+end\s+$//g; # Convert IF :DEF:to .if # gcc doesn't have the ability to do a conditional # if defined variable that is set by IF :DEF: on # armasm, so convert it to a normal .if and then # make sure to define a value elesewhere if (s/\bIF :DEF:\b/.if /g) { s/=/==/g; } # Convert IF to .if if (s/\bIF\b/.if/g) { s/=+/==/g; } # Convert INCLUDE to .INCLUDE "file" s/INCLUDE(\s*)(.*)$/.include $1\"$2\"/; # Code directive (ARM vs Thumb) s/CODE([0-9][0-9])/.code $1/; # No AREA required # But ALIGNs in AREA must be obeyed s/^\s*AREA.*ALIGN=([0-9])$/.text\n.p2align $1/; # If no ALIGN, strip the AREA and align to 4 bytes s/^\s*AREA.*$/.text\n.p2align 2/; # DCD to .word # This one is for incoming symbols s/DCD\s+\|(\w*)\|/.long $1/; # DCW to .short s/DCW\s+\|(\w*)\|/.short $1/; s/DCW(.*)/.short $1/; # Constants defined in scope s/DCD(.*)/.long $1/; s/DCB(.*)/.byte $1/; # RN to .req if (s/RN\s+([Rr]\d+|lr)/.req $1/) { print;
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
print "$comment_sub$comment\n" if defined $comment; next; } # Make function visible to linker, and make additional symbol with # prepended underscore s/EXPORT\s+\|([\$\w]*)\|/.global $1 \n\t.type $1, function/; s/IMPORT\s+\|([\$\w]*)\|/.global $1/; s/EXPORT\s+([\$\w]*)/.global $1/; s/export\s+([\$\w]*)/.global $1/; # No vertical bars required; make additional symbol with prepended # underscore s/^\|(\$?\w+)\|/_$1\n\t$1:/g; # Labels need trailing colon # s/^(\w+)/$1:/ if !/EQU/; # put the colon at the end of the line in the macro s/^([a-zA-Z_0-9\$]+)/$1:/ if !/EQU/; # ALIGN directive s/\bALIGN\b/.balign/g; if ($thumb) { # ARM code - we force everything to thumb with the declaration in the header s/\sARM//g; } else { # ARM code s/\sARM/.arm/g; } # push/pop s/(push\s+)(r\d+)/stmdb sp\!, \{$2\}/g; s/(pop\s+)(r\d+)/ldmia sp\!, \{$2\}/g; # NEON code s/(vld1.\d+\s+)(q\d+)/$1\{$2\}/g; s/(vtbl.\d+\s+[^,]+),([^,]+)/$1,\{$2\}/g; if ($thumb) { # Write additions with shifts, such as "add r10, r11, lsl #8", # in three operand form, "add r10, r10, r11, lsl #8". s/(add\s+)(r\d+),\s*(r\d+),\s*(lsl #\d+)/$1$2, $2, $3, $4/g; # Convert additions with a non-constant shift into a sequence # with left shift, addition and a right shift (to restore the # register to the original value). Currently the right shift # isn't necessary in the code base since the values in these # registers aren't used, but doing the shift for consitency. # This converts instructions such as "add r12, r12, r5, lsl r4" # into the sequence "lsl r5, r4", "add r12, r12, r5", "lsr r5, r4". s/^(\s*)(add)(\s+)(r\d+),\s*(r\d+),\s*(r\d+),\s*lsl (r\d+)/$1lsl$3$6, $7\n$1$2$3$4, $5, $6\n$1lsr$3$6, $7/g; # Convert loads with right shifts in the indexing into a # sequence of an add, load and sub. This converts # "ldrb r4, [r9, lr, asr #1]" into "add r9, r9, lr, asr #1", # "ldrb r9, [r9]", "sub r9, r9, lr, asr #1". s/^(\s*)(ldrb)(\s+)(r\d+),\s*\[(\w+),\s*(\w+),\s*(asr #\d+)\]/$1add $3$5, $5, $6, $7\n$1$2$3$4, [$5]\n$1sub $3$5, $5, $6, $7/g; # Convert register indexing with writeback into a separate add # instruction. This converts "ldrb r12, [r1, r2]!" into # "ldrb r12, [r1, r2]", "add r1, r1, r2". s/^(\s*)(ldrb)(\s+)(r\d+),\s*\[(\w+),\s*(\w+)\]!/$1$2$3$4, [$5, $6]\n$1add $3$5, $6/g; # Convert negative register indexing into separate sub/add instructions. # This converts "ldrne r4, [src, -pstep, lsl #1]" into # "subne src, src, pstep, lsl #1", "ldrne r4, [src]", # "addne src, src, pstep, lsl #1". In a couple of cases where # this is used, it's used for two subsequent load instructions,
211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280
# where a hand-written version of it could merge two subsequent # add and sub instructions. s/^(\s*)((ldr|str)(ne)?)(\s+)(r\d+),\s*\[(\w+), -([^\]]+)\]/$1sub$4$5$7, $7, $8\n$1$2$5$6, [$7]\n$1add$4$5$7, $7, $8/g; # Convert register post indexing to a separate add instruction. # This converts "ldrneb r9, [r0], r2" into "ldrneb r9, [r0]", # "add r0, r2". s/^(\s*)((ldr|str)(ne)?[bhd]?)(\s+)(\w+),(\s*\w+,)?\s*\[(\w+)\],\s*(\w+)/$1$2$5$6,$7 [$8]\n$1add$4$5$8, $8, $9/g; # Convert a conditional addition to the pc register into a series of # instructions. This converts "addlt pc, pc, r3, lsl #2" into # "ittt lt", "addlt.w r12, pc, #10", "addlt.w r12, r12, r3, lsl #2", # "movlt.n pc, r12". This assumes that r12 is free at this point. s/^(\s*)addlt(\s+)pc,\s*pc,\s*(\w+),\s*lsl\s*#(\d+)/$1ittt$2lt\n$1addlt.w$2r12, pc, #10\n$1addlt.w$2r12, r12, $3, lsl #$4\n$1movlt.n$2pc, r12/g; # Convert "mov pc, lr" into "bx lr", since the former only works # for switching from arm to thumb (and only in armv7), but not # from thumb to arm. s/mov(\s*)pc\s*,\s*lr/bx$1lr/g; } # eabi_attributes numerical equivalents can be found in the # "ARM IHI 0045C" document. # REQUIRE8 Stack is required to be 8-byte aligned s/\sREQUIRE8/.eabi_attribute 24, 1 \@Tag_ABI_align_needed/g; # PRESERVE8 Stack 8-byte align is preserved s/\sPRESERVE8/.eabi_attribute 25, 1 \@Tag_ABI_align_preserved/g; # Use PROC and ENDP to give the symbols a .size directive. # This makes them show up properly in debugging tools like gdb and valgrind. if (/\bPROC\b/) { my $proc; /^_([\.0-9A-Z_a-z]\w+)\b/; $proc = $1; push(@proc_stack, $proc) if ($proc); s/\bPROC\b/@ $&/; } if (/\bENDP\b/) { my $proc; s/\bENDP\b/@ $&/; $proc = pop(@proc_stack); $_ = "\t.size $proc, .-$proc".$_ if ($proc); } # EQU directive s/(\S+\s+)EQU(\s+\S+)/.equ $1, $2/; # Begin macro definition if (/\bMACRO\b/) { $_ = <STDIN>; s/^/.macro/; s/\$//g; # remove formal param reference s/;/@/g; # change comment characters } # For macros, use \ to reference formal params s/\$/\\/g; # End macro definition s/\bMEND\b/.endm/; # No need to tell it where to stop assembling next if /^\s*END\s*$/; print; print "$comment_sub$comment\n" if defined $comment; } # Mark that this object doesn't need an executable stack. printf ("\t.section\t.note.GNU-stack,\"\",\%\%progbits\n");