1 //===- GlobalStatus.h - Compute status info for globals ---------*- 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 #ifndef LLVM_TRANSFORMS_UTILS_GLOBALSTATUS_H 10 #define LLVM_TRANSFORMS_UTILS_GLOBALSTATUS_H 11 12 #include "llvm/IR/Instructions.h" 13 #include "llvm/Support/AtomicOrdering.h" 14 15 namespace llvm { 16 17 class Constant; 18 class Function; 19 class Value; 20 21 /// It is safe to destroy a constant iff it is only used by constants itself. 22 /// Note that constants cannot be cyclic, so this test is pretty easy to 23 /// implement recursively. 24 /// 25 bool isSafeToDestroyConstant(const Constant *C); 26 27 /// As we analyze each global, keep track of some information about it. If we 28 /// find out that the address of the global is taken, none of this info will be 29 /// accurate. 30 struct GlobalStatus { 31 /// True if the global's address is used in a comparison. 32 bool IsCompared = false; 33 34 /// True if the global is ever loaded. If the global isn't ever loaded it 35 /// can be deleted. 36 bool IsLoaded = false; 37 38 /// Number of stores to the global. 39 unsigned NumStores = 0; 40 41 /// Keep track of what stores to the global look like. 42 enum StoredType { 43 /// There is no store to this global. It can thus be marked constant. 44 NotStored, 45 46 /// This global is stored to, but the only thing stored is the constant it 47 /// was initialized with. This is only tracked for scalar globals. 48 InitializerStored, 49 50 /// This global is stored to, but only its initializer and one other value 51 /// is ever stored to it. If this global isStoredOnce, we track the value 52 /// stored to it via StoredOnceStore below. This is only tracked for scalar 53 /// globals. 54 StoredOnce, 55 56 /// This global is stored to by multiple values or something else that we 57 /// cannot track. 58 Stored 59 } StoredType = NotStored; 60 61 /// If only one value (besides the initializer constant) is ever stored to 62 /// this global, keep track of what value it is via the store instruction. 63 const StoreInst *StoredOnceStore = nullptr; 64 65 /// If only one value (besides the initializer constant) is ever stored to 66 /// this global return the stored value. 67 Value *getStoredOnceValue() const { 68 return (StoredType == StoredOnce && StoredOnceStore) 69 ? StoredOnceStore->getOperand(0) 70 : nullptr; 71 } 72 73 /// These start out null/false. When the first accessing function is noticed, 74 /// it is recorded. When a second different accessing function is noticed, 75 /// HasMultipleAccessingFunctions is set to true. 76 const Function *AccessingFunction = nullptr; 77 bool HasMultipleAccessingFunctions = false; 78 79 /// Set to the strongest atomic ordering requirement. 80 AtomicOrdering Ordering = AtomicOrdering::NotAtomic; 81 82 GlobalStatus(); 83 84 /// Look at all uses of the global and fill in the GlobalStatus structure. If 85 /// the global has its address taken, return true to indicate we can't do 86 /// anything with it. 87 static bool analyzeGlobal(const Value *V, GlobalStatus &GS); 88 }; 89 90 } // end namespace llvm 91 92 #endif // LLVM_TRANSFORMS_UTILS_GLOBALSTATUS_H 93