Parse bounds declarations for function return values.

dtarditi · dtarditi · commit d85873e84dcd · 2016-07-19T17:20:11.000-07:00
This extends parsing of function declarators to parse bounds expressions for function return values. A return bounds expression is declared by following a parameter list with ':' bounds-expression. The return bounds information is propagated to the representation of function declarations in clang. It is not propagated yet to function types because there is no way to represent it in function types. I have opened issue #20 to track taht and added a few TODO's to the code code flagging where the information will need to be added. Testing: - Add feature tests for parsing return bounds. The tests are in in the file return_bounds.c, which will be committed separately to the checkedc Github repo. - Passes existing clang regression test baseline.
diff --git a/include/clang/AST/Decl.h b/include/clang/AST/Decl.h
@@ -1584,6 +1584,8 @@ class FunctionDecl : public DeclaratorDecl, public DeclContext,
   /// 'enum Y' in 'void f(enum Y {AA} x) {}'.
   ArrayRef<NamedDecl *> DeclsInPrototypeScope;
 
+  BoundsExpr *ReturnBoundsExpr;
+
   LazyDeclStmtPtr Body;
 
   // FIXME: This can be packed into the bitfields in DeclContext.
@@ -1687,7 +1689,7 @@ class FunctionDecl : public DeclaratorDecl, public DeclContext,
                      StartLoc),
       DeclContext(DK),
       redeclarable_base(C),
-      ParamInfo(nullptr), Body(),
+      ParamInfo(nullptr), ReturnBoundsExpr(nullptr), Body(),
       SClass(S),
       IsInline(isInlineSpecified), IsInlineSpecified(isInlineSpecified),
       IsVirtualAsWritten(false), IsPure(false), HasInheritedPrototype(false),
@@ -2065,6 +2067,11 @@ class FunctionDecl : public DeclaratorDecl, public DeclContext,
   /// computed linkage of symbol, see getLinkage.
   StorageClass getStorageClass() const { return StorageClass(SClass); }
 
+  /// \brief Returns the bounds expression for the return value of this function, if
+  /// any.
+  BoundsExpr *getReturnBoundsExpr() { return ReturnBoundsExpr; }
+  void setReturnBoundsExpr(BoundsExpr *E) { ReturnBoundsExpr = E; }
+
   /// \brief Determine whether the "inline" keyword was specified for this
   /// function.
   bool isInlineSpecified() const { return IsInlineSpecified; }
