Files
carbon-lang/toolchain/sem_ir/class.h
T
David BlaikieandRichard Smith dfed743de2 Add vtable pointers to class layout (#4407)
A small step to virtual functions - adding vtable pointers to the
layout, but not initializing or otherwise using them at this stage.

A few open design questions I'd love feedback on:

* Is this the right/good enough SemIR representation for now? This patch
adds a `is_dynamic` attribute to `SemIR::Class` and populates/flags it
based on the flag of the base class, or if any virtual function is
declared in the class (or, at least that's my intent). Some other
options include:
* Each `Class` could store a `ClassId` (or `TypeId`?) of the (possibly
indirect, possibly self) base class that is the first one that is
dynamic/has a vtable pointer
* Could make the property narrower, like `has vtable pointer` and have
it `true` only on the type that introduces the vtable - then derived
classes would have to walk their base classes to check if they're the
one that needs to define the vtable pointer or not
* Should the vtable be the first element in the type? If there's a
non-dynamic base type, we could have a layout that's `{<non-dynamic base
type>, vtable ptr, <derived members>}`? Derived types would still be
able to uniquely identify where their vtable pointer is just fine... -
and the vtable pointer is, in a sense, a member of that intermediate
type, so it does seem a bit strange to force it to the front - but I
guess it's probably more efficient in some ways?

Open to any other suggestions/advice/thoughts on the direction, etc.

---------

Co-authored-by: Richard Smith <richard@metafoo.co.uk>
2024-10-16 21:26:17 +00:00

88 lines
3.0 KiB
C++

// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#ifndef CARBON_TOOLCHAIN_SEM_IR_CLASS_H_
#define CARBON_TOOLCHAIN_SEM_IR_CLASS_H_
#include "toolchain/sem_ir/entity_with_params_base.h"
#include "toolchain/sem_ir/ids.h"
namespace Carbon::SemIR {
// Class-specific fields.
struct ClassFields {
enum InheritanceKind : int8_t {
// `abstract class`
Abstract,
// `base class`
Base,
// `class`
Final,
};
// The following members always have values, and do not change throughout the
// lifetime of the class.
// The class type, which is the type of `Self` in the class definition.
TypeId self_type_id;
// The kind of inheritance that this class supports.
// TODO: The rules here are not yet decided. See #3384.
InheritanceKind inheritance_kind;
// Whether this class or any base class has at least one virtual function.
bool is_dynamic = false;
// The following members are set at the `{` of the class definition.
// The class scope.
NameScopeId scope_id = NameScopeId::Invalid;
// The first block of the class body.
// TODO: Handle control flow in the class body, such as if-expressions.
InstBlockId body_block_id = InstBlockId::Invalid;
// The following members are accumulated throughout the class definition.
// The adapted type declaration, if any. Invalid if the class is not an
// adapter. This is an AdaptDecl instruction.
// TODO: Consider sharing the storage for `adapt_id` and `base_id`. A class
// can't have both.
InstId adapt_id = InstId::Invalid;
// The base class declaration. Invalid if the class has no base class. This is
// a BaseDecl instruction.
InstId base_id = InstId::Invalid;
// The following members are set at the `}` of the class definition.
// A `CompleteTypeWitness` instruction witnessing that this class type is
// complete, and tracking its object representation. This is valid once the
// class is defined. For an adapter, the object representation is the
// non-adapter type that this class directly or transitively adapts.
InstId complete_type_witness_id = InstId::Invalid;
};
// A class. See EntityWithParamsBase regarding the inheritance here.
struct Class : public EntityWithParamsBase,
public ClassFields,
public Printable<Class> {
auto Print(llvm::raw_ostream& out) const -> void {
out << "{";
PrintBaseFields(out);
out << "}";
}
// Determines whether this class has been fully defined. This is false until
// we reach the `}` of the class definition.
auto is_defined() const -> bool {
return complete_type_witness_id.is_valid();
}
// Gets the object representation for this class. Returns Invalid if the class
// is not yet defined.
auto GetObjectRepr(const File& file, SpecificId specific_id) const -> TypeId;
};
} // namespace Carbon::SemIR
#endif // CARBON_TOOLCHAIN_SEM_IR_CLASS_H_