Commit 87e914c5 authored by Hans Wennborg's avatar Hans Wennborg
Browse files

Merging r368104 and r368202: 

------------------------------------------------------------------------
r368104 | void | 2019-08-07 00:41:22 +0200 (Wed, 07 Aug 2019) | 13 lines

Delay diagnosing asm constraints that require immediates until after inlining

Summary:
An inline asm call may result in an immediate input value after inlining.
Therefore, don't emit a diagnostic here if the input isn't an immediate.

Reviewers: joerg, eli.friedman, rsmith

Subscribers: asb, rbar, johnrusso, simoncook, apazos, sabuasal, niosHD, jrtc27, zzheng, edward-jones, rogfer01, MartinMosbeck, brucehoult, the_o, PkmX, jocewei, s.egerton, krytarowski, mgorny, riccibruno, eraman, cfe-commits

Tags: #clang

Differential Revision: https://reviews.llvm.org/D60943
------------------------------------------------------------------------

------------------------------------------------------------------------
r368202 | void | 2019-08-07 21:36:48 +0200 (Wed, 07 Aug 2019) | 2 lines

Add target requirements for those bots which don't handle x86.

------------------------------------------------------------------------

llvm-svn: 368422
parent ffea3e37

clang/lib/CodeGen/CGStmt.cpp

