Trailing whitespace.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@107360 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/CodeGen/AsmPrinter.h

@@ -64,7 +64,7 @@ namespace llvm {
     /// Target machine description.
     ///
     TargetMachine &TM;
-    
+
     /// Target Asm Printer information.
     ///
     const MCAsmInfo *MAI;
@@ -73,13 +73,13 @@ namespace llvm {
     /// streaming.  This owns all of the global MC-related objects for the
     /// generated translation unit.
     MCContext &OutContext;
-    
+
     /// OutStreamer - This is the MCStreamer object for the file we are
     /// generating.  This contains the transient state for the current
     /// translation unit that we are generating (such as the current section
     /// etc).
     MCStreamer &OutStreamer;
-    
+
     /// The current machine function.
     const MachineFunction *MF;
 
@@ -94,30 +94,30 @@ namespace llvm {
     /// beginning of each call to runOnMachineFunction().
     ///
     MCSymbol *CurrentFnSym;
-    
+
   private:
     // GCMetadataPrinters - The garbage collection metadata printer table.
     void *GCMetadataPrinters;  // Really a DenseMap.
-    
+
     /// VerboseAsm - Emit comments in assembly output if this is true.
     ///
     bool VerboseAsm;
     static char ID;
-    
+
     /// If VerboseAsm is set, a pointer to the loop info for this
     /// function.
     MachineLoopInfo *LI;
 
     /// DD - If the target supports dwarf debug info, this pointer is non-null.
     DwarfDebug *DD;
-    
+
     /// DE - If the target supports dwarf exception info, this pointer is
     /// non-null.
     DwarfException *DE;
-    
+
   protected:
     explicit AsmPrinter(TargetMachine &TM, MCStreamer &Streamer);
-    
+
   public:
     virtual ~AsmPrinter();
 
@@ -128,7 +128,7 @@ namespace llvm {
     /// getFunctionNumber - Return a unique ID for the current function.
     ///
     unsigned getFunctionNumber() const;
-    
+
     /// getObjFileLowering - Return information about object file lowering.
     const TargetLoweringObjectFile &getObjFileLowering() const;
 
@@ -137,16 +137,16 @@ namespace llvm {
 
     /// getCurrentSection() - Return the current section we are emitting to.
     const MCSection *getCurrentSection() const;
-    
+
-    
+
     //===------------------------------------------------------------------===//
     // MachineFunctionPass Implementation.
     //===------------------------------------------------------------------===//
-    
+
     /// getAnalysisUsage - Record analysis usage.
-    /// 
+    ///
     void getAnalysisUsage(AnalysisUsage &AU) const;
-    
+
     /// doInitialization - Set up the AsmPrinter when we are working on a new
     /// module.  If your pass overrides this, it must make sure to explicitly
     /// call this implementation.
@@ -155,7 +155,7 @@ namespace llvm {
     /// doFinalization - Shut down the asmprinter.  If you override this in your
     /// pass, you must make sure to call it explicitly.
     bool doFinalization(Module &M);
-    
+
     /// runOnMachineFunction - Emit the specified function out to the
     /// OutStreamer.
     virtual bool runOnMachineFunction(MachineFunction &MF) {
@@ -163,20 +163,20 @@ namespace llvm {
       EmitFunctionHeader();
       EmitFunctionBody();
       return false;
-    }      
+    }
-    
+
     //===------------------------------------------------------------------===//
     // Coarse grained IR lowering routines.
     //===------------------------------------------------------------------===//
-    
+
     /// SetupMachineFunction - This should be called when a new MachineFunction
     /// is being processed from runOnMachineFunction.
     void SetupMachineFunction(MachineFunction &MF);
-    
+
     /// EmitFunctionHeader - This method emits the header for the current
     /// function.
     void EmitFunctionHeader();
-    
+
     /// EmitFunctionBody - This method emits the body and trailer for a
     /// function.
     void EmitFunctionBody();
@@ -187,15 +187,15 @@ namespace llvm {
     /// the code generator.
     ///
     virtual void EmitConstantPool();
-    
+
-    /// EmitJumpTableInfo - Print assembly representations of the jump tables 
+    /// EmitJumpTableInfo - Print assembly representations of the jump tables
-    /// used by the current function to the current output stream.  
+    /// used by the current function to the current output stream.
     ///
     void EmitJumpTableInfo();
-    
+
     /// EmitGlobalVariable - Emit the specified global variable to the .s file.
     virtual void EmitGlobalVariable(const GlobalVariable *GV);
-    
+
     /// EmitSpecialLLVMGlobal - Check to see if the specified global is a
     /// special global used by LLVM.  If so, emit it and return true, otherwise
     /// do nothing and return false.
@@ -208,54 +208,54 @@ namespace llvm {
     /// if required for correctness.
     ///
     void EmitAlignment(unsigned NumBits, const GlobalValue *GV = 0) const;
-    
+
     /// EmitBasicBlockStart - This method prints the label for the specified
     /// MachineBasicBlock, an alignment (if present) and a comment describing
     /// it if appropriate.
     void EmitBasicBlockStart(const MachineBasicBlock *MBB) const;
-    
+
     /// EmitGlobalConstant - Print a general LLVM constant to the .s file.
     void EmitGlobalConstant(const Constant *CV, unsigned AddrSpace = 0);
-    
+
-    
+
     //===------------------------------------------------------------------===//
     // Overridable Hooks
     //===------------------------------------------------------------------===//
-    
+
     // Targets can, or in the case of EmitInstruction, must implement these to
     // customize output.
-    
+
     /// EmitStartOfAsmFile - This virtual method can be overridden by targets
     /// that want to emit something at the start of their file.
     virtual void EmitStartOfAsmFile(Module &) {}
-    
+
     /// EmitEndOfAsmFile - This virtual method can be overridden by targets that
     /// want to emit something at the end of their file.
     virtual void EmitEndOfAsmFile(Module &) {}
-    
+
     /// EmitFunctionBodyStart - Targets can override this to emit stuff before
     /// the first basic block in the function.
     virtual void EmitFunctionBodyStart() {}
-    
+
     /// EmitFunctionBodyEnd - Targets can override this to emit stuff after
     /// the last basic block in the function.
     virtual void EmitFunctionBodyEnd() {}
-    
+
     /// EmitInstruction - Targets should implement this to emit instructions.
     virtual void EmitInstruction(const MachineInstr *) {
       assert(0 && "EmitInstruction not implemented");
     }
-    
+
     virtual void EmitFunctionEntryLabel();
-    
+
     virtual void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV);
-    
+
     /// isBlockOnlyReachableByFallthough - Return true if the basic block has
     /// exactly one predecessor and the control transfer mechanism between
     /// the predecessor and this block is a fall-through.
     virtual bool
     isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const;
-    
+
     //===------------------------------------------------------------------===//
     // Symbol Lowering Routines.
     //===------------------------------------------------------------------===//
@@ -264,23 +264,23 @@ namespace llvm {
     /// GetTempSymbol - Return the MCSymbol corresponding to the assembler
     /// temporary label with the specified stem and unique ID.
     MCSymbol *GetTempSymbol(StringRef Name, unsigned ID) const;
-    
+
     /// GetTempSymbol - Return an assembler temporary label with the specified
     /// stem.
     MCSymbol *GetTempSymbol(StringRef Name) const;
-    
+
-    
+
     /// GetSymbolWithGlobalValueBase - Return the MCSymbol for a symbol with
     /// global value name as its base, with the specified suffix, and where the
     /// symbol is forced to have private linkage if ForcePrivate is true.
     MCSymbol *GetSymbolWithGlobalValueBase(const GlobalValue *GV,
                                            StringRef Suffix,
                                            bool ForcePrivate = true) const;
-    
+
     /// GetExternalSymbolSymbol - Return the MCSymbol for the specified
     /// ExternalSymbol.
     MCSymbol *GetExternalSymbolSymbol(StringRef Sym) const;
-    
+
     /// GetCPISymbol - Return the symbol for the specified constant pool entry.
     MCSymbol *GetCPISymbol(unsigned CPID) const;
 
@@ -302,42 +302,42 @@ namespace llvm {
   public:
     /// printOffset - This is just convenient handler for printing offsets.
     void printOffset(int64_t Offset, raw_ostream &OS) const;
-    
+
     /// EmitInt8 - Emit a byte directive and value.
     ///
     void EmitInt8(int Value) const;
-    
+
     /// EmitInt16 - Emit a short directive and value.
     ///
     void EmitInt16(int Value) const;
-    
+
     /// EmitInt32 - Emit a long directive and value.
     ///
     void EmitInt32(int Value) const;
-    
+
     /// EmitLabelDifference - Emit something like ".long Hi-Lo" where the size
     /// in bytes of the directive is specified by Size and Hi/Lo specify the
     /// labels.  This implicitly uses .set if it is available.
     void EmitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
                              unsigned Size) const;
-    
+
-    /// EmitLabelOffsetDifference - Emit something like ".long Hi+Offset-Lo" 
+    /// EmitLabelOffsetDifference - Emit something like ".long Hi+Offset-Lo"
     /// where the size in bytes of the directive is specified by Size and Hi/Lo
     /// specify the labels.  This implicitly uses .set if it is available.
     void EmitLabelOffsetDifference(const MCSymbol *Hi, uint64_t Offset,
                                    const MCSymbol *Lo, unsigned Size) const;
-    
+
     //===------------------------------------------------------------------===//
     // Dwarf Emission Helper Routines
     //===------------------------------------------------------------------===//
-    
+
     /// EmitSLEB128 - emit the specified signed leb128 value.
     void EmitSLEB128(int Value, const char *Desc = 0) const;
-    
+
     /// EmitULEB128 - emit the specified unsigned leb128 value.
     void EmitULEB128(unsigned Value, const char *Desc = 0,
                      unsigned PadTo = 0) const;
-    
+
     /// EmitCFAByte - Emit a .byte 42 directive for a DW_CFA_xxx value.
     void EmitCFAByte(unsigned Val) const;
 
@@ -346,15 +346,15 @@ namespace llvm {
     /// describing the encoding.  Desc is a string saying what the encoding is
     /// specifying (e.g. "LSDA").
     void EmitEncodingByte(unsigned Val, const char *Desc = 0) const;
-    
+
     /// GetSizeOfEncodedValue - Return the size of the encoding in bytes.
     unsigned GetSizeOfEncodedValue(unsigned Encoding) const;
-    
+
     /// EmitReference - Emit a reference to a label with a specified encoding.
     ///
     void EmitReference(const MCSymbol *Sym, unsigned Encoding) const;
     void EmitReference(const GlobalValue *GV, unsigned Encoding) const;
-    
+
     /// EmitSectionOffset - Emit the 4-byte offset of Label from the start of
     /// its section.  This can be done with a special directive if the target
     /// supports it (e.g. cygwin) or by emitting it as an offset from a label at
@@ -372,20 +372,20 @@ namespace llvm {
     //===------------------------------------------------------------------===//
     // Dwarf Lowering Routines
     //===------------------------------------------------------------------===//
-    
+
     /// EmitFrameMoves - Emit frame instructions to describe the layout of the
     /// frame.
-    void EmitFrameMoves(const std::vector<MachineMove> &Moves, 
+    void EmitFrameMoves(const std::vector<MachineMove> &Moves,
                         MCSymbol *BaseLabel, bool isEH) const;
-    
+
-    
+
     //===------------------------------------------------------------------===//
     // Inline Asm Support
     //===------------------------------------------------------------------===//
   public:
     // These are hooks that targets can override to implement inline asm
     // support.  These should probably be moved out of AsmPrinter someday.
-    
+
     /// PrintSpecial - Print information related to the specified machine instr
     /// that is independent of the operand, and may be independent of the instr
     /// itself.  This can be useful for portably encoding the comment character
@@ -394,7 +394,7 @@ namespace llvm {
     /// for their own strange codes.
     virtual void PrintSpecial(const MachineInstr *MI, raw_ostream &OS,
                               const char *Code) const;
-    
+
     /// PrintAsmOperand - Print the specified operand of MI, an INLINEASM
     /// instruction, using the specified assembler variant.  Targets should
     /// override this to format as appropriate.  This method can return true if
@@ -402,16 +402,16 @@ namespace llvm {
     virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
                                  unsigned AsmVariant, const char *ExtraCode,
                                  raw_ostream &OS);
-    
+
     /// PrintAsmMemoryOperand - Print the specified operand of MI, an INLINEASM
     /// instruction, using the specified assembler variant as an address.
     /// Targets should override this to format as appropriate.  This method can
     /// return true if the operand is erroneous.
     virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
-                                       unsigned AsmVariant, 
+                                       unsigned AsmVariant,
                                        const char *ExtraCode,
                                        raw_ostream &OS);
-    
+
   private:
     /// Private state for PrintSpecial()
     // Assign a unique ID to this machine instruction.
@@ -422,7 +422,7 @@ namespace llvm {
 
     /// EmitInlineAsm - Emit a blob of inline asm to the output streamer.
     void EmitInlineAsm(StringRef Str, unsigned LocCookie) const;
-    
+
     /// EmitInlineAsm - This method formats and emits the specified machine
     /// instruction that is an inline asm.
     void EmitInlineAsm(const MachineInstr *MI) const;
@@ -430,13 +430,13 @@ namespace llvm {
     //===------------------------------------------------------------------===//
     // Internal Implementation Details
     //===------------------------------------------------------------------===//
-    
+
     /// EmitVisibility - This emits visibility information about symbol, if
     /// this is suported by the target.
     void EmitVisibility(MCSymbol *Sym, unsigned Visibility) const;
-    
+
     void EmitLinkage(unsigned Linkage, MCSymbol *GVSym) const;
-    
+
     void EmitJumpTableEntry(const MachineJumpTableInfo *MJTI,
                             const MachineBasicBlock *MBB,
                             unsigned uid) const;

include/llvm/CodeGen/GCMetadata.h

@@ -1,4 +1,4 @@
-//===-- GCMetadata.h - Garbage collector metadata -------------------------===//
+//===-- GCMetadata.h - Garbage collector metadata ---------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -14,7 +14,7 @@
 //
 // The GCFunctionInfo class logs the data necessary to build a type accurate
 // stack map. The code generator outputs:
-// 
+//
 //   - Safe points as specified by the GCStrategy's NeededSafePoints.
 //   - Stack offsets for GC roots, as specified by calls to llvm.gcroot
 //
@@ -42,10 +42,10 @@ namespace llvm {
   class GCStrategy;
   class Constant;
   class MCSymbol;
-  
+
   namespace GC {
     /// PointKind - The type of a collector-safe point.
-    /// 
+    ///
     enum PointKind {
       Loop,    //< Instr is a loop (backwards branch).
       Return,  //< Instr is a return instruction.
@@ -53,138 +53,138 @@ namespace llvm {
       PostCall //< Instr is the return address of a call.
     };
   }
-  
+
   /// GCPoint - Metadata for a collector-safe point in machine code.
-  /// 
+  ///
   struct GCPoint {
     GC::PointKind Kind; //< The kind of the safe point.
     MCSymbol *Label;    //< A label.
-    
+
     GCPoint(GC::PointKind K, MCSymbol *L) : Kind(K), Label(L) {}
   };
-  
+
   /// GCRoot - Metadata for a pointer to an object managed by the garbage
   /// collector.
   struct GCRoot {
     int Num;            //< Usually a frame index.
     int StackOffset;    //< Offset from the stack pointer.
     const Constant *Metadata;//< Metadata straight from the call to llvm.gcroot.
-    
+
     GCRoot(int N, const Constant *MD) : Num(N), StackOffset(-1), Metadata(MD) {}
   };
-  
+
-  
+
   /// GCFunctionInfo - Garbage collection metadata for a single function.
-  /// 
+  ///
   class GCFunctionInfo {
   public:
     typedef std::vector<GCPoint>::iterator iterator;
     typedef std::vector<GCRoot>::iterator roots_iterator;
     typedef std::vector<GCRoot>::const_iterator live_iterator;
-    
+
   private:
     const Function &F;
     GCStrategy &S;
     uint64_t FrameSize;
     std::vector<GCRoot> Roots;
     std::vector<GCPoint> SafePoints;
-    
+
     // FIXME: Liveness. A 2D BitVector, perhaps?
-    // 
+    //
     //   BitVector Liveness;
-    //   
+    //
     //   bool islive(int point, int root) =
     //     Liveness[point * SafePoints.size() + root]
-    // 
+    //
     // The bit vector is the more compact representation where >3.2% of roots
     // are live per safe point (1.5% on 64-bit hosts).
-    
+
   public:
     GCFunctionInfo(const Function &F, GCStrategy &S);
     ~GCFunctionInfo();
-    
+
     /// getFunction - Return the function to which this metadata applies.
-    /// 
+    ///
     const Function &getFunction() const { return F; }
-    
+
     /// getStrategy - Return the GC strategy for the function.
-    /// 
+    ///
     GCStrategy &getStrategy() { return S; }
-    
+
     /// addStackRoot - Registers a root that lives on the stack. Num is the
     ///                stack object ID for the alloca (if the code generator is
     //                 using  MachineFrameInfo).
     void addStackRoot(int Num, const Constant *Metadata) {
       Roots.push_back(GCRoot(Num, Metadata));
     }
-    
+
     /// addSafePoint - Notes the existence of a safe point. Num is the ID of the
-    /// label just prior to the safe point (if the code generator is using 
+    /// label just prior to the safe point (if the code generator is using
     /// MachineModuleInfo).
     void addSafePoint(GC::PointKind Kind, MCSymbol *Label) {
       SafePoints.push_back(GCPoint(Kind, Label));
     }
-    
+
     /// getFrameSize/setFrameSize - Records the function's frame size.
-    /// 
+    ///
     uint64_t getFrameSize() const { return FrameSize; }
     void setFrameSize(uint64_t S) { FrameSize = S; }
-    
+
     /// begin/end - Iterators for safe points.
-    /// 
+    ///
     iterator begin() { return SafePoints.begin(); }
     iterator end()   { return SafePoints.end();   }
     size_t size() const { return SafePoints.size(); }
-    
+
     /// roots_begin/roots_end - Iterators for all roots in the function.
-    /// 
+    ///
     roots_iterator roots_begin() { return Roots.begin(); }
     roots_iterator roots_end  () { return Roots.end();   }
     size_t roots_size() const { return Roots.size(); }
-    
+
     /// live_begin/live_end - Iterators for live roots at a given safe point.
-    /// 
+    ///
     live_iterator live_begin(const iterator &p) { return roots_begin(); }
     live_iterator live_end  (const iterator &p) { return roots_end();   }
     size_t live_size(const iterator &p) const { return roots_size(); }
   };
-  
+
-  
+
   /// GCModuleInfo - Garbage collection metadata for a whole module.
-  /// 
+  ///
   class GCModuleInfo : public ImmutablePass {
     typedef StringMap<GCStrategy*> strategy_map_type;
     typedef std::vector<GCStrategy*> list_type;
     typedef DenseMap<const Function*,GCFunctionInfo*> finfo_map_type;
-    
+
     strategy_map_type StrategyMap;
     list_type StrategyList;
     finfo_map_type FInfoMap;
-    
+
     GCStrategy *getOrCreateStrategy(const Module *M, const std::string &Name);
-    
+
   public:
     typedef list_type::const_iterator iterator;
-    
+
     static char ID;
-    
+
     GCModuleInfo();
     ~GCModuleInfo();
-    
+
     /// clear - Resets the pass. The metadata deleter pass calls this.
-    /// 
+    ///
     void clear();
-    
+
     /// begin/end - Iterators for used strategies.
-    /// 
+    ///
     iterator begin() const { return StrategyList.begin(); }
     iterator end()   const { return StrategyList.end();   }
-    
+
     /// get - Look up function metadata.
-    /// 
+    ///
     GCFunctionInfo &getFunctionInfo(const Function &F);
   };
-  
+
 }
 
 #endif

include/llvm/CodeGen/GCMetadataPrinter.h

@@ -25,49 +25,49 @@
 #include "llvm/Support/Registry.h"
 
 namespace llvm {
-  
+
   class GCMetadataPrinter;
-  
+
   /// GCMetadataPrinterRegistry - The GC assembly printer registry uses all the
   /// defaults from Registry.
   typedef Registry<GCMetadataPrinter> GCMetadataPrinterRegistry;
-  
+
   /// GCMetadataPrinter - Emits GC metadata as assembly code.
-  /// 
+  ///
   class GCMetadataPrinter {
   public:
     typedef GCStrategy::list_type list_type;
     typedef GCStrategy::iterator iterator;
-    
+
   private:
     GCStrategy *S;
-    
+
     friend class AsmPrinter;
-    
+
   protected:
     // May only be subclassed.
     GCMetadataPrinter();
-    
+
     // Do not implement.
     GCMetadataPrinter(const GCMetadataPrinter &);
     GCMetadataPrinter &operator=(const GCMetadataPrinter &);
-    
+
   public:
     GCStrategy &getStrategy() { return *S; }
     const Module &getModule() const { return S->getModule(); }
-    
+
     /// begin/end - Iterate over the collected function metadata.
     iterator begin() { return S->begin(); }
     iterator end()   { return S->end();   }
-    
+
     /// beginAssembly/finishAssembly - Emit module metadata as assembly code.
     virtual void beginAssembly(AsmPrinter &AP);
-    
+
     virtual void finishAssembly(AsmPrinter &AP);
-    
+
     virtual ~GCMetadataPrinter();
   };
-  
+
 }
 
 #endif

include/llvm/MC/MCSection.h

@@ -23,7 +23,7 @@ namespace llvm {
   class MCContext;
   class MCAsmInfo;
   class raw_ostream;
-  
+
   /// MCSection - Instances of this class represent a uniqued identifier for a
   /// section in the current translation unit.  The MCContext class uniques and
   /// creates these.
@@ -49,7 +49,7 @@ namespace llvm {
     SectionKind getKind() const { return Kind; }
 
     SectionVariant getVariant() const { return Variant; }
-    
+
     virtual void PrintSwitchToSection(const MCAsmInfo &MAI,
                                       raw_ostream &OS) const = 0;
 
@@ -63,7 +63,7 @@ namespace llvm {
 
     static bool classof(const MCSection *) { return true; }
   };
-  
+
 } // end namespace llvm
 
 #endif

include/llvm/MC/SectionKind.h

@@ -29,10 +29,10 @@ class SectionKind {
   enum Kind {
     /// Metadata - Debug info sections or other metadata.
     Metadata,
-    
+
     /// Text - Text section, used for functions and other executable code.
     Text,
-    
+
     /// ReadOnly - Data that is never written to at program runtime by the
     /// program or the dynamic linker.  Things in the top-level readonly
     /// SectionKind are not mergeable.
@@ -45,7 +45,7 @@ class SectionKind {
 
            /// Mergeable1ByteCString - 1 byte mergable, null terminated, string.
            Mergeable1ByteCString,
-    
+
            /// Mergeable2ByteCString - 2 byte mergable, null terminated, string.
            Mergeable2ByteCString,
 
@@ -56,11 +56,11 @@ class SectionKind {
         /// constants together.  For example, this can be used to unique
         /// constant pool entries etc.
         MergeableConst,
-    
+
             /// MergeableConst4 - This is a section used by 4-byte constants,
             /// for example, floats.
             MergeableConst4,
-    
+
             /// MergeableConst8 - This is a section used by 8-byte constants,
             /// for example, doubles.
             MergeableConst8,
@@ -68,33 +68,33 @@ class SectionKind {
             /// MergeableConst16 - This is a section used by 16-byte constants,
             /// for example, vectors.
             MergeableConst16,
-    
+
     /// Writeable - This is the base of all segments that need to be written
     /// to during program runtime.
-    
+
        /// ThreadLocal - This is the base of all TLS segments.  All TLS
        /// objects must be writeable, otherwise there is no reason for them to
        /// be thread local!
-    
+
            /// ThreadBSS - Zero-initialized TLS data objects.
            ThreadBSS,
-    
+
            /// ThreadData - Initialized TLS data objects.
            ThreadData,
-    
+
        /// GlobalWriteableData - Writeable data that is global (not thread
        /// local).
-    
+
            /// BSS - Zero initialized writeable data.
            BSS,
-    
+
                /// BSSLocal - This is BSS (zero initialized and writable) data
                /// which has local linkage.
                BSSLocal,
-    
+
                /// BSSExtern - This is BSS data with normal external linkage.
                BSSExtern,
-    
+
            /// Common - Data with common linkage.  These represent tentative
            /// definitions, which always have a zero initializer and are never
            /// marked 'constant'.
@@ -123,20 +123,20 @@ class SectionKind {
            /// mark the pages these globals end up on as read-only after it is
            /// done with its relocation phase.
            ReadOnlyWithRel,
-    
+
                /// ReadOnlyWithRelLocal - This is data that is readonly by the
                /// program, but must be writeable so that the dynamic linker
                /// can perform relocations in it.  This is used when we know
                /// that all the relocations are to globals in this final
                /// linked image.
                ReadOnlyWithRelLocal
-    
+
   } K : 8;
 public:
-  
+
   bool isMetadata() const { return K == Metadata; }
   bool isText() const { return K == Text; }
-  
+
   bool isReadOnly() const {
     return K == ReadOnly || isMergeableCString() ||
            isMergeableConst();
@@ -149,7 +149,7 @@ public:
   bool isMergeable1ByteCString() const { return K == Mergeable1ByteCString; }
   bool isMergeable2ByteCString() const { return K == Mergeable2ByteCString; }
   bool isMergeable4ByteCString() const { return K == Mergeable4ByteCString; }
-  
+
   bool isMergeableConst() const {
     return K == MergeableConst || K == MergeableConst4 ||
            K == MergeableConst8 || K == MergeableConst16;
@@ -157,38 +157,38 @@ public:
   bool isMergeableConst4() const { return K == MergeableConst4; }
   bool isMergeableConst8() const { return K == MergeableConst8; }
   bool isMergeableConst16() const { return K == MergeableConst16; }
-  
+
   bool isWriteable() const {
     return isThreadLocal() || isGlobalWriteableData();
   }
-  
+
   bool isThreadLocal() const {
     return K == ThreadData || K == ThreadBSS;
   }
-  
+
-  bool isThreadBSS() const { return K == ThreadBSS; } 
+  bool isThreadBSS() const { return K == ThreadBSS; }
-  bool isThreadData() const { return K == ThreadData; } 
+  bool isThreadData() const { return K == ThreadData; }
 
   bool isGlobalWriteableData() const {
     return isBSS() || isCommon() || isDataRel() || isReadOnlyWithRel();
   }
-  
+
   bool isBSS() const { return K == BSS || K == BSSLocal || K == BSSExtern; }
   bool isBSSLocal() const { return K == BSSLocal; }
   bool isBSSExtern() const { return K == BSSExtern; }
-  
+
   bool isCommon() const { return K == Common; }
-  
+
   bool isDataRel() const {
     return K == DataRel || K == DataRelLocal || K == DataNoRel;
   }
-  
+
   bool isDataRelLocal() const {
     return K == DataRelLocal || K == DataNoRel;
   }
 
   bool isDataNoRel() const { return K == DataNoRel; }
-  
+
   bool isReadOnlyWithRel() const {
     return K == ReadOnlyWithRel || K == ReadOnlyWithRelLocal;
   }
@@ -196,14 +196,14 @@ public:
   bool isReadOnlyWithRelLocal() const {
     return K == ReadOnlyWithRelLocal;
   }
-private: 
+private:
   static SectionKind get(Kind K) {
     SectionKind Res;
     Res.K = K;
     return Res;
   }
 public:
-  
+
   static SectionKind getMetadata() { return get(Metadata); }
   static SectionKind getText() { return get(Text); }
   static SectionKind getReadOnly() { return get(ReadOnly); }
@@ -234,7 +234,7 @@ public:
     return get(ReadOnlyWithRelLocal);
   }
 };
-  
+
 } // end namespace llvm
 
 #endif

lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp

@@ -52,13 +52,13 @@ static void EmitCamlGlobal(const Module &M, AsmPrinter &AP, const char *Id) {
   SymName.append(MId.begin(), std::find(MId.begin(), MId.end(), '.'));
   SymName += "__";
   SymName += Id;
-  
+
   // Capitalize the first letter of the module name.
   SymName[Letter] = toupper(SymName[Letter]);
-  
+
   SmallString<128> TmpStr;
   AP.Mang->getNameWithPrefix(TmpStr, SymName);
-  
+
   MCSymbol *Sym = AP.OutContext.GetOrCreateSymbol(TmpStr);
 
   AP.OutStreamer.EmitSymbolAttribute(Sym, MCSA_Global);