Fix for bug 22941, [asm inline] integer template parameter ...

[Sunil_Srivastava]

Summary

It should not be an error if an expression in inline-asm statements is not evaluatable while parsing the template, as the failure may be due to the presence of template paramaters, which do not have values at this stage.

This change suppresses those errors.

If the template gets used, another check is made during instantiation, and a failure to evaluate at that time is reported as an error.

The test checks both: that the error during template parsing is not reported, and an error detectable during instantiation is reported.

[majnemer]

lib/Sema/SemaStmtAsm.cpp

257

I think we could just fix this by inserting:

if (InputExpr->isValueDependent())
  continue;

[Sunil_Srivastava]

Changed along the lines suggested by David Majnemer

[Sunil_Srivastava]

ping

lib/Sema/SemaStmtAsm.cpp

257

Just that does not work because the 'continue' skips needed code later inside the loop body, leading to assertion failures, on the windows build at least.

However, wrapping whole 10 line checking code in a (!InputExpr->isValueDependent()) works. I am updating the review to reflect that.

[majnemer]

This differential revision doesn't include a testcase.

lib/Sema/SemaStmtAsm.cpp

257–277

Please move this variable declaration to the point at which EvaluateAsInt is called.

[Sunil_Srivastava]

Moved declaration of Result to just before its use.
The test is same as original, but added it back.

[Sunil_Srivastava]

ping

[majnemer]

LGTM

[Sunil_Srivastava]

submitted in r242175

lib/Sema/SemaStmtAsm.cpp

for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
     // Only allow void types for memory constraints.
     if (Info.allowsMemory() && !Info.allowsRegister()) {
       if (CheckAsmLValue(InputExpr, *this))
         return StmtError(Diag(InputExpr->getLocStart(),
                               diag::err_asm_invalid_lvalue_in_input)
                          << Info.getConstraintStr()
                          << InputExpr->getSourceRange());
     } else if (Info.requiresImmediateConstant() && !Info.allowsRegister()) {
       llvm::APSInt Result;
-      if (!InputExpr->EvaluateAsInt(Result, Context))
-        return StmtError(
-            Diag(InputExpr->getLocStart(), diag::err_asm_immediate_expected)
-            << Info.getConstraintStr() << InputExpr->getSourceRange());
+     if (InputExpr->EvaluateAsInt(Result, Context)) {
+        // InputExpr is evaluatable as int. Verify that it satisfies the range
+        // constraints.
         if (Result.slt(Info.getImmConstantMin()) ||
             Result.sgt(Info.getImmConstantMax()))
           return StmtError(Diag(InputExpr->getLocStart(),
                                 diag::err_invalid_asm_value_for_constraint)
                            << Result.toString(10) << Info.getConstraintStr()
                            << InputExpr->getSourceRange());
-
+      } else {
+        // InputExpr is not evaluatable as int, but we do not consider this an
+        // error if we are parsing a template, because the reason for failure
+        // may have been the presence of template parameters in the expression.
+        // If the template is used, we will come to this point again
+        // with (getTemplateParamParent()==nullptr). That will catch the error.
+        if (getCurScope()->getTemplateParamParent() == nullptr) {
+          return StmtError(
+            Diag(InputExpr->getLocStart(), diag::err_asm_immediate_expected)
+            << Info.getConstraintStr() << InputExpr->getSourceRange());
+        }
+      }
     } else {
       ExprResult Result = DefaultFunctionArrayLvalueConversion(Exprs[i]);
       if (Result.isInvalid())
         return StmtError();
 
       Exprs[i] = Result.get();
     }
 

test/Sema/inline-asm-validate-tmpl.cpp

+// RUN: %clang_cc1 -triple i686 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple x86_64 -fsyntax-only -verify %s
+
+
+// this template, when instantiated with 300, violates the range contraint
+template <int N> void  test(int value)
+{
+  asm("rol %1, %0" :"=r"(value): "I"(N + 1)); // expected-error{{value '301' out of range for constraint 'I'}}
+}
+
+int    main() { test<300>(10); } // expected-note{{in instantiation of function template specialization 'test<300>' requested here}}
+
+
+// this template is not used, but the error is detectable
+template <int N> void  testb(int value)
+{
+   asm("rol %1, %0" :"=r"(value): "I"(301)); // expected-error{{value '301' out of range for constraint 'I'}}
+}
+
+// these should compile without error
+template <int N> void  testc(int value)
+{
+  asm("rol %1, %0" :"=r"(value): "I"(N + 1));
+}
+int  foo() { testc<2>(10); }