PNaCl: ExpandTls: Use C++11 range-based "for" loops

lib/Transforms/NaCl/ExpandTls.cpp

 //===- ExpandTls.cpp - Convert TLS variables to a concrete layout----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass expands out uses of thread-local (TLS) variables into
@@ skipping 104 matching lines @@
   State->Offset +=
       State->DL.getTypeAllocSize(TlsVar->getType()->getElementType());
 }
 
 static StructType *buildTlsTemplate(Module &M, std::vector<VarInfo> *TlsVars) {
   std::vector<Type*> FieldBssTypes;
   std::vector<Type*> FieldInitTypes;
   std::vector<Constant*> FieldInitValues;
   PassState State(&M);
 
-  for (Module::global_iterator GV = M.global_begin();
-       GV != M.global_end();
-       ++GV) {
-    if (GV->isThreadLocal()) {
-      if (!GV->hasInitializer()) {
+  for (GlobalVariable &GV : M.globals()) {
+    if (GV.isThreadLocal()) {
+      if (!GV.hasInitializer()) {
         // Since this is a whole-program transformation, "extern" TLS
         // variables are not allowed at this point.
         report_fatal_error(std::string("TLS variable without an initializer: ")
-                           + GV->getName());
+                           + GV.getName());
       }
-      if (!GV->getInitializer()->isNullValue()) {
-        addVarToTlsTemplate(&State, &FieldInitTypes,
-                            &FieldInitValues, GV);
+      if (!GV.getInitializer()->isNullValue()) {
+        addVarToTlsTemplate(&State, &FieldInitTypes, &FieldInitValues, &GV);
         VarInfo Info;
-        Info.TlsVar = GV;
+        Info.TlsVar = &GV;
         Info.IsBss = false;
         Info.TemplateIndex = FieldInitTypes.size() - 1;
         TlsVars->push_back(Info);
       }
     }
   }
   // Handle zero-initialized TLS variables in a second pass, because
   // these should follow non-zero-initialized TLS variables.
-  for (Module::global_iterator GV = M.global_begin();
-       GV != M.global_end();
-       ++GV) {
-    if (GV->isThreadLocal() && GV->getInitializer()->isNullValue()) {
-      addVarToTlsTemplate(&State, &FieldBssTypes, NULL, GV);
+  for (GlobalVariable &GV : M.globals()) {
+    if (GV.isThreadLocal() && GV.getInitializer()->isNullValue()) {
+      addVarToTlsTemplate(&State, &FieldBssTypes, NULL, &GV);
       VarInfo Info;
-      Info.TlsVar = GV;
+      Info.TlsVar = &GV;
       Info.IsBss = true;
       Info.TemplateIndex = FieldBssTypes.size() - 1;
       TlsVars->push_back(Info);
     }
   }
   // Add final alignment padding so that
   //   (struct tls_struct *) __nacl_read_tp() - 1
   // gives the correct, aligned start of the TLS variables given the
   // x86-style layout we are using.  This requires some more bytes to
   // be memset() to zero at runtime.  This wastage doesn't seem
@@ skipping 59 matching lines @@
   AlignmentVar->setName(AlignmentSymbol);
 
   return TemplateType;
 }
 
 static void rewriteTlsVars(Module &M, std::vector<VarInfo> *TlsVars,
                            StructType *TemplateType) {
   // Set up the intrinsic that reads the thread pointer.
   Function *ReadTpFunc = Intrinsic::getDeclaration(&M, Intrinsic::nacl_read_tp);
 
-  for (std::vector<VarInfo>::iterator VarInfo = TlsVars->begin();
-       VarInfo != TlsVars->end();
-       ++VarInfo) {
-    GlobalVariable *Var = VarInfo->TlsVar;
-    while (Var->hasNUsesOrMore(1)) {
+  for (VarInfo &VarInfo : *TlsVars) {
+    GlobalVariable *Var = VarInfo.TlsVar;
+    while (!Var->use_empty()) {
       Use *U = &*Var->use_begin();
       Instruction *InsertPt = PhiSafeInsertPt(U);
       Value *RawThreadPtr = CallInst::Create(ReadTpFunc, "tls_raw", InsertPt);
       Value *TypedThreadPtr = new BitCastInst(
           RawThreadPtr, TemplateType->getPointerTo(), "tls_struct", InsertPt);
       SmallVector<Value*, 3> Indexes;
       // We use -1 because we use the x86-style TLS layout in which
       // the TLS data is stored at addresses below the thread pointer.
       // This is largely because a check in nacl_irt_thread_create()
       // in irt/irt_thread.c requires the thread pointer to be a
       // self-pointer on x86-32.
       // TODO(mseaborn): I intend to remove that check because it is
       // non-portable.  In the mean time, we want PNaCl pexes to work
       // in older Chromium releases when translated to nexes.
       Indexes.push_back(ConstantInt::get(
           M.getContext(), APInt(32, -1)));
       Indexes.push_back(ConstantInt::get(
-          M.getContext(), APInt(32, VarInfo->IsBss ? 1 : 0)));
+          M.getContext(), APInt(32, VarInfo.IsBss ? 1 : 0)));
       Indexes.push_back(ConstantInt::get(
-          M.getContext(), APInt(32, VarInfo->TemplateIndex)));
+          M.getContext(), APInt(32, VarInfo.TemplateIndex)));
       Value *TlsField = GetElementPtrInst::Create(
           TemplateType, TypedThreadPtr, Indexes, "field", InsertPt);
       PhiSafeReplaceUses(U, TlsField);
     }
-    VarInfo->TlsVar->eraseFromParent();
+    Var->eraseFromParent();
   }
 }
 
 static void replaceFunction(Module &M, const char *Name, Value *NewFunc) {
   if (Function *Func = M.getFunction(Name)) {
     if (Func->hasLocalLinkage())
       return;
     if (!Func->isDeclaration())
       report_fatal_error(std::string("Function already defined: ") + Name);
     Func->replaceAllUsesWith(NewFunc);
@@ skipping 53 matching lines @@
   rewriteTlsVars(M, &TlsVars, TemplateType);
 
   defineTlsLayoutFunctions(M);
 
   return true;
 }
 
 ModulePass *llvm::createExpandTlsPass() {
   return new ExpandTls();
 }