+3 −5
Original line number Diff line number Diff line
@@ -1846,10 +1846,8 @@ llvm::Value* CodeGenFunction::EmitAsmInput( 
      InputExpr->EvaluateAsRValue(EVResult, getContext(), true);



      llvm::APSInt IntResult;

      if (!EVResult.Val.toIntegralConstant(IntResult, InputExpr->getType(),

      if (EVResult.Val.toIntegralConstant(IntResult, InputExpr->getType(),

                                          getContext()))

        llvm_unreachable("Invalid immediate constant!");



        return llvm::ConstantInt::get(getLLVMContext(), IntResult);

    }

clang/lib/Sema/SemaStmtAsm.cpp

+13 −19
Original line number Diff line number Diff line
@@ -383,26 +383,20 @@ StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, 
    } else if (Info.requiresImmediateConstant() && !Info.allowsRegister()) {

      if (!InputExpr->isValueDependent()) {

        Expr::EvalResult EVResult;

        if (!InputExpr->EvaluateAsRValue(EVResult, Context, true))

          return StmtError(

              Diag(InputExpr->getBeginLoc(), diag::err_asm_immediate_expected)

              << Info.getConstraintStr() << InputExpr->getSourceRange());



        if (InputExpr->EvaluateAsRValue(EVResult, Context, true)) {

          // For compatibility with GCC, we also allow pointers that would be

          // integral constant expressions if they were cast to int.

          llvm::APSInt IntResult;

        if (!EVResult.Val.toIntegralConstant(IntResult, InputExpr->getType(),

          if (EVResult.Val.toIntegralConstant(IntResult, InputExpr->getType(),

                                               Context))

          return StmtError(

              Diag(InputExpr->getBeginLoc(), diag::err_asm_immediate_expected)

              << Info.getConstraintStr() << InputExpr->getSourceRange());



            if (!Info.isValidAsmImmediate(IntResult))

              return StmtError(Diag(InputExpr->getBeginLoc(),

                                    diag::err_invalid_asm_value_for_constraint)

                           << IntResult.toString(10) << Info.getConstraintStr()

                               << IntResult.toString(10)

                               << Info.getConstraintStr()

                               << InputExpr->getSourceRange());

        }

      }



    } else {

      ExprResult Result = DefaultFunctionArrayLvalueConversion(Exprs[i]);

clang/test/Sema/pr41027.c→clang/test/CodeGen/pr41027.c

+20 −0
Original line number Diff line number Diff line 
// RUN: %clang_cc1 -triple x86_64 -fsyntax-only %s

// XFAIL: *

// REQUIRES: x86-registered-target

// RUN: %clang_cc1 -triple x86_64-unknown-unknown -S -O2 -o - %s | FileCheck %s



inline void pr41027(unsigned a, unsigned b) {

// CHECK-LABEL: f:

// CHECK:         movl $1, %eax

// CHECK-NEXT:    #APP

// CHECK-NEXT:    outl %eax, $1

// CHECK-NEXT:    #NO_APP



static inline void pr41027(unsigned a, unsigned b) {

  if (__builtin_constant_p(a)) {

    __asm__ volatile("outl %0,%w1" : : "a"(b), "n"(a));

  } else {

    __asm__ volatile("outl %0,%w1" : : "a"(b), "d"(a));

  }

}



void f(unsigned port) {

  pr41027(1, 1);

}

clang/test/Sema/inline-asm-validate-riscv.c

+0 −3
Original line number Diff line number Diff line
@@ -4,7 +4,6 @@ 
void I(int i) {

  static const int BelowMin = -2049;

  static const int AboveMax = 2048;

  asm volatile ("" :: "I"(i)); // expected-error{{constraint 'I' expects an integer constant expression}}

  asm volatile ("" :: "I"(BelowMin)); // expected-error{{value '-2049' out of range for constraint 'I'}}

  asm volatile ("" :: "I"(AboveMax)); // expected-error{{value '2048' out of range for constraint 'I'}}

}
@@ -12,7 +11,6 @@ void I(int i) { 
void J(int j) {

  static const int BelowMin = -1;

  static const int AboveMax = 1;

  asm volatile ("" :: "J"(j)); // expected-error{{constraint 'J' expects an integer constant expression}}

  asm volatile ("" :: "J"(BelowMin)); // expected-error{{value '-1' out of range for constraint 'J'}}

  asm volatile ("" :: "J"(AboveMax)); // expected-error{{value '1' out of range for constraint 'J'}}

}
@@ -20,7 +18,6 @@ void J(int j) { 
void K(int k) {

  static const int BelowMin = -1;

  static const int AboveMax = 32;

  asm volatile ("" :: "K"(k)); // expected-error{{constraint 'K' expects an integer constant expression}}

  asm volatile ("" :: "K"(BelowMin)); // expected-error{{value '-1' out of range for constraint 'K'}}

  asm volatile ("" :: "K"(AboveMax)); // expected-error{{value '32' out of range for constraint 'K'}}

}

clang/test/Sema/inline-asm-validate-x86.c

+0 −25
Original line number Diff line number Diff line
@@ -4,9 +4,6 @@ 
void I(int i, int j) {

  static const int BelowMin = -1;

  static const int AboveMax = 32;

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "I"(j)); // expected-error{{constraint 'I' expects an integer constant expression}}

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "I"(BelowMin)); // expected-error{{value '-1' out of range for constraint 'I'}}
@@ -21,9 +18,6 @@ void I(int i, int j) { 
void J(int i, int j) {

  static const int BelowMin = -1;

  static const int AboveMax = 64;

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "J"(j)); // expected-error{{constraint 'J' expects an integer constant expression}}

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "J"(BelowMin)); // expected-error{{value '-1' out of range for constraint 'J'}}
@@ -38,9 +32,6 @@ void J(int i, int j) { 
void K(int i, int j) {

  static const int BelowMin = -129;

  static const int AboveMax = 128;

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "K"(j)); // expected-error{{constraint 'K' expects an integer constant expression}}

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "K"(BelowMin)); // expected-error{{value '-129' out of range for constraint 'K'}}
@@ -60,9 +51,6 @@ void L(int i, int j) { 
  static const int Valid1 = 0xff;

  static const int Valid2 = 0xffff;

  static const int Valid3 = 0xffffffff;

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "L"(j)); // expected-error{{constraint 'L' expects an integer constant expression}}

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "L"(Invalid1)); // expected-error{{value '1' out of range for constraint 'L'}}
@@ -89,9 +77,6 @@ void L(int i, int j) { 
void M(int i, int j) {

  static const int BelowMin = -1;

  static const int AboveMax = 4;

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "M"(j)); // expected-error{{constraint 'M' expects an integer constant expression}}

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "M"(BelowMin)); // expected-error{{value '-1' out of range for constraint 'M'}}
@@ -106,9 +91,6 @@ void M(int i, int j) { 
void N(int i, int j) {

  static const int BelowMin = -1;

  static const int AboveMax = 256;

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "N"(j)); // expected-error{{constraint 'N' expects an integer constant expression}}

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "N"(BelowMin)); // expected-error{{value '-1' out of range for constraint 'N'}}
@@ -123,9 +105,6 @@ void N(int i, int j) { 
void O(int i, int j) {

  static const int BelowMin = -1;

  static const int AboveMax = 128;

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "O"(j)); // expected-error{{constraint 'O' expects an integer constant expression}}

  __asm__("xorl %0,%2"

          : "=r"(i)

          : "0"(i), "O"(BelowMin)); // expected-error{{value '-1' out of range for constraint 'O'}}
@@ -146,10 +125,6 @@ void pr40890(void) { 
  __asm__ __volatile__("\n#define S_A abcd%0\n" : : "n"(&((struct s*)0)->a));

  // This offset-from-null pointer can be used as an integer constant expression.

  __asm__ __volatile__("\n#define S_B abcd%0\n" : : "n"(&((struct s*)0)->b));

  // This pointer cannot be used as an integer constant expression.

  __asm__ __volatile__("\n#define GLOBAL_A abcd%0\n" : : "n"(&s.a)); // expected-error{{constraint 'n' expects an integer constant expression}}

  // Floating-point is also not okay.

  __asm__ __volatile__("\n#define PI abcd%0\n" : : "n"(3.14f)); // expected-error{{constraint 'n' expects an integer constant expression}}

#ifdef AMD64

  // This arbitrary pointer is fine.

  __asm__ __volatile__("\n#define BEEF abcd%0\n" : : "n"((int*)0xdeadbeeeeeef));