support non-string-literals for the message clause

Author: ro-i

clang/include/clang/AST/OpenMPClause.h

@@ -1874,6 +1874,10 @@ class OMPMessageClause final : public OMPClause {
   // Expression of the 'message' clause.
   Stmt *MessageString = nullptr;
 
+  // The message as a StringLiteral in case it is as string literal. This might
+  // be needed during compile time.
+  StringLiteral *MessageStringLiteral = nullptr;
+
   /// Set message string of the clause.
   void setMessageString(Expr *MS) { MessageString = MS; }
 
@@ -1887,10 +1891,14 @@ class OMPMessageClause final : public OMPClause {
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
+  /// \param MessageStringLiteral The message as a StringLiteral in case it is
+  /// as string literal. This might be needed during compile time.
   OMPMessageClause(Expr *MS, SourceLocation StartLoc, SourceLocation LParenLoc,
-                   SourceLocation EndLoc)
+                   SourceLocation EndLoc,
+                   StringLiteral *MessageStringLiteral = nullptr)
       : OMPClause(llvm::omp::OMPC_message, StartLoc, EndLoc),
-        LParenLoc(LParenLoc), MessageString(MS) {}
+        LParenLoc(LParenLoc), MessageString(MS),
+        MessageStringLiteral(MessageStringLiteral) {}
 
   /// Build an empty clause.
   OMPMessageClause()
@@ -1903,6 +1911,10 @@ class OMPMessageClause final : public OMPClause {
   /// Returns message string of the clause.
   Expr *getMessageString() const { return cast_or_null<Expr>(MessageString); }
 
+  // Returns the source message as a string literal in case it has been a string
+  // literal. Otherwise, return null.
+  StringLiteral *getAsStringLiteral() const { return MessageStringLiteral; }
+
   child_range children() {
     return child_range(&MessageString, &MessageString + 1);
   }

clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -1499,8 +1499,10 @@ def err_omp_unexpected_directive : Error<
   "unexpected OpenMP directive %select{|'#pragma omp %1'}0">;
 def err_omp_expected_punc : Error<
   "expected ',' or ')' in '%0' %select{clause|directive}1">;
-def warn_clause_expected_string : Warning<
+def warn_clause_expected_string_literal : Warning<
   "expected string literal in 'clause %0' - ignoring">, InGroup<IgnoredPragmas>;
+def warn_clause_expected_string: Warning<
+  "expected string in 'clause %0' - ignoring">, InGroup<IgnoredPragmas>;
 def err_omp_unexpected_clause : Error<
   "unexpected OpenMP clause '%0' in directive '#pragma omp %1'">;
 def err_omp_unexpected_clause_extension_only : Error<

clang/lib/AST/OpenMPClause.cpp

@@ -1963,8 +1963,12 @@ void OMPClausePrinter::VisitOMPSeverityClause(OMPSeverityClause *Node) {
 }
 
 void OMPClausePrinter::VisitOMPMessageClause(OMPMessageClause *Node) {
-  OS << "message(\""
-     << cast<StringLiteral>(Node->getMessageString())->getString() << "\")";
+  OS << "message(";
+  if (StringLiteral *SL = Node->getAsStringLiteral())
+    OS << "\"" << SL->getString() << "\"";
+  else if (Expr *E = Node->getMessageString())
+    E->printPretty(OS, nullptr, Policy);
+  OS << ")";
 }
 
 void OMPClausePrinter::VisitOMPScheduleClause(OMPScheduleClause *Node) {

clang/lib/CodeGen/CGOpenMPRuntime.cpp

@@ -2372,9 +2372,8 @@ void CGOpenMPRuntime::emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
 
 void CGOpenMPRuntime::emitErrorCall(CodeGenFunction &CGF, SourceLocation Loc,
                                     Expr *ME, bool IsFatal) {
-  llvm::Value *MVL =
-      ME ? CGF.EmitStringLiteralLValue(cast<StringLiteral>(ME)).getPointer(CGF)
-         : llvm::ConstantPointerNull::get(CGF.VoidPtrTy);
+  llvm::Value *MVL = ME ? CGF.EmitScalarExpr(ME)
+                        : llvm::ConstantPointerNull::get(CGF.VoidPtrTy);
   // Build call void __kmpc_error(ident_t *loc, int severity, const char
   // *message)
   llvm::Value *Args[] = {
@@ -2718,14 +2717,10 @@ void CGOpenMPRuntime::emitNumThreadsClause(
     // as if sev-level is fatal."
     Args.push_back(llvm::ConstantInt::get(
         CGM.Int32Ty, Severity == OMPC_SEVERITY_warning ? 1 : 2));
-    if (Message) {
-      if (const StringLiteral *Msg = dyn_cast<StringLiteral>(Message))
-        Args.push_back(CGF.EmitStringLiteralLValue(Msg).getPointer(CGF));
-      else
-        Args.push_back(CGF.EmitScalarExpr(Message));
-    } else {
+    if (Message)
+      Args.push_back(CGF.EmitScalarExpr(Message));
+    else
       Args.push_back(llvm::ConstantPointerNull::get(CGF.VoidPtrTy));
-    }
   }
   CGF.EmitRuntimeCall(
       OMPBuilder.getOrCreateRuntimeFunction(CGM.getModule(), FnID), Args);

clang/lib/Sema/SemaOpenMP.cpp

@@ -11082,15 +11082,19 @@ StmtResult SemaOpenMP::ActOnOpenMPErrorDirective(ArrayRef<OMPClause *> Clauses,
       OMPExecutableDirective::getSingleClause<OMPSeverityClause>(Clauses);
   const OMPMessageClause *MessageC =
       OMPExecutableDirective::getSingleClause<OMPMessageClause>(Clauses);
-  Expr *ME = MessageC ? MessageC->getMessageString() : nullptr;
 
   if (!AtC || AtC->getAtKind() == OMPC_AT_compilation) {
+    StringLiteral *SL = MessageC ? MessageC->getAsStringLiteral() : nullptr;
+    if (MessageC && !SL)
+      Diag(MessageC->getMessageString()->getBeginLoc(),
+           diag::warn_clause_expected_string_literal)
+          << getOpenMPClauseNameForDiag(OMPC_message);
     if (SeverityC && SeverityC->getSeverityKind() == OMPC_SEVERITY_warning)
       Diag(SeverityC->getSeverityKindKwLoc(), diag::warn_diagnose_if_succeeded)
-          << (ME ? cast<StringLiteral>(ME)->getString() : "WARNING");
+          << (SL ? SL->getString() : "WARNING");
     else
       Diag(StartLoc, diag::err_diagnose_if_succeeded)
-          << (ME ? cast<StringLiteral>(ME)->getString() : "ERROR");
+          << (SL ? SL->getString() : "ERROR");
     if (!SeverityC || SeverityC->getSeverityKind() != OMPC_SEVERITY_warning)
       return StmtError();
   }
@@ -16445,13 +16449,28 @@ OMPClause *SemaOpenMP::ActOnOpenMPMessageClause(Expr *ME,
                                                 SourceLocation LParenLoc,
                                                 SourceLocation EndLoc) {
   assert(ME && "NULL expr in Message clause");
-  if (!isa<StringLiteral>(ME)) {
+  QualType Type = ME->getType();
+  if ((!Type->isPointerType() && !Type->isArrayType()) ||
+      !Type->getPointeeOrArrayElementType()->isAnyCharacterType()) {
     Diag(ME->getBeginLoc(), diag::warn_clause_expected_string)
         << getOpenMPClauseNameForDiag(OMPC_message);
     return nullptr;
   }
+
+  // If the string is a string literal, save it in case it is later needed
+  // during compile time.  Also consider a const char pointer to a string
+  // literal. This is necessary for template instantiations where the string
+  // literal is not passed directly and we only get a const char pointer to it.
+  StringLiteral *SL = dyn_cast<StringLiteral>(
+      isa<ImplicitCastExpr>(ME) ? cast<ImplicitCastExpr>(ME)->getSubExpr()
+                                : ME);
+
+  // Convert array type to pointer type if needed.
+  if (Type->isArrayType())
+    ME = SemaRef.DefaultFunctionArrayConversion(ME).get();
+
   return new (getASTContext())
-      OMPMessageClause(ME, StartLoc, LParenLoc, EndLoc);
+      OMPMessageClause(ME, StartLoc, LParenLoc, EndLoc, SL);
 }
 
 OMPClause *SemaOpenMP::ActOnOpenMPOrderClause(

clang/lib/Sema/TreeTransform.h

@@ -10948,8 +10948,7 @@ TreeTransform<Derived>::TransformOMPMessageClause(OMPMessageClause *C) {
   if (E.isInvalid())
     return nullptr;
   return getDerived().RebuildOMPMessageClause(
-      C->getMessageString(), C->getBeginLoc(), C->getLParenLoc(),
-      C->getEndLoc());
+      E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
 }
 
 template <typename Derived>