Skip to content

Commit 9d34d98

Browse files
robertoraggirobertoraggi
authored
Build the class layout for the instantiated symbols
Signed-off-by: GitHub <[email protected]>
1 parent db33af7 commit 9d34d98

File tree

6 files changed

+186
-76
lines changed

6 files changed

+186
-76
lines changed

‎src/parser/cxx/name_lookup.cc‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -53,15 +53,40 @@ auto Lookup::qualifiedLookup(Symbol* scopedSymbol, const Name* name) const
5353
case SymbolKind::kNamespace:
5454
return qualifiedLookup(
5555
symbol_cast<NamespaceSymbol>(scopedSymbol)->scope(), name);
56+
5657
case SymbolKind::kClass:
5758
return qualifiedLookup(symbol_cast<ClassSymbol>(scopedSymbol)->scope(),
5859
name);
60+
5961
case SymbolKind::kEnum:
6062
return qualifiedLookup(symbol_cast<EnumSymbol>(scopedSymbol)->scope(),
6163
name);
64+
6265
case SymbolKind::kScopedEnum:
6366
return qualifiedLookup(
6467
symbol_cast<ScopedEnumSymbol>(scopedSymbol)->scope(), name);
68+
69+
case SymbolKind::kTypeAlias: {
70+
auto alias = symbol_cast<TypeAliasSymbol>(scopedSymbol);
71+
72+
if (auto classType = type_cast<ClassType>(alias->type())) {
73+
auto classSymbol = classType->symbol();
74+
return qualifiedLookup(classSymbol->scope(), name);
75+
}
76+
77+
if (auto enumType = type_cast<EnumType>(alias->type())) {
78+
auto enumSymbol = enumType->symbol();
79+
return qualifiedLookup(enumSymbol->scope(), name);
80+
}
81+
82+
if (auto scopedEnumType = type_cast<ScopedEnumType>(alias->type())) {
83+
auto scopedEnumSymbol = scopedEnumType->symbol();
84+
return qualifiedLookup(scopedEnumSymbol->scope(), name);
85+
}
86+
87+
return nullptr;
88+
}
89+
6590
default:
6691
return nullptr;
6792
} // switch

‎src/parser/cxx/parser.cc‎

