Coverage Report

Created: 2020-09-22 08:39

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/AST/Interp/Function.h
Line
Count
Source (jump to first uncovered line)
1
//===--- Function.h - Bytecode function 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 the Function class which holds all bytecode function-specific data.
10
//
11
// The scope class which describes local variables is also defined here.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CLANG_AST_INTERP_FUNCTION_H
16
#define LLVM_CLANG_AST_INTERP_FUNCTION_H
17
18
#include "Pointer.h"
19
#include "Source.h"
20
#include "clang/AST/Decl.h"
21
#include "llvm/Support/raw_ostream.h"
22
23
namespace clang {
24
namespace interp {
25
class Program;
26
class ByteCodeEmitter;
27
enum PrimType : uint32_t;
28
29
/// Describes a scope block.
30
///
31
/// The block gathers all the descriptors of the locals defined in this block.
32
class Scope {
33
public:
34
  /// Information about a local's storage.
35
  struct Local {
36
    /// Offset of the local in frame.
37
    unsigned Offset;
38
    /// Descriptor of the local.
39
    Descriptor *Desc;
40
  };
41
42
  using LocalVectorTy = llvm::SmallVector<Local, 8>;
43
44
0
  Scope(LocalVectorTy &&Descriptors) : Descriptors(std::move(Descriptors)) {}
45
46
0
  llvm::iterator_range<LocalVectorTy::iterator> locals() {
47
0
    return llvm::make_range(Descriptors.begin(), Descriptors.end());
48
0
  }
49
50
private:
51
  /// Object descriptors in this block.
52
  LocalVectorTy Descriptors;
53
};
54
55
/// Bytecode function.
56
///
57
/// Contains links to the bytecode of the function, as well as metadata
58
/// describing all arguments and stack-local variables.
59
class Function {
60
public:
61
  using ParamDescriptor = std::pair<PrimType, Descriptor *>;
62
63
  /// Returns the size of the function's local stack.
64
1
  unsigned getFrameSize() const { return FrameSize; }
65
  /// Returns the size of the argument stackx
66
1
  unsigned getArgSize() const { return ArgSize; }
67
68
  /// Returns a pointer to the start of the code.
69
  CodePtr getCodeBegin() const;
70
  /// Returns a pointer to the end of the code.
71
  CodePtr getCodeEnd() const;
72
73
  /// Returns the original FunctionDecl.
74
0
  const FunctionDecl *getDecl() const { return F; }
75
76
  /// Returns the lcoation.
77
0
  SourceLocation getLoc() const { return Loc; }
78
79
  /// Returns a parameter descriptor.
80
  ParamDescriptor getParamDescriptor(unsigned Offset) const;
81
82
  /// Checks if the first argument is a RVO pointer.
83
0
  bool hasRVO() const { return ParamTypes.size() != Params.size(); }
84
85
  /// Range over the scope blocks.
86
0
  llvm::iterator_range<llvm::SmallVector<Scope, 2>::iterator> scopes() {
87
0
    return llvm::make_range(Scopes.begin(), Scopes.end());
88
0
  }
89
90
  /// Range over argument types.
91
  using arg_reverse_iterator = SmallVectorImpl<PrimType>::reverse_iterator;
92
0
  llvm::iterator_range<arg_reverse_iterator> args_reverse() {
93
0
    return llvm::make_range(ParamTypes.rbegin(), ParamTypes.rend());
94
0
  }
95
96
  /// Returns a specific scope.
97
0
  Scope &getScope(unsigned Idx) { return Scopes[Idx]; }
98
99
  /// Returns the source information at a given PC.
100
  SourceInfo getSource(CodePtr PC) const;
101
102
  /// Checks if the function is valid to call in constexpr.
103
1
  bool isConstexpr() const { return IsValid; }
104
105
  /// Checks if the function is virtual.
106
  bool isVirtual() const;
107
108
  /// Checks if the function is a constructor.
109
1
  bool isConstructor() const { return isa<CXXConstructorDecl>(F); }
110
111
private:
112
  /// Construct a function representing an actual function.
113
  Function(Program &P, const FunctionDecl *F, unsigned ArgSize,
114
           llvm::SmallVector<PrimType, 8> &&ParamTypes,
115
           llvm::DenseMap<unsigned, ParamDescriptor> &&Params);
116
117
  /// Sets the code of a function.
118
  void setCode(unsigned NewFrameSize, std::vector<char> &&NewCode, SourceMap &&NewSrcMap,
119
1
               llvm::SmallVector<Scope, 2> &&NewScopes) {
120
1
    FrameSize = NewFrameSize;
121
1
    Code = std::move(NewCode);
122
1
    SrcMap = std::move(NewSrcMap);
123
1
    Scopes = std::move(NewScopes);
124
1
    IsValid = true;
125
1
  }
126
127
private:
128
  friend class Program;
129
  friend class ByteCodeEmitter;
130
131
  /// Program reference.
132
  Program &P;
133
  /// Location of the executed code.
134
  SourceLocation Loc;
135
  /// Declaration this function was compiled from.
136
  const FunctionDecl *F;
137
  /// Local area size: storage + metadata.
138
  unsigned FrameSize;
139
  /// Size of the argument stack.
140
  unsigned ArgSize;
141
  /// Program code.
142
  std::vector<char> Code;
143
  /// Opcode-to-expression mapping.
144
  SourceMap SrcMap;
145
  /// List of block descriptors.
146
  llvm::SmallVector<Scope, 2> Scopes;
147
  /// List of argument types.
148
  llvm::SmallVector<PrimType, 8> ParamTypes;
149
  /// Map from byte offset to parameter descriptor.
150
  llvm::DenseMap<unsigned, ParamDescriptor> Params;
151
  /// Flag to indicate if the function is valid.
152
  bool IsValid = false;
153
154
public:
155
  /// Dumps the disassembled bytecode to \c llvm::errs().
156
  void dump() const;
157
  void dump(llvm::raw_ostream &OS) const;
158
};
159
160
} // namespace interp
161
} // namespace clang
162
163
#endif