Files
carbon-lang/toolchain/lowering/lowering_function_context.h
T
Jon Ross-Perkins 67da700dd5 Split Semantics into Check and SemIR namespaces (#3138)
Splits IR files into SemIR, and logic files into Check. These will be
split into separate directories as part of a later move; the namespaces
are being done first in order to vet the switch, and hopefully make
conflicts a little easier to manage due to the substantial renames.

A lot of this is just automated removal of Semantics prefixes from
names, adding namespace references where needed. A few special-cases
are:

- SemanticsIR -> SemIR::File
- A few things were discussed, like Unit, CompileUnit, or CompiledUnit.
Unit was too vague for chandlerc, and I thought CompileUnit might lead
to incorrect inferences (CompilationUnit would be more precise, but
typically written as SemIR::CompilationUnit which is pretty long). File
seemed to be a short name that we could agree on.
- SemanticsIRFormatter -> SemIR::Formatter
- FormatSemanticsIR -> SemIR::FormatFile
- SemanticsFileTest -> CheckFileTest
- It remains in the Testing namespace, where just "FileTest" might be
too broad a name.
- SemanticsDeclarationNameStack::Context ->
Check::DeclarationNameStack::NameContext
  - This avoids a Check::Context name shadowing.

Changes check_internal.h to include ostream.h to improve finding of
Print/operator<< (otherwise it didn't compile).

This is part of #3070
2023-08-23 22:51:23 +00:00

142 lines
5.1 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_LOWERING_LOWERING_FUNCTION_CONTEXT_H_
#define CARBON_TOOLCHAIN_LOWERING_LOWERING_FUNCTION_CONTEXT_H_
#include <optional>
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "toolchain/lowering/lowering_context.h"
#include "toolchain/semantics/semantics_ir.h"
#include "toolchain/semantics/semantics_node.h"
namespace Carbon {
// Context and shared functionality for lowering handlers that produce an
// `llvm::Function` definition.
class LoweringFunctionContext {
public:
explicit LoweringFunctionContext(LoweringContext& lowering_context,
llvm::Function* function);
// 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;
// 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;
return it->second;
}
// Returns a local (versus global) value for the given node in loaded state.
// Loads will only be inserted on an as-needed basis.
auto GetLocalLoaded(SemIR::NodeId node_id) -> llvm::Value*;
// 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;
}
// Returns the requested index into val based on whether val is a pointer
// type.
auto GetIndexFromStructOrArray(llvm::Type* llvm_type, llvm::Value* val,
unsigned idx, const llvm::Twine& name)
-> llvm::Value* {
return val->getType()->isPointerTy()
? builder().CreateStructGEP(llvm_type, val, idx, name)
: builder().CreateExtractValue(val, idx, name);
}
// Gets a callable's function.
auto GetFunction(SemIR::FunctionId function_id) -> llvm::Function* {
return lowering_context_->GetFunction(function_id);
}
// Returns a lowered type for the given type_id.
auto GetType(SemIR::TypeId type_id) -> llvm::Type* {
return lowering_context_->GetType(type_id);
}
// Returns a lowered value to use for a value of type `type`.
auto GetTypeAsValue() -> llvm::Value* {
return lowering_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;
}
auto llvm_context() -> llvm::LLVMContext& {
return lowering_context_->llvm_context();
}
auto llvm_module() -> llvm::Module& {
return lowering_context_->llvm_module();
}
auto builder() -> llvm::IRBuilder<>& { return builder_; }
auto semantics_ir() -> const SemIR::File& {
return lowering_context_->semantics_ir();
}
private:
// Context for the overall lowering process.
LoweringContext* lowering_context_;
// The IR function we're generating.
llvm::Function* function_;
llvm::IRBuilder<> builder_;
// 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_SEMANTICS_NODE_KIND(Name) \
auto LoweringHandle##Name(LoweringFunctionContext& context, \
SemIR::NodeId node_id, SemIR::Node node) \
->void;
#include "toolchain/semantics/semantics_node_kind.def"
} // namespace Carbon
#endif // CARBON_TOOLCHAIN_LOWERING_LOWERING_FUNCTION_CONTEXT_H_