[llvm] r265611 - ValueMapper: clang-format ValueMapper.h, NFC
Duncan P. N. Exon Smith via llvm-commits
llvm-commits at lists.llvm.org
Wed Apr 6 15:37:30 PDT 2016
Author: dexonsmith
Date: Wed Apr 6 17:37:30 2016
New Revision: 265611
URL: http://llvm.org/viewvc/llvm-project?rev=265611&view=rev
Log:
ValueMapper: clang-format ValueMapper.h, NFC
Also remove duplicated identifiers from comments.
Modified:
llvm/trunk/include/llvm/Transforms/Utils/ValueMapper.h
Modified: llvm/trunk/include/llvm/Transforms/Utils/ValueMapper.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Utils/ValueMapper.h?rev=265611&r1=265610&r2=265611&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Transforms/Utils/ValueMapper.h (original)
+++ llvm/trunk/include/llvm/Transforms/Utils/ValueMapper.h Wed Apr 6 17:37:30 2016
@@ -18,101 +18,102 @@
#include "llvm/IR/ValueMap.h"
namespace llvm {
- class Value;
- class Instruction;
- typedef ValueMap<const Value *, WeakVH> ValueToValueMapTy;
-
- /// ValueMapTypeRemapper - This is a class that can be implemented by clients
- /// to remap types when cloning constants and instructions.
- class ValueMapTypeRemapper {
- virtual void anchor(); // Out of line method.
- public:
- virtual ~ValueMapTypeRemapper() {}
-
- /// remapType - The client should implement this method if they want to
- /// remap types while mapping values.
- virtual Type *remapType(Type *SrcTy) = 0;
- };
-
- /// ValueMaterializer - This is a class that can be implemented by clients
- /// to materialize Values on demand.
- class ValueMaterializer {
- virtual void anchor(); // Out of line method.
-
- protected:
- ~ValueMaterializer() = default;
- ValueMaterializer() = default;
- ValueMaterializer(const ValueMaterializer&) = default;
- ValueMaterializer &operator=(const ValueMaterializer&) = default;
-
- public:
- /// The client should implement this method if they want to generate a
- /// mapped Value on demand. For example, if linking lazily.
- virtual Value *materializeDeclFor(Value *V) = 0;
-
- /// If the data being mapped is recursive, the above function can map
- /// just the declaration and this is called to compute the initializer.
- /// It is called after the mapping is recorded, so it doesn't need to worry
- /// about recursion.
- virtual void materializeInitFor(GlobalValue *New, GlobalValue *Old);
- };
-
- /// RemapFlags - These are flags that the value mapping APIs allow.
- enum RemapFlags {
- RF_None = 0,
-
- /// RF_NoModuleLevelChanges - If this flag is set, the remapper knows that
- /// only local values within a function (such as an instruction or argument)
- /// are mapped, not global values like functions and global metadata.
- RF_NoModuleLevelChanges = 1,
-
- /// RF_IgnoreMissingEntries - If this flag is set, the remapper ignores
- /// entries that are not in the value map. If it is unset, it aborts if an
- /// operand is asked to be remapped which doesn't exist in the mapping.
- RF_IgnoreMissingEntries = 2,
-
- /// Instruct the remapper to move distinct metadata instead of duplicating
- /// it when there are module-level changes.
- RF_MoveDistinctMDs = 4,
-
- /// Any global values not in value map are mapped to null instead of
- /// mapping to self. Illegal if RF_IgnoreMissingEntries is also set.
- RF_NullMapMissingGlobalValues = 8,
- };
-
- static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) {
- return RemapFlags(unsigned(LHS)|unsigned(RHS));
- }
-
- Value *MapValue(const Value *V, ValueToValueMapTy &VM,
- RemapFlags Flags = RF_None,
- ValueMapTypeRemapper *TypeMapper = nullptr,
- ValueMaterializer *Materializer = nullptr);
-
- Metadata *MapMetadata(const Metadata *MD, ValueToValueMapTy &VM,
- RemapFlags Flags = RF_None,
- ValueMapTypeRemapper *TypeMapper = nullptr,
- ValueMaterializer *Materializer = nullptr);
- /// MapMetadata - provide versions that preserve type safety for MDNodes.
- MDNode *MapMetadata(const MDNode *MD, ValueToValueMapTy &VM,
+class Value;
+class Instruction;
+typedef ValueMap<const Value *, WeakVH> ValueToValueMapTy;
+
+/// This is a class that can be implemented by clients to remap types when
+/// cloning constants and instructions.
+class ValueMapTypeRemapper {
+ virtual void anchor(); // Out of line method.
+public:
+ virtual ~ValueMapTypeRemapper() {}
+
+ /// The client should implement this method if they want to remap types while
+ /// mapping values.
+ virtual Type *remapType(Type *SrcTy) = 0;
+};
+
+/// This is a class that can be implemented by clients to materialize Values on
+/// demand.
+class ValueMaterializer {
+ virtual void anchor(); // Out of line method.
+
+protected:
+ ~ValueMaterializer() = default;
+ ValueMaterializer() = default;
+ ValueMaterializer(const ValueMaterializer &) = default;
+ ValueMaterializer &operator=(const ValueMaterializer &) = default;
+
+public:
+ /// The client should implement this method if they want to generate a mapped
+ /// Value on demand. For example, if linking lazily.
+ virtual Value *materializeDeclFor(Value *V) = 0;
+
+ /// If the data being mapped is recursive, the above function can map just
+ /// the declaration and this is called to compute the initializer. It is
+ /// called after the mapping is recorded, so it doesn't need to worry about
+ /// recursion.
+ virtual void materializeInitFor(GlobalValue *New, GlobalValue *Old);
+};
+
+/// These are flags that the value mapping APIs allow.
+enum RemapFlags {
+ RF_None = 0,
+
+ /// If this flag is set, the remapper knows that only local values within a
+ /// function (such as an instruction or argument) are mapped, not global
+ /// values like functions and global metadata.
+ RF_NoModuleLevelChanges = 1,
+
+ /// If this flag is set, the remapper ignores entries that are not in the
+ /// value map. If it is unset, it aborts if an operand is asked to be
+ /// remapped which doesn't exist in the mapping.
+ RF_IgnoreMissingEntries = 2,
+
+ /// Instruct the remapper to move distinct metadata instead of duplicating it
+ /// when there are module-level changes.
+ RF_MoveDistinctMDs = 4,
+
+ /// Any global values not in value map are mapped to null instead of mapping
+ /// to self. Illegal if RF_IgnoreMissingEntries is also set.
+ RF_NullMapMissingGlobalValues = 8,
+};
+
+static inline RemapFlags operator|(RemapFlags LHS, RemapFlags RHS) {
+ return RemapFlags(unsigned(LHS) | unsigned(RHS));
+}
+
+Value *MapValue(const Value *V, ValueToValueMapTy &VM,
+ RemapFlags Flags = RF_None,
+ ValueMapTypeRemapper *TypeMapper = nullptr,
+ ValueMaterializer *Materializer = nullptr);
+
+Metadata *MapMetadata(const Metadata *MD, ValueToValueMapTy &VM,
+ RemapFlags Flags = RF_None,
+ ValueMapTypeRemapper *TypeMapper = nullptr,
+ ValueMaterializer *Materializer = nullptr);
+
+/// Version of MapMetadata with type safety for MDNode.
+MDNode *MapMetadata(const MDNode *MD, ValueToValueMapTy &VM,
+ RemapFlags Flags = RF_None,
+ ValueMapTypeRemapper *TypeMapper = nullptr,
+ ValueMaterializer *Materializer = nullptr);
+
+void RemapInstruction(Instruction *I, ValueToValueMapTy &VM,
RemapFlags Flags = RF_None,
ValueMapTypeRemapper *TypeMapper = nullptr,
ValueMaterializer *Materializer = nullptr);
- void RemapInstruction(Instruction *I, ValueToValueMapTy &VM,
- RemapFlags Flags = RF_None,
- ValueMapTypeRemapper *TypeMapper = nullptr,
- ValueMaterializer *Materializer = nullptr);
-
- /// MapValue - provide versions that preserve type safety for Constants.
- inline Constant *MapValue(const Constant *V, ValueToValueMapTy &VM,
- RemapFlags Flags = RF_None,
- ValueMapTypeRemapper *TypeMapper = nullptr,
- ValueMaterializer *Materializer = nullptr) {
- return cast<Constant>(MapValue((const Value*)V, VM, Flags, TypeMapper,
- Materializer));
- }
+/// Version of MapValue with type safety for Constant.
+inline Constant *MapValue(const Constant *V, ValueToValueMapTy &VM,
+ RemapFlags Flags = RF_None,
+ ValueMapTypeRemapper *TypeMapper = nullptr,
+ ValueMaterializer *Materializer = nullptr) {
+ return cast<Constant>(
+ MapValue((const Value *)V, VM, Flags, TypeMapper, Materializer));
+}
} // End llvm namespace
More information about the llvm-commits
mailing list