mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-11-17 03:38:12 +00:00
This is a prerequisite for class support, where a class can be
referenced as a type before it becomes complete. For example, given:
```carbon
class A {
fn F(a: A);
class B {}
var b: B;
}
fn A.F(a: A) {}
```
we need to lower `B` before we lower `A`, even though `A` is used as a
type first.
This will also start catching some cases where we don't require a type
to be complete despite using it, as we now only lower types that are
required to be complete.
Remove the poison values for struct and tuple literals. We don't need
those any more, because we never generate references to those literals
as values, and we don't have a type to use for them because we never
require the type of a literal to be complete, only the type of the
entity initialized by the literal, which can be different, for example
when initializing an array from a tuple literal or a class from a struct
literal.
This doesn't affect the output: `llvm::Type` objects that are not
referenced by an LLVM module don't affect the IR for that module, and
the order in which `llvm::Type`s are created doesn't affect anything
either.
145 lines
5.4 KiB
C++
145 lines
5.4 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_LOWER_FUNCTION_CONTEXT_H_
|
|
#define CARBON_TOOLCHAIN_LOWER_FUNCTION_CONTEXT_H_
|
|
|
|
#include "llvm/IR/IRBuilder.h"
|
|
#include "llvm/IR/LLVMContext.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "toolchain/lower/file_context.h"
|
|
#include "toolchain/sem_ir/file.h"
|
|
#include "toolchain/sem_ir/node.h"
|
|
|
|
namespace Carbon::Lower {
|
|
|
|
// Context and shared functionality for lowering handlers that produce an
|
|
// `llvm::Function` definition.
|
|
class FunctionContext {
|
|
public:
|
|
explicit FunctionContext(FileContext& file_context, llvm::Function* function,
|
|
llvm::raw_ostream* vlog_stream);
|
|
|
|
// Returns a basic block corresponding to the start of the given semantics
|
|
// block, and enqueues it for emission.
|
|
auto GetBlock(SemIR::NodeBlockId block_id) -> llvm::BasicBlock*;
|
|
|
|
// If we have not yet allocated a `BasicBlock` for this `block_id`, set it to
|
|
// `block`, and enqueue `block_id` for emission. Returns whether we set the
|
|
// block.
|
|
auto TryToReuseBlock(SemIR::NodeBlockId block_id, llvm::BasicBlock* block)
|
|
-> bool;
|
|
|
|
// Builds LLVM IR for the sequence of instructions in `block_id`.
|
|
auto LowerBlock(SemIR::NodeBlockId block_id) -> void;
|
|
|
|
// Returns a phi node corresponding to the block argument of the given basic
|
|
// block.
|
|
auto GetBlockArg(SemIR::NodeBlockId block_id, SemIR::TypeId type_id)
|
|
-> llvm::PHINode*;
|
|
|
|
// Returns a local (versus global) value for the given node.
|
|
auto GetLocal(SemIR::NodeId node_id) -> llvm::Value* {
|
|
// All builtins are types, with the same empty lowered value.
|
|
if (node_id.index < SemIR::BuiltinKind::ValidCount) {
|
|
return GetTypeAsValue();
|
|
}
|
|
|
|
auto it = locals_.find(node_id);
|
|
CARBON_CHECK(it != locals_.end()) << "Missing local: " << node_id << " "
|
|
<< semantics_ir().GetNode(node_id);
|
|
return it->second;
|
|
}
|
|
|
|
// Sets the value for the given node.
|
|
auto SetLocal(SemIR::NodeId node_id, llvm::Value* value) {
|
|
bool added = locals_.insert({node_id, value}).second;
|
|
CARBON_CHECK(added) << "Duplicate local insert: " << node_id << " "
|
|
<< semantics_ir().GetNode(node_id);
|
|
}
|
|
|
|
// Gets a callable's function.
|
|
auto GetFunction(SemIR::FunctionId function_id) -> llvm::Function* {
|
|
return file_context_->GetFunction(function_id);
|
|
}
|
|
|
|
// Returns a lowered type for the given type_id.
|
|
auto GetType(SemIR::TypeId type_id) -> llvm::Type* {
|
|
return file_context_->GetType(type_id);
|
|
}
|
|
|
|
// Returns a lowered value to use for a value of type `type`.
|
|
auto GetTypeAsValue() -> llvm::Value* {
|
|
return file_context_->GetTypeAsValue();
|
|
}
|
|
|
|
// Create a synthetic block that corresponds to no SemIR::NodeBlockId. Such
|
|
// a block should only ever have a single predecessor, and is used when we
|
|
// need multiple `llvm::BasicBlock`s to model the linear control flow in a
|
|
// single SemIR::File block.
|
|
auto CreateSyntheticBlock() -> llvm::BasicBlock*;
|
|
|
|
// Determine whether block is the most recently created synthetic block.
|
|
auto IsCurrentSyntheticBlock(llvm::BasicBlock* block) -> bool {
|
|
return synthetic_block_ == block;
|
|
}
|
|
|
|
// After emitting an initializer `init_id`, finishes performing the
|
|
// initialization of `dest_id` from that initializer. This is a no-op if the
|
|
// initialization was performed in-place, and otherwise performs a store or a
|
|
// copy.
|
|
auto FinishInitialization(SemIR::TypeId type_id, SemIR::NodeId dest_id,
|
|
SemIR::NodeId init_id) -> void;
|
|
|
|
auto llvm_context() -> llvm::LLVMContext& {
|
|
return file_context_->llvm_context();
|
|
}
|
|
auto llvm_module() -> llvm::Module& { return file_context_->llvm_module(); }
|
|
auto builder() -> llvm::IRBuilder<>& { return builder_; }
|
|
auto semantics_ir() -> const SemIR::File& {
|
|
return file_context_->semantics_ir();
|
|
}
|
|
|
|
private:
|
|
// Emits a value copy for type `type_id` from `source_id` to `dest_id`.
|
|
// `source_id` must produce a value representation for `type_id`, and
|
|
// `dest_id` must be a pointer to a `type_id` object.
|
|
auto CopyValue(SemIR::TypeId type_id, SemIR::NodeId source_id,
|
|
SemIR::NodeId dest_id) -> void;
|
|
|
|
// Context for the overall lowering process.
|
|
FileContext* file_context_;
|
|
|
|
// The IR function we're generating.
|
|
llvm::Function* function_;
|
|
|
|
llvm::IRBuilder<> builder_;
|
|
|
|
// The optional vlog stream.
|
|
llvm::raw_ostream* vlog_stream_;
|
|
|
|
// Maps a function's SemIR::File blocks to lowered blocks.
|
|
llvm::DenseMap<SemIR::NodeBlockId, llvm::BasicBlock*> blocks_;
|
|
|
|
// The synthetic block we most recently created. May be null if there is no
|
|
// such block.
|
|
llvm::BasicBlock* synthetic_block_ = nullptr;
|
|
|
|
// Maps a function's SemIR::File nodes to lowered values.
|
|
// TODO: Handle nested scopes. Right now this is just cleared at the end of
|
|
// every block.
|
|
llvm::DenseMap<SemIR::NodeId, llvm::Value*> locals_;
|
|
};
|
|
|
|
// Declare handlers for each SemIR::File node.
|
|
#define CARBON_SEM_IR_NODE_KIND(Name) \
|
|
auto Handle##Name(FunctionContext& context, SemIR::NodeId node_id, \
|
|
SemIR::Name node) \
|
|
->void;
|
|
#include "toolchain/sem_ir/node_kind.def"
|
|
|
|
} // namespace Carbon::Lower
|
|
|
|
#endif // CARBON_TOOLCHAIN_LOWER_FUNCTION_CONTEXT_H_
|