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 
VisitStmt(clang::Stmt * S)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 
WarnOnSetElementAt(clang::CallExpr * E)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 
VisitCallExpr(clang::CallExpr * E)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 
ValidateFunctionDecl(clang::FunctionDecl * FD)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 
ValidateVarDecl(clang::VarDecl * VD)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 
VisitDeclStmt(clang::DeclStmt * DS)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 
VisitCastExpr(clang::CastExpr * CE)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 
VisitExpr(clang::Expr * E)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 
Validate()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