slang_rs_export_type.h revision d56a92fc2b1d417ce53d9550548fe1661fa37d40
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 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: 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); 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 343 inline DataType getType() const { return mType; } 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); 351 static RSReflectionType *getRSReflectionType( 352 const RSExportPrimitiveType *EPT) { 353 return getRSReflectionType(EPT->getType()); 354 } 355 356 virtual unsigned getSize() const { return (GetSizeInBits(this) >> 3); } 357 358 std::string getElementName() const { 359 return getRSReflectionType(this)->rs_short_type; 360 } 361}; // RSExportPrimitiveType 362 363 364class RSExportPointerType : public RSExportType { 365 friend class RSExportType; 366 friend class RSExportFunc; 367 private: 368 const RSExportType *mPointeeType; 369 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 388 inline const RSExportType *getPointeeType() const { return mPointeeType; } 389 390 virtual bool equals(const RSExportable *E) const; 391}; // RSExportPointerType 392 393 394class RSExportVectorType : public RSExportPrimitiveType { 395 friend class RSExportType; 396 friend class RSExportElement; 397 private: 398 unsigned mNumElement; // number of element 399 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 422 inline unsigned getNumElement() const { return mNumElement; } 423 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. 443class RSExportMatrixType : public RSExportType { 444 friend class RSExportType; 445 private: 446 unsigned mDim; // dimension 447 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 465 inline unsigned getDim() const { return mDim; } 466 467 virtual bool equals(const RSExportable *E) const; 468}; 469 470class RSExportConstantArrayType : public RSExportType { 471 friend class RSExportType; 472 private: 473 const RSExportType *mElementType; // Array element type 474 unsigned mSize; // Array size 475 476 RSExportConstantArrayType(RSContext *Context, 477 const RSExportType *ElementType, 478 unsigned Size) 479 : RSExportType(Context, 480 ExportClassConstantArray, 481 CreateDummyName("ConstantArray", std::string())), 482 mElementType(ElementType), 483 mSize(Size) { 484 } 485 486 // @CAT was normalized by calling RSExportType::NormalizeType() before 487 // calling this. 488 static RSExportConstantArrayType *Create(RSContext *Context, 489 const clang::ConstantArrayType *CAT); 490 491 virtual llvm::Type *convertToLLVMType() const; 492 493 public: 494 virtual unsigned getSize() const { return mSize; } 495 inline const RSExportType *getElementType() const { return mElementType; } 496 497 std::string getElementName() const { 498 return mElementType->getElementName(); 499 } 500 501 virtual bool keep(); 502 virtual bool equals(const RSExportable *E) const; 503}; 504 505class RSExportRecordType : public RSExportType { 506 friend class RSExportType; 507 public: 508 class Field { 509 private: 510 const RSExportType *mType; 511 // Field name 512 std::string mName; 513 // Link to the struct that contain this field 514 const RSExportRecordType *mParent; 515 // Offset in the container 516 size_t mOffset; 517 518 public: 519 Field(const RSExportType *T, 520 const llvm::StringRef &Name, 521 const RSExportRecordType *Parent, 522 size_t Offset) 523 : mType(T), 524 mName(Name.data(), Name.size()), 525 mParent(Parent), 526 mOffset(Offset) { 527 } 528 529 inline const RSExportRecordType *getParent() const { return mParent; } 530 inline const RSExportType *getType() const { return mType; } 531 inline const std::string &getName() const { return mName; } 532 inline size_t getOffsetInParent() const { return mOffset; } 533 }; 534 535 typedef std::list<const Field*>::const_iterator const_field_iterator; 536 537 inline const_field_iterator fields_begin() const { 538 return this->mFields.begin(); 539 } 540 inline const_field_iterator fields_end() const { 541 return this->mFields.end(); 542 } 543 544 private: 545 std::list<const Field*> mFields; 546 bool mIsPacked; 547 // Artificial export struct type is not exported by user (and thus it won't 548 // get reflected) 549 bool mIsArtificial; 550 size_t mStoreSize; 551 size_t mAllocSize; 552 553 RSExportRecordType(RSContext *Context, 554 const llvm::StringRef &Name, 555 bool IsPacked, 556 bool IsArtificial, 557 size_t StoreSize, 558 size_t AllocSize) 559 : RSExportType(Context, ExportClassRecord, Name), 560 mIsPacked(IsPacked), 561 mIsArtificial(IsArtificial), 562 mStoreSize(StoreSize), 563 mAllocSize(AllocSize) { 564 } 565 566 // @RT was normalized by calling RSExportType::NormalizeType() before calling 567 // this. 568 // @TypeName was retrieved from RSExportType::GetTypeName() before calling 569 // this. 570 static RSExportRecordType *Create(RSContext *Context, 571 const clang::RecordType *RT, 572 const llvm::StringRef &TypeName, 573 bool mIsArtificial = false); 574 575 virtual llvm::Type *convertToLLVMType() const; 576 577 public: 578 inline const std::list<const Field*>& getFields() const { return mFields; } 579 inline bool isPacked() const { return mIsPacked; } 580 inline bool isArtificial() const { return mIsArtificial; } 581 virtual size_t getStoreSize() const { return mStoreSize; } 582 virtual size_t getAllocSize() const { return mAllocSize; } 583 584 virtual std::string getElementName() const { 585 return "ScriptField_" + getName(); 586 } 587 588 virtual bool keep(); 589 virtual bool equals(const RSExportable *E) const; 590 591 ~RSExportRecordType() { 592 for (std::list<const Field*>::iterator I = mFields.begin(), 593 E = mFields.end(); 594 I != E; 595 I++) 596 if (*I != NULL) 597 delete *I; 598 } 599}; // RSExportRecordType 600 601} // namespace slang 602 603#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_EXPORT_TYPE_H_ NOLINT 604