src/ppapi/tests/clang/print_names_and_sizes.cc

   1 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Clang plugin which prints the names and sizes of all the top-level
   6 // structs, enums, and typedefs in the input file.
   7
   8 #include <cstdio>
   9 #include <cstring>
  10 #include <string>
  11
  12 #include "clang/AST/AST.h"
  13 #include "clang/AST/ASTConsumer.h"
  14 #include "clang/AST/CharUnits.h"
  15 #include "clang/AST/Decl.h"
  16 #include "clang/Basic/SourceManager.h"
  17 #include "clang/Basic/TargetInfo.h"
  18 #include "clang/Frontend/CompilerInstance.h"
  19 #include "clang/Frontend/FrontendPluginRegistry.h"
  20
  21 namespace {
  22
  23 const char* const kTypedefName = "Typedef";
  24 const char* const kDelim = ",";
  25 const char* const kArchDependent = "ArchDependentSize";
  26 const char* const kNotArchDependent = "NotArchDependentSize";
  27
  28 // This class consumes a Clang-parsed AST and prints out information about types
  29 // defined in the global namespace.  Specifically, for each type definition
  30 // encountered, it prints:
  31 // "kind,name,size,arch_dependent,source_file,first_line,last_line\n"
  32 // Where:
  33 // - kind:  The Clang TypeClassName (Record, Enum, Typedef, Union, etc)
  34 // - name:  The unmangled string name of the type.
  35 // - size:  The size in bytes of the type.
  36 // - arch_dependent:  'ArchDependentSize' if the type has architecture-dependent
  37 //                    size, NotArchDependentSize otherwise.
  38 // - source_file:  The source file in which the type is defined.
  39 // - first_line:  The first line of the definition (counting from 0).
  40 // - last_line:  The last line of the definition (counting from 0).
  41 class PrintNamesAndSizesConsumer : public clang::ASTConsumer {
  42  public:
  43   explicit PrintNamesAndSizesConsumer(clang::SourceManager* source_mgr)
  44       : source_manager_(source_mgr) {}
  45
  46  private:
  47   // SourceManager has information about source code locations, to help us know
  48   // where definitions appear.  We do not own this pointer, so we must not
  49   // delete it.
  50   clang::SourceManager* source_manager_;
  51
  52   // Return true if the type contains types that differ in size between 32-bit
  53   // and 64-bit architectures.  This is true for types that are typedefed to a
  54   // pointer, long, or unsigned long and also any types that contain an
  55   // architecture-dependent type.  Note that this is a bit overly restrictive;
  56   // some unions may be consistent size on 32-bit and 64-bit architectures
  57   // despite containing one of these types.  But it's not an important enough
  58   // issue to warrant coding the special case.
  59   // Structs, enums, and unions that do NOT contain arch-dependent types are
  60   // crafted to be the same size on 32-bit and 64-bit platforms by convention.
  61   bool HasArchDependentSize(const clang::Type& type) {
  62     if (type.isPointerType()) {
  63       return true;
  64     } else if (const clang::BuiltinType* builtin =
  65         dyn_cast<clang::BuiltinType>(&type)) {
  66       if ((builtin->getKind() == clang::BuiltinType::Long) ||
  67           (builtin->getKind() == clang::BuiltinType::ULong)) {
  68         return true;
  69       }
  70     } else if (const clang::ArrayType* array =
  71         dyn_cast<clang::ArrayType>(&type)) {
  72       // If it's an array, it has architecture-dependent size if its elements
  73       // do.
  74       return HasArchDependentSize(*(array->getElementType().getTypePtr()));
  75     } else if (const clang::TypedefType* typedef_type =
  76         dyn_cast<clang::TypedefType>(&type)) {
  77       return HasArchDependentSize(*(typedef_type->desugar().getTypePtr()));
  78     } else if (const clang::RecordType* record =
  79         dyn_cast<clang::RecordType>(&type)) {
  80       // If it's a struct or union, iterate through the fields.  If any of them
  81       // has architecture-dependent size, then we do too.
  82       const clang::RecordDecl* decl = record->getDecl();
  83       clang::RecordDecl::field_iterator iter(decl->field_begin());
  84       clang::RecordDecl::field_iterator end(decl->field_end());
  85       for (; iter != end; ++iter) {
  86         if (HasArchDependentSize(*(iter->getType().getTypePtr()))) {
  87           return true;
  88         }
  89       }
  90       // It's a struct or union, but contains no architecture-dependent members.
  91       return false;
  92     }
  93     return false;
  94   }
  95
  96   void PrintTypeInfo(const std::string& name, const clang::Type& type,
  97                      const std::string& kind, const clang::CharUnits& size,
  98                      const clang::SourceLocation& begin_loc,
  99                      const clang::SourceLocation& end_loc) {
 100     clang::PresumedLoc presumed_begin(
 101         source_manager_->getPresumedLoc(begin_loc));
 102     clang::PresumedLoc presumed_end(source_manager_->getPresumedLoc(end_loc));
 103     std::printf("%s,%s,%lu,%s,%s,%u,%u\n",
 104                 kind.c_str(),
 105                 name.c_str(),
 106                 size.getQuantity(),
 107                 HasArchDependentSize(type) ? kArchDependent : kNotArchDependent,
 108                 presumed_begin.getFilename(),
 109                 presumed_begin.getLine(),
 110                 presumed_end.getLine());
 111   }
 112
 113   // Virtual function to consume top-level declarations.  For each one, we check
 114   // to see if it is a type definition.  If it is, we print information about
 115   // it.
 116   virtual void HandleTopLevelDecl(clang::DeclGroupRef decl_group) {
 117     clang::DeclGroupRef::iterator iter(decl_group.begin());
 118     clang::DeclGroupRef::iterator the_end(decl_group.end());
 119     for (; iter != the_end; ++iter) {
 120       const clang::Decl *decl = *iter;
 121       if (const clang::TypeDecl* type_decl = dyn_cast<clang::TypeDecl>(decl)) {
 122         std::string name(type_decl->getNameAsString());
 123         clang::SourceLocation start_loc = type_decl->getLocStart();
 124         clang::SourceLocation end_loc = type_decl->getLocEnd();
 125         // TagDecl covers structs, enums, unions, and classes.
 126         if (const clang::TagDecl* tag = dyn_cast<clang::TagDecl>(type_decl)) {
 127           // Only print out info when we find the definition;  ignore forward
 128           // references.
 129           if (tag->isDefinition()) {
 130             clang::Type* type = type_decl->getTypeForDecl();
 131             clang::CharUnits size =
 132                 tag->getASTContext().getTypeSizeInChars(type);
 133             PrintTypeInfo(name, *type, type->getTypeClassName(), size,
 134                           start_loc, end_loc);
 135           }
 136         } else if (const clang::TypedefDecl* td =
 137                    dyn_cast<clang::TypedefDecl>(type_decl)) {
 138           clang::Type* type = td->getUnderlyingType().getTypePtr();
 139           clang::CharUnits size = td->getASTContext().getTypeSizeInChars(type);
 140           PrintTypeInfo(name, *type, kTypedefName, size, start_loc, end_loc);
 141         }
 142       }
 143     }
 144   }
 145 };
 146
 147 class PrintNamesAndSizesAction : public clang::PluginASTAction {
 148  public:
 149   PrintNamesAndSizesAction() {}
 150
 151  private:
 152   virtual clang::ASTConsumer *CreateASTConsumer(
 153       clang::CompilerInstance &instance, llvm::StringRef /*input_file*/) {
 154     return new PrintNamesAndSizesConsumer(
 155         &(instance.getDiagnostics().getSourceManager()));
 156   }
 157
 158   // We don't accept any arguments, but ParseArgs is pure-virtual.
 159   virtual bool ParseArgs(const clang::CompilerInstance& /*instance*/,
 160                          const std::vector<std::string>& /*args*/) {
 161     return true;
 162   }
 163 };
 164
 165 }  // namespace
 166
 167 static clang::FrontendPluginRegistry::Add<PrintNamesAndSizesAction>
 168 X("PrintNamesAndSizes",
 169   "Print the names and sizes of classes, enums, and typedefs.");
 170