slang_rs_context.h revision 34e6205f1d5ceb90a73192cee8b215fa0b7ab306
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_CONTEXT_H_ // NOLINT 18#define _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_CONTEXT_H_ 19 20#include <cstdio> 21#include <list> 22#include <map> 23#include <string> 24#include <vector> 25 26#include "clang/Lex/Preprocessor.h" 27#include "clang/AST/Mangle.h" 28 29#include "llvm/ADT/StringSet.h" 30#include "llvm/ADT/StringMap.h" 31 32#include "slang_pragma_list.h" 33 34namespace llvm { 35 class LLVMContext; 36 class DataLayout; 37} // namespace llvm 38 39namespace clang { 40 class VarDecl; 41 class ASTContext; 42 class TargetInfo; 43 class FunctionDecl; 44 class QualType; 45 class SourceManager; 46 class TypeDecl; 47} // namespace clang 48 49namespace slang { 50 class RSExportable; 51 class RSExportVar; 52 class RSExportFunc; 53 class RSExportForEach; 54 class RSExportReduce; 55 class RSExportType; 56 57class RSContext { 58 typedef llvm::StringSet<> NeedExportVarSet; 59 typedef llvm::StringSet<> NeedExportFuncSet; 60 typedef llvm::StringSet<> NeedExportTypeSet; 61 62 public: 63 typedef std::list<RSExportable*> ExportableList; 64 typedef std::list<RSExportVar*> ExportVarList; 65 typedef std::list<RSExportFunc*> ExportFuncList; 66 typedef std::vector<RSExportForEach*> ExportForEachVector; 67 typedef std::list<RSExportReduce*> ExportReduceList; 68 typedef llvm::StringMap<RSExportType*> ExportTypeMap; 69 70 private: 71 clang::Preprocessor &mPP; 72 clang::ASTContext &mCtx; 73 PragmaList *mPragmas; 74 // Precision specified via pragma, either rs_fp_full or rs_fp_relaxed. If 75 // empty, rs_fp_full is assumed. 76 std::string mPrecision; 77 unsigned int mTargetAPI; 78 bool mVerbose; 79 80 llvm::DataLayout *mDataLayout; 81 llvm::LLVMContext &mLLVMContext; 82 83 ExportableList mExportables; 84 85 NeedExportTypeSet mNeedExportTypes; 86 87 std::string *mLicenseNote; 88 std::string mReflectJavaPackageName; 89 std::string mReflectJavaPathName; 90 91 std::string mRSPackageName; 92 93 int version; 94 95 std::unique_ptr<clang::MangleContext> mMangleCtx; 96 97 bool mIs64Bit; 98 99 bool processExportVar(const clang::VarDecl *VD); 100 bool processExportFunc(const clang::FunctionDecl *FD); 101 bool processExportType(const llvm::StringRef &Name); 102 103 int getForEachSlotNumber(const clang::StringRef& funcName); 104 unsigned mNextSlot; 105 106 ExportVarList mExportVars; 107 ExportFuncList mExportFuncs; 108 std::map<llvm::StringRef, unsigned> mExportForEachMap; 109 ExportForEachVector mExportForEach; 110 ExportReduceList mExportReduce; 111 ExportTypeMap mExportTypes; 112 113 clang::QualType mAllocationType; 114 115 public: 116 RSContext(clang::Preprocessor &PP, 117 clang::ASTContext &Ctx, 118 const clang::TargetInfo &Target, 119 PragmaList *Pragmas, 120 unsigned int TargetAPI, 121 bool Verbose); 122 123 inline clang::Preprocessor &getPreprocessor() const { return mPP; } 124 inline clang::ASTContext &getASTContext() const { return mCtx; } 125 inline clang::MangleContext &getMangleContext() const { 126 return *mMangleCtx; 127 } 128 inline const llvm::DataLayout *getDataLayout() const { return mDataLayout; } 129 inline llvm::LLVMContext &getLLVMContext() const { return mLLVMContext; } 130 inline const clang::SourceManager *getSourceManager() const { 131 return &mPP.getSourceManager(); 132 } 133 inline clang::DiagnosticsEngine *getDiagnostics() const { 134 return &mPP.getDiagnostics(); 135 } 136 inline unsigned int getTargetAPI() const { 137 return mTargetAPI; 138 } 139 140 inline bool getVerbose() const { 141 return mVerbose; 142 } 143 inline bool is64Bit() const { 144 return mIs64Bit; 145 } 146 147 inline void setLicenseNote(const std::string &S) { 148 mLicenseNote = new std::string(S); 149 } 150 inline const std::string *getLicenseNote() const { return mLicenseNote; } 151 152 inline void addExportType(const std::string &S) { 153 mNeedExportTypes.insert(S); 154 } 155 156 inline void setReflectJavaPackageName(const std::string &S) { 157 mReflectJavaPackageName = S; 158 } 159 inline const std::string &getReflectJavaPackageName() const { 160 return mReflectJavaPackageName; 161 } 162 163 inline void setRSPackageName(const std::string &S) { 164 mRSPackageName = S; 165 } 166 167 inline const std::string &getRSPackageName() const { return mRSPackageName; } 168 169 bool addForEach(const clang::FunctionDecl* FD); 170 bool processExports(); 171 inline void newExportable(RSExportable *E) { 172 if (E != nullptr) 173 mExportables.push_back(E); 174 } 175 typedef ExportableList::iterator exportable_iterator; 176 exportable_iterator exportable_begin() { 177 return mExportables.begin(); 178 } 179 exportable_iterator exportable_end() { 180 return mExportables.end(); 181 } 182 183 typedef ExportVarList::const_iterator const_export_var_iterator; 184 const_export_var_iterator export_vars_begin() const { 185 return mExportVars.begin(); 186 } 187 const_export_var_iterator export_vars_end() const { 188 return mExportVars.end(); 189 } 190 inline bool hasExportVar() const { 191 return !mExportVars.empty(); 192 } 193 194 typedef ExportFuncList::const_iterator const_export_func_iterator; 195 const_export_func_iterator export_funcs_begin() const { 196 return mExportFuncs.begin(); 197 } 198 const_export_func_iterator export_funcs_end() const { 199 return mExportFuncs.end(); 200 } 201 inline bool hasExportFunc() const { return !mExportFuncs.empty(); } 202 203 typedef ExportForEachVector::const_iterator const_export_foreach_iterator; 204 const_export_foreach_iterator export_foreach_begin() const { 205 return mExportForEach.begin(); 206 } 207 const_export_foreach_iterator export_foreach_end() const { 208 return mExportForEach.end(); 209 } 210 inline bool hasExportForEach() const { return !mExportForEach.empty(); } 211 int getForEachSlotNumber(const clang::FunctionDecl* FD); 212 213 typedef ExportReduceList::const_iterator const_export_reduce_iterator; 214 const_export_reduce_iterator export_reduce_begin() const { 215 return mExportReduce.begin(); 216 } 217 const_export_reduce_iterator export_reduce_end() const { 218 return mExportReduce.end(); 219 } 220 inline bool hasExportReduce() const { return !mExportReduce.empty(); } 221 222 typedef ExportTypeMap::iterator export_type_iterator; 223 typedef ExportTypeMap::const_iterator const_export_type_iterator; 224 export_type_iterator export_types_begin() { return mExportTypes.begin(); } 225 export_type_iterator export_types_end() { return mExportTypes.end(); } 226 const_export_type_iterator export_types_begin() const { 227 return mExportTypes.begin(); 228 } 229 const_export_type_iterator export_types_end() const { 230 return mExportTypes.end(); 231 } 232 inline bool hasExportType() const { return !mExportTypes.empty(); } 233 export_type_iterator findExportType(const llvm::StringRef &TypeName) { 234 return mExportTypes.find(TypeName); 235 } 236 const_export_type_iterator findExportType(const llvm::StringRef &TypeName) 237 const { 238 return mExportTypes.find(TypeName); 239 } 240 241 // Insert the specified Typename/Type pair into the map. If the key already 242 // exists in the map, return false and ignore the request, otherwise insert it 243 // and return true. 244 bool insertExportType(const llvm::StringRef &TypeName, RSExportType *Type); 245 246 int getVersion() const { return version; } 247 void setVersion(int v) { 248 version = v; 249 } 250 251 bool isCompatLib() const { 252 // If we are not targeting the actual Android Renderscript classes, 253 // we should reflect code that works with the compatibility library. 254 return (mRSPackageName.compare("android.renderscript") != 0); 255 } 256 257 void addPragma(const std::string &T, const std::string &V) { 258 mPragmas->push_back(make_pair(T, V)); 259 } 260 void setPrecision(const std::string &P) { mPrecision = P; } 261 std::string getPrecision() { return mPrecision; } 262 263 // Report an error or a warning to the user. 264 template <unsigned N> 265 clang::DiagnosticBuilder Report(clang::DiagnosticsEngine::Level Level, 266 const char (&Message)[N]) { 267 clang::DiagnosticsEngine *DiagEngine = getDiagnostics(); 268 return DiagEngine->Report(DiagEngine->getCustomDiagID(Level, Message)); 269} 270 271 template <unsigned N> 272 clang::DiagnosticBuilder Report(clang::DiagnosticsEngine::Level Level, 273 const clang::SourceLocation Loc, 274 const char (&Message)[N]) { 275 clang::DiagnosticsEngine *DiagEngine = getDiagnostics(); 276 const clang::SourceManager *SM = getSourceManager(); 277 return DiagEngine->Report(clang::FullSourceLoc(Loc, *SM), 278 DiagEngine->getCustomDiagID(Level, Message)); 279} 280 281 // Utility functions to report errors and warnings to make the calling code 282 // easier to read. 283 template <unsigned N> 284 clang::DiagnosticBuilder ReportError(const char (&Message)[N]) { 285 return Report<N>(clang::DiagnosticsEngine::Error, Message); 286 } 287 288 template <unsigned N> 289 clang::DiagnosticBuilder ReportError(const clang::SourceLocation Loc, 290 const char (&Message)[N]) { 291 return Report<N>(clang::DiagnosticsEngine::Error, Loc, Message); 292 } 293 294 template <unsigned N> 295 clang::DiagnosticBuilder ReportWarning(const char (&Message)[N]) { 296 return Report<N>(clang::DiagnosticsEngine::Warning, Message); 297 } 298 299 template <unsigned N> 300 clang::DiagnosticBuilder ReportWarning(const clang::SourceLocation Loc, 301 const char (&Message)[N]) { 302 return Report<N>(clang::DiagnosticsEngine::Warning, Loc, Message); 303 } 304 305 ~RSContext(); 306}; 307 308} // namespace slang 309 310#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_CONTEXT_H_ NOLINT 311