1 /*
2  * Copyright 2010-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 #ifndef _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_EXPORT_TYPE_H_  // NOLINT
18 #define _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_EXPORT_TYPE_H_
19 
20 #include <list>
21 #include <set>
22 #include <string>
23 #include <sstream>
24 
25 #include "clang/AST/Decl.h"
26 #include "clang/AST/Type.h"
27 
28 #include "llvm/ADT/SmallPtrSet.h"
29 #include "llvm/ADT/StringMap.h"
30 #include "llvm/ADT/StringRef.h"
31 
32 #include "llvm/Support/ManagedStatic.h"
33 
34 #include "slang_rs_exportable.h"
35 
36 
GetCanonicalType(const clang::Type * T)37 inline const clang::Type* GetCanonicalType(const clang::Type* T) {
38   if (T == nullptr) {
39     return  nullptr;
40   }
41   return T->getCanonicalTypeInternal().getTypePtr();
42 }
43 
GetCanonicalType(clang::QualType QT)44 inline const clang::Type* GetCanonicalType(clang::QualType QT) {
45   return GetCanonicalType(QT.getTypePtr());
46 }
47 
GetExtVectorElementType(const clang::ExtVectorType * T)48 inline const clang::Type* GetExtVectorElementType(const clang::ExtVectorType *T) {
49   if (T == nullptr) {
50     return nullptr;
51   }
52   return GetCanonicalType(T->getElementType());
53 }
54 
GetPointeeType(const clang::PointerType * T)55 inline const clang::Type* GetPointeeType(const clang::PointerType *T) {
56   if (T == nullptr) {
57     return nullptr;
58   }
59   return GetCanonicalType(T->getPointeeType());
60 }
61 
GetConstantArrayElementType(const clang::ConstantArrayType * T)62 inline const clang::Type* GetConstantArrayElementType(const clang::ConstantArrayType *T) {
63   if (T == nullptr) {
64     return nullptr;
65   }
66   return GetCanonicalType(T->getElementType());
67 }
68 
69 
70 namespace llvm {
71   class Type;
72 }   // namespace llvm
73 
74 namespace slang {
75 
76 class RSContext;
77 
78 // Broad grouping of the data types
79 enum DataTypeCategory {
80     PrimitiveDataType,
81     MatrixDataType,
82     ObjectDataType
83 };
84 
85 // From graphics/java/android/renderscript/Element.java: Element.DataType
86 /* NOTE: The values of the enums are found compiled in the bit code (i.e. as
87  * values, not symbolic.  When adding new types, you must add them to the end.
88  * If removing types, you can't re-use the integer value.
89  *
90  * TODO: but if you do this, you won't be able to keep using First* & Last*
91  * for validation.
92  *
93  * IMPORTANT: This enum should correspond one-for-one to the entries found in the
94  * gReflectionsTypes table (except for the two negative numbers).  Don't edit one without
95  * the other.
96  */
97 enum DataType {
98     DataTypeIsStruct = -2,
99     DataTypeUnknown = -1,
100 
101     DataTypeFloat16 = 0,
102     DataTypeFloat32 = 1,
103     DataTypeFloat64 = 2,
104     DataTypeSigned8 = 3,
105     DataTypeSigned16 = 4,
106     DataTypeSigned32 = 5,
107     DataTypeSigned64 = 6,
108     DataTypeUnsigned8 = 7,
109     DataTypeUnsigned16 = 8,
110     DataTypeUnsigned32 = 9,
111     DataTypeUnsigned64 = 10,
112     DataTypeBoolean = 11,
113     DataTypeUnsigned565 = 12,
114     DataTypeUnsigned5551 = 13,
115     DataTypeUnsigned4444 = 14,
116 
117     DataTypeRSMatrix2x2 = 15,
118     DataTypeRSMatrix3x3 = 16,
119     DataTypeRSMatrix4x4 = 17,
120 
121     DataTypeRSElement = 18,
122     DataTypeRSType = 19,
123     DataTypeRSAllocation = 20,
124     DataTypeRSSampler = 21,
125     DataTypeRSScript = 22,
126     DataTypeRSMesh = 23,
127     DataTypeRSPath = 24,
128     DataTypeRSProgramFragment = 25,
129     DataTypeRSProgramVertex = 26,
130     DataTypeRSProgramRaster = 27,
131     DataTypeRSProgramStore = 28,
132     DataTypeRSFont = 29,
133 
134     // This should always be last and correspond to the size of the gReflectionTypes table.
135     DataTypeMax
136 };
137 
138 typedef struct {
139     DataTypeCategory category;
140     const char * rs_type;
141     const char * rs_short_type;
142     uint32_t size_in_bits;
143     const char * c_name;
144     const char * java_name;
145     const char * rs_c_vector_prefix;
146     const char * rs_java_vector_prefix;
147     bool java_promotion;
148 } RSReflectionType;
149 
150 
151 typedef struct RSReflectionTypeData_rec {
152     const RSReflectionType *type;
153     uint32_t vecSize;
154     bool isPointer;
155     uint32_t arraySize;
156 
157     // Subelements
158     //std::vector<const struct RSReflectionTypeData_rec *> fields;
159     //std::vector< std::string > fieldNames;
160     //std::vector< uint32_t> fieldOffsetBytes;
161 } RSReflectionTypeData;
162 
163 // Make a name for types that are too complicated to create the real names.
164 std::string CreateDummyName(const char *type, const std::string &name);
165 
IsDummyName(const llvm::StringRef & Name)166 inline bool IsDummyName(const llvm::StringRef &Name) {
167   return Name.startswith("<");
168 }
169 
170 class RSExportType : public RSExportable {
171   friend class RSExportElement;
172  public:
173   typedef enum {
174     ExportClassPrimitive,
175     ExportClassPointer,
176     ExportClassVector,
177     ExportClassMatrix,
178     ExportClassConstantArray,
179     ExportClassRecord
180   } ExportClass;
181 
182   void convertToRTD(RSReflectionTypeData *rtd) const;
183 
184  private:
185   ExportClass mClass;
186   std::string mName;
187 
188   // Cache the result after calling convertToLLVMType() at the first time
189   mutable llvm::Type *mLLVMType;
190 
191  protected:
192   RSExportType(RSContext *Context,
193                ExportClass Class,
194                const llvm::StringRef &Name);
195 
196   // Let's make it private since there're some prerequisites to call this
197   // function.
198   //
199   // @T was normalized by calling RSExportType::NormalizeType().
200   // @TypeName was retrieve from RSExportType::GetTypeName() before calling
201   //           this.
202   //
203   static RSExportType *Create(RSContext *Context,
204                               const clang::Type *T,
205                               const llvm::StringRef &TypeName);
206 
207   static llvm::StringRef GetTypeName(const clang::Type *T);
208 
209   // This function convert the RSExportType to LLVM type. Actually, it should be
210   // "convert Clang type to LLVM type." However, clang doesn't make this API
211   // (lib/CodeGen/CodeGenTypes.h) public, we need to do by ourselves.
212   //
213   // Once we can get LLVM type, we can use LLVM to get alignment information,
214   // allocation size of a given type and structure layout that LLVM used
215   // (all of these information are target dependent) without dealing with these
216   // by ourselves.
217   virtual llvm::Type *convertToLLVMType() const = 0;
218   // Record type may recursively reference its type definition. We need a
219   // temporary type setup before the type construction gets done.
setAbstractLLVMType(llvm::Type * LLVMType)220   inline void setAbstractLLVMType(llvm::Type *LLVMType) const {
221     mLLVMType = LLVMType;
222   }
223 
224   virtual ~RSExportType();
225 
226  public:
227   // This function additionally verifies that the Type T is exportable.
228   // If it is not, this function returns false. Otherwise it returns true.
229   static bool NormalizeType(const clang::Type *&T,
230                             llvm::StringRef &TypeName,
231                             RSContext *Context,
232                             const clang::VarDecl *VD);
233 
234   // This function checks whether the specified type can be handled by RS/FS.
235   // If it cannot, this function returns false. Otherwise it returns true.
236   // Filterscript has additional restrictions on supported types.
237   static bool ValidateType(slang::RSContext *Context, clang::ASTContext &C,
238                            clang::QualType QT, clang::NamedDecl *ND,
239                            clang::SourceLocation Loc, unsigned int TargetAPI,
240                            bool IsFilterscript, bool IsExtern);
241 
242   // This function ensures that the VarDecl can be properly handled by RS.
243   // If it cannot, this function returns false. Otherwise it returns true.
244   // Filterscript has additional restrictions on supported types.
245   static bool ValidateVarDecl(slang::RSContext *Context, clang::VarDecl *VD,
246                               unsigned int TargetAPI, bool IsFilterscript);
247 
248   // @T may not be normalized
249   static RSExportType *Create(RSContext *Context, const clang::Type *T);
250   static RSExportType *CreateFromDecl(RSContext *Context,
251                                       const clang::VarDecl *VD);
252 
253   static const clang::Type *GetTypeOfDecl(const clang::DeclaratorDecl *DD);
254 
getClass()255   inline ExportClass getClass() const { return mClass; }
256 
getSize()257   virtual unsigned getSize() const { return 1; }
258 
getLLVMType()259   inline llvm::Type *getLLVMType() const {
260     if (mLLVMType == nullptr)
261       mLLVMType = convertToLLVMType();
262     return mLLVMType;
263   }
264 
265   // Return the maximum number of bytes that may be written when this type is stored.
266   virtual size_t getStoreSize() const;
267 
268   // Return the distance in bytes between successive elements of this type; it includes padding.
269   virtual size_t getAllocSize() const;
270 
getName()271   inline const std::string &getName() const { return mName; }
272 
getElementName()273   virtual std::string getElementName() const {
274     // Base case is actually an invalid C/Java identifier.
275     return "@@INVALID@@";
276   }
277 
278   virtual bool keep();
279   virtual bool equals(const RSExportable *E) const;
280 };  // RSExportType
281 
282 // Primitive types
283 class RSExportPrimitiveType : public RSExportType {
284   friend class RSExportType;
285   friend class RSExportElement;
286  private:
287   DataType mType;
288   bool mNormalized;
289 
290   typedef llvm::StringMap<DataType> RSSpecificTypeMapTy;
291   static llvm::ManagedStatic<RSSpecificTypeMapTy> RSSpecificTypeMap;
292 
293   static const size_t SizeOfDataTypeInBits[];
294   // @T was normalized by calling RSExportType::NormalizeType() before calling
295   // this.
296   // @TypeName was retrieved from RSExportType::GetTypeName() before calling
297   // this
298   static RSExportPrimitiveType *Create(RSContext *Context,
299                                        const clang::Type *T,
300                                        const llvm::StringRef &TypeName,
301                                        bool Normalized = false);
302 
303  protected:
RSExportPrimitiveType(RSContext * Context,ExportClass Class,const llvm::StringRef & Name,DataType DT,bool Normalized)304   RSExportPrimitiveType(RSContext *Context,
305                         // for derived class to set their type class
306                         ExportClass Class,
307                         const llvm::StringRef &Name,
308                         DataType DT,
309                         bool Normalized)
310       : RSExportType(Context, Class, Name),
311         mType(DT),
312         mNormalized(Normalized) {
313   }
314 
315   virtual llvm::Type *convertToLLVMType() const;
316 
317   static DataType GetDataType(RSContext *Context, const clang::Type *T);
318 
319  public:
320   // T is normalized by calling RSExportType::NormalizeType() before
321   // calling this
322   static bool IsPrimitiveType(const clang::Type *T);
323 
324   // @T may not be normalized
325   static RSExportPrimitiveType *Create(RSContext *Context,
326                                        const clang::Type *T);
327 
328   static DataType GetRSSpecificType(const llvm::StringRef &TypeName);
329   static DataType GetRSSpecificType(const clang::Type *T);
330 
331   static bool IsRSMatrixType(DataType DT);
332   static bool IsRSObjectType(DataType DT);
IsRSObjectType(const clang::Type * T)333   static bool IsRSObjectType(const clang::Type *T) {
334     return IsRSObjectType(GetRSSpecificType(T));
335   }
336 
337   // Determines whether T is [an array of] struct that contains at least one
338   // RS object type within it.
339   static bool IsStructureTypeWithRSObject(const clang::Type *T);
340 
341   static size_t GetSizeInBits(const RSExportPrimitiveType *EPT);
342 
getType()343   inline DataType getType() const { return mType; }
isRSObjectType()344   inline bool isRSObjectType() const {
345       return IsRSObjectType(mType);
346   }
347 
348   virtual bool equals(const RSExportable *E) const;
349 
350   static RSReflectionType *getRSReflectionType(DataType DT);
getRSReflectionType(const RSExportPrimitiveType * EPT)351   static RSReflectionType *getRSReflectionType(
352       const RSExportPrimitiveType *EPT) {
353     return getRSReflectionType(EPT->getType());
354   }
355 
getSize()356   virtual unsigned getSize() const { return (GetSizeInBits(this) >> 3); }
357 
getElementName()358   std::string getElementName() const {
359     return getRSReflectionType(this)->rs_short_type;
360   }
361 };  // RSExportPrimitiveType
362 
363 
364 class RSExportPointerType : public RSExportType {
365   friend class RSExportType;
366   friend class RSExportFunc;
367  private:
368   const RSExportType *mPointeeType;
369 
RSExportPointerType(RSContext * Context,const llvm::StringRef & Name,const RSExportType * PointeeType)370   RSExportPointerType(RSContext *Context,
371                       const llvm::StringRef &Name,
372                       const RSExportType *PointeeType)
373       : RSExportType(Context, ExportClassPointer, Name),
374         mPointeeType(PointeeType) {
375   }
376 
377   // @PT was normalized by calling RSExportType::NormalizeType() before calling
378   // this.
379   static RSExportPointerType *Create(RSContext *Context,
380                                      const clang::PointerType *PT,
381                                      const llvm::StringRef &TypeName);
382 
383   virtual llvm::Type *convertToLLVMType() const;
384 
385  public:
386   virtual bool keep();
387 
getPointeeType()388   inline const RSExportType *getPointeeType() const { return mPointeeType; }
389 
390   virtual bool equals(const RSExportable *E) const;
391 };  // RSExportPointerType
392 
393 
394 class RSExportVectorType : public RSExportPrimitiveType {
395   friend class RSExportType;
396   friend class RSExportElement;
397  private:
398   unsigned mNumElement;   // number of element
399 
RSExportVectorType(RSContext * Context,const llvm::StringRef & Name,DataType DT,bool Normalized,unsigned NumElement)400   RSExportVectorType(RSContext *Context,
401                      const llvm::StringRef &Name,
402                      DataType DT,
403                      bool Normalized,
404                      unsigned NumElement)
405       : RSExportPrimitiveType(Context, ExportClassVector, Name,
406                               DT, Normalized),
407         mNumElement(NumElement) {
408   }
409 
410   // @EVT was normalized by calling RSExportType::NormalizeType() before
411   // calling this.
412   static RSExportVectorType *Create(RSContext *Context,
413                                     const clang::ExtVectorType *EVT,
414                                     const llvm::StringRef &TypeName,
415                                     bool Normalized = false);
416 
417   virtual llvm::Type *convertToLLVMType() const;
418 
419  public:
420   static llvm::StringRef GetTypeName(const clang::ExtVectorType *EVT);
421 
getNumElement()422   inline unsigned getNumElement() const { return mNumElement; }
423 
getElementName()424   std::string getElementName() const {
425     std::stringstream Name;
426     Name << RSExportPrimitiveType::getRSReflectionType(this)->rs_short_type
427          << "_" << getNumElement();
428     return Name.str();
429   }
430 
431   virtual bool equals(const RSExportable *E) const;
432 };
433 
434 // Only *square* *float* matrix is supported by now.
435 //
436 // struct rs_matrix{2x2,3x3,4x4, ..., NxN} should be defined as the following
437 // form *exactly*:
438 //  typedef struct {
439 //    float m[{NxN}];
440 //  } rs_matrixNxN;
441 //
442 //  where mDim will be N.
443 class RSExportMatrixType : public RSExportType {
444   friend class RSExportType;
445  private:
446   unsigned mDim;  // dimension
447 
RSExportMatrixType(RSContext * Context,const llvm::StringRef & Name,unsigned Dim)448   RSExportMatrixType(RSContext *Context,
449                      const llvm::StringRef &Name,
450                      unsigned Dim)
451     : RSExportType(Context, ExportClassMatrix, Name),
452       mDim(Dim) {
453   }
454 
455   virtual llvm::Type *convertToLLVMType() const;
456 
457  public:
458   // @RT was normalized by calling RSExportType::NormalizeType() before
459   // calling this.
460   static RSExportMatrixType *Create(RSContext *Context,
461                                     const clang::RecordType *RT,
462                                     const llvm::StringRef &TypeName,
463                                     unsigned Dim);
464 
getDim()465   inline unsigned getDim() const { return mDim; }
466 
467   virtual bool equals(const RSExportable *E) const;
468 };
469 
470 class RSExportConstantArrayType : public RSExportType {
471   friend class RSExportType;
472  private:
473   const RSExportType *mElementType;  // Array element type
474   unsigned mSize;  // Array size
475 
RSExportConstantArrayType(RSContext * Context,const RSExportType * ElementType,unsigned Size)476   RSExportConstantArrayType(RSContext *Context,
477                             const RSExportType *ElementType,
478                             unsigned Size)
479     : RSExportType(Context, ExportClassConstantArray, "<ConstantArray>"),
480       mElementType(ElementType),
481       mSize(Size) {
482   }
483 
484   // @CAT was normalized by calling RSExportType::NormalizeType() before
485   // calling this.
486   static RSExportConstantArrayType *Create(RSContext *Context,
487                                            const clang::ConstantArrayType *CAT);
488 
489   virtual llvm::Type *convertToLLVMType() const;
490 
491  public:
getSize()492   virtual unsigned getSize() const { return mSize; }
getElementType()493   inline const RSExportType *getElementType() const { return mElementType; }
494 
getElementName()495   std::string getElementName() const {
496     return mElementType->getElementName();
497   }
498 
499   virtual bool keep();
500   virtual bool equals(const RSExportable *E) const;
501 };
502 
503 class RSExportRecordType : public RSExportType {
504   friend class RSExportType;
505  public:
506   class Field {
507    private:
508     const RSExportType *mType;
509     // Field name
510     std::string mName;
511     // Link to the struct that contain this field
512     const RSExportRecordType *mParent;
513     // Offset in the container
514     size_t mOffset;
515 
516    public:
Field(const RSExportType * T,const llvm::StringRef & Name,const RSExportRecordType * Parent,size_t Offset)517     Field(const RSExportType *T,
518           const llvm::StringRef &Name,
519           const RSExportRecordType *Parent,
520           size_t Offset)
521         : mType(T),
522           mName(Name.data(), Name.size()),
523           mParent(Parent),
524           mOffset(Offset) {
525     }
526 
getParent()527     inline const RSExportRecordType *getParent() const { return mParent; }
getType()528     inline const RSExportType *getType() const { return mType; }
getName()529     inline const std::string &getName() const { return mName; }
getOffsetInParent()530     inline size_t getOffsetInParent() const { return mOffset; }
531   };
532 
533   typedef std::list<const Field*>::const_iterator const_field_iterator;
534 
fields_begin()535   inline const_field_iterator fields_begin() const {
536     return this->mFields.begin();
537   }
fields_end()538   inline const_field_iterator fields_end() const {
539     return this->mFields.end();
540   }
541 
542  private:
543   std::list<const Field*> mFields;
544   bool mIsPacked;
545   // Artificial export struct type is not exported by user (and thus it won't
546   // get reflected)
547   bool mIsArtificial;
548   size_t mStoreSize;
549   size_t mAllocSize;
550 
RSExportRecordType(RSContext * Context,const llvm::StringRef & Name,bool IsPacked,bool IsArtificial,size_t StoreSize,size_t AllocSize)551   RSExportRecordType(RSContext *Context,
552                      const llvm::StringRef &Name,
553                      bool IsPacked,
554                      bool IsArtificial,
555                      size_t StoreSize,
556                      size_t AllocSize)
557       : RSExportType(Context, ExportClassRecord, Name),
558         mIsPacked(IsPacked),
559         mIsArtificial(IsArtificial),
560         mStoreSize(StoreSize),
561         mAllocSize(AllocSize) {
562   }
563 
564   // @RT was normalized by calling RSExportType::NormalizeType() before calling
565   // this.
566   // @TypeName was retrieved from RSExportType::GetTypeName() before calling
567   // this.
568   static RSExportRecordType *Create(RSContext *Context,
569                                     const clang::RecordType *RT,
570                                     const llvm::StringRef &TypeName,
571                                     bool mIsArtificial = false);
572 
573   virtual llvm::Type *convertToLLVMType() const;
574 
575  public:
getFields()576   inline const std::list<const Field*>& getFields() const { return mFields; }
isPacked()577   inline bool isPacked() const { return mIsPacked; }
isArtificial()578   inline bool isArtificial() const { return mIsArtificial; }
getStoreSize()579   virtual size_t getStoreSize() const { return mStoreSize; }
getAllocSize()580   virtual size_t getAllocSize() const { return mAllocSize; }
581 
getElementName()582   virtual std::string getElementName() const {
583     return "ScriptField_" + getName();
584   }
585 
586   virtual bool keep();
587   virtual bool equals(const RSExportable *E) const;
588 
~RSExportRecordType()589   ~RSExportRecordType() {
590     for (std::list<const Field*>::iterator I = mFields.begin(),
591              E = mFields.end();
592          I != E;
593          I++)
594       if (*I != nullptr)
595         delete *I;
596   }
597 };  // RSExportRecordType
598 
599 }   // namespace slang
600 
601 #endif  // _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_EXPORT_TYPE_H_  NOLINT
602