builtins: Select correct code fragments when compiling for Thumb1/Thum2/ARM ISA.

[strejda]

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()

---

Note: This patch doesn't fix broken Thumb1 variant of __udivsi3 !

[compnerd]

I really think that we shouldnt introduce the USE_* macros, opting to re-organise the code (separate change) and then using the appropriate macros. It avoids the layer of indirection which makes it easier for others to follow what is going on.

[weimingz]

lib/builtins/assembly.h

97 ↗

(On Diff #91710)

If using '-march=armv6 -marm', thumb2 and thumb will both be defined.

[strejda]

I'm very sorry, but due to my current overload in FreeBSD, I will have not a free time to manage this for next week or two.
The problem is obvious, so please can you (or somebody else) take this review and process it to commit ?

lib/builtins/assembly.h

97 ↗

(On Diff #91710)

???
root@tegra124:~ # gcc49 -marm -march=armv6 -dM -E -x c /dev/null | grep thumb
root@tegra124:~ # gcc49 -marm -march=armv7-a -dM -E -x c /dev/null | grep thumb
root@tegra124:~ # gcc49 -mthumb -march=armv6 -dM -E -x c /dev/null | grep thumb
#define thumb 1
root@tegra124:~ # gcc49 -mthumb -march=armv7-a -dM -E -x c /dev/null | grep thumb
#define thumb2 1
#define thumb 1

root@tegra124:~ # clang -marm -march=armv6 -dM -E -x c /dev/null | grep thumb
root@tegra124:~ # clang -marm -march=armv7-a -dM -E -x c /dev/null | grep thumb
root@tegra124:~ # clang -mthumb -march=armv6 -dM -E -x c /dev/null | grep thumb
#define thumb 1
root@tegra124:~ # clang -mthumb -march=armv7-a -dM -E -x c /dev/null | grep thumb
#define thumb2 1
#define thumb 1
root@tegra124:~ #

[weimingz]

Hi Michal,

Looks the system won't let me upload a new revision under this patch.
I have to create a new one: https://reviews.llvm.org/D31220

[weimingz]

it was commited by mistake and was reverted immediately.

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

 //   return {quot, rem};
 // }
 
 #if defined(__MINGW32__)
 #define __aeabi_idivmod __rt_sdiv
 #endif
 
         .syntax unified
+        .syntax unified
+        .text
+#if defined(USE_THUMB_PROLOGUE)
+        .thumb
+#endif
         .p2align 2
+#if defined(USE_THUMB_PROLOGUE)
+DEFINE_COMPILERRT_THUMB_FUNCTION(__aeabi_idivmod)
+#else
 DEFINE_COMPILERRT_FUNCTION(__aeabi_idivmod)
-#if __ARM_ARCH_ISA_THUMB == 1
+#endif
+#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
+#if defined(USE_THUMB_PROLOGUE)
+        .thumb
+#endif
         .p2align 2
+#if defined(USE_THUMB_PROLOGUE)
+DEFINE_COMPILERRT_THUMB_FUNCTION(__aeabi_uidivmod)
+#else
 DEFINE_COMPILERRT_FUNCTION(__aeabi_uidivmod)
+#endif
 #if __ARM_ARCH_ISA_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

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
+#if defined(USE_THUMB_PROLOGUE)
   .thumb
 #endif
 
 //
 // extern uint64_t __bswapdi2(uint64_t);
 //
 // Reverse all the bytes in a 64-bit integer.
 //
   .p2align 2
-#if __ARM_ARCH_ISA_THUMB == 2
+#if defined(USE_THUMB_PROLOGUE)
 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

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
+#if defined(USE_THUMB_PROLOGUE)
   .thumb
 #endif
 
 //
 // extern uint32_t __bswapsi2(uint32_t);
 //
 // Reverse all the bytes in a 32-bit integer.
 //
   .p2align 2
-#if __ARM_ARCH_ISA_THUMB == 2
+#if defined(USE_THUMB_PROLOGUE)
 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

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
+#if defined(USE_THUMB_PROLOGUE)
   .thumb
 #endif
 
 
   .p2align  2
-#if __ARM_ARCH_ISA_THUMB == 2
+#if defined(USE_THUMB_PROLOGUE)
 DEFINE_COMPILERRT_THUMB_FUNCTION(__clzdi2)
 #else
 DEFINE_COMPILERRT_FUNCTION(__clzdi2)
 #endif
 #ifdef __ARM_FEATURE_CLZ
 #ifdef __ARMEB__
   cmp r0, 0
   itee ne

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
+#if defined(USE_THUMB_PROLOGUE)
   .thumb
 #endif
 
   .p2align  2
-#if __ARM_ARCH_ISA_THUMB == 2
+#if defined(USE_THUMB_PROLOGUE)
 DEFINE_COMPILERRT_THUMB_FUNCTION(__clzsi2)
 #else
 DEFINE_COMPILERRT_FUNCTION(__clzsi2)
 #endif
 #ifdef __ARM_FEATURE_CLZ
   clz r0, r0
   JMP(lr)
 #else

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
+    .text
+#if defined(USE_THUMB_PROLOGUE)
     .thumb
 #endif
 
 @ int __eqsf2(float a, float b)
 
     .p2align 2
+#if defined(USE_THUMB_PROLOGUE)
+DEFINE_COMPILERRT_THUMB_FUNCTION(__eqsf2)
+#else
 DEFINE_COMPILERRT_FUNCTION(__eqsf2)
+#endif
 #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
     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_ALIAS(__lesf2, __eqsf2)
 DEFINE_COMPILERRT_FUNCTION_ALIAS(__ltsf2, __eqsf2)
 DEFINE_COMPILERRT_FUNCTION_ALIAS(__nesf2, __eqsf2)
 
 @ int __gtsf2(float a, float b)
 
     .p2align 2
+#if defined(USE_THUMB)
+DEFINE_COMPILERRT_THUMB_FUNCTION(__gtsf2)
+#else
 DEFINE_COMPILERRT_FUNCTION(__gtsf2)
+#endif
     // 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

 #endif
 END_COMPILERRT_FUNCTION(__gtsf2)
 
 DEFINE_COMPILERRT_FUNCTION_ALIAS(__gesf2, __gtsf2)
 
 @ int __unordsf2(float a, float b)
 
     .p2align 2
+#if defined(USE_THUMB)
+DEFINE_COMPILERRT_THUMB_FUNCTION(__unordsf2)
+#else
 DEFINE_COMPILERRT_FUNCTION(__unordsf2)
+#endif
+
 #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
+#if defined(USE_THUMB_PROLOGUE)
   .thumb
 #endif
 
 @ 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
+#if defined(USE_THUMB_PROLOGUE)
 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

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
+   .syntax unified
+   .text
+#if defined(USE_THUMB_PROLOGUE)
+   .thumb
 #endif
 
   .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
+#if defined(USE_THUMB_PROLOGUE)
 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
#  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
+#if defined(USE_THUMB_PROLOGUE)
   .thumb
 #endif
 
 @ int __modsi3(int divident, int divisor)
 @   Calculate and return the remainder of the (signed) division.
 
   .p2align 3
-#if __ARM_ARCH_ISA_THUMB == 2
+#if defined(USE_THUMB_PROLOGUE)
 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

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
+#if defined(USE_THUMB_PROLOGUE)
   .thumb
 #endif
 
 @ 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
+#if defined(USE_THUMB_PROLOGUE)
 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
#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

  * function for the ARM 32-bit architecture.
  *
  *===----------------------------------------------------------------------===*/
 
 #include "../assembly.h"
 
   .syntax unified
   .text
-
-#if __ARM_ARCH_ISA_THUMB == 2
+#if defined(USE_THUMB_PROLOGUE)
   .thumb
 #endif
 
   .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
+#if defined(USE_THUMB_PROLOGUE)
 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
 #else
   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

 LOCAL_LABEL(divby0):
   movs  r0, #0
 #      if defined(__ARM_EABI__)
   bl  __aeabi_idiv0 // due to relocation limit, can't use b.
 #      endif
   JMP(lr)
 
 
-#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
+#if defined(USE_THUMB_PROLOGUE)
   .thumb
 #endif
 
 @ 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
+#if defined(USE_THUMB_PROLOGUE)
 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
#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

 #if __ARM_ARCH >= 5
 #define POP_PC() pop {pc}
 #else
 #define POP_PC()                                                               \
   pop {ip};                                                                    \
   JMP(ip)
 #endif
 
-#if __ARM_ARCH_ISA_THUMB == 2
+/*
+ * 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__)
+#define USE_THUMB_2 1
+#elif defined(__thumb__)
+#define USE_THUMB_1 1
+#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(USE_THUMB_1) || defined(USE_THUMB_1)
+#define USE_THUMB_PROLOGUE 1
+#endif
+
+#if defined(USE_THUMB_2)
 #define IT(cond)  it cond
 #define ITT(cond) itt cond
+#define WIDE(op) op.w
 #else
 #define IT(cond)
 #define ITT(cond)
-#endif
-
-#if __ARM_ARCH_ISA_THUMB == 2
-#define WIDE(op) op.w
-#else
 #define WIDE(op) op
 #endif
-#endif
+#endif /* defined(__arm__) */
 
 #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