diff --git a/include/clang/Sema/DeclSpec.h b/include/clang/Sema/DeclSpec.h
@@ -1287,11 +1287,18 @@ struct DeclaratorChunk {
     /// \brief The end location of the exception specification, if any.
     unsigned ExceptionSpecLocEnd;
 
+    /// The location of the ':' for the return bounds expression in the source
+    unsigned ReturnBoundsColon;
+
     /// Params - This is a pointer to a new[]'d array of ParamInfo objects that
     /// describe the parameters specified by this function declarator.  null if
     /// there are no parameters specified.
     ParamInfo *Params;
 
+    /// The bounds for the value returned by the function. Null if there is
+    /// no bounds specified.
+    BoundsExpr *ReturnBounds;
+
     union {
       /// \brief Pointer to a new[]'d array of TypeAndRange objects that
       /// contain the types in the function's dynamic exception specification
@@ -1352,6 +1359,10 @@ struct DeclaratorChunk {
       return SourceLocation::getFromRawEncoding(RParenLoc);
     }
 
+    SourceLocation getReturnBoundsColon() const {
+      return SourceLocation::getFromRawEncoding(ReturnBoundsColon);
+    }
+
     SourceLocation getExceptionSpecLocBeg() const {
       return SourceLocation::getFromRawEncoding(ExceptionSpecLocBeg);
     }
@@ -1408,6 +1419,9 @@ struct DeclaratorChunk {
 
     /// \brief Get the trailing-return-type for this function declarator.
     ParsedType getTrailingReturnType() const { return TrailingReturnType; }
+
+    /// \brief The bounds expression for the return value
+    BoundsExpr *getReturnBounds() const { return ReturnBounds; }
   };
 
   struct BlockPointerTypeInfo : TypeInfoCommon {
@@ -1552,6 +1566,8 @@ struct DeclaratorChunk {
                                      CachedTokens *ExceptionSpecTokens,
                                      SourceLocation LocalRangeBegin,
                                      SourceLocation LocalRangeEnd,
+                                     SourceLocation ReturnBoundsColonLoc,
+                                     BoundsExpr *ReturnBoundsExpr,
                                      Declarator &TheDeclarator,
                                      TypeResult TrailingReturnType =
                                                     TypeResult());
diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h
@@ -4116,6 +4116,7 @@ class Sema {
 
   void ActOnBoundsExpr(VarDecl *D, BoundsExpr *Expr);
   void ActOnInvalidBoundsExpr(VarDecl *D);
+  BoundsExpr *CreateInvalidBoundsExpr();
 
   //===---------------------------- Clang Extensions ----------------------===//
 
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -5586,6 +5586,10 @@ void Parser::ParseParenDeclarator(Declarator &D) {
 ///           dynamic-exception-specification
 ///           noexcept-specification
 ///
+/// For Checked C, after the parameter-list, it also parses the optional return
+/// bounds expression for the function declarator:
+/// [Checked C] ':' bounds-expression
+////
 void Parser::ParseFunctionDeclarator(Declarator &D,
                                      ParsedAttributes &FirstArgAttrs,
                                      BalancedDelimiterTracker &Tracker,
@@ -5626,6 +5630,8 @@ void Parser::ParseFunctionDeclarator(Declarator &D,
   SourceLocation LParenLoc, RParenLoc;
   LParenLoc = Tracker.getOpenLocation();
   StartLoc = LParenLoc;
+  SourceLocation BoundsColonLoc;
+  BoundsExpr *ReturnBoundsExpr = nullptr;
 
   if (isFunctionDeclaratorIdentifierList()) {
     if (RequiresArg)
@@ -5741,6 +5747,17 @@ void Parser::ParseFunctionDeclarator(Declarator &D,
     }
   }
 
+  if (getLangOpts().CheckedC && Tok.is(tok::colon)) {
+    BoundsColonLoc = Tok.getLocation();
+    ConsumeToken();
+    ExprResult BoundsExprResult = ParseBoundsExpression();
+    if (BoundsExprResult.isInvalid()) {
+      ReturnBoundsExpr = Actions.CreateInvalidBoundsExpr();
+      SkipUntil(tok::l_brace, SkipUntilFlags::StopAtSemi | SkipUntilFlags::StopBeforeMatch);
+    } else
+      ReturnBoundsExpr = cast<BoundsExpr>(BoundsExprResult.get());
+  }
+
   // Remember that we parsed a function type, and remember the attributes.
   D.AddTypeInfo(DeclaratorChunk::getFunction(HasProto,
                                              IsAmbiguous,
@@ -5760,7 +5777,9 @@ void Parser::ParseFunctionDeclarator(Declarator &D,
                                              NoexceptExpr.isUsable() ?
                                                NoexceptExpr.get() : nullptr,
                                              ExceptionSpecTokens,
-                                             StartLoc, LocalEndLoc, D,
+                                             StartLoc, LocalEndLoc,
+                                             BoundsColonLoc, ReturnBoundsExpr,
+                                             D,
                                              TrailingReturnType),
                 FnAttrs, EndLoc);
 }
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
@@ -2971,6 +2971,8 @@ ExprResult Parser::ParseBlockLiteralExpression() {
                                              /*NoexceptExpr=*/nullptr,
                                              /*ExceptionSpecTokens=*/nullptr,
                                              CaretLoc, CaretLoc,
+                                             /*ReturnBoundsColon=*/NoLoc,
+                                             /*ReturnBoundsExpr=*/nullptr,
                                              ParamInfo),
                           attrs, CaretLoc);
 
diff --git a/lib/Parse/ParseExprCXX.cpp b/lib/Parse/ParseExprCXX.cpp
@@ -1221,7 +1221,10 @@ ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
                                            NoexceptExpr.isUsable() ?
                                              NoexceptExpr.get() : nullptr,
                                            /*ExceptionSpecTokens*/nullptr,
-                                           LParenLoc, FunLocalRangeEnd, D,
+                                           LParenLoc, FunLocalRangeEnd,
+                                           /*ReturnBoundsColon=*/NoLoc,
+                                           /*ReturnBoundsExpr=*/nullptr,
+                                           D,
                                            TrailingReturnType),
                   Attr, DeclEndLoc);
   } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
@@ -1290,7 +1293,10 @@ ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
                                                /*NumExceptions=*/0,
                                                /*NoexceptExpr=*/nullptr,
                                                /*ExceptionSpecTokens=*/nullptr,
-                                               DeclLoc, DeclEndLoc, D,
+                                               DeclLoc, DeclEndLoc,
+                                               /*ReturnBoundsColon=*/NoLoc,
+                                               /*ReturnBoundsExpr=*/nullptr,
+                                               D,
                                                TrailingReturnType),
                   Attr, DeclEndLoc);
   }
diff --git a/lib/Sema/DeclSpec.cpp b/lib/Sema/DeclSpec.cpp
@@ -175,6 +175,8 @@ DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto,
                                              CachedTokens *ExceptionSpecTokens,
                                              SourceLocation LocalRangeBegin,
                                              SourceLocation LocalRangeEnd,
+                                             SourceLocation ReturnBoundsColonLoc,
+                                             BoundsExpr *ReturnBoundsExpr,
                                              Declarator &TheDeclarator,
                                              TypeResult TrailingReturnType) {
   assert(!(TypeQuals & DeclSpec::TQ_atomic) &&
@@ -210,6 +212,8 @@ DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto,
   I.Fun.HasTrailingReturnType   = TrailingReturnType.isUsable() ||
                                   TrailingReturnType.isInvalid();
   I.Fun.TrailingReturnType      = TrailingReturnType.get();
+  I.Fun.ReturnBoundsColon       = ReturnBoundsColonLoc.getRawEncoding();
+  I.Fun.ReturnBounds            = ReturnBoundsExpr;
 
   assert(I.Fun.TypeQuals == TypeQuals && "bitfield overflow");
   assert(I.Fun.ExceptionSpecType == ESpecType && "bitfield overflow");
diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
@@ -7973,6 +7973,14 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
   // Finally, we know we have the right number of parameters, install them.
   NewFD->setParams(Params);
 
+  // TODO: clang-checked-issue #20.  Issue #20 is attaching bounds information
+  // to function types.  After it is address, we need to make sure that bounds
+  // information is propgated to newFD from the FunctionPrototype instance.
+  if (D.isFunctionDeclarator()) {
+    DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
+    NewFD->setReturnBoundsExpr(FTI.getReturnBounds());
+  }
+
   // Find all anonymous symbols defined during the declaration of this function
   // and add to NewFD. This lets us track decls such 'enum Y' in:
   //
@@ -10880,13 +10888,19 @@ void Sema::ActOnInvalidBoundsExpr(VarDecl *D) {
   if (!D)
     return;
 
+  BoundsExpr *InvalidExpr = CreateInvalidBoundsExpr();
+  D->setBoundsExpr(InvalidExpr);
+}
+
+BoundsExpr *Sema::CreateInvalidBoundsExpr() {
   ExprResult Result =
     ActOnNullaryBoundsExpr(SourceLocation(),
                            NullaryBoundsExpr::Kind::Invalid,
                            SourceLocation());
-
   if (!Result.isInvalid())
-    D->setBoundsExpr(cast<BoundsExpr>(Result.get()));
+    return cast<BoundsExpr>(Result.get());
+  else
+    return nullptr;
 }
 
 Decl *
@@ -11613,7 +11627,9 @@ NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
                                              /*NumExceptions=*/0,
                                              /*NoexceptExpr=*/nullptr,
                                              /*ExceptionSpecTokens=*/nullptr,
-                                             Loc, Loc, D),
+                                             Loc, Loc,
+                                             /*ReturnBoundsColon=*/NoLoc,
+                                             /*ReturnBoundsExpr=*/nullptr, D),
                 DS.getAttributes(),
                 SourceLocation());
   D.SetIdentifier(&II, Loc);
diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp
@@ -718,7 +718,10 @@ static void maybeSynthesizeBlockSignature(TypeProcessingState &state,
       /*NumExceptions=*/0,
       /*NoexceptExpr=*/nullptr,
       /*ExceptionSpecTokens=*/nullptr,
-      loc, loc, declarator));
+      loc, loc,
+      /*ReturnBoundsColon=*/NoLoc,
+      /*ReturnBoundsExpr=*/nullptr,
+      declarator));
 
   // For consistency, make sure the state still has us as processing
   // the decl spec.
@@ -4238,6 +4241,10 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
         SmallVector<QualType, 16> ParamTys;
         ParamTys.reserve(FTI.NumParams);
 
+        // TODO: checkedc-clang issue #20: represent bounds information
+        // in function types.  The code below will need to be updated
+        // to add the bounds information to the FunctionType.
+
         SmallVector<FunctionProtoType::ExtParameterInfo, 16>
           ExtParameterInfos(FTI.NumParams);
         bool HasAnyInterestingExtParameterInfos = false;
