ByteCodeEmitter.h

Go to the documentation of this file.

//===--- ByteCodeEmitter.h - Instruction emitter for the VM -----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Defines the instruction emitters.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_AST_INTERP_LINKEMITTER_H
#define LLVM_CLANG_AST_INTERP_LINKEMITTER_H
 
#include "Context.h"
#include "PrimType.h"
#include "Program.h"
#include "Source.h"
 
namespace clang {
namespace interp {
enum Opcode : uint32_t;
 
/// An emitter which links the program to bytecode for later use.
class ByteCodeEmitter {
protected:
  using AddrTy = uintptr_t;
  using Local = Scope::Local;
 
public:
  using LabelTy = uint32_t;
  /// Compiles the function into the module.
  void compileFunc(const FunctionDecl *FuncDecl, Function *Func = nullptr);
 
protected:
  ByteCodeEmitter(Context &Ctx, Program &P) : Ctx(Ctx), P(P) {}
 
  virtual ~ByteCodeEmitter() {}
 
  /// Define a label.
  void emitLabel(LabelTy Label);
  /// Create a label.
  LabelTy getLabel() { return ++NextLabel; }
 
  /// Methods implemented by the compiler.
  virtual bool visitFunc(const FunctionDecl *E) = 0;
  virtual bool visitExpr(const Expr *E, bool DestroyToplevelScope) = 0;
  virtual bool visitLValueExpr(const Expr *E, bool DestroyToplevelScope) = 0;
  virtual bool visitDeclAndReturn(const VarDecl *VD, const Expr *Init,
                                  bool ConstantContext) = 0;
  virtual bool visitDtorCall(const VarDecl *VD, const APValue &) = 0;
  virtual bool visitWithSubstitutions(const FunctionDecl *Callee,
                                      ArrayRef<const Expr *> Args,
                                      const Expr *This,
                                      const Expr *Condition) = 0;
  virtual bool visit(const Expr *E) = 0;
  virtual bool emitBool(bool V, const Expr *E) = 0;
 
  /// Emits jumps.
  bool jumpTrue(const LabelTy &Label, SourceInfo SI);
  bool jumpFalse(const LabelTy &Label, SourceInfo SI);
  bool jump(const LabelTy &Label, SourceInfo SI);
  bool fallthrough(const LabelTy &Label);
  /// Speculative execution.
  bool speculate(const CallExpr *E, const LabelTy &EndLabel);
 
  /// We're always emitting bytecode.
  bool isActive() const { return true; }
  bool checkingForUndefinedBehavior() const { return false; }
 
  /// Callback for local registration.
  Local createLocal(Descriptor *D);
 
  /// Parameter indices.
  llvm::DenseMap<const ParmVarDecl *, FuncParam> Params;
  /// Lambda captures.
  llvm::DenseMap<const ValueDecl *, ParamOffset> LambdaCaptures;
  /// Offset of the This parameter in a lambda record.
  ParamOffset LambdaThisCapture{0, false};
  /// Local descriptors.
  llvm::SmallVector<SmallVector<Local, 8>, 2> Descriptors;
  std::optional<SourceInfo> LocOverride = std::nullopt;
 
private:
  /// Current compilation context.
  Context &Ctx;
  /// Program to link to.
  Program &P;
  /// Index of the next available label.
  LabelTy NextLabel = 0;
  /// Offset of the next local variable.
  unsigned NextLocalOffset = 0;
  /// Label information for linker.
  llvm::DenseMap<LabelTy, unsigned> LabelOffsets;
  /// Location of label relocations.
  llvm::DenseMap<LabelTy, llvm::SmallVector<unsigned, 5>> LabelRelocs;
  /// Program code.
  llvm::SmallVector<std::byte> Code;
  /// Opcode to expression mapping.
  SourceMap SrcMap;
 
  /// Returns the offset for a jump or records a relocation.
  int32_t getOffset(LabelTy Label);
 
  /// Emits an opcode.
  template <typename... Tys>
  bool emitOp(Opcode Op, const Tys &...Args, SourceInfo L);
 
protected:
#define GET_LINK_PROTO
#include "Opcodes.inc"
#undef GET_LINK_PROTO
};
 
} // namespace interp
} // namespace clang
 
#endif