PNaCl: ExpandTls: Simplify by using a C++11 lambda function

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 41 matching lines @@
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Transforms/NaCl.h"
 
 using namespace llvm;
 
 namespace {
-  class PassState {
-  public:
-    PassState(Module *M): M(M), DL(M), Offset(0), Alignment(1) {}
-
-    Module *M;
-    DataLayout DL;
-    uint32_t Offset;
-    // 'Alignment' is the maximum variable alignment seen so far, in
-    // bytes.  After visiting all TLS variables, this is the overall
-    // alignment required for the TLS template.
-    uint32_t Alignment;
-  };
-
   class ExpandTls : public ModulePass {
   public:
     static char ID; // Pass identification, replacement for typeid
     ExpandTls() : ModulePass(ID) {
       initializeExpandTlsPass(*PassRegistry::getPassRegistry());
     }
 
     virtual bool runOnModule(Module &M);
   };
 }
 
 char ExpandTls::ID = 0;
 INITIALIZE_PASS(ExpandTls, "nacl-expand-tls",
                 "Expand out TLS variables and fix TLS variable layout",
                 false, false)
 
 static void setGlobalVariableValue(Module &M, const char *Name,
                                    Constant *Value) {
   if (GlobalVariable *Var = M.getNamedGlobal(Name)) {
     if (Var->hasInitializer()) {
       report_fatal_error(std::string("Variable ") + Name +
                          " already has an initializer");
     }
     Var->replaceAllUsesWith(ConstantExpr::getBitCast(Value, Var->getType()));
     Var->eraseFromParent();
   }
 }
 
-// Insert alignment padding into the TLS template.
-static void padToAlignment(PassState *State,
-                           std::vector<Constant*> *FieldValues,
-                           unsigned Alignment) {
-  if ((State->Offset & (Alignment - 1)) != 0) {
-    unsigned PadSize = Alignment - (State->Offset & (Alignment - 1));
-    Type *i8 = Type::getInt8Ty(State->M->getContext());
-    Type *PadType = ArrayType::get(i8, PadSize);
-    if (FieldValues)
-      FieldValues->push_back(Constant::getNullValue(PadType));
-    State->Offset += PadSize;
-  }
-  if (State->Alignment < Alignment) {
-    State->Alignment = Alignment;
-  }
-}
-
-static uint32_t addVarToTlsTemplate(PassState *State,
-                                    std::vector<Constant*> *FieldValues,
-                                    GlobalVariable *TlsVar) {
-  unsigned Alignment = State->DL.getPreferredAlignment(TlsVar);
-  padToAlignment(State, FieldValues, Alignment);
-
-  if (FieldValues)
-    FieldValues->push_back(TlsVar->getInitializer());
-  uint32_t Offset = State->Offset;
-  State->Offset +=
-      State->DL.getTypeAllocSize(TlsVar->getType()->getElementType());
-  return Offset;
-}
-
 // This is similar to ConstantStruct::getAnon(), but we give a name to the
 // struct type to make the IR output more readable.
 static Constant *makeInitStruct(Module &M, ArrayRef<Constant *> Elements) {
   SmallVector<Type *, 32> FieldTypes;
   FieldTypes.reserve(Elements.size());
   for (Constant *Val : Elements)
     FieldTypes.push_back(Val->getType());
 
   // We create the TLS template struct as "packed" because we insert
   // alignment padding ourselves.
   StructType *Ty = StructType::create(M.getContext(), FieldTypes,
                                       "tls_init_template", /*isPacked=*/ true);
   return ConstantStruct::get(Ty, Elements);
 }
 
 void llvm::buildTlsTemplate(Module &M, TlsTemplate *Result) {
   std::vector<Constant*> FieldInitValues;
-  PassState State(&M);
+  DataLayout DL(&M);
+  uint32_t CurrentOffset = 0;
+  uint32_t OverallAlignment = 1;
+
+  auto addVarToTlsTemplate = [&](GlobalVariable *TlsVar, bool IsBss) {
+    // Add alignment padding if necessary.
+    uint32_t VarAlignment = DL.getPreferredAlignment(TlsVar);
+    if ((CurrentOffset & (VarAlignment - 1)) != 0) {
+      uint32_t PadSize = VarAlignment - (CurrentOffset & (VarAlignment - 1));
+      CurrentOffset += PadSize;
+      if (!IsBss) {
+        Type *I8 = Type::getInt8Ty(M.getContext());
+        Type *PadType = ArrayType::get(I8, PadSize);
+        FieldInitValues.push_back(Constant::getNullValue(PadType));
+      }
+    }
+    if (OverallAlignment < VarAlignment)
+      OverallAlignment = VarAlignment;
+
+    TlsVarInfo Info;
+    Info.TlsVar = TlsVar;
+    Info.Offset = CurrentOffset;
+    Result->TlsVars.push_back(Info);
+
+    CurrentOffset += DL.getTypeAllocSize(TlsVar->getType()->getElementType());
+    if (!IsBss)
+      FieldInitValues.push_back(TlsVar->getInitializer());
+  };
 
   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());
       }
-      if (!GV.getInitializer()->isNullValue()) {
-        TlsVarInfo Info;
-        Info.TlsVar = &GV;
-        Info.Offset = addVarToTlsTemplate(&State, &FieldInitValues, &GV);
-        Result->TlsVars.push_back(Info);
-      }
+      if (!GV.getInitializer()->isNullValue())
+        addVarToTlsTemplate(&GV, /*IsBss=*/ false);
     }
   }
-  Result->DataSize = State.Offset;
+  Result->DataSize = CurrentOffset;
   // Handle zero-initialized TLS variables in a second pass, because
   // these should follow non-zero-initialized TLS variables.
   for (GlobalVariable &GV : M.globals()) {
-    if (GV.isThreadLocal() && GV.getInitializer()->isNullValue()) {
-      TlsVarInfo Info;
-      Info.TlsVar = &GV;
-      Info.Offset = addVarToTlsTemplate(&State, NULL, &GV);
-      Result->TlsVars.push_back(Info);
-    }
+    if (GV.isThreadLocal() && GV.getInitializer()->isNullValue())
+      addVarToTlsTemplate(&GV, /*IsBss=*/ true);
   }
-  Result->TotalSize = State.Offset;
-  Result->Alignment = State.Alignment;
+  Result->TotalSize = CurrentOffset;
+  Result->Alignment = OverallAlignment;
   Result->Data = makeInitStruct(M, FieldInitValues);
 }
 
 static void adjustToX86StyleLayout(TlsTemplate *Templ) {
   // 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
   // important gives that we're not trying to optimize packing by
@@ skipping 134 matching lines @@
   rewriteTlsVars(M, &Templ.TlsVars);
 
   defineTlsLayoutFunctions(M);
 
   return true;
 }
 
 ModulePass *llvm::createExpandTlsPass() {
   return new ExpandTls();
 }