llvm/clang/lib/AST/ByteCode/ByteCodeEmitter.cpp

//===--- ByteCodeEmitter.cpp - 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
//
//===----------------------------------------------------------------------===//

#include "ByteCodeEmitter.h"
#include "Context.h"
#include "FixedPoint.h"
#include "Floating.h"
#include "IntegralAP.h"
#include "Opcode.h"
#include "Program.h"
#include "clang/AST/ASTLambda.h"
#include "clang/AST/Attr.h"
#include "clang/AST/DeclCXX.h"
#include "clang/Basic/Builtins.h"
#include <type_traits>

usingnamespaceclang;
usingnamespaceclang::interp;

Function *ByteCodeEmitter::compileFunc(const FunctionDecl *FuncDecl) { … }

/// Compile an ObjC block, i.e. ^(){}, that thing.
///
/// FIXME: We do not support calling the block though, so we create a function
/// here but do not compile any code for it.
Function *ByteCodeEmitter::compileObjCBlock(const BlockExpr *BE) { … }

Scope::Local ByteCodeEmitter::createLocal(Descriptor *D) { … }

void ByteCodeEmitter::emitLabel(LabelTy Label) { … }

int32_t ByteCodeEmitter::getOffset(LabelTy Label) { … }

/// Helper to write bytecode and bail out if 32-bit offsets become invalid.
/// Pointers will be automatically marshalled as 32-bit IDs.
template <typename T>
static void emit(Program &P, std::vector<std::byte> &Code, const T &Val,
                 bool &Success) { … }

/// Emits a serializable value. These usually (potentially) contain
/// heap-allocated memory and aren't trivially copyable.
template <typename T>
static void emitSerialized(std::vector<std::byte> &Code, const T &Val,
                           bool &Success) { … }

template <>
void emit(Program &P, std::vector<std::byte> &Code, const Floating &Val,
          bool &Success) { … }

template <>
void emit(Program &P, std::vector<std::byte> &Code,
          const IntegralAP<false> &Val, bool &Success) { … }

template <>
void emit(Program &P, std::vector<std::byte> &Code, const IntegralAP<true> &Val,
          bool &Success) { … }

template <typename... Tys>
bool ByteCodeEmitter::emitOp(Opcode Op, const Tys &...Args,
                             const SourceInfo &SI) { … }

bool ByteCodeEmitter::jumpTrue(const LabelTy &Label) { … }

bool ByteCodeEmitter::jumpFalse(const LabelTy &Label) { … }

bool ByteCodeEmitter::jump(const LabelTy &Label) { … }

bool ByteCodeEmitter::fallthrough(const LabelTy &Label) { … }

//===----------------------------------------------------------------------===//
// Opcode emitters
//===----------------------------------------------------------------------===//

#define GET_LINK_IMPL
#include "Opcodes.inc"
#undef GET_LINK_IMPL