clang/lib/Frontend/LayoutOverrideSource.cpp

   1 //===--- LayoutOverrideSource.cpp --Override Record Layouts ---------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 #include "clang/Frontend/LayoutOverrideSource.h"
   9 #include "clang/AST/Decl.h"
  10 #include "clang/Basic/CharInfo.h"
  11 #include "llvm/Support/raw_ostream.h"
  12 #include <fstream>
  13 #include <string>
  14
  15 using namespace clang;
  16
  17 /// Parse a simple identifier.
  18 static std::string parseName(StringRef S) {
  19   if (S.empty() || !isAsciiIdentifierStart(S[0]))
  20     return "";
  21
  22   unsigned Offset = 1;
  23   while (Offset < S.size() && isAsciiIdentifierContinue(S[Offset]))
  24     ++Offset;
  25
  26   return S.substr(0, Offset).str();
  27 }
  28
  29 LayoutOverrideSource::LayoutOverrideSource(StringRef Filename) {
  30   std::ifstream Input(Filename.str().c_str());
  31   if (!Input.is_open())
  32     return;
  33
  34   // Parse the output of -fdump-record-layouts.
  35   std::string CurrentType;
  36   Layout CurrentLayout;
  37   bool ExpectingType = false;
  38
  39   while (Input.good()) {
  40     std::string Line;
  41     getline(Input, Line);
  42
  43     StringRef LineStr(Line);
  44
  45     // Determine whether the following line will start a
  46     if (LineStr.contains("*** Dumping AST Record Layout")) {
  47       // Flush the last type/layout, if there is one.
  48       if (!CurrentType.empty())
  49         Layouts[CurrentType] = CurrentLayout;
  50       CurrentLayout = Layout();
  51
  52       ExpectingType = true;
  53       continue;
  54     }
  55
  56     // If we're expecting a type, grab it.
  57     if (ExpectingType) {
  58       ExpectingType = false;
  59
  60       StringRef::size_type Pos;
  61       if ((Pos = LineStr.find("struct ")) != StringRef::npos)
  62         LineStr = LineStr.substr(Pos + strlen("struct "));
  63       else if ((Pos = LineStr.find("class ")) != StringRef::npos)
  64         LineStr = LineStr.substr(Pos + strlen("class "));
  65       else if ((Pos = LineStr.find("union ")) != StringRef::npos)
  66         LineStr = LineStr.substr(Pos + strlen("union "));
  67       else
  68         continue;
  69
  70       // Find the name of the type.
  71       CurrentType = parseName(LineStr);
  72       CurrentLayout = Layout();
  73       continue;
  74     }
  75
  76     // Check for the size of the type.
  77     StringRef::size_type Pos = LineStr.find(" Size:");
  78     if (Pos != StringRef::npos) {
  79       // Skip past the " Size:" prefix.
  80       LineStr = LineStr.substr(Pos + strlen(" Size:"));
  81
  82       unsigned long long Size = 0;
  83       (void)LineStr.getAsInteger(10, Size);
  84       CurrentLayout.Size = Size;
  85       continue;
  86     }
  87
  88     // Check for the alignment of the type.
  89     Pos = LineStr.find("Alignment:");
  90     if (Pos != StringRef::npos) {
  91       // Skip past the "Alignment:" prefix.
  92       LineStr = LineStr.substr(Pos + strlen("Alignment:"));
  93
  94       unsigned long long Alignment = 0;
  95       (void)LineStr.getAsInteger(10, Alignment);
  96       CurrentLayout.Align = Alignment;
  97       continue;
  98     }
  99
 100     // Check for the size/alignment of the type.
 101     Pos = LineStr.find("sizeof=");
 102     if (Pos != StringRef::npos) {
 103       /* Skip past the sizeof= prefix. */
 104       LineStr = LineStr.substr(Pos + strlen("sizeof="));
 105
 106       // Parse size.
 107       unsigned long long Size = 0;
 108       (void)LineStr.getAsInteger(10, Size);
 109       CurrentLayout.Size = Size;
 110
 111       Pos = LineStr.find("align=");
 112       if (Pos != StringRef::npos) {
 113         /* Skip past the align= prefix. */
 114         LineStr = LineStr.substr(Pos + strlen("align="));
 115
 116         // Parse alignment.
 117         unsigned long long Alignment = 0;
 118         (void)LineStr.getAsInteger(10, Alignment);
 119         CurrentLayout.Align = Alignment;
 120       }
 121
 122       continue;
 123     }
 124
 125     // Check for the field offsets of the type.
 126     Pos = LineStr.find("FieldOffsets: [");
 127     if (Pos == StringRef::npos)
 128       continue;
 129
 130     LineStr = LineStr.substr(Pos + strlen("FieldOffsets: ["));
 131     while (!LineStr.empty() && isDigit(LineStr[0])) {
 132       // Parse this offset.
 133       unsigned Idx = 1;
 134       while (Idx < LineStr.size() && isDigit(LineStr[Idx]))
 135         ++Idx;
 136
 137       unsigned long long Offset = 0;
 138       (void)LineStr.substr(0, Idx).getAsInteger(10, Offset);
 139
 140       CurrentLayout.FieldOffsets.push_back(Offset);
 141
 142       // Skip over this offset, the following comma, and any spaces.
 143       LineStr = LineStr.substr(Idx + 1);
 144       while (!LineStr.empty() && isWhitespace(LineStr[0]))
 145         LineStr = LineStr.substr(1);
 146     }
 147   }
 148
 149   // Flush the last type/layout, if there is one.
 150   if (!CurrentType.empty())
 151     Layouts[CurrentType] = CurrentLayout;
 152 }
 153
 154 bool
 155 LayoutOverrideSource::layoutRecordType(const RecordDecl *Record,
 156   uint64_t &Size, uint64_t &Alignment,
 157   llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
 158   llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
 159   llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets)
 160 {
 161   // We can't override unnamed declarations.
 162   if (!Record->getIdentifier())
 163     return false;
 164
 165   // Check whether we have a layout for this record.
 166   llvm::StringMap<Layout>::iterator Known = Layouts.find(Record->getName());
 167   if (Known == Layouts.end())
 168     return false;
 169
 170   // Provide field layouts.
 171   unsigned NumFields = 0;
 172   for (RecordDecl::field_iterator F = Record->field_begin(),
 173                                FEnd = Record->field_end();
 174        F != FEnd; ++F, ++NumFields) {
 175     if (NumFields >= Known->second.FieldOffsets.size())
 176       continue;
 177
 178     FieldOffsets[*F] = Known->second.FieldOffsets[NumFields];
 179   }
 180
 181   // Wrong number of fields.
 182   if (NumFields != Known->second.FieldOffsets.size())
 183     return false;
 184
 185   Size = Known->second.Size;
 186   Alignment = Known->second.Align;
 187   return true;
 188 }
 189
 190 LLVM_DUMP_METHOD void LayoutOverrideSource::dump() {
 191   raw_ostream &OS = llvm::errs();
 192   for (llvm::StringMap<Layout>::iterator L = Layouts.begin(),
 193                                       LEnd = Layouts.end();
 194        L != LEnd; ++L) {
 195     OS << "Type: blah " << L->first() << '\n';
 196     OS << "  Size:" << L->second.Size << '\n';
 197     OS << "  Alignment:" << L->second.Align << '\n';
 198     OS << "  FieldOffsets: [";
 199     for (unsigned I = 0, N = L->second.FieldOffsets.size(); I != N; ++I) {
 200       if (I)
 201         OS << ", ";
 202       OS << L->second.FieldOffsets[I];
 203     }
 204     OS << "]\n";
 205   }
 206 }
 207