Reflow comments to use the full width.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// This file defines aspects of the compilation that persist across
-/// multiple functions.
+/// This file defines aspects of the compilation that persist across multiple
+/// functions.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceGlobalContext.h"
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceELFObjectWriter.h"
@@ skipping 18 matching lines @@
     return hash<Ice::IceString>()(Key.Name) +
            hash<Ice::RelocOffsetT>()(Key.Offset);
   }
 };
 } // end of namespace std
 
 namespace Ice {
 
 namespace {
 
-// Define the key comparison function for the constant pool's
-// unordered_map, but only for key types of interest: integer types,
-// floating point types, and the special RelocatableTuple.
+// Define the key comparison function for the constant pool's unordered_map,
+// but only for key types of interest: integer types, floating point types, and
+// the special RelocatableTuple.
 template <typename KeyType, class Enable = void> struct KeyCompare {};
 
 template <typename KeyType>
 struct KeyCompare<KeyType,
                   typename std::enable_if<
                       std::is_integral<KeyType>::value ||
                       std::is_same<KeyType, RelocatableTuple>::value>::type> {
   bool operator()(const KeyType &Value1, const KeyType &Value2) const {
     return Value1 == Value2;
   }
 };
 template <typename KeyType>
 struct KeyCompare<KeyType, typename std::enable_if<
                                std::is_floating_point<KeyType>::value>::type> {
   bool operator()(const KeyType &Value1, const KeyType &Value2) const {
     return !memcmp(&Value1, &Value2, sizeof(KeyType));
   }
 };
 
-// Define a key comparison function for sorting the constant pool's
-// values after they are dumped to a vector.  This covers integer
-// types, floating point types, and ConstantRelocatable values.
+// Define a key comparison function for sorting the constant pool's values
+// after they are dumped to a vector. This covers integer types, floating point
+// types, and ConstantRelocatable values.
 template <typename ValueType, class Enable = void> struct KeyCompareLess {};
 
 template <typename ValueType>
 struct KeyCompareLess<ValueType,
                       typename std::enable_if<std::is_floating_point<
                           typename ValueType::PrimType>::value>::type> {
   bool operator()(const Constant *Const1, const Constant *Const2) const {
     using CompareType = uint64_t;
     static_assert(sizeof(typename ValueType::PrimType) <= sizeof(CompareType),
                   "Expected floating-point type of width 64-bit or less");
@@ skipping 508 matching lines @@
         }
       }
       if (Found) {
         NewName[NewPos++] = OldName[OldPos++]; // 'S'
         size_t Length = Last - OldPos;
         // NewPos and OldPos point just past the 'S'.
         assert(NewName[NewPos - 1] == 'S');
         assert(OldName[OldPos - 1] == 'S');
         assert(OldName[OldPos + Length] == '_');
         if (AllZs) {
-          // Replace N 'Z' characters with a '0' (if N=0) or '1' (if
-          // N>0) followed by N '0' characters.
+          // Replace N 'Z' characters with a '0' (if N=0) or '1' (if N>0)
+          // followed by N '0' characters.
           NewName[NewPos++] = (Length ? '1' : '0');
           for (size_t i = 0; i < Length; ++i) {
             NewName[NewPos++] = '0';
           }
         } else {
           // Iterate right-to-left and increment the base-36 number.
           bool Carry = true;
           for (size_t i = 0; i < Length; ++i) {
             size_t Offset = Length - 1 - i;
             char Ch = OldName[OldPos + Offset];
@@ skipping 19 matching lines @@
         OldPos = Last;
         // Fall through and let the '_' be copied across.
       }
     }
     NewName[NewPos] = OldName[OldPos];
   }
   assert(NewName[NewPos] == '\0');
   OldName = NewName;
 }
 
-// In this context, name mangling means to rewrite a symbol using a
-// given prefix.  For a C++ symbol, nest the original symbol inside
-// the "prefix" namespace.  For other symbols, just prepend the
-// prefix.
+// In this context, name mangling means to rewrite a symbol using a given
+// prefix. For a C++ symbol, nest the original symbol inside the "prefix"
+// namespace. For other symbols, just prepend the prefix.
 IceString GlobalContext::mangleName(const IceString &Name) const {
-  // An already-nested name like foo::bar() gets pushed down one
-  // level, making it equivalent to Prefix::foo::bar().
+  // An already-nested name like foo::bar() gets pushed down one level, making
+  // it equivalent to Prefix::foo::bar().
   //   _ZN3foo3barExyz ==> _ZN6Prefix3foo3barExyz
-  // A non-nested but mangled name like bar() gets nested, making it
-  // equivalent to Prefix::bar().
+  // A non-nested but mangled name like bar() gets nested, making it equivalent
+  // to Prefix::bar().
   //   _Z3barxyz ==> ZN6Prefix3barExyz
   // An unmangled, extern "C" style name, gets a simple prefix:
   //   bar ==> Prefixbar
   if (!BuildDefs::dump() || getFlags().getTestPrefix().empty())
     return Name;
 
   const IceString &TestPrefix = getFlags().getTestPrefix();
   unsigned PrefixLength = TestPrefix.length();
   ManglerVector NameBase(1 + Name.length());
   const size_t BufLen = 30 + Name.length() + PrefixLength;
   ManglerVector NewName(BufLen);
   uint32_t BaseLength = 0; // using uint32_t due to sscanf format string
 
   int ItemsParsed = sscanf(Name.c_str(), "_ZN%s", NameBase.data());
   if (ItemsParsed == 1) {
     // Transform _ZN3foo3barExyz ==> _ZN6Prefix3foo3barExyz
     //   (splice in "6Prefix")          ^^^^^^^
     snprintf(NewName.data(), BufLen, "_ZN%u%s%s", PrefixLength,
              TestPrefix.c_str(), NameBase.data());
-    // We ignore the snprintf return value (here and below).  If we
-    // somehow miscalculated the output buffer length, the output will
-    // be truncated, but it will be truncated consistently for all
-    // mangleName() calls on the same input string.
+    // We ignore the snprintf return value (here and below). If we somehow
+    // miscalculated the output buffer length, the output will be truncated,
+    // but it will be truncated consistently for all mangleName() calls on the
+    // same input string.
     incrementSubstitutions(NewName);
     return NewName.data();
   }
 
-  // Artificially limit BaseLength to 9 digits (less than 1 billion)
-  // because sscanf behavior is undefined on integer overflow.  If
-  // there are more than 9 digits (which we test by looking at the
-  // beginning of NameBase), then we consider this a failure to parse
-  // a namespace mangling, and fall back to the simple prefixing.
+  // Artificially limit BaseLength to 9 digits (less than 1 billion) because
+  // sscanf behavior is undefined on integer overflow. If there are more than 9
+  // digits (which we test by looking at the beginning of NameBase), then we
+  // consider this a failure to parse a namespace mangling, and fall back to
+  // the simple prefixing.
   ItemsParsed = sscanf(Name.c_str(), "_Z%9u%s", &BaseLength, NameBase.data());
   if (ItemsParsed == 2 && BaseLength <= strlen(NameBase.data()) &&
       !isdigit(NameBase[0])) {
     // Transform _Z3barxyz ==> _ZN6Prefix3barExyz
     //                           ^^^^^^^^    ^
-    // (splice in "N6Prefix", and insert "E" after "3bar")
-    // But an "I" after the identifier indicates a template argument
-    // list terminated with "E"; insert the new "E" before/after the
-    // old "E".  E.g.:
+    // (splice in "N6Prefix", and insert "E" after "3bar") But an "I" after the
+    // identifier indicates a template argument list terminated with "E";
+    // insert the new "E" before/after the old "E".  E.g.:
     // Transform _Z3barIabcExyz ==> _ZN6Prefix3barIabcEExyz
     //                                ^^^^^^^^         ^
     // (splice in "N6Prefix", and insert "E" after "3barIabcE")
     ManglerVector OrigName(Name.length());
     ManglerVector OrigSuffix(Name.length());
     uint32_t ActualBaseLength = BaseLength;
     if (NameBase[ActualBaseLength] == 'I') {
       ++ActualBaseLength;
       while (NameBase[ActualBaseLength] != 'E' &&
              NameBase[ActualBaseLength] != '\0')
@@ skipping 17 matching lines @@
 GlobalContext::~GlobalContext() {
   llvm::DeleteContainerPointers(AllThreadContexts);
   LockedPtr<DestructorArray> Dtors = getDestructors();
   // Destructors are invoked in the opposite object construction order.
   for (auto DtorIter = Dtors->crbegin(); DtorIter != Dtors->crend();
        ++DtorIter) {
     (*DtorIter)();
   }
 }
 
-// TODO(stichnot): Consider adding thread-local caches of constant
-// pool entries to reduce contention.
+// TODO(stichnot): Consider adding thread-local caches of constant pool entries
+// to reduce contention.
 
 // All locking is done by the getConstantInt[0-9]+() target function.
 Constant *GlobalContext::getConstantInt(Type Ty, int64_t Value) {
   switch (Ty) {
   case IceType_i1:
     return getConstantInt1(Value);
   case IceType_i8:
     return getConstantInt8(Value);
   case IceType_i16:
     return getConstantInt16(Value);
@@ skipping 123 matching lines @@
   }
   llvm_unreachable("Unknown type");
 }
 
 ConstantList GlobalContext::getConstantExternSyms() {
   return getConstPool()->ExternRelocatables.getConstantPool();
 }
 
 JumpTableDataList GlobalContext::getJumpTables() {
   JumpTableDataList JumpTables(*getJumpTableList());
-  // Make order deterministic by sorting into functions and then ID of the
-  // jump table within that function.
+  // Make order deterministic by sorting into functions and then ID of the jump
+  // table within that function.
   std::sort(JumpTables.begin(), JumpTables.end(),
             [](const JumpTableData &A, const JumpTableData &B) {
               if (A.getFunctionName() != B.getFunctionName())
                 return A.getFunctionName() < B.getFunctionName();
               return A.getId() < B.getId();
             });
 
   if (getFlags().shouldReorderPooledConstants()) {
     // If reorder-pooled-constants option is set to true, we also shuffle the
     // jump tables before emitting them.
@@ skipping 49 matching lines @@
   Timers->at(StackID).reset();
 }
 
 void GlobalContext::setTimerName(TimerStackIdT StackID,
                                  const IceString &NewName) {
   auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).setName(NewName);
 }
 
-// Note: optQueueBlockingPush and optQueueBlockingPop use unique_ptr
-// at the interface to take and transfer ownership, but they
-// internally store the raw Cfg pointer in the work queue.  This
-// allows e.g. future queue optimizations such as the use of atomics
-// to modify queue elements.
+// Note: optQueueBlockingPush and optQueueBlockingPop use unique_ptr at the
+// interface to take and transfer ownership, but they internally store the raw
+// Cfg pointer in the work queue. This allows e.g. future queue optimizations
+// such as the use of atomics to modify queue elements.
 void GlobalContext::optQueueBlockingPush(std::unique_ptr<Cfg> Func) {
   assert(Func);
   OptQ.blockingPush(Func.release());
   if (getFlags().isSequential())
     translateFunctions();
 }
 
 std::unique_ptr<Cfg> GlobalContext::optQueueBlockingPop() {
   return std::unique_ptr<Cfg>(OptQ.blockingPop());
 }
@@ skipping 48 matching lines @@
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice