Changes from 3.7 merge to files not in upstream

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 98 matching lines @@
   unsigned Alignment = State->DL.getPreferredAlignment(TlsVar);
   padToAlignment(State, FieldTypes, FieldValues, Alignment);
 
   FieldTypes->push_back(TlsVar->getType()->getElementType());
   if (FieldValues)
     FieldValues->push_back(TlsVar->getInitializer());
   State->Offset +=
       State->DL.getTypeAllocSize(TlsVar->getType()->getElementType());
 }
 
-static PointerType *buildTlsTemplate(Module &M, std::vector<VarInfo> *TlsVars) {
+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()) {
@@ skipping 66 matching lines @@
   const char *StartSymbol = "__tls_template_start";
   Constant *TemplateData = ConstantStruct::get(InitTemplateType,
                                                FieldInitValues);
   GlobalVariable *TemplateDataVar =
       new GlobalVariable(M, InitTemplateType, /*isConstant=*/true,
                          GlobalValue::InternalLinkage, TemplateData);
   setGlobalVariableValue(M, StartSymbol, TemplateDataVar);
   TemplateDataVar->setName(StartSymbol);
 
   Constant *TdataEnd = ConstantExpr::getGetElementPtr(
+      InitTemplateType,
       TemplateDataVar,
       ConstantInt::get(M.getContext(), APInt(32, 1)));
   setGlobalVariableValue(M, "__tls_template_tdata_end", TdataEnd);
 
   Constant *TotalEnd = ConstantExpr::getGetElementPtr(
+      TemplateType,
       ConstantExpr::getBitCast(TemplateDataVar, TemplatePtrType),
       ConstantInt::get(M.getContext(), APInt(32, 1)));
   setGlobalVariableValue(M, "__tls_template_end", TotalEnd);
 
   const char *AlignmentSymbol = "__tls_template_alignment";
   Type *i32 = Type::getInt32Ty(M.getContext());
   GlobalVariable *AlignmentVar = new GlobalVariable(
       M, i32, /*isConstant=*/true,
       GlobalValue::InternalLinkage,
       ConstantInt::get(M.getContext(), APInt(32, State.Alignment)));
   setGlobalVariableValue(M, AlignmentSymbol, AlignmentVar);
   AlignmentVar->setName(AlignmentSymbol);
 
-  return TemplatePtrType;
+  return TemplateType;
 }
 
 static void rewriteTlsVars(Module &M, std::vector<VarInfo> *TlsVars,
-                           PointerType *TemplatePtrType) {
+                           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)) {
       Use *U = &*Var->use_begin();
       Instruction *InsertPt = PhiSafeInsertPt(U);
       Value *RawThreadPtr = CallInst::Create(ReadTpFunc, "tls_raw", InsertPt);
-      Value *TypedThreadPtr = new BitCastInst(RawThreadPtr, TemplatePtrType,
-                                              "tls_struct", 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)));
       Indexes.push_back(ConstantInt::get(
           M.getContext(), APInt(32, VarInfo->TemplateIndex)));
-      Value *TlsField = GetElementPtrInst::Create(TypedThreadPtr, Indexes,
-                                                  "field", InsertPt);
+      Value *TlsField = GetElementPtrInst::Create(
+          TemplateType, TypedThreadPtr, Indexes, "field", InsertPt);
       PhiSafeReplaceUses(U, TlsField);
     }
     VarInfo->TlsVar->eraseFromParent();
   }
 }
 
 static void replaceFunction(Module &M, const char *Name, Value *NewFunc) {
   if (Function *Func = M.getFunction(Name)) {
     if (Func->hasLocalLinkage())
       return;
@@ skipping 45 matching lines @@
   ReturnInst::Create(M.getContext(), Result, BB);
   replaceFunction(M, "__nacl_tp_tls_offset", NewFunc);
 }
 
 bool ExpandTls::runOnModule(Module &M) {
   ModulePass *Pass = createExpandTlsConstantExprPass();
   Pass->runOnModule(M);
   delete Pass;
 
   std::vector<VarInfo> TlsVars;
-  PointerType *TemplatePtrType = buildTlsTemplate(M, &TlsVars);
-  rewriteTlsVars(M, &TlsVars, TemplatePtrType);
+  StructType *TemplateType = buildTlsTemplate(M, &TlsVars);
+  rewriteTlsVars(M, &TlsVars, TemplateType);
 
   defineTlsLayoutFunctions(M);
 
   return true;
 }
 
 ModulePass *llvm::createExpandTlsPass() {
   return new ExpandTls();
 }