Print this page
4853 illumos-gate is not lint-clean when built with openssl 1.0

Split Close
Expand all
Collapse all
          --- old/usr/src/lib/openssl/include/bn_lcl.h
          +++ new/usr/src/lib/openssl/include/bn_lcl.h
↓ open down ↓ 229 lines elided ↑ open up ↑
 230  230   * inline assembler, then it's not impossible to implement the
 231  231   * "bignum" routines (and have the compiler optimize 'em)
 232  232   * exhibiting "native" performance in C. That's what BN_UMULT_HIGH
 233  233   * macro is about:-)
 234  234   *
 235  235   *                                      <appro@fy.chalmers.se>
 236  236   */
 237  237  # if defined(__alpha) && (defined(SIXTY_FOUR_BIT_LONG) || defined(SIXTY_FOUR_BIT))
 238  238  #  if defined(__DECC)
 239  239  #   include <c_asm.h>
 240      -#   define BN_UMULT_HIGH(a,b)   (BN_ULONG)asm("umulh %a0,%a1,%v0",(a),(b))
      240 +#   define BN_UMULT_HIGH(a,b)   (BN_ULONG)__asm__("umulh %a0,%a1,%v0",(a),(b))
 241  241  #  elif defined(__GNUC__) && __GNUC__>=2
 242  242  #   define BN_UMULT_HIGH(a,b)   ({      \
 243  243          register BN_ULONG ret;          \
 244      -        asm ("umulh     %1,%2,%0"       \
      244 +        __asm__ ("umulh %1,%2,%0"       \
 245  245               : "=r"(ret)                \
 246  246               : "r"(a), "r"(b));         \
 247  247          ret;                    })
 248  248  #  endif        /* compiler */
 249  249  # elif defined(_ARCH_PPC) && defined(__64BIT__) && defined(SIXTY_FOUR_BIT_LONG)
 250  250  #  if defined(__GNUC__) && __GNUC__>=2
 251  251  #   define BN_UMULT_HIGH(a,b)   ({      \
 252  252          register BN_ULONG ret;          \
 253      -        asm ("mulhdu    %0,%1,%2"       \
      253 +        __asm__ ("mulhdu        %0,%1,%2"       \
 254  254               : "=r"(ret)                \
 255  255               : "r"(a), "r"(b));         \
 256  256          ret;                    })
 257  257  #  endif        /* compiler */
 258  258  # elif (defined(__x86_64) || defined(__x86_64__)) && \
 259  259         (defined(SIXTY_FOUR_BIT_LONG) || defined(SIXTY_FOUR_BIT))
 260  260  #  if defined(__GNUC__) && __GNUC__>=2
 261  261  #   define BN_UMULT_HIGH(a,b)   ({      \
 262  262          register BN_ULONG ret,discard;  \
 263      -        asm ("mulq      %3"             \
      263 +        __asm__ ("mulq  %3"             \
 264  264               : "=a"(discard),"=d"(ret)  \
 265  265               : "a"(a), "g"(b)           \
 266  266               : "cc");                   \
 267  267          ret;                    })
 268  268  #   define BN_UMULT_LOHI(low,high,a,b)  \
 269      -        asm ("mulq      %3"             \
      269 +        __asm__ ("mulq  %3"             \
 270  270                  : "=a"(low),"=d"(high)  \
 271  271                  : "a"(a),"g"(b)         \
 272  272                  : "cc");
 273  273  #  endif
 274  274  # elif (defined(_M_AMD64) || defined(_M_X64)) && defined(SIXTY_FOUR_BIT)
 275  275  #  if defined(_MSC_VER) && _MSC_VER>=1400
 276  276      unsigned __int64 __umulh    (unsigned __int64 a,unsigned __int64 b);
 277  277      unsigned __int64 _umul128   (unsigned __int64 a,unsigned __int64 b,
 278  278                                   unsigned __int64 *h);
 279  279  #   pragma intrinsic(__umulh,_umul128)
↓ open down ↓ 3 lines elided ↑ open up ↑
 283  283  # elif defined(__mips) && (defined(SIXTY_FOUR_BIT) || defined(SIXTY_FOUR_BIT_LONG))
 284  284  #  if defined(__GNUC__) && __GNUC__>=2
 285  285  #   if __GNUC__>=4 && __GNUC_MINOR__>=4 /* "h" constraint is no more since 4.4 */
 286  286  #     define BN_UMULT_HIGH(a,b)          (((__uint128_t)(a)*(b))>>64)
 287  287  #     define BN_UMULT_LOHI(low,high,a,b) ({     \
 288  288          __uint128_t ret=(__uint128_t)(a)*(b);   \
 289  289          (high)=ret>>64; (low)=ret;       })
 290  290  #   else
 291  291  #     define BN_UMULT_HIGH(a,b) ({      \
 292  292          register BN_ULONG ret;          \
 293      -        asm ("dmultu    %1,%2"          \
      293 +        __asm__ ("dmultu        %1,%2"          \
 294  294               : "=h"(ret)                \
 295  295               : "r"(a), "r"(b) : "l");   \
 296  296          ret;                    })
 297  297  #     define BN_UMULT_LOHI(low,high,a,b)\
 298      -        asm ("dmultu    %2,%3"          \
      298 +        __asm__ ("dmultu        %2,%3"          \
 299  299               : "=l"(low),"=h"(high)     \
 300  300               : "r"(a), "r"(b));
 301  301  #    endif
 302  302  #  endif
 303  303  # endif         /* cpu */
 304  304  #endif          /* OPENSSL_NO_ASM */
 305  305  
 306  306  /*************************************************************
 307  307   * Using the long long type
 308  308   */
↓ open down ↓ 207 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX