Home | History | Annotate | Download | only in slang 
      1 /*
      2  * Copyright 2012, The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *     http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "clang/AST/Attr.h"
     18 
     19 #include "slang_rs_check_ast.h"
     20 
     21 #include "slang_assert.h"
     22 #include "slang.h"
     23 #include "slang_rs_export_foreach.h"
     24 #include "slang_rs_export_reduce.h"
     25 #include "slang_rs_export_type.h"
     26 
     27 namespace slang {
     28 
     29 void RSCheckAST::VisitStmt(clang::Stmt *S) {
     30   // This function does the actual iteration through all sub-Stmt's within
     31   // a given Stmt. Note that this function is skipped by all of the other
     32   // Visit* functions if we have already found a higher-level match.
     33   for (clang::Stmt::child_iterator I = S->child_begin(), E = S->child_end();
     34        I != E;
     35        I++) {
     36     if (clang::Stmt *Child = *I) {
     37       Visit(Child);
     38     }
     39   }
     40 }
     41 
     42 void RSCheckAST::WarnOnSetElementAt(clang::CallExpr *E) {
     43   clang::FunctionDecl *Decl;
     44   Decl = clang::dyn_cast_or_null<clang::FunctionDecl>(E->getCalleeDecl());
     45 
     46   if (!Decl || Decl->getNameAsString() != std::string("rsSetElementAt")) {
     47     return;
     48   }
     49 
     50   clang::Expr *Expr;
     51   clang::ImplicitCastExpr *ImplCast;
     52   Expr = E->getArg(1);
     53   ImplCast = clang::dyn_cast_or_null<clang::ImplicitCastExpr>(Expr);
     54 
     55   if (!ImplCast) {
     56     return;
     57   }
     58 
     59   const clang::Type *Ty;
     60   const clang::VectorType *VectorTy;
     61   const clang::BuiltinType *ElementTy;
     62   Ty = ImplCast->getSubExpr()->getType()->getPointeeType()
     63     ->getUnqualifiedDesugaredType();
     64   VectorTy = clang::dyn_cast_or_null<clang::VectorType>(Ty);
     65 
     66   if (VectorTy) {
     67     ElementTy = clang::dyn_cast_or_null<clang::BuiltinType>(
     68       VectorTy->getElementType()->getUnqualifiedDesugaredType());
     69   } else {
     70     ElementTy = clang::dyn_cast_or_null<clang::BuiltinType>(
     71       Ty->getUnqualifiedDesugaredType());
     72   }
     73 
     74   if (!ElementTy) {
     75     return;
     76   }
     77 
     78   // We only support vectors with 2, 3 or 4 elements.
     79   if (VectorTy) {
     80     switch (VectorTy->getNumElements()) {
     81     default:
     82       return;
     83     case 2:
     84     case 3:
     85     case 4:
     86       break;
     87     }
     88   }
     89 
     90   const char *Name;
     91 
     92   switch (ElementTy->getKind()) {
     93     case clang::BuiltinType::Float:
     94       Name = "float";
     95       break;
     96     case clang::BuiltinType::Double:
     97       Name = "double";
     98       break;
     99     case clang::BuiltinType::Char_S:
    100       Name = "char";
    101       break;
    102     case clang::BuiltinType::Short:
    103       Name = "short";
    104       break;
    105     case clang::BuiltinType::Int:
    106       Name = "int";
    107       break;
    108     case clang::BuiltinType::Long:
    109       Name = "long";
    110       break;
    111     case clang::BuiltinType::UChar:
    112       Name = "uchar";
    113       break;
    114     case clang::BuiltinType::UShort:
    115       Name = "ushort";
    116       break;
    117     case clang::BuiltinType::UInt:
    118       Name = "uint";
    119       break;
    120     case clang::BuiltinType::ULong:
    121       Name = "ulong";
    122       break;
    123     default:
    124       return;
    125   }
    126 
    127   clang::DiagnosticBuilder DiagBuilder =
    128       Context->ReportWarning(E->getLocStart(),
    129                              "untyped rsSetElementAt() can reduce performance. "
    130                              "Use rsSetElementAt_%0%1() instead.");
    131   DiagBuilder << Name;
    132 
    133   if (VectorTy) {
    134     DiagBuilder << VectorTy->getNumElements();
    135   } else {
    136     DiagBuilder << "";
    137   }
    138 }
    139 
    140 void RSCheckAST::VisitCallExpr(clang::CallExpr *E) {
    141   WarnOnSetElementAt(E);
    142 
    143   for (clang::CallExpr::arg_iterator AI = E->arg_begin(), AE = E->arg_end();
    144        AI != AE; ++AI) {
    145     Visit(*AI);
    146   }
    147 }
    148 
    149 void RSCheckAST::ValidateFunctionDecl(clang::FunctionDecl *FD) {
    150   if (!FD) {
    151     return;
    152   }
    153 
    154   // Validate that the kernel attribute is not used with static.
    155   if (FD->hasAttr<clang::RenderScriptKernelAttr>() &&
    156       FD->getStorageClass() == clang::SC_Static) {
    157     Context->ReportError(FD->getLocation(),
    158                          "Invalid use of attribute kernel with "
    159                          "static function declaration: %0")
    160       << FD->getName();
    161     mValid = false;
    162   }
    163 
    164   clang::QualType resultType = FD->getReturnType().getCanonicalType();
    165   bool isExtern = (FD->getFormalLinkage() == clang::ExternalLinkage);
    166 
    167   // We use FD as our NamedDecl in the case of a bad return type.
    168   if (!RSExportType::ValidateType(Context, C, resultType, FD,
    169                                   FD->getLocStart(), mTargetAPI,
    170                                   mIsFilterscript, isExtern)) {
    171     mValid = false;
    172   }
    173 
    174   size_t numParams = FD->getNumParams();
    175   for (size_t i = 0; i < numParams; i++) {
    176     clang::ParmVarDecl *PVD = FD->getParamDecl(i);
    177     clang::QualType QT = PVD->getType().getCanonicalType();
    178     if (!RSExportType::ValidateType(Context, C, QT, PVD, PVD->getLocStart(),
    179                                     mTargetAPI, mIsFilterscript, isExtern)) {
    180       mValid = false;
    181     }
    182   }
    183 
    184   bool saveKernel = mInKernel;
    185   mInKernel = RSExportForEach::isRSForEachFunc(mTargetAPI, FD);
    186 
    187   if (clang::Stmt *Body = FD->getBody()) {
    188     Visit(Body);
    189   }
    190 
    191   mInKernel = saveKernel;
    192 }
    193 
    194 
    195 void RSCheckAST::ValidateVarDecl(clang::VarDecl *VD) {
    196   if (!VD || RSContext::isSyntheticName(VD->getName())) {
    197     return;
    198   }
    199 
    200   clang::QualType QT = VD->getType();
    201 
    202   if (VD->getFormalLinkage() == clang::ExternalLinkage) {
    203     llvm::StringRef TypeName;
    204     const clang::Type *T = QT.getTypePtr();
    205     if (!RSExportType::NormalizeType(T, TypeName, Context, VD,
    206                                      NotLegacyKernelArgument)) {
    207       mValid = false;
    208     }
    209   }
    210 
    211   // We don't allow static (non-const) variables within kernels.
    212   if (mInKernel && VD->isStaticLocal()) {
    213     if (!QT.isConstQualified()) {
    214       Context->ReportError(
    215           VD->getLocation(),
    216           "Non-const static variables are not allowed in kernels: '%0'")
    217           << VD->getName();
    218       mValid = false;
    219     }
    220   }
    221 
    222   if (!RSExportType::ValidateVarDecl(Context, VD, mTargetAPI, mIsFilterscript)) {
    223     mValid = false;
    224   } else if (clang::Expr *Init = VD->getInit()) {
    225     // Only check the initializer if the decl is already ok.
    226     Visit(Init);
    227   }
    228 }
    229 
    230 
    231 void RSCheckAST::VisitDeclStmt(clang::DeclStmt *DS) {
    232   if (!Slang::IsLocInRSHeaderFile(DS->getLocStart(), mSM)) {
    233     for (clang::DeclStmt::decl_iterator I = DS->decl_begin(),
    234                                         E = DS->decl_end();
    235          I != E;
    236          ++I) {
    237       if (clang::VarDecl *VD = llvm::dyn_cast<clang::VarDecl>(*I)) {
    238         ValidateVarDecl(VD);
    239       } else if (clang::FunctionDecl *FD =
    240             llvm::dyn_cast<clang::FunctionDecl>(*I)) {
    241         ValidateFunctionDecl(FD);
    242       }
    243     }
    244   }
    245 }
    246 
    247 
    248 void RSCheckAST::VisitCastExpr(clang::CastExpr *CE) {
    249   if (CE->getCastKind() == clang::CK_BitCast) {
    250     clang::QualType QT = CE->getType();
    251     const clang::Type *T = QT.getTypePtr();
    252     if (T->isVectorType()) {
    253       if (llvm::isa<clang::ImplicitCastExpr>(CE)) {
    254         Context->ReportError(CE->getExprLoc(), "invalid implicit vector cast");
    255       } else {
    256         Context->ReportError(CE->getExprLoc(), "invalid vector cast");
    257       }
    258       mValid = false;
    259     }
    260   }
    261   Visit(CE->getSubExpr());
    262 }
    263 
    264 
    265 void RSCheckAST::VisitExpr(clang::Expr *E) {
    266   // This is where FS checks for code using pointer and/or 64-bit expressions
    267   // (i.e. things like casts).
    268 
    269   // First we skip implicit casts (things like function calls and explicit
    270   // array accesses rely heavily on them and they are valid.
    271   E = E->IgnoreImpCasts();
    272 
    273   // Expressions at this point in the checker are not externally visible.
    274   static const bool kIsExtern = false;
    275 
    276   if (mIsFilterscript &&
    277       !Slang::IsLocInRSHeaderFile(E->getExprLoc(), mSM) &&
    278       !RSExportType::ValidateType(Context, C, E->getType(), nullptr, E->getExprLoc(),
    279                                   mTargetAPI, mIsFilterscript, kIsExtern)) {
    280     mValid = false;
    281   } else {
    282     // Only visit sub-expressions if we haven't already seen a violation.
    283     VisitStmt(E);
    284   }
    285 }
    286 
    287 
    288 bool RSCheckAST::Validate() {
    289   clang::TranslationUnitDecl *TUDecl = C.getTranslationUnitDecl();
    290   for (clang::DeclContext::decl_iterator DI = TUDecl->decls_begin(),
    291           DE = TUDecl->decls_end();
    292        DI != DE;
    293        DI++) {
    294 
    295     // Following tests are not applicable to implicitly defined types
    296     if (DI->isImplicit())
    297       continue;
    298 
    299     if (!Slang::IsLocInRSHeaderFile(DI->getLocStart(), mSM)) {
    300       if (clang::VarDecl *VD = llvm::dyn_cast<clang::VarDecl>(*DI)) {
    301         ValidateVarDecl(VD);
    302       } else if (clang::FunctionDecl *FD =
    303             llvm::dyn_cast<clang::FunctionDecl>(*DI)) {
    304         ValidateFunctionDecl(FD);
    305       } else if (clang::Stmt *Body = (*DI)->getBody()) {
    306         Visit(Body);
    307       }
    308     }
    309   }
    310 
    311   return mValid;
    312 }
    313 
    314 }  // namespace slang
    315