From 669a33f0cefbe7a627c6b49e8c153ce52ce28f3f Mon Sep 17 00:00:00 2001 From: "Duncan P. N. Exon Smith" Date: Wed, 6 Apr 2016 22:37:30 +0000 Subject: [PATCH] ValueMapper: clang-format ValueMapper.h, NFC Also remove duplicated identifiers from comments. llvm-svn: 265611 --- llvm/include/llvm/Transforms/Utils/ValueMapper.h | 183 ++++++++++++----------- 1 file changed, 92 insertions(+), 91 deletions(-) diff --git a/llvm/include/llvm/Transforms/Utils/ValueMapper.h b/llvm/include/llvm/Transforms/Utils/ValueMapper.h index 5687bd2..315de64 100644 --- a/llvm/include/llvm/Transforms/Utils/ValueMapper.h +++ b/llvm/include/llvm/Transforms/Utils/ValueMapper.h @@ -18,101 +18,102 @@ #include "llvm/IR/ValueMap.h" namespace llvm { - class Value; - class Instruction; - typedef ValueMap 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 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(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( + MapValue((const Value *)V, VM, Flags, TypeMapper, Materializer)); +} } // End llvm namespace -- 2.7.4