Lines changed: 42 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -5272,29 +5272,41 @@ auto Parser::parse_static_assert_declaration(DeclarationAST*& yyast) -> bool {
52725272

52735273
expect(TokenKind::T_SEMICOLON, ast->semicolonLoc);
52745274

5275-
bool value = false;
5276-
5277-
if (constValue.has_value()) {
5278-
value = visit(to_bool, *constValue);
5275+
bool inTemplate = false;
5276+
for (auto current = scope_; current; current = current->parent()) {
5277+
if (current->isTemplateParametersScope()) {
5278+
inTemplate = true;
5279+
break;
5280+
}
52795281
}
52805282

5281-
if (!value && config_.staticAssert) {
5282-
SourceLocation loc = ast->firstSourceLocation();
5283+
if (!inTemplate) {
5284+
// not in a template context
52835285

5284-
if (!ast->expression || !constValue.has_value()) {
5285-
parse_error(
5286-
loc,
5287-
"static assertion expression is not an integral constant expression");
5288-
} else {
5289-
if (ast->literalLoc)
5290-
loc = ast->literalLoc;
5291-
else if (ast->expression)
5292-
ast->expression->firstSourceLocation();
5286+
bool value = false;
5287+
5288+
if (constValue.has_value()) {
5289+
value = visit(to_bool, *constValue);
5290+
}
5291+
5292+
if (!value && config_.staticAssert) {
5293+
SourceLocation loc = ast->firstSourceLocation();
5294+
5295+
if (!ast->expression || !constValue.has_value()) {
5296+
parse_error(loc,
5297+
"static assertion expression is not an integral constant "
5298+
"expression");
5299+
} else {
5300+
if (ast->literalLoc)
5301+
loc = ast->literalLoc;
5302+
else if (ast->expression)
5303+
ast->expression->firstSourceLocation();
52935304

5294-
std::string message =
5295-
ast->literal ? ast->literal->value() : "static assert failed";
5305+
std::string message =
5306+
ast->literal ? ast->literal->value() : "static assert failed";
52965307

5297-
unit->error(loc, std::move(message));
5308+
unit->error(loc, std::move(message));
5309+
}
52985310
}
52995311
}
53005312

@@ -9431,66 +9443,20 @@ auto Parser::parse_class_specifier(
94319443
expect(TokenKind::T_RBRACE, ast->rbraceLoc);
94329444
}
94339445

9434-
if (!is_template(classSymbol)) {
9435-
int offset = 0;
9436-
int alignment = 1;
9437-
9438-
for (auto base : classSymbol->baseClasses()) {
9439-
auto baseClassSymbol = symbol_cast<ClassSymbol>(base->symbol());
9440-
9441-
if (!baseClassSymbol) {
9442-
if (config_.checkTypes) {
9443-
parse_error(base->location(), std::format("base class '{}' not found",
9444-
to_string(base->name())));
9445-
}
9446-
continue;
9447-
}
9448-
9449-
offset = align_to(offset, baseClassSymbol->alignment());
9450-
offset += baseClassSymbol->sizeInBytes();
9451-
alignment = std::max(alignment, baseClassSymbol->alignment());
9452-
}
9453-
9454-
for (auto member : classSymbol->scope()->symbols()) {
9455-
auto field = symbol_cast<FieldSymbol>(member);
9456-
if (!field) continue;
9457-
if (field->isStatic()) continue;
9458-
9459-
if (!field->alignment()) {
9460-
if (config_.checkTypes) {
9461-
parse_error(field->location(),
9462-
std::format("alignment of incomplete type '{}'",
9463-
to_string(field->type(), field->name())));
9464-
}
9465-
continue;
9466-
}
9467-
9468-
auto size = control_->memoryLayout()->sizeOf(field->type());
9469-
9470-
if (!size.has_value()) {
9471-
if (config_.checkTypes) {
9472-
parse_error(field->location(),
9473-
std::format("size of incomplete type '{}'",
9474-
to_string(field->type(), field->name())));
9475-
}
9476-
continue;
9477-
}
9478-
9479-
if (classSymbol->isUnion()) {
9480-
offset = std::max(offset, int(size.value()));
9481-
} else {
9482-
offset = align_to(offset, field->alignment());
9483-
field->setOffset(offset);
9484-
offset += size.value();
9485-
}
9486-
9487-
alignment = std::max(alignment, field->alignment());
9446+
bool inTemplate = false;
9447+
for (auto current = scope_; current; current = current->parent()) {
9448+
if (current->isTemplateParametersScope()) {
9449+
inTemplate = true;
9450+
break;
94889451
}
9452+
}
94899453

9490-
offset = align_to(offset, alignment);
9491-
9492-
classSymbol->setAlignment(alignment);
9493-
classSymbol->setSizeInBytes(offset);
9454+
if (!inTemplate) {
9455+
auto _ = classSymbol->buildClassLayout(control_).transform_error(
9456+
[&](const std::string& e) {
9457+
parse_error(classSymbol->location(), e);
9458+
return false;
9459+
});
94949460
}
94959461

94969462
classSymbol->setComplete(true);

‎src/parser/cxx/symbol_instantiation.cc‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23,9 +23,12 @@
2323
// cxx
2424
#include <cxx/ast.h>
2525
#include <cxx/control.h>
26+
#include <cxx/memory_layout.h>
27+
#include <cxx/name_printer.h>
2628
#include <cxx/scope.h>
2729
#include <cxx/symbols.h>
2830
#include <cxx/translation_unit.h>
31+
#include <cxx/type_printer.h>
2932
#include <cxx/types.h>
3033

3134
#include <format>
@@ -185,9 +188,19 @@ auto SymbolInstantiation::findOrCreateReplacement(Symbol* symbol) -> Symbol* {
185188
replacements_[symbol] = newSymbol;
186189

187190
auto enclosingSymbol = replacement(symbol->enclosingSymbol());
191+
188192
newSymbol->setEnclosingScope(enclosingSymbol->scope());
193+
189194
if (symbol->type()) {
190195
newSymbol->setType(visit(VisitType{*this}, symbol->type()));
196+
197+
auto field = symbol_cast<FieldSymbol>(newSymbol);
198+
199+
if (field) {
200+
auto memoryLayout = control()->memoryLayout();
201+
auto alignment = memoryLayout->alignmentOf(newSymbol->type());
202+
field->setAlignment(alignment.value_or(0));
203+
}
191204
}
192205

193206
newSymbol->setName(symbol->name());
@@ -217,6 +230,10 @@ auto SymbolInstantiation::VisitSymbol::operator()(ClassSymbol* symbol)
217230
auto newSymbol = self.replacement(symbol);
218231
newSymbol->setFlags(symbol->flags());
219232

233+
if (symbol->isComplete()) {
234+
newSymbol->setComplete(true);
235+
}
236+
220237
if (symbol != self.current_) {
221238
newSymbol->setTemplateParameters(
222239
self.instantiate(symbol->templateParameters()));
@@ -226,14 +243,19 @@ auto SymbolInstantiation::VisitSymbol::operator()(ClassSymbol* symbol)
226243
auto newBaseClass = self.instantiate(baseClass);
227244
newSymbol->addBaseClass(newBaseClass);
228245
}
246+
229247
for (auto ctor : symbol->constructors()) {
230248
auto newCtor = self.instantiate(ctor);
231249
newSymbol->addConstructor(newCtor);
232250
}
251+
233252
for (auto member : views::members(symbol)) {
234253
auto newMember = self.instantiate(member);
235254
newSymbol->addMember(newMember);
236255
}
256+
257+
auto status = newSymbol->buildClassLayout(self.control());
258+
237259
return newSymbol;
238260
}
239261

‎src/parser/cxx/symbols.cc‎

Lines changed: 65 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -22,8 +22,15 @@
2222

2323
// cxx
2424
#include <cxx/ast.h>
25+
#include <cxx/control.h>
26+
#include <cxx/memory_layout.h>
27+
#include <cxx/name_printer.h>
2528
#include <cxx/scope.h>
29+
#include <cxx/type_printer.h>
2630
#include <cxx/types.h>
31+
#include <cxx/util.h>
32+
33+
#include <format>
2734

2835
namespace cxx {
2936

@@ -241,6 +248,64 @@ void ClassSymbol::addSpecialization(std::vector<TemplateArgument> arguments,
241248
templateInfo_->addSpecialization(std::move(arguments), specialization);
242249
}
243250

251+
auto ClassSymbol::buildClassLayout(Control* control)
252+
-> std::expected<bool, std::string> {
253+
int offset = 0;
254+
int alignment = 1;
255+
256+
auto memoryLayout = control->memoryLayout();
257+
258+
for (auto base : baseClasses()) {
259+
auto baseClassSymbol = symbol_cast<ClassSymbol>(base->symbol());
260+
261+
if (!baseClassSymbol) {
262+
return std::unexpected(
263+
std::format("base class '{}' not found", to_string(base->name())));
264+
}
265+
266+
offset = align_to(offset, baseClassSymbol->alignment());
267+
offset += baseClassSymbol->sizeInBytes();
268+
alignment = std::max(alignment, baseClassSymbol->alignment());
269+
}
270+
271+
for (auto member : scope()->symbols()) {
272+
auto field = symbol_cast<FieldSymbol>(member);
273+
if (!field) continue;
274+
if (field->isStatic()) continue;
275+
276+
if (!field->alignment()) {
277+
return std::unexpected(
278+
std::format("alignment of incomplete type '{}'",
279+
to_string(field->type(), field->name())));
280+
}
281+
282+
auto size = memoryLayout->sizeOf(field->type());
283+
284+
if (!size.has_value()) {
285+
return std::unexpected(
286+
std::format("size of incomplete type '{}'",
287+
to_string(field->type(), field->name())));
288+
}
289+
290+
if (isUnion()) {
291+
offset = std::max(offset, int(size.value()));
292+
} else {
293+
offset = align_to(offset, field->alignment());
294+
field->setOffset(offset);
295+
offset += size.value();
296+
}
297+
298+
alignment = std::max(alignment, field->alignment());
299+
}
300+
301+
offset = align_to(offset, alignment);
302+
303+
setAlignment(alignment);
304+
setSizeInBytes(offset);
305+
306+
return true;
307+
}
308+
244309
EnumSymbol::EnumSymbol(Scope* enclosingScope)
245310
: ScopedSymbol(Kind, enclosingScope) {}
246311

‎src/parser/cxx/symbols.h‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,7 @@
2727
#include <cxx/symbols_fwd.h>
2828
#include <cxx/types_fwd.h>
2929

30+
#include <expected>
3031
#include <memory>
3132
#include <optional>
3233
#include <ranges>
@@ -298,6 +299,9 @@ class ClassSymbol final : public ScopedSymbol {
298299
return templateSepcializationIndex_;
299300
}
300301

302+
[[nodiscard]] auto buildClassLayout(Control* control)
303+
-> std::expected<bool, std::string>;
304+
301305
private:
302306
[[nodiscard]] auto hasBaseClass(Symbol* symbol,
303307
std::unordered_set<const ClassSymbol*>&) const

‎tests/unit_tests/sema/template_class_04.cc‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
// RUN: %cxx -verify -ftemplates -fcheck %s
2+
3+
template <typename Key, typename Value>
4+
struct X {
5+
Key key;
6+
Value value;
7+
8+
void check() { static_assert(sizeof(*this)); }
9+
};
10+
11+
auto main() -> int {
12+
using U = X<char, int>;
13+
U u;
14+
15+
static_assert(sizeof(U) == 8);
16+
static_assert(sizeof(u) == 8);
17+
18+
static_assert(__builtin_offsetof(U, key) == 0);
19+
static_assert(__builtin_offsetof(U, value) == 4);
20+
21+
static_assert(sizeof(X<char, int>::key) == 1);
22+
static_assert(sizeof(X<char, int>::value) == 4);
23+
24+
static_assert(sizeof(U::key) == 1);
25+
static_assert(sizeof(U::value) == 4);
26+
27+
return 0;
28+
}

0 commit comments

Comments
 (0)