llvm.org GIT mirror llvm / release_33 include / llvm / IR / GlobalAlias.h
release_33

Tree @release_33 (Download .tar.gz)

GlobalAlias.h @release_33

a80e118
7bc428f
 
 
7ed47a1
 
7bc428f
 
 
 
a80e118
7bc428f
 
 
674be02
 
7bc428f
255f89f
 
0b8c9a8
 
7bc428f
 
 
 
 
 
 
fed90b6
7bc428f
9f9ce61
 
7bc428f
 
 
 
efe6536
051a950
efe6536
051a950
7bc428f
a80e118
db125cf
a80e118
7bc428f
efe6536
4f2d695
efe6536
7bc428f
 
 
71c8c17
7bc428f
 
 
 
71c8c17
7bc428f
a80e118
1afcace
 
4f2d695
a80e118
1afcace
4f2d695
a80e118
c6c98af
 
1afcace
e846dd8
aff1678
 
19e861a
832b2a9
 
1afcace
e846dd8
7bc428f
 
 
 
 
 
efe6536
67c619b
 
efe6536
 
ff7782b
efe6536
7bc428f
 
 
//===-------- llvm/GlobalAlias.h - GlobalAlias class ------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of the GlobalAlias class, which
// represents a single function or variable alias in the IR.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_IR_GLOBALALIAS_H
#define LLVM_IR_GLOBALALIAS_H

#include "llvm/ADT/Twine.h"
#include "llvm/ADT/ilist_node.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/OperandTraits.h"

namespace llvm {

class Module;
template<typename ValueSubClass, typename ItemParentClass>
  class SymbolTableListTraits;

class GlobalAlias : public GlobalValue, public ilist_node<GlobalAlias> {
  friend class SymbolTableListTraits<GlobalAlias, Module>;
  void operator=(const GlobalAlias &) LLVM_DELETED_FUNCTION;
  GlobalAlias(const GlobalAlias &) LLVM_DELETED_FUNCTION;

  void setParent(Module *parent);

public:
  // allocate space for exactly one operand
  void *operator new(size_t s) {
    return User::operator new(s, 1);
  }
  /// GlobalAlias ctor - If a parent module is specified, the alias is
  /// automatically inserted into the end of the specified module's alias list.
  GlobalAlias(Type *Ty, LinkageTypes Linkage, const Twine &Name = "",
              Constant* Aliasee = 0, Module *Parent = 0);

  /// Provide fast operand accessors
  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);

  /// removeFromParent - This method unlinks 'this' from the containing module,
  /// but does not delete it.
  ///
  virtual void removeFromParent();

  /// eraseFromParent - This method unlinks 'this' from the containing module
  /// and deletes it.
  ///
  virtual void eraseFromParent();

  /// set/getAliasee - These methods retrive and set alias target.
  void setAliasee(Constant *GV);
  const Constant *getAliasee() const {
    return getOperand(0);
  }
  Constant *getAliasee() {
    return getOperand(0);
  }
  /// getAliasedGlobal() - Aliasee can be either global or bitcast of
  /// global. This method retrives the global for both aliasee flavours.
  const GlobalValue *getAliasedGlobal() const;

  /// resolveAliasedGlobal() - This method tries to ultimately resolve the alias
  /// by going through the aliasing chain and trying to find the very last
  /// global. Returns NULL if a cycle was found. If stopOnWeak is false, then
  /// the whole chain aliasing chain is traversed, otherwise - only strong
  /// aliases.
  const GlobalValue *resolveAliasedGlobal(bool stopOnWeak = true) const;

  // Methods for support type inquiry through isa, cast, and dyn_cast:
  static inline bool classof(const Value *V) {
    return V->getValueID() == Value::GlobalAliasVal;
  }
};

template <>
struct OperandTraits<GlobalAlias> :
  public FixedNumOperandTraits<GlobalAlias, 1> {
};

DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalAlias, Constant)

} // End llvm namespace

#endif