slang_rs_export_type.h revision 796e7b1400d3f3f7c07496d88bb48129ea925bb9
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 37inline const clang::Type* GetCanonicalType(const clang::Type* T) { 38 if (T == NULL) { 39 return NULL; 40 } 41 return T->getCanonicalTypeInternal().getTypePtr(); 42} 43 44inline const clang::Type* GetCanonicalType(clang::QualType QT) { 45 return GetCanonicalType(QT.getTypePtr()); 46} 47 48inline const clang::Type* GetExtVectorElementType(const clang::ExtVectorType *T) { 49 if (T == NULL) { 50 return NULL; 51 } 52 return GetCanonicalType(T->getElementType()); 53} 54 55inline const clang::Type* GetPointeeType(const clang::PointerType *T) { 56 if (T == NULL) { 57 return NULL; 58 } 59 return GetCanonicalType(T->getPointeeType()); 60} 61 62inline const clang::Type* GetConstantArrayElementType(const clang::ConstantArrayType *T) { 63 if (T == NULL) { 64 return NULL; 65 } 66 return GetCanonicalType(T->getElementType()); 67} 68 69 70namespace llvm { 71 class Type; 72} // namespace llvm 73 74namespace slang { 75 76class RSContext; 77 78// Broad grouping of the data types 79enum 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 */ 97enum 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 138typedef 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 151typedef 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. 164std::string CreateDummyName(const char *type, const std::string &name); 165 166inline bool IsDummyName(const llvm::StringRef &Name) { 167 return Name.startswith("<"); 168} 169 170class 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. 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); 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 255 inline ExportClass getClass() const { return mClass; } 256 257 virtual unsigned getSize() const { return 1; } 258 259 inline llvm::Type *getLLVMType() const { 260 if (mLLVMType == NULL) 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 271 inline const std::string &getName() const { return mName; } 272 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 283class 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 llvm::Type *RSObjectLLVMType; 294 295 static const size_t SizeOfDataTypeInBits[]; 296 // @T was normalized by calling RSExportType::NormalizeType() before calling 297 // this. 298 // @TypeName was retrieved from RSExportType::GetTypeName() before calling 299 // this 300 static RSExportPrimitiveType *Create(RSContext *Context, 301 const clang::Type *T, 302 const llvm::StringRef &TypeName, 303 bool Normalized = false); 304 305 protected: 306 RSExportPrimitiveType(RSContext *Context, 307 // for derived class to set their type class 308 ExportClass Class, 309 const llvm::StringRef &Name, 310 DataType DT, 311 bool Normalized) 312 : RSExportType(Context, Class, Name), 313 mType(DT), 314 mNormalized(Normalized) { 315 } 316 317 virtual llvm::Type *convertToLLVMType() const; 318 319 static DataType GetDataType(RSContext *Context, const clang::Type *T); 320 321 public: 322 // T is normalized by calling RSExportType::NormalizeType() before 323 // calling this 324 static bool IsPrimitiveType(const clang::Type *T); 325 326 // @T may not be normalized 327 static RSExportPrimitiveType *Create(RSContext *Context, 328 const clang::Type *T); 329 330 static DataType GetRSSpecificType(const llvm::StringRef &TypeName); 331 static DataType GetRSSpecificType(const clang::Type *T); 332 333 static bool IsRSMatrixType(DataType DT); 334 static bool IsRSObjectType(DataType DT); 335 static bool IsRSObjectType(const clang::Type *T) { 336 return IsRSObjectType(GetRSSpecificType(T)); 337 } 338 339 // Determines whether T is [an array of] struct that contains at least one 340 // RS object type within it. 341 static bool IsStructureTypeWithRSObject(const clang::Type *T); 342 343 static size_t GetSizeInBits(const RSExportPrimitiveType *EPT); 344 345 inline DataType getType() const { return mType; } 346 inline bool isRSObjectType() const { 347 return IsRSObjectType(mType); 348 } 349 350 virtual bool equals(const RSExportable *E) const; 351 352 static RSReflectionType *getRSReflectionType(DataType DT); 353 static RSReflectionType *getRSReflectionType( 354 const RSExportPrimitiveType *EPT) { 355 return getRSReflectionType(EPT->getType()); 356 } 357 358 virtual unsigned getSize() const { return (GetSizeInBits(this) >> 3); } 359 360 std::string getElementName() const { 361 return getRSReflectionType(this)->rs_short_type; 362 } 363}; // RSExportPrimitiveType 364 365 366class RSExportPointerType : public RSExportType { 367 friend class RSExportType; 368 friend class RSExportFunc; 369 private: 370 const RSExportType *mPointeeType; 371 372 RSExportPointerType(RSContext *Context, 373 const llvm::StringRef &Name, 374 const RSExportType *PointeeType) 375 : RSExportType(Context, ExportClassPointer, Name), 376 mPointeeType(PointeeType) { 377 } 378 379 // @PT was normalized by calling RSExportType::NormalizeType() before calling 380 // this. 381 static RSExportPointerType *Create(RSContext *Context, 382 const clang::PointerType *PT, 383 const llvm::StringRef &TypeName); 384 385 virtual llvm::Type *convertToLLVMType() const; 386 387 public: 388 virtual bool keep(); 389 390 inline const RSExportType *getPointeeType() const { return mPointeeType; } 391 392 virtual bool equals(const RSExportable *E) const; 393}; // RSExportPointerType 394 395 396class RSExportVectorType : public RSExportPrimitiveType { 397 friend class RSExportType; 398 friend class RSExportElement; 399 private: 400 unsigned mNumElement; // number of element 401 402 RSExportVectorType(RSContext *Context, 403 const llvm::StringRef &Name, 404 DataType DT, 405 bool Normalized, 406 unsigned NumElement) 407 : RSExportPrimitiveType(Context, ExportClassVector, Name, 408 DT, Normalized), 409 mNumElement(NumElement) { 410 } 411 412 // @EVT was normalized by calling RSExportType::NormalizeType() before 413 // calling this. 414 static RSExportVectorType *Create(RSContext *Context, 415 const clang::ExtVectorType *EVT, 416 const llvm::StringRef &TypeName, 417 bool Normalized = false); 418 419 virtual llvm::Type *convertToLLVMType() const; 420 421 public: 422 static llvm::StringRef GetTypeName(const clang::ExtVectorType *EVT); 423 424 inline unsigned getNumElement() const { return mNumElement; } 425 426 std::string getElementName() const { 427 std::stringstream Name; 428 Name << RSExportPrimitiveType::getRSReflectionType(this)->rs_short_type 429 << "_" << getNumElement(); 430 return Name.str(); 431 } 432 433 virtual bool equals(const RSExportable *E) const; 434}; 435 436// Only *square* *float* matrix is supported by now. 437// 438// struct rs_matrix{2x2,3x3,4x4, ..., NxN} should be defined as the following 439// form *exactly*: 440// typedef struct { 441// float m[{NxN}]; 442// } rs_matrixNxN; 443// 444// where mDim will be N. 445class RSExportMatrixType : public RSExportType { 446 friend class RSExportType; 447 private: 448 unsigned mDim; // dimension 449 450 RSExportMatrixType(RSContext *Context, 451 const llvm::StringRef &Name, 452 unsigned Dim) 453 : RSExportType(Context, ExportClassMatrix, Name), 454 mDim(Dim) { 455 } 456 457 virtual llvm::Type *convertToLLVMType() const; 458 459 public: 460 // @RT was normalized by calling RSExportType::NormalizeType() before 461 // calling this. 462 static RSExportMatrixType *Create(RSContext *Context, 463 const clang::RecordType *RT, 464 const llvm::StringRef &TypeName, 465 unsigned Dim); 466 467 inline unsigned getDim() const { return mDim; } 468 469 virtual bool equals(const RSExportable *E) const; 470}; 471 472class RSExportConstantArrayType : public RSExportType { 473 friend class RSExportType; 474 private: 475 const RSExportType *mElementType; // Array element type 476 unsigned mSize; // Array size 477 478 RSExportConstantArrayType(RSContext *Context, 479 const RSExportType *ElementType, 480 unsigned Size) 481 : RSExportType(Context, 482 ExportClassConstantArray, 483 CreateDummyName("ConstantArray", std::string())), 484 mElementType(ElementType), 485 mSize(Size) { 486 } 487 488 // @CAT was normalized by calling RSExportType::NormalizeType() before 489 // calling this. 490 static RSExportConstantArrayType *Create(RSContext *Context, 491 const clang::ConstantArrayType *CAT); 492 493 virtual llvm::Type *convertToLLVMType() const; 494 495 public: 496 virtual unsigned getSize() const { return mSize; } 497 inline const RSExportType *getElementType() const { return mElementType; } 498 499 std::string getElementName() const { 500 return mElementType->getElementName(); 501 } 502 503 virtual bool keep(); 504 virtual bool equals(const RSExportable *E) const; 505}; 506 507class RSExportRecordType : public RSExportType { 508 friend class RSExportType; 509 public: 510 class Field { 511 private: 512 const RSExportType *mType; 513 // Field name 514 std::string mName; 515 // Link to the struct that contain this field 516 const RSExportRecordType *mParent; 517 // Offset in the container 518 size_t mOffset; 519 520 public: 521 Field(const RSExportType *T, 522 const llvm::StringRef &Name, 523 const RSExportRecordType *Parent, 524 size_t Offset) 525 : mType(T), 526 mName(Name.data(), Name.size()), 527 mParent(Parent), 528 mOffset(Offset) { 529 } 530 531 inline const RSExportRecordType *getParent() const { return mParent; } 532 inline const RSExportType *getType() const { return mType; } 533 inline const std::string &getName() const { return mName; } 534 inline size_t getOffsetInParent() const { return mOffset; } 535 }; 536 537 typedef std::list<const Field*>::const_iterator const_field_iterator; 538 539 inline const_field_iterator fields_begin() const { 540 return this->mFields.begin(); 541 } 542 inline const_field_iterator fields_end() const { 543 return this->mFields.end(); 544 } 545 546 private: 547 std::list<const Field*> mFields; 548 bool mIsPacked; 549 // Artificial export struct type is not exported by user (and thus it won't 550 // get reflected) 551 bool mIsArtificial; 552 size_t mStoreSize; 553 size_t mAllocSize; 554 555 RSExportRecordType(RSContext *Context, 556 const llvm::StringRef &Name, 557 bool IsPacked, 558 bool IsArtificial, 559 size_t StoreSize, 560 size_t AllocSize) 561 : RSExportType(Context, ExportClassRecord, Name), 562 mIsPacked(IsPacked), 563 mIsArtificial(IsArtificial), 564 mStoreSize(StoreSize), 565 mAllocSize(AllocSize) { 566 } 567 568 // @RT was normalized by calling RSExportType::NormalizeType() before calling 569 // this. 570 // @TypeName was retrieved from RSExportType::GetTypeName() before calling 571 // this. 572 static RSExportRecordType *Create(RSContext *Context, 573 const clang::RecordType *RT, 574 const llvm::StringRef &TypeName, 575 bool mIsArtificial = false); 576 577 virtual llvm::Type *convertToLLVMType() const; 578 579 public: 580 inline const std::list<const Field*>& getFields() const { return mFields; } 581 inline bool isPacked() const { return mIsPacked; } 582 inline bool isArtificial() const { return mIsArtificial; } 583 virtual size_t getStoreSize() const { return mStoreSize; } 584 virtual size_t getAllocSize() const { return mAllocSize; } 585 586 virtual std::string getElementName() const { 587 return "ScriptField_" + getName(); 588 } 589 590 virtual bool keep(); 591 virtual bool equals(const RSExportable *E) const; 592 593 ~RSExportRecordType() { 594 for (std::list<const Field*>::iterator I = mFields.begin(), 595 E = mFields.end(); 596 I != E; 597 I++) 598 if (*I != NULL) 599 delete *I; 600 } 601}; // RSExportRecordType 602 603} // namespace slang 604 605#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_EXPORT_TYPE_H_ NOLINT 606