1 //===-------- llvm/GlobalAlias.h - GlobalAlias class ------------*- 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 file contains the declaration of the GlobalAlias class, which
10 // represents a single function or variable alias in the IR.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_IR_GLOBALALIAS_H
15 #define LLVM_IR_GLOBALALIAS_H
16 
17 #include "llvm/ADT/ilist_node.h"
18 #include "llvm/IR/GlobalValue.h"
19 #include "llvm/IR/OperandTraits.h"
20 #include "llvm/IR/Value.h"
21 
22 namespace llvm {
23 
24 class Twine;
25 class Module;
26 template <typename ValueSubClass, typename... Args> class SymbolTableListTraits;
27 
28 class GlobalAlias : public GlobalValue, public ilist_node<GlobalAlias> {
29   friend class SymbolTableListTraits<GlobalAlias>;
30 
31   GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
32               const Twine &Name, Constant *Aliasee, Module *Parent);
33 
34 public:
35   GlobalAlias(const GlobalAlias &) = delete;
36   GlobalAlias &operator=(const GlobalAlias &) = delete;
37 
38   /// If a parent module is specified, the alias is automatically inserted into
39   /// the end of the specified module's alias list.
40   static GlobalAlias *create(Type *Ty, unsigned AddressSpace,
41                              LinkageTypes Linkage, const Twine &Name,
42                              Constant *Aliasee, Module *Parent);
43 
44   // Without the Aliasee.
45   static GlobalAlias *create(Type *Ty, unsigned AddressSpace,
46                              LinkageTypes Linkage, const Twine &Name,
47                              Module *Parent);
48 
49   // The module is taken from the Aliasee.
50   static GlobalAlias *create(Type *Ty, unsigned AddressSpace,
51                              LinkageTypes Linkage, const Twine &Name,
52                              GlobalValue *Aliasee);
53 
54   // Type, Parent and AddressSpace taken from the Aliasee.
55   static GlobalAlias *create(LinkageTypes Linkage, const Twine &Name,
56                              GlobalValue *Aliasee);
57 
58   // Linkage, Type, Parent and AddressSpace taken from the Aliasee.
59   static GlobalAlias *create(const Twine &Name, GlobalValue *Aliasee);
60 
61   // allocate space for exactly one operand
new(size_t S)62   void *operator new(size_t S) { return User::operator new(S, 1); }
delete(void * Ptr)63   void operator delete(void *Ptr) { User::operator delete(Ptr); }
64 
65   /// Provide fast operand accessors
66   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
67 
copyAttributesFrom(const GlobalAlias * Src)68   void copyAttributesFrom(const GlobalAlias *Src) {
69     GlobalValue::copyAttributesFrom(Src);
70   }
71 
72   /// removeFromParent - This method unlinks 'this' from the containing module,
73   /// but does not delete it.
74   ///
75   void removeFromParent();
76 
77   /// eraseFromParent - This method unlinks 'this' from the containing module
78   /// and deletes it.
79   ///
80   void eraseFromParent();
81 
82   /// These methods retrieve and set alias target.
83   void setAliasee(Constant *Aliasee);
getAliasee()84   const Constant *getAliasee() const {
85     return static_cast<Constant *>(Op<0>().get());
86   }
getAliasee()87   Constant *getAliasee() { return static_cast<Constant *>(Op<0>().get()); }
88 
89   const GlobalObject *getAliaseeObject() const;
getAliaseeObject()90   GlobalObject *getAliaseeObject() {
91     return const_cast<GlobalObject *>(
92         static_cast<const GlobalAlias *>(this)->getAliaseeObject());
93   }
94 
isValidLinkage(LinkageTypes L)95   static bool isValidLinkage(LinkageTypes L) {
96     return isExternalLinkage(L) || isLocalLinkage(L) || isWeakLinkage(L) ||
97            isLinkOnceLinkage(L) || isAvailableExternallyLinkage(L);
98   }
99 
100   // Methods for support type inquiry through isa, cast, and dyn_cast:
classof(const Value * V)101   static bool classof(const Value *V) {
102     return V->getValueID() == Value::GlobalAliasVal;
103   }
104 };
105 
106 template <>
107 struct OperandTraits<GlobalAlias>
108     : public FixedNumOperandTraits<GlobalAlias, 1> {};
109 
110 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalAlias, Constant)
111 
112 } // end namespace llvm
113 
114 #endif // LLVM_IR_GLOBALALIAS_H
115