Coverage Report

Created: 2019-02-21 13:17

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/CodeGen/ConstantInitFuture.h
Line
Count
Source (jump to first uncovered line)
1
//===- ConstantInitFuture.h - "Future" constant initializers ----*- 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
// This class defines the ConstantInitFuture class.  This is split out
10
// from ConstantInitBuilder.h in order to allow APIs to work with it
11
// without having to include that entire header.  This is particularly
12
// important because it is often useful to be able to default-construct
13
// a future in, say, a default argument.
14
//
15
//===----------------------------------------------------------------------===//
16
17
#ifndef LLVM_CLANG_CODEGEN_CONSTANTINITFUTURE_H
18
#define LLVM_CLANG_CODEGEN_CONSTANTINITFUTURE_H
19
20
#include "llvm/ADT/PointerUnion.h"
21
#include "llvm/IR/Constant.h"
22
23
// Forward-declare ConstantInitBuilderBase and give it a
24
// PointerLikeTypeTraits specialization so that we can safely use it
25
// in a PointerUnion below.
26
namespace clang {
27
namespace CodeGen {
28
class ConstantInitBuilderBase;
29
}
30
}
31
namespace llvm {
32
template <>
33
struct PointerLikeTypeTraits< ::clang::CodeGen::ConstantInitBuilderBase*> {
34
  using T = ::clang::CodeGen::ConstantInitBuilderBase*;
35
36
0
  static inline void *getAsVoidPointer(T p) { return p; }
37
0
  static inline T getFromVoidPointer(void *p) {return static_cast<T>(p);}
38
  enum { NumLowBitsAvailable = 2 };
39
};
40
}
41
42
namespace clang {
43
namespace CodeGen {
44
45
/// A "future" for a completed constant initializer, which can be passed
46
/// around independently of any sub-builders (but not the original parent).
47
class ConstantInitFuture {
48
  using PairTy = llvm::PointerUnion<ConstantInitBuilderBase*, llvm::Constant*>;
49
50
  PairTy Data;
51
52
  friend class ConstantInitBuilderBase;
53
  explicit ConstantInitFuture(ConstantInitBuilderBase *builder);
54
55
public:
56
  ConstantInitFuture() {}
57
58
  /// A future can be explicitly created from a fixed initializer.
59
  explicit ConstantInitFuture(llvm::Constant *initializer) : Data(initializer) {
60
    assert(initializer && "creating null future");
61
  }
62
63
  /// Is this future non-null?
64
0
  explicit operator bool() const { return bool(Data); }
65
66
  /// Return the type of the initializer.
67
  llvm::Type *getType() const;
68
69
  /// Abandon this initializer.
70
  void abandon();
71
72
  /// Install the initializer into a global variable.  This cannot
73
  /// be called multiple times.
74
  void installInGlobal(llvm::GlobalVariable *global);
75
76
0
  void *getOpaqueValue() const { return Data.getOpaqueValue(); }
77
0
  static ConstantInitFuture getFromOpaqueValue(void *value) {
78
0
    ConstantInitFuture result;
79
0
    result.Data = PairTy::getFromOpaqueValue(value);
80
0
    return result;
81
0
  }
82
  enum {
83
    NumLowBitsAvailable =
84
      llvm::PointerLikeTypeTraits<PairTy>::NumLowBitsAvailable
85
  };
86
};
87
88
}  // end namespace CodeGen
89
}  // end namespace clang
90
91
namespace llvm {
92
93
template <>
94
struct PointerLikeTypeTraits< ::clang::CodeGen::ConstantInitFuture> {
95
  using T = ::clang::CodeGen::ConstantInitFuture;
96
97
  static inline void *getAsVoidPointer(T future) {
98
    return future.getOpaqueValue();
99
  }
100
  static inline T getFromVoidPointer(void *p) {
101
    return T::getFromOpaqueValue(p);
102
  }
103
  enum { NumLowBitsAvailable = T::NumLowBitsAvailable };
104
};
105
106
} // end namespace llvm
107
108
#endif