clang/lib/AST/Interp/Source.h

   1 //===--- Source.h - Source location provider for the VM  --------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Defines a program which organises and links multiple bytecode functions.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_CLANG_AST_INTERP_SOURCE_H
  14 #define LLVM_CLANG_AST_INTERP_SOURCE_H
  15
  16 #include "PrimType.h"
  17 #include "clang/AST/DeclBase.h"
  18 #include "clang/AST/Stmt.h"
  19 #include "llvm/ADT/PointerUnion.h"
  20 #include "llvm/Support/Endian.h"
  21
  22 namespace clang {
  23 class Expr;
  24 class SourceLocation;
  25 class SourceRange;
  26 namespace interp {
  27 class Function;
  28
  29 /// Pointer into the code segment.
  30 class CodePtr final {
  31 public:
  32   CodePtr() : Ptr(nullptr) {}
  33
  34   CodePtr &operator+=(int32_t Offset) {
  35     Ptr += Offset;
  36     return *this;
  37   }
  38
  39   int32_t operator-(const CodePtr &RHS) const {
  40     assert(Ptr != nullptr && RHS.Ptr != nullptr && "Invalid code pointer");
  41     return Ptr - RHS.Ptr;
  42   }
  43
  44   CodePtr operator-(size_t RHS) const {
  45     assert(Ptr != nullptr && "Invalid code pointer");
  46     return CodePtr(Ptr - RHS);
  47   }
  48
  49   bool operator!=(const CodePtr &RHS) const { return Ptr != RHS.Ptr; }
  50   const std::byte *operator*() const { return Ptr; }
  51
  52   operator bool() const { return Ptr; }
  53
  54   /// Reads data and advances the pointer.
  55   template <typename T> std::enable_if_t<!std::is_pointer<T>::value, T> read() {
  56     assert(aligned(Ptr));
  57     using namespace llvm::support;
  58     T Value = endian::read<T, llvm::endianness::native>(Ptr);
  59     Ptr += align(sizeof(T));
  60     return Value;
  61   }
  62
  63 private:
  64   friend class Function;
  65   /// Constructor used by Function to generate pointers.
  66   CodePtr(const std::byte *Ptr) : Ptr(Ptr) {}
  67   /// Pointer into the code owned by a function.
  68   const std::byte *Ptr;
  69 };
  70
  71 /// Describes the statement/declaration an opcode was generated from.
  72 class SourceInfo final {
  73 public:
  74   SourceInfo() {}
  75   SourceInfo(const Stmt *E) : Source(E) {}
  76   SourceInfo(const Decl *D) : Source(D) {}
  77
  78   SourceLocation getLoc() const;
  79   SourceRange getRange() const;
  80
  81   const Stmt *asStmt() const { return Source.dyn_cast<const Stmt *>(); }
  82   const Decl *asDecl() const { return Source.dyn_cast<const Decl *>(); }
  83   const Expr *asExpr() const;
  84
  85   operator bool() const { return !Source.isNull(); }
  86
  87 private:
  88   llvm::PointerUnion<const Decl *, const Stmt *> Source;
  89 };
  90
  91 using SourceMap = std::vector<std::pair<unsigned, SourceInfo>>;
  92
  93 /// Interface for classes which map locations to sources.
  94 class SourceMapper {
  95 public:
  96   virtual ~SourceMapper() {}
  97
  98   /// Returns source information for a given PC in a function.
  99   virtual SourceInfo getSource(const Function *F, CodePtr PC) const = 0;
 100
 101   /// Returns the expression if an opcode belongs to one, null otherwise.
 102   const Expr *getExpr(const Function *F, CodePtr PC) const;
 103   /// Returns the location from which an opcode originates.
 104   SourceLocation getLocation(const Function *F, CodePtr PC) const;
 105   SourceRange getRange(const Function *F, CodePtr PC) const;
 106 };
 107
 108 } // namespace interp
 109 } // namespace clang
 110
 111 #endif