slang_rs_export_type.cpp revision 23c4358f12bd9d0ba7166eceebd683db95a41b3f 
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#include "slang_rs_export_type.h"
18
19#include <list>
20#include <vector>
21
22#include "clang/AST/ASTContext.h"
23#include "clang/AST/Attr.h"
24#include "clang/AST/RecordLayout.h"
25
26#include "llvm/ADT/StringExtras.h"
27#include "llvm/IR/DataLayout.h"
28#include "llvm/IR/DerivedTypes.h"
29#include "llvm/IR/Type.h"
30
31#include "slang_assert.h"
32#include "slang_rs_context.h"
33#include "slang_rs_export_element.h"
34#include "slang_rs_type_spec.h"
35#include "slang_version.h"
36
37#define CHECK_PARENT_EQUALITY(ParentClass, E) \
38  if (!ParentClass::equals(E))                \
39    return false;
40
41namespace slang {
42
43namespace {
44
45static RSReflectionType gReflectionTypes[] = {
46    {"FLOAT_16", "F16", 16, "half", "half", "Half", "Half", false},
47    {"FLOAT_32", "F32", 32, "float", "float", "Float", "Float", false},
48    {"FLOAT_64", "F64", 64, "double", "double", "Double", "Double",false},
49    {"SIGNED_8", "I8", 8, "int8_t", "byte", "Byte", "Byte", false},
50    {"SIGNED_16", "I16", 16, "int16_t", "short", "Short", "Short", false},
51    {"SIGNED_32", "I32", 32, "int32_t", "int", "Int", "Int", false},
52    {"SIGNED_64", "I64", 64, "int64_t", "long", "Long", "Long", false},
53    {"UNSIGNED_8", "U8", 8, "uint8_t", "short", "UByte", "Short", true},
54    {"UNSIGNED_16", "U16", 16, "uint16_t", "int", "UShort", "Int", true},
55    {"UNSIGNED_32", "U32", 32, "uint32_t", "long", "UInt", "Long", true},
56    {"UNSIGNED_64", "U64", 64, "uint64_t", "long", "ULong", "Long", false},
57
58    {"BOOLEAN", "BOOLEAN", 8, "bool", "boolean", NULL, NULL, false},
59
60    {"UNSIGNED_5_6_5", NULL, 16, NULL, NULL, NULL, NULL, false},
61    {"UNSIGNED_5_5_5_1", NULL, 16, NULL, NULL, NULL, NULL, false},
62    {"UNSIGNED_4_4_4_4", NULL, 16, NULL, NULL, NULL, NULL, false},
63
64    {"MATRIX_2X2", NULL, 4*32, "rsMatrix_2x2", "Matrix2f", NULL, NULL, false},
65    {"MATRIX_3X3", NULL, 9*32, "rsMatrix_3x3", "Matrix3f", NULL, NULL, false},
66    {"MATRIX_4X4", NULL, 16*32, "rsMatrix_4x4", "Matrix4f", NULL, NULL, false},
67
68    {"RS_ELEMENT", "ELEMENT", 32, "Element", "Element", NULL, NULL, false},
69    {"RS_TYPE", "TYPE", 32, "Type", "Type", NULL, NULL, false},
70    {"RS_ALLOCATION", "ALLOCATION", 32, "Allocation", "Allocation", NULL, NULL, false},
71    {"RS_SAMPLER", "SAMPLER", 32, "Sampler", "Sampler", NULL, NULL, false},
72    {"RS_SCRIPT", "SCRIPT", 32, "Script", "Script", NULL, NULL, false},
73    {"RS_MESH", "MESH", 32, "Mesh", "Mesh", NULL, NULL, false},
74    {"RS_PATH", "PATH", 32, "Path", "Path", NULL, NULL, false},
75    {"RS_PROGRAM_FRAGMENT", "PROGRAM_FRAGMENT", 32, "ProgramFragment", "ProgramFragment", NULL, NULL, false},
76    {"RS_PROGRAM_VERTEX", "PROGRAM_VERTEX", 32, "ProgramVertex", "ProgramVertex", NULL, NULL, false},
77    {"RS_PROGRAM_RASTER", "PROGRAM_RASTER", 32, "ProgramRaster", "ProgramRaster", NULL, NULL, false},
78    {"RS_PROGRAM_STORE", "PROGRAM_STORE", 32, "ProgramStore", "ProgramStore", NULL, NULL, false},
79    {"RS_FONT", "FONT", 32, "Font", "Font", NULL, NULL, false}
80};
81
82static const clang::Type *TypeExportableHelper(
83    const clang::Type *T,
84    llvm::SmallPtrSet<const clang::Type*, 8>& SPS,
85    clang::DiagnosticsEngine *DiagEngine,
86    const clang::VarDecl *VD,
87    const clang::RecordDecl *TopLevelRecord);
88
89static void ReportTypeError(clang::DiagnosticsEngine *DiagEngine,
90                            const clang::NamedDecl *ND,
91                            const clang::RecordDecl *TopLevelRecord,
92                            const char *Message,
93                            unsigned int TargetAPI = 0) {
94  if (!DiagEngine) {
95    return;
96  }
97
98  const clang::SourceManager &SM = DiagEngine->getSourceManager();
99
100  // Attempt to use the type declaration first (if we have one).
101  // Fall back to the variable definition, if we are looking at something
102  // like an array declaration that can't be exported.
103  if (TopLevelRecord) {
104    DiagEngine->Report(
105      clang::FullSourceLoc(TopLevelRecord->getLocation(), SM),
106      DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error, Message))
107      << TopLevelRecord->getName() << TargetAPI;
108  } else if (ND) {
109    DiagEngine->Report(
110      clang::FullSourceLoc(ND->getLocation(), SM),
111      DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error, Message))
112      << ND->getName() << TargetAPI;
113  } else {
114    slangAssert(false && "Variables should be validated before exporting");
115  }
116}
117
118static const clang::Type *ConstantArrayTypeExportableHelper(
119    const clang::ConstantArrayType *CAT,
120    llvm::SmallPtrSet<const clang::Type*, 8>& SPS,
121    clang::DiagnosticsEngine *DiagEngine,
122    const clang::VarDecl *VD,
123    const clang::RecordDecl *TopLevelRecord) {
124  // Check element type
125  const clang::Type *ElementType = GET_CONSTANT_ARRAY_ELEMENT_TYPE(CAT);
126  if (ElementType->isArrayType()) {
127    ReportTypeError(DiagEngine, VD, TopLevelRecord,
128                    "multidimensional arrays cannot be exported: '%0'");
129    return NULL;
130  } else if (ElementType->isExtVectorType()) {
131    const clang::ExtVectorType *EVT =
132        static_cast<const clang::ExtVectorType*>(ElementType);
133    unsigned numElements = EVT->getNumElements();
134
135    const clang::Type *BaseElementType = GET_EXT_VECTOR_ELEMENT_TYPE(EVT);
136    if (!RSExportPrimitiveType::IsPrimitiveType(BaseElementType)) {
137      ReportTypeError(DiagEngine, VD, TopLevelRecord,
138        "vectors of non-primitive types cannot be exported: '%0'");
139      return NULL;
140    }
141
142    if (numElements == 3 && CAT->getSize() != 1) {
143      ReportTypeError(DiagEngine, VD, TopLevelRecord,
144        "arrays of width 3 vector types cannot be exported: '%0'");
145      return NULL;
146    }
147  }
148
149  if (TypeExportableHelper(ElementType, SPS, DiagEngine, VD,
150                           TopLevelRecord) == NULL) {
151    return NULL;
152  } else {
153    return CAT;
154  }
155}
156
157static const clang::Type *TypeExportableHelper(
158    clang::Type const *T,
159    llvm::SmallPtrSet<clang::Type const *, 8> &SPS,
160    clang::DiagnosticsEngine *DiagEngine,
161    clang::VarDecl const *VD,
162    clang::RecordDecl const *TopLevelRecord) {
163  // Normalize first
164  if ((T = GET_CANONICAL_TYPE(T)) == NULL)
165    return NULL;
166
167  if (SPS.count(T))
168    return T;
169
170  switch (T->getTypeClass()) {
171    case clang::Type::Builtin: {
172      const clang::BuiltinType *BT =
173        UNSAFE_CAST_TYPE(const clang::BuiltinType, T);
174
175      switch (BT->getKind()) {
176#define ENUM_SUPPORT_BUILTIN_TYPE(builtin_type, type, cname)  \
177        case builtin_type:
178#include "RSClangBuiltinEnums.inc"
179          return T;
180        default: {
181          return NULL;
182        }
183      }
184    }
185    case clang::Type::Record: {
186      if (RSExportPrimitiveType::GetRSSpecificType(T) !=
187          RSExportPrimitiveType::DataTypeUnknown) {
188        return T;  // RS object type, no further checks are needed
189      }
190
191      // Check internal struct
192      if (T->isUnionType()) {
193        ReportTypeError(DiagEngine, VD, T->getAsUnionType()->getDecl(),
194                        "unions cannot be exported: '%0'");
195        return NULL;
196      } else if (!T->isStructureType()) {
197        slangAssert(false && "Unknown type cannot be exported");
198        return NULL;
199      }
200
201      clang::RecordDecl *RD = T->getAsStructureType()->getDecl();
202      if (RD != NULL) {
203        RD = RD->getDefinition();
204        if (RD == NULL) {
205          ReportTypeError(DiagEngine, NULL, T->getAsStructureType()->getDecl(),
206                          "struct is not defined in this module");
207          return NULL;
208        }
209      }
210
211      if (!TopLevelRecord) {
212        TopLevelRecord = RD;
213      }
214      if (RD->getName().empty()) {
215        ReportTypeError(DiagEngine, NULL, RD,
216                        "anonymous structures cannot be exported");
217        return NULL;
218      }
219
220      // Fast check
221      if (RD->hasFlexibleArrayMember() || RD->hasObjectMember())
222        return NULL;
223
224      // Insert myself into checking set
225      SPS.insert(T);
226
227      // Check all element
228      for (clang::RecordDecl::field_iterator FI = RD->field_begin(),
229               FE = RD->field_end();
230           FI != FE;
231           FI++) {
232        const clang::FieldDecl *FD = *FI;
233        const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
234        FT = GET_CANONICAL_TYPE(FT);
235
236        if (!TypeExportableHelper(FT, SPS, DiagEngine, VD, TopLevelRecord)) {
237          return NULL;
238        }
239
240        // We don't support bit fields yet
241        //
242        // TODO(zonr/srhines): allow bit fields of size 8, 16, 32
243        if (FD->isBitField()) {
244          if (DiagEngine) {
245            DiagEngine->Report(
246              clang::FullSourceLoc(FD->getLocation(),
247                                   DiagEngine->getSourceManager()),
248              DiagEngine->getCustomDiagID(
249                clang::DiagnosticsEngine::Error,
250                "bit fields are not able to be exported: '%0.%1'"))
251              << RD->getName()
252              << FD->getName();
253          }
254          return NULL;
255        }
256      }
257
258      return T;
259    }
260    case clang::Type::Pointer: {
261      if (TopLevelRecord) {
262        ReportTypeError(DiagEngine, VD, TopLevelRecord,
263            "structures containing pointers cannot be exported: '%0'");
264        return NULL;
265      }
266
267      const clang::PointerType *PT =
268        UNSAFE_CAST_TYPE(const clang::PointerType, T);
269      const clang::Type *PointeeType = GET_POINTEE_TYPE(PT);
270
271      if (PointeeType->getTypeClass() == clang::Type::Pointer) {
272        ReportTypeError(DiagEngine, VD, TopLevelRecord,
273            "multiple levels of pointers cannot be exported: '%0'");
274        return NULL;
275      }
276      // We don't support pointer with array-type pointee or unsupported pointee
277      // type
278      if (PointeeType->isArrayType() ||
279          (TypeExportableHelper(PointeeType, SPS, DiagEngine, VD,
280                                TopLevelRecord) == NULL))
281        return NULL;
282      else
283        return T;
284    }
285    case clang::Type::ExtVector: {
286      const clang::ExtVectorType *EVT =
287          UNSAFE_CAST_TYPE(const clang::ExtVectorType, T);
288      // Only vector with size 2, 3 and 4 are supported.
289      if (EVT->getNumElements() < 2 || EVT->getNumElements() > 4)
290        return NULL;
291
292      // Check base element type
293      const clang::Type *ElementType = GET_EXT_VECTOR_ELEMENT_TYPE(EVT);
294
295      if ((ElementType->getTypeClass() != clang::Type::Builtin) ||
296          (TypeExportableHelper(ElementType, SPS, DiagEngine, VD,
297                                TopLevelRecord) == NULL))
298        return NULL;
299      else
300        return T;
301    }
302    case clang::Type::ConstantArray: {
303      const clang::ConstantArrayType *CAT =
304          UNSAFE_CAST_TYPE(const clang::ConstantArrayType, T);
305
306      return ConstantArrayTypeExportableHelper(CAT, SPS, DiagEngine, VD,
307                                               TopLevelRecord);
308    }
309    default: {
310      return NULL;
311    }
312  }
313}
314
315// Return the type that can be used to create RSExportType, will always return
316// the canonical type
317// If the Type T is not exportable, this function returns NULL. DiagEngine is
318// used to generate proper Clang diagnostic messages when a
319// non-exportable type is detected. TopLevelRecord is used to capture the
320// highest struct (in the case of a nested hierarchy) for detecting other
321// types that cannot be exported (mostly pointers within a struct).
322static const clang::Type *TypeExportable(const clang::Type *T,
323                                         clang::DiagnosticsEngine *DiagEngine,
324                                         const clang::VarDecl *VD) {
325  llvm::SmallPtrSet<const clang::Type*, 8> SPS =
326      llvm::SmallPtrSet<const clang::Type*, 8>();
327
328  return TypeExportableHelper(T, SPS, DiagEngine, VD, NULL);
329}
330
331static bool ValidateRSObjectInVarDecl(clang::VarDecl *VD,
332                                      bool InCompositeType,
333                                      unsigned int TargetAPI) {
334  if (TargetAPI < SLANG_JB_TARGET_API) {
335    // Only if we are already in a composite type (like an array or structure).
336    if (InCompositeType) {
337      // Only if we are actually exported (i.e. non-static).
338      if (VD->hasLinkage() && (VD->getLinkage() == clang::ExternalLinkage)) {
339        // Only if we are not a pointer to an object.
340        const clang::Type *T = GET_CANONICAL_TYPE(VD->getType().getTypePtr());
341        if (T->getTypeClass() != clang::Type::Pointer) {
342          clang::ASTContext &C = VD->getASTContext();
343          ReportTypeError(&C.getDiagnostics(), VD, NULL,
344                          "arrays/structures containing RS object types "
345                          "cannot be exported in target API < %1: '%0'",
346                          SLANG_JB_TARGET_API);
347          return false;
348        }
349      }
350    }
351  }
352
353  return true;
354}
355
356// Helper function for ValidateType(). We do a recursive descent on the
357// type hierarchy to ensure that we can properly export/handle the
358// declaration.
359// \return true if the variable declaration is valid,
360//         false if it is invalid (along with proper diagnostics).
361//
362// C - ASTContext (for diagnostics + builtin types).
363// T - sub-type that we are validating.
364// ND - (optional) top-level named declaration that we are validating.
365// SPS - set of types we have already seen/validated.
366// InCompositeType - true if we are within an outer composite type.
367// UnionDecl - set if we are in a sub-type of a union.
368// TargetAPI - target SDK API level.
369// IsFilterscript - whether or not we are compiling for Filterscript
370static bool ValidateTypeHelper(
371    clang::ASTContext &C,
372    const clang::Type *&T,
373    clang::NamedDecl *ND,
374    clang::SourceLocation Loc,
375    llvm::SmallPtrSet<const clang::Type*, 8>& SPS,
376    bool InCompositeType,
377    clang::RecordDecl *UnionDecl,
378    unsigned int TargetAPI,
379    bool IsFilterscript) {
380  if ((T = GET_CANONICAL_TYPE(T)) == NULL)
381    return true;
382
383  if (SPS.count(T))
384    return true;
385
386  switch (T->getTypeClass()) {
387    case clang::Type::Record: {
388      if (RSExportPrimitiveType::IsRSObjectType(T)) {
389        clang::VarDecl *VD = (ND ? llvm::dyn_cast<clang::VarDecl>(ND) : NULL);
390        if (VD && !ValidateRSObjectInVarDecl(VD, InCompositeType, TargetAPI)) {
391          return false;
392        }
393      }
394
395      if (RSExportPrimitiveType::GetRSSpecificType(T) !=
396          RSExportPrimitiveType::DataTypeUnknown) {
397        if (!UnionDecl) {
398          return true;
399        } else if (RSExportPrimitiveType::IsRSObjectType(T)) {
400          ReportTypeError(&C.getDiagnostics(), NULL, UnionDecl,
401              "unions containing RS object types are not allowed");
402          return false;
403        }
404      }
405
406      clang::RecordDecl *RD = NULL;
407
408      // Check internal struct
409      if (T->isUnionType()) {
410        RD = T->getAsUnionType()->getDecl();
411        UnionDecl = RD;
412      } else if (T->isStructureType()) {
413        RD = T->getAsStructureType()->getDecl();
414      } else {
415        slangAssert(false && "Unknown type cannot be exported");
416        return false;
417      }
418
419      if (RD != NULL) {
420        RD = RD->getDefinition();
421        if (RD == NULL) {
422          // FIXME
423          return true;
424        }
425      }
426
427      // Fast check
428      if (RD->hasFlexibleArrayMember() || RD->hasObjectMember())
429        return false;
430
431      // Insert myself into checking set
432      SPS.insert(T);
433
434      // Check all elements
435      for (clang::RecordDecl::field_iterator FI = RD->field_begin(),
436               FE = RD->field_end();
437           FI != FE;
438           FI++) {
439        const clang::FieldDecl *FD = *FI;
440        const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
441        FT = GET_CANONICAL_TYPE(FT);
442
443        if (!ValidateTypeHelper(C, FT, ND, Loc, SPS, true, UnionDecl,
444                                TargetAPI, IsFilterscript)) {
445          return false;
446        }
447      }
448
449      return true;
450    }
451
452    case clang::Type::Builtin: {
453      if (IsFilterscript) {
454        clang::QualType QT = T->getCanonicalTypeInternal();
455        if (QT == C.DoubleTy ||
456            QT == C.LongDoubleTy ||
457            QT == C.LongTy ||
458            QT == C.LongLongTy) {
459          clang::DiagnosticsEngine &DiagEngine = C.getDiagnostics();
460          if (ND) {
461            DiagEngine.Report(
462              clang::FullSourceLoc(Loc, C.getSourceManager()),
463              DiagEngine.getCustomDiagID(
464                clang::DiagnosticsEngine::Error,
465                "Builtin types > 32 bits in size are forbidden in "
466                "Filterscript: '%0'")) << ND->getName();
467          } else {
468            DiagEngine.Report(
469              clang::FullSourceLoc(Loc, C.getSourceManager()),
470              DiagEngine.getCustomDiagID(
471                clang::DiagnosticsEngine::Error,
472                "Builtin types > 32 bits in size are forbidden in "
473                "Filterscript"));
474          }
475          return false;
476        }
477      }
478      break;
479    }
480
481    case clang::Type::Pointer: {
482      if (IsFilterscript) {
483        if (ND) {
484          clang::DiagnosticsEngine &DiagEngine = C.getDiagnostics();
485          DiagEngine.Report(
486            clang::FullSourceLoc(Loc, C.getSourceManager()),
487            DiagEngine.getCustomDiagID(
488              clang::DiagnosticsEngine::Error,
489              "Pointers are forbidden in Filterscript: '%0'")) << ND->getName();
490          return false;
491        } else {
492          // TODO(srhines): Find a better way to handle expressions (i.e. no
493          // NamedDecl) involving pointers in FS that should be allowed.
494          // An example would be calls to library functions like
495          // rsMatrixMultiply() that take rs_matrixNxN * types.
496        }
497      }
498
499      const clang::PointerType *PT =
500        UNSAFE_CAST_TYPE(const clang::PointerType, T);
501      const clang::Type *PointeeType = GET_POINTEE_TYPE(PT);
502
503      return ValidateTypeHelper(C, PointeeType, ND, Loc, SPS, InCompositeType,
504                                UnionDecl, TargetAPI, IsFilterscript);
505    }
506
507    case clang::Type::ExtVector: {
508      const clang::ExtVectorType *EVT =
509          UNSAFE_CAST_TYPE(const clang::ExtVectorType, T);
510      const clang::Type *ElementType = GET_EXT_VECTOR_ELEMENT_TYPE(EVT);
511      if (TargetAPI < SLANG_ICS_TARGET_API &&
512          InCompositeType &&
513          EVT->getNumElements() == 3 &&
514          ND &&
515          ND->getLinkage() == clang::ExternalLinkage) {
516        ReportTypeError(&C.getDiagnostics(), ND, NULL,
517                        "structs containing vectors of dimension 3 cannot "
518                        "be exported at this API level: '%0'");
519        return false;
520      }
521      return ValidateTypeHelper(C, ElementType, ND, Loc, SPS, true, UnionDecl,
522                                TargetAPI, IsFilterscript);
523    }
524
525    case clang::Type::ConstantArray: {
526      const clang::ConstantArrayType *CAT =
527          UNSAFE_CAST_TYPE(const clang::ConstantArrayType, T);
528      const clang::Type *ElementType = GET_CONSTANT_ARRAY_ELEMENT_TYPE(CAT);
529      return ValidateTypeHelper(C, ElementType, ND, Loc, SPS, true, UnionDecl,
530                                TargetAPI, IsFilterscript);
531    }
532
533    default: {
534      break;
535    }
536  }
537
538  return true;
539}
540
541}  // namespace
542
543/****************************** RSExportType ******************************/
544bool RSExportType::NormalizeType(const clang::Type *&T,
545                                 llvm::StringRef &TypeName,
546                                 clang::DiagnosticsEngine *DiagEngine,
547                                 const clang::VarDecl *VD) {
548  if ((T = TypeExportable(T, DiagEngine, VD)) == NULL) {
549    return false;
550  }
551  // Get type name
552  TypeName = RSExportType::GetTypeName(T);
553  if (TypeName.empty()) {
554    if (DiagEngine) {
555      if (VD) {
556        DiagEngine->Report(
557          clang::FullSourceLoc(VD->getLocation(),
558                               DiagEngine->getSourceManager()),
559          DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
560                                      "anonymous types cannot be exported"));
561      } else {
562        DiagEngine->Report(
563          DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
564                                      "anonymous types cannot be exported"));
565      }
566    }
567    return false;
568  }
569
570  return true;
571}
572
573bool RSExportType::ValidateType(clang::ASTContext &C, clang::QualType QT,
574    clang::NamedDecl *ND, clang::SourceLocation Loc, unsigned int TargetAPI,
575    bool IsFilterscript) {
576  const clang::Type *T = QT.getTypePtr();
577  llvm::SmallPtrSet<const clang::Type*, 8> SPS =
578      llvm::SmallPtrSet<const clang::Type*, 8>();
579
580  return ValidateTypeHelper(C, T, ND, Loc, SPS, false, NULL, TargetAPI,
581                            IsFilterscript);
582  return true;
583}
584
585bool RSExportType::ValidateVarDecl(clang::VarDecl *VD, unsigned int TargetAPI,
586                                   bool IsFilterscript) {
587  return ValidateType(VD->getASTContext(), VD->getType(), VD,
588                      VD->getLocation(), TargetAPI, IsFilterscript);
589}
590
591const clang::Type
592*RSExportType::GetTypeOfDecl(const clang::DeclaratorDecl *DD) {
593  if (DD) {
594    clang::QualType T;
595    if (DD->getTypeSourceInfo())
596      T = DD->getTypeSourceInfo()->getType();
597    else
598      T = DD->getType();
599
600    if (T.isNull())
601      return NULL;
602    else
603      return T.getTypePtr();
604  }
605  return NULL;
606}
607
608llvm::StringRef RSExportType::GetTypeName(const clang::Type* T) {
609  T = GET_CANONICAL_TYPE(T);
610  if (T == NULL)
611    return llvm::StringRef();
612
613  switch (T->getTypeClass()) {
614    case clang::Type::Builtin: {
615      const clang::BuiltinType *BT =
616        UNSAFE_CAST_TYPE(const clang::BuiltinType, T);
617
618      switch (BT->getKind()) {
619#define ENUM_SUPPORT_BUILTIN_TYPE(builtin_type, type, cname)  \
620        case builtin_type:                                    \
621          return cname;                                       \
622        break;
623#include "RSClangBuiltinEnums.inc"
624        default: {
625          slangAssert(false && "Unknown data type of the builtin");
626          break;
627        }
628      }
629      break;
630    }
631    case clang::Type::Record: {
632      clang::RecordDecl *RD;
633      if (T->isStructureType()) {
634        RD = T->getAsStructureType()->getDecl();
635      } else {
636        break;
637      }
638
639      llvm::StringRef Name = RD->getName();
640      if (Name.empty()) {
641        if (RD->getTypedefNameForAnonDecl() != NULL) {
642          Name = RD->getTypedefNameForAnonDecl()->getName();
643        }
644
645        if (Name.empty()) {
646          // Try to find a name from redeclaration (i.e. typedef)
647          for (clang::TagDecl::redecl_iterator RI = RD->redecls_begin(),
648                   RE = RD->redecls_end();
649               RI != RE;
650               RI++) {
651            slangAssert(*RI != NULL && "cannot be NULL object");
652
653            Name = (*RI)->getName();
654            if (!Name.empty())
655              break;
656          }
657        }
658      }
659      return Name;
660    }
661    case clang::Type::Pointer: {
662      // "*" plus pointee name
663      const clang::Type *PT = GET_POINTEE_TYPE(T);
664      llvm::StringRef PointeeName;
665      if (NormalizeType(PT, PointeeName, NULL, NULL)) {
666        char *Name = new char[ 1 /* * */ + PointeeName.size() + 1 ];
667        Name[0] = '*';
668        memcpy(Name + 1, PointeeName.data(), PointeeName.size());
669        Name[PointeeName.size() + 1] = '\0';
670        return Name;
671      }
672      break;
673    }
674    case clang::Type::ExtVector: {
675      const clang::ExtVectorType *EVT =
676          UNSAFE_CAST_TYPE(const clang::ExtVectorType, T);
677      return RSExportVectorType::GetTypeName(EVT);
678      break;
679    }
680    case clang::Type::ConstantArray : {
681      // Construct name for a constant array is too complicated.
682      return DUMMY_TYPE_NAME_FOR_RS_CONSTANT_ARRAY_TYPE;
683    }
684    default: {
685      break;
686    }
687  }
688
689  return llvm::StringRef();
690}
691
692
693RSExportType *RSExportType::Create(RSContext *Context,
694                                   const clang::Type *T,
695                                   const llvm::StringRef &TypeName) {
696  // Lookup the context to see whether the type was processed before.
697  // Newly created RSExportType will insert into context
698  // in RSExportType::RSExportType()
699  RSContext::export_type_iterator ETI = Context->findExportType(TypeName);
700
701  if (ETI != Context->export_types_end())
702    return ETI->second;
703
704  RSExportType *ET = NULL;
705  switch (T->getTypeClass()) {
706    case clang::Type::Record: {
707      RSExportPrimitiveType::DataType dt =
708          RSExportPrimitiveType::GetRSSpecificType(TypeName);
709      switch (dt) {
710        case RSExportPrimitiveType::DataTypeUnknown: {
711          // User-defined types
712          ET = RSExportRecordType::Create(Context,
713                                          T->getAsStructureType(),
714                                          TypeName);
715          break;
716        }
717        case RSExportPrimitiveType::DataTypeRSMatrix2x2: {
718          // 2 x 2 Matrix type
719          ET = RSExportMatrixType::Create(Context,
720                                          T->getAsStructureType(),
721                                          TypeName,
722                                          2);
723          break;
724        }
725        case RSExportPrimitiveType::DataTypeRSMatrix3x3: {
726          // 3 x 3 Matrix type
727          ET = RSExportMatrixType::Create(Context,
728                                          T->getAsStructureType(),
729                                          TypeName,
730                                          3);
731          break;
732        }
733        case RSExportPrimitiveType::DataTypeRSMatrix4x4: {
734          // 4 x 4 Matrix type
735          ET = RSExportMatrixType::Create(Context,
736                                          T->getAsStructureType(),
737                                          TypeName,
738                                          4);
739          break;
740        }
741        default: {
742          // Others are primitive types
743          ET = RSExportPrimitiveType::Create(Context, T, TypeName);
744          break;
745        }
746      }
747      break;
748    }
749    case clang::Type::Builtin: {
750      ET = RSExportPrimitiveType::Create(Context, T, TypeName);
751      break;
752    }
753    case clang::Type::Pointer: {
754      ET = RSExportPointerType::Create(Context,
755               UNSAFE_CAST_TYPE(const clang::PointerType, T), TypeName);
756      // FIXME: free the name (allocated in RSExportType::GetTypeName)
757      delete [] TypeName.data();
758      break;
759    }
760    case clang::Type::ExtVector: {
761      ET = RSExportVectorType::Create(Context,
762               UNSAFE_CAST_TYPE(const clang::ExtVectorType, T), TypeName);
763      break;
764    }
765    case clang::Type::ConstantArray: {
766      ET = RSExportConstantArrayType::Create(
767              Context,
768              UNSAFE_CAST_TYPE(const clang::ConstantArrayType, T));
769      break;
770    }
771    default: {
772      clang::DiagnosticsEngine *DiagEngine = Context->getDiagnostics();
773      DiagEngine->Report(
774        DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
775                                    "unknown type cannot be exported: '%0'"))
776        << T->getTypeClassName();
777      break;
778    }
779  }
780
781  return ET;
782}
783
784RSExportType *RSExportType::Create(RSContext *Context, const clang::Type *T) {
785  llvm::StringRef TypeName;
786  if (NormalizeType(T, TypeName, Context->getDiagnostics(), NULL)) {
787    return Create(Context, T, TypeName);
788  } else {
789    return NULL;
790  }
791}
792
793RSExportType *RSExportType::CreateFromDecl(RSContext *Context,
794                                           const clang::VarDecl *VD) {
795  return RSExportType::Create(Context, GetTypeOfDecl(VD));
796}
797
798size_t RSExportType::GetTypeStoreSize(const RSExportType *ET) {
799  return ET->getRSContext()->getDataLayout()->getTypeStoreSize(
800      ET->getLLVMType());
801}
802
803size_t RSExportType::GetTypeAllocSize(const RSExportType *ET) {
804  if (ET->getClass() == RSExportType::ExportClassRecord)
805    return static_cast<const RSExportRecordType*>(ET)->getAllocSize();
806  else
807    return ET->getRSContext()->getDataLayout()->getTypeAllocSize(
808        ET->getLLVMType());
809}
810
811RSExportType::RSExportType(RSContext *Context,
812                           ExportClass Class,
813                           const llvm::StringRef &Name)
814    : RSExportable(Context, RSExportable::EX_TYPE),
815      mClass(Class),
816      // Make a copy on Name since memory stored @Name is either allocated in
817      // ASTContext or allocated in GetTypeName which will be destroyed later.
818      mName(Name.data(), Name.size()),
819      mLLVMType(NULL),
820      mSpecType(NULL) {
821  // Don't cache the type whose name start with '<'. Those type failed to
822  // get their name since constructing their name in GetTypeName() requiring
823  // complicated work.
824  if (!Name.startswith(DUMMY_RS_TYPE_NAME_PREFIX))
825    // TODO(zonr): Need to check whether the insertion is successful or not.
826    Context->insertExportType(llvm::StringRef(Name), this);
827  return;
828}
829
830bool RSExportType::keep() {
831  if (!RSExportable::keep())
832    return false;
833  // Invalidate converted LLVM type.
834  mLLVMType = NULL;
835  return true;
836}
837
838bool RSExportType::equals(const RSExportable *E) const {
839  CHECK_PARENT_EQUALITY(RSExportable, E);
840  return (static_cast<const RSExportType*>(E)->getClass() == getClass());
841}
842
843RSExportType::~RSExportType() {
844  delete mSpecType;
845}
846
847/************************** RSExportPrimitiveType **************************/
848llvm::ManagedStatic<RSExportPrimitiveType::RSSpecificTypeMapTy>
849RSExportPrimitiveType::RSSpecificTypeMap;
850
851llvm::Type *RSExportPrimitiveType::RSObjectLLVMType = NULL;
852
853bool RSExportPrimitiveType::IsPrimitiveType(const clang::Type *T) {
854  if ((T != NULL) && (T->getTypeClass() == clang::Type::Builtin))
855    return true;
856  else
857    return false;
858}
859
860RSExportPrimitiveType::DataType
861RSExportPrimitiveType::GetRSSpecificType(const llvm::StringRef &TypeName) {
862  if (TypeName.empty())
863    return DataTypeUnknown;
864
865  if (RSSpecificTypeMap->empty()) {
866#define ENUM_RS_MATRIX_TYPE(type, cname, dim)                       \
867    RSSpecificTypeMap->GetOrCreateValue(cname, DataType ## type);
868#include "RSMatrixTypeEnums.inc"
869#define ENUM_RS_OBJECT_TYPE(type, cname)                            \
870    RSSpecificTypeMap->GetOrCreateValue(cname, DataType ## type);
871#include "RSObjectTypeEnums.inc"
872  }
873
874  RSSpecificTypeMapTy::const_iterator I = RSSpecificTypeMap->find(TypeName);
875  if (I == RSSpecificTypeMap->end())
876    return DataTypeUnknown;
877  else
878    return I->getValue();
879}
880
881RSExportPrimitiveType::DataType
882RSExportPrimitiveType::GetRSSpecificType(const clang::Type *T) {
883  T = GET_CANONICAL_TYPE(T);
884  if ((T == NULL) || (T->getTypeClass() != clang::Type::Record))
885    return DataTypeUnknown;
886
887  return GetRSSpecificType( RSExportType::GetTypeName(T) );
888}
889
890bool RSExportPrimitiveType::IsRSMatrixType(DataType DT) {
891  return ((DT >= FirstRSMatrixType) && (DT <= LastRSMatrixType));
892}
893
894bool RSExportPrimitiveType::IsRSObjectType(DataType DT) {
895  return ((DT >= FirstRSObjectType) && (DT <= LastRSObjectType));
896}
897
898bool RSExportPrimitiveType::IsStructureTypeWithRSObject(const clang::Type *T) {
899  bool RSObjectTypeSeen = false;
900  while (T && T->isArrayType()) {
901    T = T->getArrayElementTypeNoTypeQual();
902  }
903
904  const clang::RecordType *RT = T->getAsStructureType();
905  if (!RT) {
906    return false;
907  }
908
909  const clang::RecordDecl *RD = RT->getDecl();
910  if (RD) {
911    RD = RD->getDefinition();
912  }
913  if (!RD) {
914    return false;
915  }
916
917  for (clang::RecordDecl::field_iterator FI = RD->field_begin(),
918         FE = RD->field_end();
919       FI != FE;
920       FI++) {
921    // We just look through all field declarations to see if we find a
922    // declaration for an RS object type (or an array of one).
923    const clang::FieldDecl *FD = *FI;
924    const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
925    while (FT && FT->isArrayType()) {
926      FT = FT->getArrayElementTypeNoTypeQual();
927    }
928
929    RSExportPrimitiveType::DataType DT = GetRSSpecificType(FT);
930    if (IsRSObjectType(DT)) {
931      // RS object types definitely need to be zero-initialized
932      RSObjectTypeSeen = true;
933    } else {
934      switch (DT) {
935        case RSExportPrimitiveType::DataTypeRSMatrix2x2:
936        case RSExportPrimitiveType::DataTypeRSMatrix3x3:
937        case RSExportPrimitiveType::DataTypeRSMatrix4x4:
938          // Matrix types should get zero-initialized as well
939          RSObjectTypeSeen = true;
940          break;
941        default:
942          // Ignore all other primitive types
943          break;
944      }
945      while (FT && FT->isArrayType()) {
946        FT = FT->getArrayElementTypeNoTypeQual();
947      }
948      if (FT->isStructureType()) {
949        // Recursively handle structs of structs (even though these can't
950        // be exported, it is possible for a user to have them internally).
951        RSObjectTypeSeen |= IsStructureTypeWithRSObject(FT);
952      }
953    }
954  }
955
956  return RSObjectTypeSeen;
957}
958
959const size_t RSExportPrimitiveType::SizeOfDataTypeInBits[] = {
960#define ENUM_RS_DATA_TYPE(type, cname, bits)  \
961  bits,
962#include "RSDataTypeEnums.inc"
963  0   // DataTypeMax
964};
965
966size_t RSExportPrimitiveType::GetSizeInBits(const RSExportPrimitiveType *EPT) {
967  slangAssert(((EPT->getType() > DataTypeUnknown) &&
968               (EPT->getType() < DataTypeMax)) &&
969              "RSExportPrimitiveType::GetSizeInBits : unknown data type");
970  return SizeOfDataTypeInBits[ static_cast<int>(EPT->getType()) ];
971}
972
973RSExportPrimitiveType::DataType
974RSExportPrimitiveType::GetDataType(RSContext *Context, const clang::Type *T) {
975  if (T == NULL)
976    return DataTypeUnknown;
977
978  switch (T->getTypeClass()) {
979    case clang::Type::Builtin: {
980      const clang::BuiltinType *BT =
981        UNSAFE_CAST_TYPE(const clang::BuiltinType, T);
982      switch (BT->getKind()) {
983#define ENUM_SUPPORT_BUILTIN_TYPE(builtin_type, type, cname)  \
984        case builtin_type: {                                  \
985          return DataType ## type;                            \
986        }
987#include "RSClangBuiltinEnums.inc"
988        // The size of type WChar depend on platform so we abandon the support
989        // to them.
990        default: {
991          clang::DiagnosticsEngine *DiagEngine = Context->getDiagnostics();
992          DiagEngine->Report(
993            DiagEngine->getCustomDiagID(
994              clang::DiagnosticsEngine::Error,
995              "built-in type cannot be exported: '%0'"))
996            << T->getTypeClassName();
997          break;
998        }
999      }
1000      break;
1001    }
1002    case clang::Type::Record: {
1003      // must be RS object type
1004      return RSExportPrimitiveType::GetRSSpecificType(T);
1005    }
1006    default: {
1007      clang::DiagnosticsEngine *DiagEngine = Context->getDiagnostics();
1008      DiagEngine->Report(
1009        DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
1010                                    "primitive type cannot be exported: '%0'"))
1011          << T->getTypeClassName();
1012      break;
1013    }
1014  }
1015
1016  return DataTypeUnknown;
1017}
1018
1019RSExportPrimitiveType
1020*RSExportPrimitiveType::Create(RSContext *Context,
1021                               const clang::Type *T,
1022                               const llvm::StringRef &TypeName,
1023                               bool Normalized) {
1024  DataType DT = GetDataType(Context, T);
1025
1026  if ((DT == DataTypeUnknown) || TypeName.empty())
1027    return NULL;
1028  else
1029    return new RSExportPrimitiveType(Context, ExportClassPrimitive, TypeName,
1030                                     DT, Normalized);
1031}
1032
1033RSExportPrimitiveType *RSExportPrimitiveType::Create(RSContext *Context,
1034                                                     const clang::Type *T) {
1035  llvm::StringRef TypeName;
1036  if (RSExportType::NormalizeType(T, TypeName, Context->getDiagnostics(), NULL)
1037      && IsPrimitiveType(T)) {
1038    return Create(Context, T, TypeName);
1039  } else {
1040    return NULL;
1041  }
1042}
1043
1044llvm::Type *RSExportPrimitiveType::convertToLLVMType() const {
1045  llvm::LLVMContext &C = getRSContext()->getLLVMContext();
1046
1047  if (isRSObjectType()) {
1048    // struct {
1049    //   int *p;
1050    // } __attribute__((packed, aligned(pointer_size)))
1051    //
1052    // which is
1053    //
1054    // <{ [1 x i32] }> in LLVM
1055    //
1056    if (RSObjectLLVMType == NULL) {
1057      std::vector<llvm::Type *> Elements;
1058      Elements.push_back(llvm::ArrayType::get(llvm::Type::getInt32Ty(C), 1));
1059      RSObjectLLVMType = llvm::StructType::get(C, Elements, true);
1060    }
1061    return RSObjectLLVMType;
1062  }
1063
1064  switch (mType) {
1065    case DataTypeFloat32: {
1066      return llvm::Type::getFloatTy(C);
1067      break;
1068    }
1069    case DataTypeFloat64: {
1070      return llvm::Type::getDoubleTy(C);
1071      break;
1072    }
1073    case DataTypeBoolean: {
1074      return llvm::Type::getInt1Ty(C);
1075      break;
1076    }
1077    case DataTypeSigned8:
1078    case DataTypeUnsigned8: {
1079      return llvm::Type::getInt8Ty(C);
1080      break;
1081    }
1082    case DataTypeSigned16:
1083    case DataTypeUnsigned16:
1084    case DataTypeUnsigned565:
1085    case DataTypeUnsigned5551:
1086    case DataTypeUnsigned4444: {
1087      return llvm::Type::getInt16Ty(C);
1088      break;
1089    }
1090    case DataTypeSigned32:
1091    case DataTypeUnsigned32: {
1092      return llvm::Type::getInt32Ty(C);
1093      break;
1094    }
1095    case DataTypeSigned64:
1096    case DataTypeUnsigned64: {
1097      return llvm::Type::getInt64Ty(C);
1098      break;
1099    }
1100    default: {
1101      slangAssert(false && "Unknown data type");
1102    }
1103  }
1104
1105  return NULL;
1106}
1107
1108union RSType *RSExportPrimitiveType::convertToSpecType() const {
1109  llvm::OwningPtr<union RSType> ST(new union RSType);
1110  RS_TYPE_SET_CLASS(ST, RS_TC_Primitive);
1111  // enum RSExportPrimitiveType::DataType is synced with enum RSDataType in
1112  // slang_rs_type_spec.h
1113  RS_PRIMITIVE_TYPE_SET_DATA_TYPE(ST, getType());
1114  return ST.take();
1115}
1116
1117bool RSExportPrimitiveType::equals(const RSExportable *E) const {
1118  CHECK_PARENT_EQUALITY(RSExportType, E);
1119  return (static_cast<const RSExportPrimitiveType*>(E)->getType() == getType());
1120}
1121
1122RSReflectionType *RSExportPrimitiveType::getRSReflectionType(DataType DT) {
1123  if (DT > DataTypeUnknown && DT < DataTypeMax) {
1124    return &gReflectionTypes[DT];
1125  } else {
1126    return NULL;
1127  }
1128}
1129
1130/**************************** RSExportPointerType ****************************/
1131
1132RSExportPointerType
1133*RSExportPointerType::Create(RSContext *Context,
1134                             const clang::PointerType *PT,
1135                             const llvm::StringRef &TypeName) {
1136  const clang::Type *PointeeType = GET_POINTEE_TYPE(PT);
1137  const RSExportType *PointeeET;
1138
1139  if (PointeeType->getTypeClass() != clang::Type::Pointer) {
1140    PointeeET = RSExportType::Create(Context, PointeeType);
1141  } else {
1142    // Double or higher dimension of pointer, export as int*
1143    PointeeET = RSExportPrimitiveType::Create(Context,
1144                    Context->getASTContext().IntTy.getTypePtr());
1145  }
1146
1147  if (PointeeET == NULL) {
1148    // Error diagnostic is emitted for corresponding pointee type
1149    return NULL;
1150  }
1151
1152  return new RSExportPointerType(Context, TypeName, PointeeET);
1153}
1154
1155llvm::Type *RSExportPointerType::convertToLLVMType() const {
1156  llvm::Type *PointeeType = mPointeeType->getLLVMType();
1157  return llvm::PointerType::getUnqual(PointeeType);
1158}
1159
1160union RSType *RSExportPointerType::convertToSpecType() const {
1161  llvm::OwningPtr<union RSType> ST(new union RSType);
1162
1163  RS_TYPE_SET_CLASS(ST, RS_TC_Pointer);
1164  RS_POINTER_TYPE_SET_POINTEE_TYPE(ST, getPointeeType()->getSpecType());
1165
1166  if (RS_POINTER_TYPE_GET_POINTEE_TYPE(ST) != NULL)
1167    return ST.take();
1168  else
1169    return NULL;
1170}
1171
1172bool RSExportPointerType::keep() {
1173  if (!RSExportType::keep())
1174    return false;
1175  const_cast<RSExportType*>(mPointeeType)->keep();
1176  return true;
1177}
1178
1179bool RSExportPointerType::equals(const RSExportable *E) const {
1180  CHECK_PARENT_EQUALITY(RSExportType, E);
1181  return (static_cast<const RSExportPointerType*>(E)
1182              ->getPointeeType()->equals(getPointeeType()));
1183}
1184
1185/***************************** RSExportVectorType *****************************/
1186llvm::StringRef
1187RSExportVectorType::GetTypeName(const clang::ExtVectorType *EVT) {
1188  const clang::Type *ElementType = GET_EXT_VECTOR_ELEMENT_TYPE(EVT);
1189
1190  if ((ElementType->getTypeClass() != clang::Type::Builtin))
1191    return llvm::StringRef();
1192
1193  const clang::BuiltinType *BT = UNSAFE_CAST_TYPE(const clang::BuiltinType,
1194                                                  ElementType);
1195  if ((EVT->getNumElements() < 1) ||
1196      (EVT->getNumElements() > 4))
1197    return llvm::StringRef();
1198
1199  switch (BT->getKind()) {
1200    // Compiler is smart enough to optimize following *big if branches* since
1201    // they all become "constant comparison" after macro expansion
1202#define ENUM_SUPPORT_BUILTIN_TYPE(builtin_type, type, cname)  \
1203    case builtin_type: {                                      \
1204      const char *Name[] = { cname"2", cname"3", cname"4" };  \
1205      return Name[EVT->getNumElements() - 2];                 \
1206      break;                                                  \
1207    }
1208#include "RSClangBuiltinEnums.inc"
1209    default: {
1210      return llvm::StringRef();
1211    }
1212  }
1213}
1214
1215RSExportVectorType *RSExportVectorType::Create(RSContext *Context,
1216                                               const clang::ExtVectorType *EVT,
1217                                               const llvm::StringRef &TypeName,
1218                                               bool Normalized) {
1219  slangAssert(EVT != NULL && EVT->getTypeClass() == clang::Type::ExtVector);
1220
1221  const clang::Type *ElementType = GET_EXT_VECTOR_ELEMENT_TYPE(EVT);
1222  RSExportPrimitiveType::DataType DT =
1223      RSExportPrimitiveType::GetDataType(Context, ElementType);
1224
1225  if (DT != RSExportPrimitiveType::DataTypeUnknown)
1226    return new RSExportVectorType(Context,
1227                                  TypeName,
1228                                  DT,
1229                                  Normalized,
1230                                  EVT->getNumElements());
1231  else
1232    return NULL;
1233}
1234
1235llvm::Type *RSExportVectorType::convertToLLVMType() const {
1236  llvm::Type *ElementType = RSExportPrimitiveType::convertToLLVMType();
1237  return llvm::VectorType::get(ElementType, getNumElement());
1238}
1239
1240union RSType *RSExportVectorType::convertToSpecType() const {
1241  llvm::OwningPtr<union RSType> ST(new union RSType);
1242
1243  RS_TYPE_SET_CLASS(ST, RS_TC_Vector);
1244  RS_VECTOR_TYPE_SET_ELEMENT_TYPE(ST, getType());
1245  RS_VECTOR_TYPE_SET_VECTOR_SIZE(ST, getNumElement());
1246
1247  return ST.take();
1248}
1249
1250bool RSExportVectorType::equals(const RSExportable *E) const {
1251  CHECK_PARENT_EQUALITY(RSExportPrimitiveType, E);
1252  return (static_cast<const RSExportVectorType*>(E)->getNumElement()
1253              == getNumElement());
1254}
1255
1256/***************************** RSExportMatrixType *****************************/
1257RSExportMatrixType *RSExportMatrixType::Create(RSContext *Context,
1258                                               const clang::RecordType *RT,
1259                                               const llvm::StringRef &TypeName,
1260                                               unsigned Dim) {
1261  slangAssert((RT != NULL) && (RT->getTypeClass() == clang::Type::Record));
1262  slangAssert((Dim > 1) && "Invalid dimension of matrix");
1263
1264  // Check whether the struct rs_matrix is in our expected form (but assume it's
1265  // correct if we're not sure whether it's correct or not)
1266  const clang::RecordDecl* RD = RT->getDecl();
1267  RD = RD->getDefinition();
1268  if (RD != NULL) {
1269    clang::DiagnosticsEngine *DiagEngine = Context->getDiagnostics();
1270    const clang::SourceManager *SM = Context->getSourceManager();
1271    // Find definition, perform further examination
1272    if (RD->field_empty()) {
1273      DiagEngine->Report(
1274        clang::FullSourceLoc(RD->getLocation(), *SM),
1275        DiagEngine->getCustomDiagID(
1276          clang::DiagnosticsEngine::Error,
1277          "invalid matrix struct: must have 1 field for saving values: '%0'"))
1278           << RD->getName();
1279      return NULL;
1280    }
1281
1282    clang::RecordDecl::field_iterator FIT = RD->field_begin();
1283    const clang::FieldDecl *FD = *FIT;
1284    const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
1285    if ((FT == NULL) || (FT->getTypeClass() != clang::Type::ConstantArray)) {
1286      DiagEngine->Report(
1287        clang::FullSourceLoc(RD->getLocation(), *SM),
1288        DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
1289                                    "invalid matrix struct: first field should"
1290                                    " be an array with constant size: '%0'"))
1291        << RD->getName();
1292      return NULL;
1293    }
1294    const clang::ConstantArrayType *CAT =
1295      static_cast<const clang::ConstantArrayType *>(FT);
1296    const clang::Type *ElementType = GET_CONSTANT_ARRAY_ELEMENT_TYPE(CAT);
1297    if ((ElementType == NULL) ||
1298        (ElementType->getTypeClass() != clang::Type::Builtin) ||
1299        (static_cast<const clang::BuiltinType *>(ElementType)->getKind() !=
1300         clang::BuiltinType::Float)) {
1301      DiagEngine->Report(
1302        clang::FullSourceLoc(RD->getLocation(), *SM),
1303        DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
1304                                    "invalid matrix struct: first field "
1305                                    "should be a float array: '%0'"))
1306        << RD->getName();
1307      return NULL;
1308    }
1309
1310    if (CAT->getSize() != Dim * Dim) {
1311      DiagEngine->Report(
1312        clang::FullSourceLoc(RD->getLocation(), *SM),
1313        DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
1314                                    "invalid matrix struct: first field "
1315                                    "should be an array with size %0: '%1'"))
1316        << (Dim * Dim) << (RD->getName());
1317      return NULL;
1318    }
1319
1320    FIT++;
1321    if (FIT != RD->field_end()) {
1322      DiagEngine->Report(
1323        clang::FullSourceLoc(RD->getLocation(), *SM),
1324        DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
1325                                    "invalid matrix struct: must have "
1326                                    "exactly 1 field: '%0'"))
1327        << RD->getName();
1328      return NULL;
1329    }
1330  }
1331
1332  return new RSExportMatrixType(Context, TypeName, Dim);
1333}
1334
1335llvm::Type *RSExportMatrixType::convertToLLVMType() const {
1336  // Construct LLVM type:
1337  // struct {
1338  //  float X[mDim * mDim];
1339  // }
1340
1341  llvm::LLVMContext &C = getRSContext()->getLLVMContext();
1342  llvm::ArrayType *X = llvm::ArrayType::get(llvm::Type::getFloatTy(C),
1343                                            mDim * mDim);
1344  return llvm::StructType::get(C, X, false);
1345}
1346
1347union RSType *RSExportMatrixType::convertToSpecType() const {
1348  llvm::OwningPtr<union RSType> ST(new union RSType);
1349  RS_TYPE_SET_CLASS(ST, RS_TC_Matrix);
1350  switch (getDim()) {
1351    case 2: RS_MATRIX_TYPE_SET_DATA_TYPE(ST, RS_DT_RSMatrix2x2); break;
1352    case 3: RS_MATRIX_TYPE_SET_DATA_TYPE(ST, RS_DT_RSMatrix3x3); break;
1353    case 4: RS_MATRIX_TYPE_SET_DATA_TYPE(ST, RS_DT_RSMatrix4x4); break;
1354    default: slangAssert(false && "Matrix type with unsupported dimension.");
1355  }
1356  return ST.take();
1357}
1358
1359bool RSExportMatrixType::equals(const RSExportable *E) const {
1360  CHECK_PARENT_EQUALITY(RSExportType, E);
1361  return (static_cast<const RSExportMatrixType*>(E)->getDim() == getDim());
1362}
1363
1364/************************* RSExportConstantArrayType *************************/
1365RSExportConstantArrayType
1366*RSExportConstantArrayType::Create(RSContext *Context,
1367                                   const clang::ConstantArrayType *CAT) {
1368  slangAssert(CAT != NULL && CAT->getTypeClass() == clang::Type::ConstantArray);
1369
1370  slangAssert((CAT->getSize().getActiveBits() < 32) && "array too large");
1371
1372  unsigned Size = static_cast<unsigned>(CAT->getSize().getZExtValue());
1373  slangAssert((Size > 0) && "Constant array should have size greater than 0");
1374
1375  const clang::Type *ElementType = GET_CONSTANT_ARRAY_ELEMENT_TYPE(CAT);
1376  RSExportType *ElementET = RSExportType::Create(Context, ElementType);
1377
1378  if (ElementET == NULL) {
1379    return NULL;
1380  }
1381
1382  return new RSExportConstantArrayType(Context,
1383                                       ElementET,
1384                                       Size);
1385}
1386
1387llvm::Type *RSExportConstantArrayType::convertToLLVMType() const {
1388  return llvm::ArrayType::get(mElementType->getLLVMType(), getSize());
1389}
1390
1391union RSType *RSExportConstantArrayType::convertToSpecType() const {
1392  llvm::OwningPtr<union RSType> ST(new union RSType);
1393
1394  RS_TYPE_SET_CLASS(ST, RS_TC_ConstantArray);
1395  RS_CONSTANT_ARRAY_TYPE_SET_ELEMENT_TYPE(
1396      ST, getElementType()->getSpecType());
1397  RS_CONSTANT_ARRAY_TYPE_SET_ELEMENT_SIZE(ST, getSize());
1398
1399  if (RS_CONSTANT_ARRAY_TYPE_GET_ELEMENT_TYPE(ST) != NULL)
1400    return ST.take();
1401  else
1402    return NULL;
1403}
1404
1405bool RSExportConstantArrayType::keep() {
1406  if (!RSExportType::keep())
1407    return false;
1408  const_cast<RSExportType*>(mElementType)->keep();
1409  return true;
1410}
1411
1412bool RSExportConstantArrayType::equals(const RSExportable *E) const {
1413  CHECK_PARENT_EQUALITY(RSExportType, E);
1414  const RSExportConstantArrayType *RHS =
1415      static_cast<const RSExportConstantArrayType*>(E);
1416  return ((getSize() == RHS->getSize()) &&
1417          (getElementType()->equals(RHS->getElementType())));
1418}
1419
1420/**************************** RSExportRecordType ****************************/
1421RSExportRecordType *RSExportRecordType::Create(RSContext *Context,
1422                                               const clang::RecordType *RT,
1423                                               const llvm::StringRef &TypeName,
1424                                               bool mIsArtificial) {
1425  slangAssert(RT != NULL && RT->getTypeClass() == clang::Type::Record);
1426
1427  const clang::RecordDecl *RD = RT->getDecl();
1428  slangAssert(RD->isStruct());
1429
1430  RD = RD->getDefinition();
1431  if (RD == NULL) {
1432    slangAssert(false && "struct is not defined in this module");
1433    return NULL;
1434  }
1435
1436  // Struct layout construct by clang. We rely on this for obtaining the
1437  // alloc size of a struct and offset of every field in that struct.
1438  const clang::ASTRecordLayout *RL =
1439      &Context->getASTContext().getASTRecordLayout(RD);
1440  slangAssert((RL != NULL) &&
1441      "Failed to retrieve the struct layout from Clang.");
1442
1443  RSExportRecordType *ERT =
1444      new RSExportRecordType(Context,
1445                             TypeName,
1446                             RD->hasAttr<clang::PackedAttr>(),
1447                             mIsArtificial,
1448                             RL->getSize().getQuantity());
1449  unsigned int Index = 0;
1450
1451  for (clang::RecordDecl::field_iterator FI = RD->field_begin(),
1452           FE = RD->field_end();
1453       FI != FE;
1454       FI++, Index++) {
1455    clang::DiagnosticsEngine *DiagEngine = Context->getDiagnostics();
1456
1457    // FIXME: All fields should be primitive type
1458    slangAssert(FI->getKind() == clang::Decl::Field);
1459    clang::FieldDecl *FD = *FI;
1460
1461    if (FD->isBitField()) {
1462      return NULL;
1463    }
1464
1465    // Type
1466    RSExportType *ET = RSExportElement::CreateFromDecl(Context, FD);
1467
1468    if (ET != NULL) {
1469      ERT->mFields.push_back(
1470          new Field(ET, FD->getName(), ERT,
1471                    static_cast<size_t>(RL->getFieldOffset(Index) >> 3)));
1472    } else {
1473      DiagEngine->Report(
1474        clang::FullSourceLoc(RD->getLocation(), DiagEngine->getSourceManager()),
1475        DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
1476                                    "field type cannot be exported: '%0.%1'"))
1477        << RD->getName() << FD->getName();
1478      return NULL;
1479    }
1480  }
1481
1482  return ERT;
1483}
1484
1485llvm::Type *RSExportRecordType::convertToLLVMType() const {
1486  // Create an opaque type since struct may reference itself recursively.
1487
1488  // TODO(sliao): LLVM took out the OpaqueType. Any other to migrate to?
1489  std::vector<llvm::Type*> FieldTypes;
1490
1491  for (const_field_iterator FI = fields_begin(), FE = fields_end();
1492       FI != FE;
1493       FI++) {
1494    const Field *F = *FI;
1495    const RSExportType *FET = F->getType();
1496
1497    FieldTypes.push_back(FET->getLLVMType());
1498  }
1499
1500  llvm::StructType *ST = llvm::StructType::get(getRSContext()->getLLVMContext(),
1501                                               FieldTypes,
1502                                               mIsPacked);
1503  if (ST != NULL) {
1504    return ST;
1505  } else {
1506    return NULL;
1507  }
1508}
1509
1510union RSType *RSExportRecordType::convertToSpecType() const {
1511  unsigned NumFields = getFields().size();
1512  unsigned AllocSize = sizeof(union RSType) +
1513                       sizeof(struct RSRecordField) * NumFields;
1514  llvm::OwningPtr<union RSType> ST(
1515      reinterpret_cast<union RSType*>(operator new(AllocSize)));
1516
1517  ::memset(ST.get(), 0, AllocSize);
1518
1519  RS_TYPE_SET_CLASS(ST, RS_TC_Record);
1520  RS_RECORD_TYPE_SET_NAME(ST, getName().c_str());
1521  RS_RECORD_TYPE_SET_NUM_FIELDS(ST, NumFields);
1522
1523  setSpecTypeTemporarily(ST.get());
1524
1525  unsigned FieldIdx = 0;
1526  for (const_field_iterator FI = fields_begin(), FE = fields_end();
1527       FI != FE;
1528       FI++, FieldIdx++) {
1529    const Field *F = *FI;
1530
1531    RS_RECORD_TYPE_SET_FIELD_NAME(ST, FieldIdx, F->getName().c_str());
1532    RS_RECORD_TYPE_SET_FIELD_TYPE(ST, FieldIdx, F->getType()->getSpecType());
1533  }
1534
1535  // TODO(slang): Check whether all fields were created normally.
1536
1537  return ST.take();
1538}
1539
1540bool RSExportRecordType::keep() {
1541  if (!RSExportType::keep())
1542    return false;
1543  for (std::list<const Field*>::iterator I = mFields.begin(),
1544          E = mFields.end();
1545       I != E;
1546       I++) {
1547    const_cast<RSExportType*>((*I)->getType())->keep();
1548  }
1549  return true;
1550}
1551
1552bool RSExportRecordType::equals(const RSExportable *E) const {
1553  CHECK_PARENT_EQUALITY(RSExportType, E);
1554
1555  const RSExportRecordType *ERT = static_cast<const RSExportRecordType*>(E);
1556
1557  if (ERT->getFields().size() != getFields().size())
1558    return false;
1559
1560  const_field_iterator AI = fields_begin(), BI = ERT->fields_begin();
1561
1562  for (unsigned i = 0, e = getFields().size(); i != e; i++) {
1563    if (!(*AI)->getType()->equals((*BI)->getType()))
1564      return false;
1565    AI++;
1566    BI++;
1567  }
1568
1569  return true;
1570}
1571
1572void RSExportType::convertToRTD(RSReflectionTypeData *rtd) const {
1573    memset(rtd, 0, sizeof(*rtd));
1574    rtd->vecSize = 1;
1575
1576    switch(getClass()) {
1577    case RSExportType::ExportClassPrimitive: {
1578            const RSExportPrimitiveType *EPT = static_cast<const RSExportPrimitiveType*>(this);
1579            rtd->type = RSExportPrimitiveType::getRSReflectionType(EPT);
1580            return;
1581        }
1582    case RSExportType::ExportClassPointer: {
1583            const RSExportPointerType *EPT = static_cast<const RSExportPointerType*>(this);
1584            const RSExportType *PointeeType = EPT->getPointeeType();
1585            PointeeType->convertToRTD(rtd);
1586            rtd->isPointer = true;
1587            return;
1588        }
1589    case RSExportType::ExportClassVector: {
1590            const RSExportVectorType *EVT = static_cast<const RSExportVectorType*>(this);
1591            rtd->type = EVT->getRSReflectionType(EVT);
1592            rtd->vecSize = EVT->getNumElement();
1593            return;
1594        }
1595    case RSExportType::ExportClassMatrix: {
1596            const RSExportMatrixType *EMT = static_cast<const RSExportMatrixType*>(this);
1597            unsigned Dim = EMT->getDim();
1598            slangAssert((Dim >= 2) && (Dim <= 4));
1599            rtd->type = &gReflectionTypes[15 + Dim-2];
1600            return;
1601        }
1602    case RSExportType::ExportClassConstantArray: {
1603            const RSExportConstantArrayType* CAT =
1604              static_cast<const RSExportConstantArrayType*>(this);
1605            CAT->getElementType()->convertToRTD(rtd);
1606            rtd->arraySize = CAT->getSize();
1607            return;
1608        }
1609    case RSExportType::ExportClassRecord: {
1610            slangAssert(!"RSExportType::ExportClassRecord not implemented");
1611            return;// RS_TYPE_CLASS_NAME_PREFIX + ET->getName() + ".Item";
1612        }
1613    default: {
1614            slangAssert(false && "Unknown class of type");
1615        }
1616    }
1617}
1618
1619
1620}  // namespace slang
1621