[builtins][ARM] Select correct code fragments when compiling for Thumb1/Thum2/ARM ISA

[weimingz]

Summary

Value of __ARM_ARCH_ISA_THUMB isn't based on the actual compilation
mode (-mthumb, -marm), it reflect's capability of given CPU.

Due to this:
•use tbumb and thumb2 insteand of __ARM_ARCH_ISA_THUMB
•use '.thumb' directive consistently in all affected files
•decorate all thumb functions using DEFINE_COMPILERRT_THUMB_FUNCTION()

(This is based off Michal's patch https://reviews.llvm.org/D30938)

[compnerd]

Some of the implementations are not going to build in thumb1 mode, but would in thumb2, which is why we didnt do this uniformly. I think we need to preserve that, or rewrite the functions.

lib/builtins/assembly.h

105 ↗

(On Diff #92566)

Is there a reason to use this alternate macro rather than directly using __thumb2__ and __thumb__ and ordering the sources to prefer thumb2, thumb, arm?

[weimingz]

lib/builtins/assembly.h

105 ↗

(On Diff #92566)

Sort of. For example, to check if it is Thumb1 only, we need to do
#if defined(thumb) && !defined(thumb2)
To check if it's on ARM mode, we need to do
#if defined(arm) && !defined(thumb) && !defined(thumb2__)

So still nice to have an indirect macro.

[compnerd]

lib/builtins/assembly.h

105 ↗

(On Diff #92566)

Or we can do the following:

#if defined(__thumb2__)
  ...
#elif defined(__thumb__)
  ...
#else
  ...
#endif

The idea being that thumb2 is preferred, thumb1 accepted, and we fall back to ARM otherwise. Is there something which cannot be represented that way?

[weimingz]

lib/builtins/assembly.h

105 ↗

(On Diff #92566)

A lot of code work for both thumb2 and arm under the unified syntax.
What we need is to specialize for thumb1.

[strejda]

lib/builtins/assembly.h

105 ↗

(On Diff #92566)

"The idea being that thumb2 is preferred,"

Preferred? I'm afraid that we have not choice.
Thumb[1][2] must be supported by OS, ARM ISA isn't available on all CPUs. Thus so we cannot hard-force ISA for any file...

Also interworking is slightly problematic, it needs compiler/linker support, and is slow in many cases.
By this all, I don't see any other "realistic" option that compile whole library using one ISA.

[jamesduley]

@weimingz, what's the current status of this patch? Currently, AFAIK, there is one place where incorrect code is generated without these fixes because it depends on the size of the code generated, that is BLOCK_SIZE in udivsi3.S when compiled with -march=armv6 -marm (see https://github.com/rust-lang-nursery/compiler-builtins/issues/173).

[weimingz]

rebased

[jamesduley]

lib/builtins/assembly.h

74 ↗

(On Diff #106478)

@weimingz thanks for the rebase, just one more thing I've noticed, I believe this can also be !defined(USE_THUMB_1).

[peter.smith]

Just a few comments on the ARM specific terminology. I think it would be better to match the existing documentation such as using state for ARM/Thumb and not mode.

lib/builtins/assembly.h

102 ↗

(On Diff #106478)

I think DEFINE_CODE_STATE would be a better choice of name. This would match the ARM documentation more closely. ARM and Thumb are instruction states, this is distinct from modes which are User, IRQ, FIQ etc.

110 ↗

(On Diff #106478)

I think it would be better to say USE_THUMB rather than USE_THUMB_1.

Strictly speaking there isn't such a thing as Thumb 1. There is just ARM and Thumb states and Thumb 2 is a set of extensions called "Thumb 2 technology".

test/asan/CMakeLists.txt

10 ↗

(On Diff #106478)

I'm in no position to judge whether removing this is the right thing to do, but I can't immediately see how it is related to this patch?

[weimingz]

address the review comments by @peter.smith and @jamesduley

[peter.smith]

I'm happy with the changes, probably best to wait for compnerd to approve though.

Although not for this patch. On older pre cortex cores such as the ARM1176JF-S (used in the original raspberry pi) that have Thumb but not Thumb2, and crucially not the v6m system extensions, it may be better to switch to ARM state for performance critical functions. Alternatively compiler-rt could always be compiled entirely in ARM state.

[rengolin]

ping @compnerd

[compnerd]

Please adjust the comment and remove the CMake change prior to committing this.

lib/builtins/assembly.h

90 ↗

(On Diff #106677)

Use:

// defined(__thumb2__)

test/asan/CMakeLists.txt

10 ↗

(On Diff #106478)

This shouldn't be part of this patch.

[weimingz]

remove unreleated change (CMakefile) and address comments from Saleem

compiler-rt/trunk/lib/builtins/arm/aeabi_cdcmp.S

 // }
 
         .syntax unified
         .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__aeabi_cdcmpeq)
         push {r0-r3, lr}
         bl __aeabi_cdcmpeq_check_nan
         cmp r0, #1
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
         beq 1f
         // NaN has been ruled out, so __aeabi_cdcmple can't trap
         mov r0, sp
         ldm r0, {r0-r3}
         bl __aeabi_cdcmple
         pop {r0-r3, pc}
 1:
         // Z = 0, C = 1
// }
         .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__aeabi_cdcmple)
         // Per the RTABI, this function must preserve r0-r11.
         // Save lr in the same instruction for compactness
         push {r0-r3, lr}
 
         bl __aeabi_dcmplt
         cmp r0, #1
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
         bne 1f
         // Z = 0, C = 0
         movs r0, #1
         lsls r0, r0, #1
         pop {r0-r3, pc}
 1:
         mov r0, sp
         ldm r0, {r0-r3}

compiler-rt/trunk/lib/builtins/arm/aeabi_cfcmp.S

 // }
 
         .syntax unified
         .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__aeabi_cfcmpeq)
         push {r0-r3, lr}
         bl __aeabi_cfcmpeq_check_nan
         cmp r0, #1
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
         beq 1f
         // NaN has been ruled out, so __aeabi_cfcmple can't trap
         mov r0, sp
         ldm r0, {r0-r3}
         bl __aeabi_cfcmple
         pop {r0-r3, pc}
 1:
         // Z = 0, C = 1
// }
         .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__aeabi_cfcmple)
         // Per the RTABI, this function must preserve r0-r11.
         // Save lr in the same instruction for compactness
         push {r0-r3, lr}
 
         bl __aeabi_fcmplt
         cmp r0, #1
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
         bne 1f
         // Z = 0, C = 0
         movs r0, #1
         lsls r0, r0, #1
         pop {r0-r3, pc}
 1:
         mov r0, sp
         ldm r0, {r0-r3}

compiler-rt/trunk/lib/builtins/arm/aeabi_idivmod.S

 //   return {quot, rem};
 // }
 
 #if defined(__MINGW32__)
 #define __aeabi_idivmod __rt_sdiv
 #endif
 
         .syntax unified
+        .text
+        DEFINE_CODE_STATE
         .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__aeabi_idivmod)
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
         push    {r0, r1, lr}
         bl      SYMBOL_NAME(__divsi3)
         pop     {r1, r2, r3} // now r0 = quot, r1 = num, r2 = denom
         muls    r2, r0, r2   // r2 = quot * denom
         subs    r1, r1, r2
         JMP     (r3)
-#else
+#else  // defined(USE_THUMB_1)
         push    { lr }
         sub     sp, sp, #4
         mov     r2, sp
 #if defined(__MINGW32__)
         mov     r3, r0
         mov     r0, r1
         mov     r1, r3
 #endif
         bl      SYMBOL_NAME(__divmodsi4)
         ldr     r1, [sp]
         add     sp, sp, #4
         pop     { pc }
-#endif // __ARM_ARCH_ISA_THUMB == 1
+#endif //  defined(USE_THUMB_1)
 END_COMPILERRT_FUNCTION(__aeabi_idivmod)
 
 NO_EXEC_STACK_DIRECTIVE
 

compiler-rt/trunk/lib/builtins/arm/aeabi_uidivmod.S

 //   return {quot, rem};
 // }
 
 #if defined(__MINGW32__)
 #define __aeabi_uidivmod __rt_udiv
 #endif
 
         .syntax unified
+        .text
+        DEFINE_CODE_STATE
         .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__aeabi_uidivmod)
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
         cmp     r0, r1
         bcc     LOCAL_LABEL(case_denom_larger)
         push    {r0, r1, lr}
         bl      SYMBOL_NAME(__aeabi_uidiv)
         pop     {r1, r2, r3}
         muls    r2, r0, r2 // r2 = quot * denom
         subs    r1, r1, r2
         JMP     (r3)
 LOCAL_LABEL(case_denom_larger):
         movs    r1, r0
         movs    r0, #0
         JMP     (lr)
-#else
+#else // defined(USE_THUMB_1)
         push    { lr }
         sub     sp, sp, #4
         mov     r2, sp
 #if defined(__MINGW32__)
         mov     r3, r0
         mov     r0, r1
         mov     r1, r3
 #endif

compiler-rt/trunk/lib/builtins/arm/bswapdi2.S

 //===------- bswapdi2 - Implement bswapdi2 --------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../assembly.h"
 
   .syntax unified
   .text
-#if __ARM_ARCH_ISA_THUMB == 2
-  .thumb
-#endif
+  DEFINE_CODE_STATE
 
 //
 // extern uint64_t __bswapdi2(uint64_t);
 //
 // Reverse all the bytes in a 64-bit integer.
 //
   .p2align 2
-#if __ARM_ARCH_ISA_THUMB == 2
-DEFINE_COMPILERRT_THUMB_FUNCTION(__bswapdi2)
-#else
 DEFINE_COMPILERRT_FUNCTION(__bswapdi2)
-#endif
 #if __ARM_ARCH < 6
     // before armv6 does not have "rev" instruction
     // r2 = rev(r0)
     eor r2, r0, r0, ror #16
     bic r2, r2, #0xff0000
     mov r2, r2, lsr #8
     eor r2, r2, r0, ror #8
     // r0 = rev(r1)

compiler-rt/trunk/lib/builtins/arm/bswapsi2.S

 //===------- bswapsi2 - Implement bswapsi2 --------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../assembly.h"
 
   .syntax unified
   .text
-#if __ARM_ARCH_ISA_THUMB == 2
-  .thumb
-#endif
+  DEFINE_CODE_STATE
 
 //
 // extern uint32_t __bswapsi2(uint32_t);
 //
 // Reverse all the bytes in a 32-bit integer.
 //
   .p2align 2
-#if __ARM_ARCH_ISA_THUMB == 2
-DEFINE_COMPILERRT_THUMB_FUNCTION(__bswapsi2)
-#else
 DEFINE_COMPILERRT_FUNCTION(__bswapsi2)
-#endif
 #if __ARM_ARCH < 6
     // before armv6 does not have "rev" instruction
   eor r1, r0, r0, ror #16
   bic r1, r1, #0xff0000
   mov r1, r1, lsr #8
   eor r0, r1, r0, ror #8
 #else
     rev r0, r0
 #endif
     JMP(lr)
 END_COMPILERRT_FUNCTION(__bswapsi2)
 
 NO_EXEC_STACK_DIRECTIVE
 

compiler-rt/trunk/lib/builtins/arm/clzdi2.S

  * This file implements count leading zeros for 64bit arguments.
  *
  * ===----------------------------------------------------------------------===
  */
 #include "../assembly.h"
 
   .syntax unified
   .text
-#if __ARM_ARCH_ISA_THUMB == 2
-  .thumb
-#endif
-
+  DEFINE_CODE_STATE
 
   .p2align  2
-#if __ARM_ARCH_ISA_THUMB == 2
-DEFINE_COMPILERRT_THUMB_FUNCTION(__clzdi2)
-#else
 DEFINE_COMPILERRT_FUNCTION(__clzdi2)
-#endif
 #ifdef __ARM_FEATURE_CLZ
 #ifdef __ARMEB__
   cmp r0, 0
   itee ne
   clzne r0, r0
   clzeq r0, r1
   addeq r0, r0, 32
 #else

compiler-rt/trunk/lib/builtins/arm/clzsi2.S

  * This file implements count leading zeros for 32bit arguments.
  *
  * ===----------------------------------------------------------------------===
  */
 #include "../assembly.h"
 
   .syntax unified
   .text
-#if __ARM_ARCH_ISA_THUMB == 2
-  .thumb
-#endif
+  DEFINE_CODE_STATE
 
   .p2align  2
-#if __ARM_ARCH_ISA_THUMB == 2
-DEFINE_COMPILERRT_THUMB_FUNCTION(__clzsi2)
-#else
 DEFINE_COMPILERRT_FUNCTION(__clzsi2)
-#endif
 #ifdef __ARM_FEATURE_CLZ
   clz r0, r0
   JMP(lr)
 #else
   /* Assumption: n != 0 */
 
   /*
    * r0: n

compiler-rt/trunk/lib/builtins/arm/comparesf2.S

 //                           1 if either a or b is NaN
 //
 // Note that __lesf2( ) and __gesf2( ) are identical except in their handling of
 // NaN values.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../assembly.h"
     .syntax unified
-#if __ARM_ARCH_ISA_THUMB == 2
-.thumb
-#endif
+    .text
+    DEFINE_CODE_STATE
 
 @ int __eqsf2(float a, float b)
 
     .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__eqsf2)
 #if defined(COMPILER_RT_ARMHF_TARGET)
     vmov r0, s0
     vmov r1, s1
 #endif
     // Make copies of a and b with the sign bit shifted off the top.  These will
     // be used to detect zeros and NaNs.
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
     push    {r6, lr}
     lsls    r2,         r0, #1
     lsls    r3,         r1, #1
 #else
     mov     r2,         r0, lsl #1
     mov     r3,         r1, lsl #1
 #endif
 
     // We do the comparison in three stages (ignoring NaN values for the time
     // being).  First, we orr the absolute values of a and b; this sets the Z
     // flag if both a and b are zero (of either sign).  The shift of r3 doesn't
     // effect this at all, but it *does* make sure that the C flag is clear for
     // the subsequent operations.
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
     lsrs    r6,     r3, #1
     orrs    r6,     r2
 #else
     orrs    r12,    r2, r3, lsr #1
 #endif
     // Next, we check if a and b have the same or different signs.  If they have
     // opposite signs, this eor will set the N flag.
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
     beq     1f
     movs    r6,     r0
     eors    r6,     r1
 1:
 #else
     it ne
     eorsne  r12,    r0, r1
 #endif
 
     // If a and b are equal (either both zeros or bit identical; again, we're
     // ignoring NaNs for now), this subtract will zero out r0.  If they have the
     // same sign, the flags are updated as they would be for a comparison of the
     // absolute values of a and b.
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
     bmi     1f
     subs    r0,     r2, r3
 1:
 #else
     it pl
     subspl  r0,     r2, r3
 #endif
 
     // If a is smaller in magnitude than b and both have the same sign, place
     // the negation of the sign of b in r0.  Thus, if both are negative and
     // a > b, this sets r0 to 0; if both are positive and a < b, this sets
     // r0 to -1.
     //
     // This is also done if a and b have opposite signs and are not both zero,
     // because in that case the subtract was not performed and the C flag is
     // still clear from the shift argument in orrs; if a is positive and b
     // negative, this places 0 in r0; if a is negative and b positive, -1 is
     // placed in r0.
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
     bhs     1f
     // Here if a and b have the same sign and absA < absB, the result is thus
     // b < 0 ? 1 : -1. Same if a and b have the opposite sign (ignoring Nan).
     movs    r0,         #1
     lsrs    r1,         #31
     bne     LOCAL_LABEL(CHECK_NAN)
     negs    r0,         r0
     b       LOCAL_LABEL(CHECK_NAN)
 1:
 #else
     it lo
     mvnlo   r0,         r1, asr #31
 #endif
 
     // If a is greater in magnitude than b and both have the same sign, place
     // the sign of b in r0.  Thus, if both are negative and a < b, -1 is placed
     // in r0, which is the desired result.  Conversely, if both are positive
     // and a > b, zero is placed in r0.
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
     bls     1f
     // Here both have the same sign and absA > absB.
     movs    r0,         #1
     lsrs    r1,         #31
     beq     LOCAL_LABEL(CHECK_NAN)
     negs    r0, r0
 1:
 #else
     it hi
     movhi   r0,         r1, asr #31
 #endif
 
     // If you've been keeping track, at this point r0 contains -1 if a < b and
     // 0 if a >= b.  All that remains to be done is to set it to 1 if a > b.
     // If a == b, then the Z flag is set, so we can get the correct final value
     // into r0 by simply or'ing with 1 if Z is clear.
     // For Thumb-1, r0 contains -1 if a < b, 0 if a > b and 0 if a == b.
-#if __ARM_ARCH_ISA_THUMB != 1
+#if !defined(USE_THUMB_1)
     it ne
     orrne   r0,     r0, #1
 #endif
 
     // Finally, we need to deal with NaNs.  If either argument is NaN, replace
     // the value in r0 with 1.
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
 LOCAL_LABEL(CHECK_NAN):
     movs    r6,         #0xff
     lsls    r6,         #24
     cmp     r2,         r6
     bhi     1f
     cmp     r3,         r6
 1:
     bls     2f
DEFINE_COMPILERRT_FUNCTION(__gtsf2)
     // Identical to the preceding except in that we return -1 for NaN values.
     // Given that the two paths share so much code, one might be tempted to
     // unify them; however, the extra code needed to do so makes the code size
     // to performance tradeoff very hard to justify for such small functions.
 #if defined(COMPILER_RT_ARMHF_TARGET)
     vmov r0, s0
     vmov r1, s1
 #endif
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
     push    {r6, lr}
     lsls    r2,        r0, #1
     lsls    r3,        r1, #1
     lsrs    r6,        r3, #1
     orrs    r6,        r2
     beq     1f
     movs    r6,        r0
     eors    r6,        r1

 END_COMPILERRT_FUNCTION(__gtsf2)
 
 DEFINE_COMPILERRT_FUNCTION_ALIAS(__gesf2, __gtsf2)
 
 @ int __unordsf2(float a, float b)
 
     .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__unordsf2)
+
 #if defined(COMPILER_RT_ARMHF_TARGET)
     vmov    r0,         s0
     vmov    r1,         s1
 #endif
     // Return 1 for NaN values, 0 otherwise.
     lsls    r2,         r0, #1
     lsls    r3,         r1, #1
     movs    r0,         #0
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
     movs    r1,         #0xff
     lsls    r1,         #24
     cmp     r2,         r1
     bhi     1f
     cmp     r3,         r1
 1:
     bls     2f
     movs    r0,         #1

compiler-rt/trunk/lib/builtins/arm/divmodsi4.S

 #define ESTABLISH_FRAME    \
     push   {r4-r7, lr}   ;\
     add     r7,     sp, #12
 #define CLEAR_FRAME_AND_RETURN \
     pop    {r4-r7, pc}
 
   .syntax unified
   .text
-#if __ARM_ARCH_ISA_THUMB == 2
-  .thumb
-#endif
+  DEFINE_CODE_STATE
 
 @ int __divmodsi4(int divident, int divisor, int *remainder)
 @   Calculate the quotient and remainder of the (signed) division.  The return
 @   value is the quotient, the remainder is placed in the variable.
 
   .p2align 3
-#if __ARM_ARCH_ISA_THUMB == 2
-DEFINE_COMPILERRT_THUMB_FUNCTION(__divmodsi4)
-#else
 DEFINE_COMPILERRT_FUNCTION(__divmodsi4)
-#endif
 #if __ARM_ARCH_EXT_IDIV__
   tst     r1, r1
   beq     LOCAL_LABEL(divzero)
   mov   r3, r0
   sdiv  r0, r3, r1
   mls   r1, r0, r1, r3
   str   r1, [r2]
   bx    lr

compiler-rt/trunk/lib/builtins/arm/divsi3.S

 #include "../assembly.h"
 
 #define ESTABLISH_FRAME \
     push   {r4, r7, lr}    ;\
     add     r7,     sp, #4
 #define CLEAR_FRAME_AND_RETURN \
     pop    {r4, r7, pc}
 
-  .syntax unified
-  .text
-#if __ARM_ARCH_ISA_THUMB == 2
-  .thumb
-#endif
+   .syntax unified
+   .text
+   DEFINE_CODE_STATE
 
   .p2align 3
 // Ok, APCS and AAPCS agree on 32 bit args, so it's safe to use the same routine.
 DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_idiv, __divsi3)
 
 @ int __divsi3(int divident, int divisor)
 @   Calculate and return the quotient of the (signed) division.
 
-#if __ARM_ARCH_ISA_THUMB == 2
-DEFINE_COMPILERRT_THUMB_FUNCTION(__divsi3)
-#else
 DEFINE_COMPILERRT_FUNCTION(__divsi3)
-#endif
 #if __ARM_ARCH_EXT_IDIV__
    tst     r1,r1
    beq     LOCAL_LABEL(divzero)
    sdiv    r0, r0, r1
    bx      lr
 LOCAL_LABEL(divzero):
    mov     r0,#0
    bx      lr
 #else
 ESTABLISH_FRAME
 //  Set aside the sign of the quotient.
-#  if __ARM_ARCH_ISA_THUMB == 1
+#  if defined(USE_THUMB_1)
     movs    r4,     r0
     eors    r4,     r1
 #  else
     eor     r4,     r0, r1
 #  endif
 //  Take absolute value of a and b via abs(x) = (x^(x >> 31)) - (x >> 31).
-#  if   __ARM_ARCH_ISA_THUMB == 1
+#  if defined(USE_THUMB_1)
     asrs    r2,     r0, #31
     asrs    r3,     r1, #31
     eors    r0,     r2
     eors    r1,     r3
     subs    r0,     r0, r2
     subs    r1,     r1, r3
 #  else
     eor     r2,     r0, r0, asr #31
     eor     r3,     r1, r1, asr #31
     sub     r0,     r2, r0, asr #31
     sub     r1,     r3, r1, asr #31
 #  endif
 //  abs(a) / abs(b)
     bl      SYMBOL_NAME(__udivsi3)
 //  Apply sign of quotient to result and return.
-#  if __ARM_ARCH_ISA_THUMB == 1
+#  if defined(USE_THUMB_1)
     asrs    r4,     #31
     eors    r0,     r4
     subs    r0,     r0, r4
 #  else
     eor     r0,     r0, r4, asr #31
     sub     r0,     r0, r4, asr #31
 #  endif
     CLEAR_FRAME_AND_RETURN
 #endif
 END_COMPILERRT_FUNCTION(__divsi3)
 
 NO_EXEC_STACK_DIRECTIVE
 

compiler-rt/trunk/lib/builtins/arm/modsi3.S

 #define ESTABLISH_FRAME \
     push   {r4, r7, lr}    ;\
     add     r7,     sp, #4
 #define CLEAR_FRAME_AND_RETURN \
     pop    {r4, r7, pc}
 
   .syntax unified
   .text
-#if __ARM_ARCH_ISA_THUMB == 2
-  .thumb
-#endif
+  DEFINE_CODE_STATE
 
 @ int __modsi3(int divident, int divisor)
 @   Calculate and return the remainder of the (signed) division.
 
   .p2align 3
-#if __ARM_ARCH_ISA_THUMB == 2
-DEFINE_COMPILERRT_THUMB_FUNCTION(__modsi3)
-#else
 DEFINE_COMPILERRT_FUNCTION(__modsi3)
-#endif
 #if __ARM_ARCH_EXT_IDIV__
   tst     r1, r1
   beq     LOCAL_LABEL(divzero)
   sdiv  r2, r0, r1
   mls   r0, r2, r1, r0
   bx      lr
 LOCAL_LABEL(divzero):
   mov     r0, #0

compiler-rt/trunk/lib/builtins/arm/udivmodsi4.S

  * modulus) function for the ARM 32-bit architecture.
  *
  *===----------------------------------------------------------------------===*/
 
 #include "../assembly.h"
 
   .syntax unified
   .text
-
-#if __ARM_ARCH_ISA_THUMB == 2
-  .thumb
-#endif
+  DEFINE_CODE_STATE
 
 @ unsigned int __udivmodsi4(unsigned int divident, unsigned int divisor,
 @                           unsigned int *remainder)
 @   Calculate the quotient and remainder of the (unsigned) division.  The return
 @   value is the quotient, the remainder is placed in the variable.
 
   .p2align 2
-#if __ARM_ARCH_ISA_THUMB == 2
-DEFINE_COMPILERRT_THUMB_FUNCTION(__udivmodsi4)
-#else
 DEFINE_COMPILERRT_FUNCTION(__udivmodsi4)
-#endif
 #if __ARM_ARCH_EXT_IDIV__
   tst     r1, r1
   beq     LOCAL_LABEL(divby0)
   mov   r3, r0
   udiv  r0, r3, r1
   mls   r1, r0, r1, r3
   str   r1, [r2]
   bx    lr
#else
    * that (r0 << shift) < 2 * r1. The quotient is stored in r3.
    */
 
 #  ifdef __ARM_FEATURE_CLZ
   clz ip, r0
   clz r3, r1
   /* r0 >= r1 implies clz(r0) <= clz(r1), so ip <= r3. */
   sub r3, r3, ip
-#    if __ARM_ARCH_ISA_THUMB == 2
+#    if defined(USE_THUMB_2)
   adr ip, LOCAL_LABEL(div0block) + 1
   sub ip, ip, r3, lsl #1
 #    else
   adr ip, LOCAL_LABEL(div0block)
 #    endif
   sub ip, ip, r3, lsl #2
   sub ip, ip, r3, lsl #3
   mov r3, #0
   bx  ip
 #  else
-#    if __ARM_ARCH_ISA_THUMB == 2
+#    if defined(USE_THUMB_2)
 #    error THUMB mode requires CLZ or UDIV
 #    endif
   str r4, [sp, #-8]!
 
   mov r4, r0
   adr ip, LOCAL_LABEL(div0block)
 
   lsr r3, r4, #16

compiler-rt/trunk/lib/builtins/arm/udivsi3.S

  *
  *===----------------------------------------------------------------------===*/
 
 #include "../assembly.h"
 
   .syntax unified
   .text
 
-#if __ARM_ARCH_ISA_THUMB == 2
-  .thumb
-#endif
+DEFINE_CODE_STATE
 
   .p2align 2
 DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_uidiv, __udivsi3)
 
 @ unsigned int __udivsi3(unsigned int divident, unsigned int divisor)
 @   Calculate and return the quotient of the (unsigned) division.
 
-#if __ARM_ARCH_ISA_THUMB == 2
-DEFINE_COMPILERRT_THUMB_FUNCTION(__udivsi3)
-#else
 DEFINE_COMPILERRT_FUNCTION(__udivsi3)
-#endif
 #if __ARM_ARCH_EXT_IDIV__
   tst     r1, r1
   beq     LOCAL_LABEL(divby0)
   udiv  r0, r0, r1
   bx    lr
 
 LOCAL_LABEL(divby0):
   mov     r0, #0
 #  ifdef __ARM_EABI__
   b       __aeabi_idiv0
 #  else
   JMP(lr)
 #  endif
 
 #else /* ! __ARM_ARCH_EXT_IDIV__ */
   cmp r1, #1
   bcc LOCAL_LABEL(divby0)
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
   bne LOCAL_LABEL(num_neq_denom)
   JMP(lr)
 LOCAL_LABEL(num_neq_denom):
 #else
   IT(eq)
   JMPc(lr, eq)
 #endif
   cmp r0, r1
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
   bhs LOCAL_LABEL(num_ge_denom)
   movs r0, #0
   JMP(lr)
 LOCAL_LABEL(num_ge_denom):
 #else
   ITT(cc)
   movcc r0, #0
   JMPc(lr, cc)
#endif
    * that (r0 << shift) < 2 * r1. The quotient is stored in r3.
    */
 
 #  if defined(__ARM_FEATURE_CLZ)
   clz ip, r0
   clz r3, r1
   /* r0 >= r1 implies clz(r0) <= clz(r1), so ip <= r3. */
   sub r3, r3, ip
-#    if __ARM_ARCH_ISA_THUMB == 2
+#    if defined(USE_THUMB_2)
   adr ip, LOCAL_LABEL(div0block) + 1
   sub ip, ip, r3, lsl #1
 #    else
   adr ip, LOCAL_LABEL(div0block)
 #    endif
   sub ip, ip, r3, lsl #2
   sub ip, ip, r3, lsl #3
   mov r3, #0
   bx  ip
 #  else /* No CLZ Feature */
-#    if __ARM_ARCH_ISA_THUMB == 2
+#    if defined(USE_THUMB_2)
 #    error THUMB mode requires CLZ or UDIV
 #    endif
-#    if __ARM_ARCH_ISA_THUMB == 1
+#    if defined(USE_THUMB_1)
 #      define BLOCK_SIZE 10
 #    else
 #      define BLOCK_SIZE 12
 #    endif
 
   mov r2, r0
-#    if __ARM_ARCH_ISA_THUMB == 1
+#    if defined(USE_THUMB_1)
   mov ip, r0
   adr r0, LOCAL_LABEL(div0block)
   adds r0, #1
 #    else
   adr ip, LOCAL_LABEL(div0block)
 #    endif
   lsrs  r3, r2, #16
   cmp r3, r1
-#    if __ARM_ARCH_ISA_THUMB == 1
+#    if defined(USE_THUMB_1)
   blo LOCAL_LABEL(skip_16)
   movs r2, r3
   subs r0, r0, #(16 * BLOCK_SIZE)
 LOCAL_LABEL(skip_16):
 #    else
   movhs r2, r3
   subhs ip, ip, #(16 * BLOCK_SIZE)
 #    endif
 
   lsrs  r3, r2, #8
   cmp r3, r1
-#    if __ARM_ARCH_ISA_THUMB == 1
+#    if defined(USE_THUMB_1)
   blo LOCAL_LABEL(skip_8)
   movs r2, r3
   subs r0, r0, #(8 * BLOCK_SIZE)
 LOCAL_LABEL(skip_8):
 #    else
   movhs r2, r3
   subhs ip, ip, #(8 * BLOCK_SIZE)
 #    endif
 
   lsrs  r3, r2, #4
   cmp r3, r1
-#    if __ARM_ARCH_ISA_THUMB == 1
+#    if defined(USE_THUMB_1)
   blo LOCAL_LABEL(skip_4)
   movs r2, r3
   subs r0, r0, #(4 * BLOCK_SIZE)
 LOCAL_LABEL(skip_4):
 #    else
   movhs r2, r3
   subhs ip, #(4 * BLOCK_SIZE)
 #    endif
 
   lsrs  r3, r2, #2
   cmp r3, r1
-#    if __ARM_ARCH_ISA_THUMB == 1
+#    if defined(USE_THUMB_1)
   blo LOCAL_LABEL(skip_2)
   movs r2, r3
   subs r0, r0, #(2 * BLOCK_SIZE)
 LOCAL_LABEL(skip_2):
 #    else
   movhs r2, r3
   subhs ip, ip, #(2 * BLOCK_SIZE)
 #    endif
 
   /* Last block, no need to update r2 or r3. */
-#    if __ARM_ARCH_ISA_THUMB == 1
+#    if defined(USE_THUMB_1)
   lsrs r3, r2, #1
   cmp r3, r1
   blo LOCAL_LABEL(skip_1)
   subs r0, r0, #(1 * BLOCK_SIZE)
 LOCAL_LABEL(skip_1):
   movs r2, r0
   mov r0, ip
   movs r3, #0
#      if defined(__ARM_EABI__)
   push {r7, lr}
   bl  __aeabi_idiv0 // due to relocation limit, can't use b.
   pop  {r7, pc}
 #      else
   JMP(lr)
 #      endif
 
 
-#if __ARM_ARCH_ISA_THUMB == 1
+#if defined(USE_THUMB_1)
 #define block(shift)                                                           \
   lsls r2, r1, IMM shift;                                                      \
   cmp r0, r2;                                                                  \
   blo LOCAL_LABEL(block_skip_##shift);                                         \
   subs r0, r0, r2;                                                             \
   LOCAL_LABEL(block_skip_##shift) :;                                           \
   adcs r3, r3 /* same as ((r3 << 1) | Carry). Carry is set if r0 >= r2. */
 

compiler-rt/trunk/lib/builtins/arm/umodsi3.S

  * function for the ARM 32-bit architecture.
  *
  *===----------------------------------------------------------------------===*/
 
 #include "../assembly.h"
 
   .syntax unified
   .text
-#if __ARM_ARCH_ISA_THUMB == 2
-  .thumb
-#endif
+  DEFINE_CODE_STATE
 
 @ unsigned int __umodsi3(unsigned int divident, unsigned int divisor)
 @   Calculate and return the remainder of the (unsigned) division.
 
   .p2align 2
-#if __ARM_ARCH_ISA_THUMB == 2
-DEFINE_COMPILERRT_THUMB_FUNCTION(__umodsi3)
-#else
 DEFINE_COMPILERRT_FUNCTION(__umodsi3)
-#endif
 #if __ARM_ARCH_EXT_IDIV__
   tst     r1, r1
   beq     LOCAL_LABEL(divby0)
   udiv  r2, r0, r1
   mls   r0, r2, r1, r0
   bx    lr
 #else
   cmp r1, #1
#else
    * that (r0 << shift) < 2 * r1. The quotient is stored in r3.
    */
 
 #  ifdef __ARM_FEATURE_CLZ
   clz ip, r0
   clz r3, r1
   /* r0 >= r1 implies clz(r0) <= clz(r1), so ip <= r3. */
   sub r3, r3, ip
-#    if __ARM_ARCH_ISA_THUMB == 2
+#    if defined(USE_THUMB_2)
   adr ip, LOCAL_LABEL(div0block) + 1
   sub ip, ip, r3, lsl #1
 #    else
   adr ip, LOCAL_LABEL(div0block)
 #    endif
   sub ip, ip, r3, lsl #3
   bx  ip
 #  else
-#    if __ARM_ARCH_ISA_THUMB == 2
+#    if defined(USE_THUMB_2)
 #    error THUMB mode requires CLZ or UDIV
 #    endif
   mov r2, r0
   adr ip, LOCAL_LABEL(div0block)
 
   lsr r3, r2, #16
   cmp r3, r1
   movhs r2, r3

compiler-rt/trunk/lib/builtins/assembly.h

#define SYMBOL_IS_FUNC(name)                                                   \
   .endef
 #define CONST_SECTION .section .rdata,"rd"
 
 #define NO_EXEC_STACK_DIRECTIVE
 
 #endif
 
 #if defined(__arm__)
+
+/*
+ * Determine actual [ARM][THUMB[1][2]] ISA using compiler predefined macros:
+ * - for '-mthumb -march=armv6' compiler defines '__thumb__'
+ * - for '-mthumb -march=armv7' compiler defines '__thumb__' and '__thumb2__'
+ */
+#if defined(__thumb2__) || defined(__thumb__)
+#define DEFINE_CODE_STATE .thumb
+#define DECLARE_FUNC_ENCODING    .thumb_func SEPARATOR
+#if defined(__thumb2__)
+#define USE_THUMB_2
+#define IT(cond)  it cond
+#define ITT(cond) itt cond
+#define ITE(cond) ite cond
+#else
+#define USE_THUMB_1
+#define IT(cond)
+#define ITT(cond)
+#define ITE(cond)
+#endif // defined(__thumb__2)
+#else // !defined(__thumb2__) && !defined(__thumb__)
+#define DEFINE_CODE_STATE .arm
+#define DECLARE_FUNC_ENCODING
+#define IT(cond)
+#define ITT(cond)
+#define ITE(cond)
+#endif
+
+#if defined(USE_THUMB_1) && defined(USE_THUMB_2)
+#error "USE_THUMB_1 and USE_THUMB_2 can't be defined together."
+#endif
+
 #if defined(__ARM_ARCH_4T__) || __ARM_ARCH >= 5
 #define ARM_HAS_BX
 #endif
-#if !defined(__ARM_FEATURE_CLZ) && __ARM_ARCH_ISA_THUMB != 1 &&                \
+#if !defined(__ARM_FEATURE_CLZ) && !defined(USE_THUMB_1) &&  \
     (__ARM_ARCH >= 6 || (__ARM_ARCH == 5 && !defined(__ARM_ARCH_5__)))
 #define __ARM_FEATURE_CLZ
 #endif
 
 #ifdef ARM_HAS_BX
 #define JMP(r) bx r
 #define JMPc(r, c) bx##c r
 #else
 #define JMP(r) mov pc, r
 #define JMPc(r, c) mov##c pc, r
 #endif
 
 // pop {pc} can't switch Thumb mode on ARMv4T
 #if __ARM_ARCH >= 5
 #define POP_PC() pop {pc}
 #else
 #define POP_PC()                                                               \
   pop {ip};                                                                    \
   JMP(ip)
 #endif
 
-#if __ARM_ARCH_ISA_THUMB == 2
-#define IT(cond)  it cond
-#define ITT(cond) itt cond
-#define ITE(cond) ite cond
-#else
-#define IT(cond)
-#define ITT(cond)
-#define ITE(cond)
-#endif
-
-#if __ARM_ARCH_ISA_THUMB == 2
+#if defined(USE_THUMB_2)
 #define WIDE(op) op.w
 #else
 #define WIDE(op) op
 #endif
 #endif
 
 #define GLUE2(a, b) a##b
 #define GLUE(a, b) GLUE2(a, b)
 #define SYMBOL_NAME(name) GLUE(__USER_LABEL_PREFIX__, name)
 
 #ifdef VISIBILITY_HIDDEN
 #define DECLARE_SYMBOL_VISIBILITY(name)                                        \
   HIDDEN(SYMBOL_NAME(name)) SEPARATOR
 #else
 #define DECLARE_SYMBOL_VISIBILITY(name)
 #endif
 
 #define DEFINE_COMPILERRT_FUNCTION(name)                                       \
   FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
   .globl SYMBOL_NAME(name) SEPARATOR                                           \
   SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
   DECLARE_SYMBOL_VISIBILITY(name)                                              \
+  DECLARE_FUNC_ENCODING                                                        \
   SYMBOL_NAME(name):
 
 #define DEFINE_COMPILERRT_THUMB_FUNCTION(name)                                 \
   FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
   .globl SYMBOL_NAME(name) SEPARATOR                                           \
   SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
   DECLARE_SYMBOL_VISIBILITY(name) SEPARATOR                                    \
   .thumb_func SEPARATOR                                                        \
   SYMBOL_NAME(name):
 
 #define DEFINE_COMPILERRT_PRIVATE_FUNCTION(name)                               \
   FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
   .globl SYMBOL_NAME(name) SEPARATOR                                           \
   SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
   HIDDEN(SYMBOL_NAME(name)) SEPARATOR                                          \
+  DECLARE_FUNC_ENCODING                                                        \
   SYMBOL_NAME(name):
 
 #define DEFINE_COMPILERRT_PRIVATE_FUNCTION_UNMANGLED(name)                     \
   .globl name SEPARATOR                                                        \
   SYMBOL_IS_FUNC(name) SEPARATOR                                               \
   HIDDEN(name) SEPARATOR                                                       \
+  DECLARE_FUNC_ENCODING                                                        \
   name:
 
 #define DEFINE_COMPILERRT_FUNCTION_ALIAS(name, target)                         \
   .globl SYMBOL_NAME(name) SEPARATOR                                           \
   SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
   DECLARE_SYMBOL_VISIBILITY(SYMBOL_NAME(name)) SEPARATOR                       \
   .set SYMBOL_NAME(name), SYMBOL_NAME(target) SEPARATOR