diff --git a/include/bcc/Compiler.h b/include/bcc/Compiler.h
index a0925b8..1097bad 100644
--- a/include/bcc/Compiler.h
+++ b/include/bcc/Compiler.h
@@ -68,7 +68,9 @@
 
     kErrInvalidSource,
 
-    kIllegalGlobalFunction
+    kIllegalGlobalFunction,
+
+    kErrInvalidTargetMachine
   };
 
   static const char *GetErrorString(enum ErrorCode pErrCode);
@@ -116,6 +118,8 @@
   // all RenderScript functions.  Returns error if any external function that is
   // not in this whitelist is callable from the script.
   enum ErrorCode screenGlobalFunctions(Script &pScript);
+
+  void translateGEPs(Script &pScript);
 };
 
 } // end namespace bcc
diff --git a/include/bcc/Config/Config.h b/include/bcc/Config/Config.h
index 5c209fd..8293827 100644
--- a/include/bcc/Config/Config.h
+++ b/include/bcc/Config/Config.h
@@ -81,6 +81,13 @@
 #define DEFAULT_X86_TRIPLE_STRING      "i686-unknown-linux"
 #define DEFAULT_X86_64_TRIPLE_STRING   "x86_64-unknown-linux"
 
+// Custom DataLayout string for X86 with i64 and f64 set to match the ARM32
+// alignment requirement of 64-bits.
+#define X86_CUSTOM_DL_STRING "e-m:e-p:32:32-i64:64-f64:64:64-f80:32-n8:16:32-S128"
+// Default DataLayout string for X86.  Present to detect future LLVM datalayout
+// changes so X86_CUSTOM_DL_STRING above can be modified appropriately.
+#define X86_DEFAULT_DL_STRING "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
+
 #if defined(DEFAULT_ARM_CODEGEN)
   #define DEFAULT_TARGET_TRIPLE_STRING DEFAULT_ARM_TRIPLE_STRING
 #elif defined(DEFAULT_ARM64_CODEGEN)
diff --git a/include/bcc/Renderscript/RSTransforms.h b/include/bcc/Renderscript/RSTransforms.h
index 66353a3..04e8460 100644
--- a/include/bcc/Renderscript/RSTransforms.h
+++ b/include/bcc/Renderscript/RSTransforms.h
@@ -47,6 +47,8 @@
 
 llvm::ModulePass * createRSAddDebugInfoPass();
 
+llvm::FunctionPass *createRSX86TranslateGEPPass();
+
 } // end namespace bcc
 
 #endif // BCC_RS_TRANSFORMS_H
diff --git a/lib/Core/Compiler.cpp b/lib/Core/Compiler.cpp
index 57fd392..1988da3 100644
--- a/lib/Core/Compiler.cpp
+++ b/lib/Core/Compiler.cpp
@@ -32,6 +32,7 @@
 #include <llvm/Transforms/Vectorize.h>
 
 #include "bcc/Assert.h"
+#include "bcc/Config/Config.h"
 #include "bcc/Renderscript/RSScript.h"
 #include "bcc/Renderscript/RSTransforms.h"
 #include "bcc/Renderscript/RSUtils.h"
@@ -75,6 +76,8 @@
     return "Error loading input bitcode";
   case kIllegalGlobalFunction:
     return "Use of undefined external function";
+  case kErrInvalidTargetMachine:
+    return "Invalid/unexpected llvm::TargetMachine.";
   }
 
   // This assert should never be reached as the compiler verifies that the
@@ -252,6 +255,15 @@
     return kErrInvalidSource;
   }
 
+  if (getTargetMachine().getTargetTriple().getArch() == llvm::Triple::x86) {
+    // Detect and fail if TargetMachine datalayout is different than what we
+    // expect.  This is to detect changes in default target layout for x86 and
+    // update X86_CUSTOM_DL_STRING in include/bcc/Config/Config.h appropriately.
+    if (dl.getStringRepresentation().compare(X86_DEFAULT_DL_STRING) != 0) {
+      return kErrInvalidTargetMachine;
+    }
+  }
+
   // Sanitize module's target information.
   module.setTargetTriple(getTargetMachine().getTargetTriple().str());
   module.setDataLayout(getTargetMachine().createDataLayout());
@@ -458,3 +470,11 @@
   return kSuccess;
 
 }
+
+void Compiler::translateGEPs(Script &pScript) {
+  llvm::legacy::PassManager pPM;
+  pPM.add(createRSX86TranslateGEPPass());
+
+  // Materialization done in screenGlobalFunctions above.
+  pPM.run(pScript.getSource().getModule());
+}
diff --git a/lib/Renderscript/Android.mk b/lib/Renderscript/Android.mk
index b406be7..e392994 100644
--- a/lib/Renderscript/Android.mk
+++ b/lib/Renderscript/Android.mk
@@ -34,7 +34,8 @@
   RSScreenFunctionsPass.cpp \
   RSStubsWhiteList.cpp \
   RSScriptGroupFusion.cpp \
-  RSX86CallConvPass.cpp
+  RSX86CallConvPass.cpp \
+  RSX86TranslateGEPPass.cpp
 
 #=====================================================================
 # Device Static Library: libbccRenderscript
diff --git a/lib/Renderscript/RSCompilerDriver.cpp b/lib/Renderscript/RSCompilerDriver.cpp
index d851187..0370e42 100644
--- a/lib/Renderscript/RSCompilerDriver.cpp
+++ b/lib/Renderscript/RSCompilerDriver.cpp
@@ -23,6 +23,7 @@
 #include <llvm/Support/CommandLine.h>
 #include <llvm/Support/Path.h>
 #include <llvm/Support/raw_ostream.h>
+#include <llvm/Target/TargetMachine.h>
 
 #include "bcinfo/BitcodeWrapper.h"
 #include "bcc/Assert.h"
@@ -126,6 +127,19 @@
     return Compiler::kErrInvalidSource;
   }
 
+  // For (32-bit) x86, translate GEPs on structs or arrays of structs to GEPs on
+  // int8* with byte offsets.  This is to ensure that layout of structs with
+  // 64-bit scalar fields matches frontend-generated code that adheres to ARM
+  // data layout.
+  //
+  // The translation is done before RenderScript runtime library is linked
+  // (during LinkRuntime below) to ensure that RenderScript-driver-provided
+  // structs (like Allocation_t) don't get forced into using the ARM layout
+  // rules.
+  if (mCompiler.getTargetMachine().getTargetTriple().getArch() == llvm::Triple::x86) {
+    mCompiler.translateGEPs(pScript);
+  }
+
   //===--------------------------------------------------------------------===//
   // Link RS script with Renderscript runtime.
   //===--------------------------------------------------------------------===//
diff --git a/lib/Renderscript/RSKernelExpand.cpp b/lib/Renderscript/RSKernelExpand.cpp
index 4193639..d7e4996 100644
--- a/lib/Renderscript/RSKernelExpand.cpp
+++ b/lib/Renderscript/RSKernelExpand.cpp
@@ -646,8 +646,9 @@
   // ArgIter - iterator pointing to first input of the UNexpanded function
   // NumInputs - number of inputs (NOT number of ARGUMENTS)
   //
-  // InBufPtrs[] - this function sets each array element to point to the first
-  //               cell of the corresponding input allocation
+  // InTypes[] - this function saves input type, they will be used in ExpandInputsBody().
+  // InBufPtrs[] - this function sets each array element to point to the first cell / byte
+  //               (byte for x86, cell for other platforms) of the corresponding input allocation
   // InStructTempSlots[] - this function sets each array element either to nullptr
   //                       or to the result of an alloca (for the case where the
   //                       calling convention dictates that a value must be passed
@@ -658,6 +659,7 @@
                                  llvm::MDNode *TBAAPointer,
                                  llvm::Function::arg_iterator ArgIter,
                                  const size_t NumInputs,
+                                 llvm::SmallVectorImpl<llvm::Type *> &InTypes,
                                  llvm::SmallVectorImpl<llvm::Value *> &InBufPtrs,
                                  llvm::SmallVectorImpl<llvm::Value *> &InStructTempSlots) {
     bccAssert(NumInputs <= RS_KERNEL_INPUT_LIMIT);
@@ -693,12 +695,25 @@
                                              static_cast<int32_t>(InputIndex)}));
       llvm::Value    *InBufPtrAddr = Builder.CreateInBoundsGEP(Arg_p, InBufPtrGEP, "input_buf.gep");
       llvm::LoadInst *InBufPtr = Builder.CreateLoad(InBufPtrAddr, "input_buf");
-      llvm::Value    *CastInBufPtr = Builder.CreatePointerCast(InBufPtr, InType, "casted_in");
+
+      llvm::Value *CastInBufPtr = nullptr;
+      if (Module->getTargetTriple() != DEFAULT_X86_TRIPLE_STRING) {
+        CastInBufPtr = Builder.CreatePointerCast(InBufPtr, InType, "casted_in");
+      } else {
+        // The disagreement between module and x86 target machine datalayout
+        // causes mismatched input/output data offset between slang reflected
+        // code and bcc codegen for GetElementPtr. To solve this issue, skip the
+        // cast to InType and leave CastInBufPtr as an int8_t*.  The buffer is
+        // later indexed with an explicit byte offset computed based on
+        // X86_CUSTOM_DL_STRING and then bitcast it to actual input type.
+        CastInBufPtr = InBufPtr;
+      }
 
       if (gEnableRsTbaa) {
         InBufPtr->setMetadata("tbaa", TBAAPointer);
       }
 
+      InTypes.push_back(InType);
       InBufPtrs.push_back(CastInBufPtr);
     }
 
@@ -713,6 +728,8 @@
   // Arg_x1 - first X coordinate to be processed by the expanded function
   // TBAAAllocation - metadata for marking loads of input values out of allocations
   // NumInputs -- number of inputs (NOT number of ARGUMENTS)
+  // InTypes[] - this function uses the saved input types in ExpandInputsLoopInvariant()
+  //             to convert the pointer of byte InPtr to its real type.
   // InBufPtrs[] - this function consumes the information produced by ExpandInputsLoopInvariant()
   // InStructTempSlots[] - this function consumes the information produced by ExpandInputsLoopInvariant()
   // IndVar - value of loop induction variable (X coordinate) for a given loop iteration
@@ -723,16 +740,32 @@
                         llvm::Value *Arg_x1,
                         llvm::MDNode *TBAAAllocation,
                         const size_t NumInputs,
+                        const llvm::SmallVectorImpl<llvm::Type *> &InTypes,
                         const llvm::SmallVectorImpl<llvm::Value *> &InBufPtrs,
                         const llvm::SmallVectorImpl<llvm::Value *> &InStructTempSlots,
                         llvm::Value *IndVar,
                         llvm::SmallVectorImpl<llvm::Value *> &RootArgs) {
     llvm::Value *Offset = Builder.CreateSub(IndVar, Arg_x1);
+    llvm::Type *Int32Ty = llvm::Type::getInt32Ty(*Context);
 
     for (size_t Index = 0; Index < NumInputs; ++Index) {
-      llvm::Value *InPtr = Builder.CreateInBoundsGEP(InBufPtrs[Index], Offset);
-      llvm::Value *Input;
 
+      llvm::Value *InPtr = nullptr;
+      if (Module->getTargetTriple() != DEFAULT_X86_TRIPLE_STRING) {
+        InPtr = Builder.CreateInBoundsGEP(InBufPtrs[Index], Offset);
+      } else {
+        // Treat x86 input buffer as byte[], get indexed pointer with explicit
+        // byte offset computed using a datalayout based on
+        // X86_CUSTOM_DL_STRING, then bitcast it to actual input type.
+        llvm::DataLayout DL(X86_CUSTOM_DL_STRING);
+        llvm::Type *InTy = InTypes[Index];
+        uint64_t InStep = DL.getTypeAllocSize(InTy->getPointerElementType());
+        llvm::Value *OffsetInBytes = Builder.CreateMul(Offset, llvm::ConstantInt::get(Int32Ty, InStep));
+        InPtr = Builder.CreateInBoundsGEP(InBufPtrs[Index], OffsetInBytes);
+        InPtr = Builder.CreatePointerCast(InPtr, InTy);
+      }
+
+      llvm::Value *Input;
       llvm::LoadInst *InputLoad = Builder.CreateLoad(InPtr, "input");
 
       if (gEnableRsTbaa) {
@@ -774,6 +807,9 @@
     }
 
     llvm::DataLayout DL(Module);
+    if (Module->getTargetTriple() == DEFAULT_X86_TRIPLE_STRING) {
+      DL.reset(X86_CUSTOM_DL_STRING);
+    }
 
     llvm::Function *ExpandedFunction =
       createEmptyExpandedForEachKernel(Function->getName());
@@ -904,6 +940,10 @@
 
     // TODO: Refactor this to share functionality with ExpandOldStyleForEach.
     llvm::DataLayout DL(Module);
+    if (Module->getTargetTriple() == DEFAULT_X86_TRIPLE_STRING) {
+      DL.reset(X86_CUSTOM_DL_STRING);
+    }
+    llvm::Type *Int32Ty = llvm::Type::getInt32Ty(*Context);
 
     llvm::Function *ExpandedFunction =
       createEmptyExpandedForEachKernel(Function->getName());
@@ -984,9 +1024,20 @@
         OutBasePtr->setMetadata("tbaa", TBAAPointer);
       }
 
-      CastedOutBasePtr = Builder.CreatePointerCast(OutBasePtr, OutTy, "casted_out");
+      if (Module->getTargetTriple() != DEFAULT_X86_TRIPLE_STRING) {
+        CastedOutBasePtr = Builder.CreatePointerCast(OutBasePtr, OutTy, "casted_out");
+      } else {
+        // The disagreement between module and x86 target machine datalayout
+        // causes mismatched input/output data offset between slang reflected
+        // code and bcc codegen for GetElementPtr. To solve this issue, skip the
+        // cast to OutTy and leave CastedOutBasePtr as an int8_t*.  The buffer
+        // is later indexed with an explicit byte offset computed based on
+        // X86_CUSTOM_DL_STRING and then bitcast it to actual output type.
+        CastedOutBasePtr = OutBasePtr;
+      }
     }
 
+    llvm::SmallVector<llvm::Type*,  8> InTypes;
     llvm::SmallVector<llvm::Value*, 8> InBufPtrs;
     llvm::SmallVector<llvm::Value*, 8> InStructTempSlots;
 
@@ -1011,7 +1062,7 @@
 
     if (NumInPtrArguments > 0) {
       ExpandInputsLoopInvariant(Builder, LoopHeader, Arg_p, TBAAPointer, ArgIter, NumInPtrArguments,
-                                InBufPtrs, InStructTempSlots);
+                                InTypes, InBufPtrs, InStructTempSlots);
     }
 
     // Populate the actual call to kernel().
@@ -1024,7 +1075,18 @@
     llvm::Value *OutPtr = nullptr;
     if (CastedOutBasePtr) {
       llvm::Value *OutOffset = Builder.CreateSub(IV, Arg_x1);
-      OutPtr = Builder.CreateInBoundsGEP(CastedOutBasePtr, OutOffset);
+
+      if (Module->getTargetTriple() != DEFAULT_X86_TRIPLE_STRING) {
+        OutPtr = Builder.CreateInBoundsGEP(CastedOutBasePtr, OutOffset);
+      } else {
+        // Treat x86 output buffer as byte[], get indexed pointer with explicit
+        // byte offset computed using a datalayout based on
+        // X86_CUSTOM_DL_STRING, then bitcast it to actual output type.
+        uint64_t OutStep = DL.getTypeAllocSize(OutTy->getPointerElementType());
+        llvm::Value *OutOffsetInBytes = Builder.CreateMul(OutOffset, llvm::ConstantInt::get(Int32Ty, OutStep));
+        OutPtr = Builder.CreateInBoundsGEP(CastedOutBasePtr, OutOffsetInBytes);
+        OutPtr = Builder.CreatePointerCast(OutPtr, OutTy);
+      }
 
       if (PassOutByPointer) {
         RootArgs.push_back(OutPtr);
@@ -1035,7 +1097,7 @@
 
     if (NumInPtrArguments > 0) {
       ExpandInputsBody(Builder, Arg_x1, TBAAAllocation, NumInPtrArguments,
-                       InBufPtrs, InStructTempSlots, IV, RootArgs);
+                       InTypes, InBufPtrs, InStructTempSlots, IV, RootArgs);
     }
 
     finishArgList(RootArgs, CalleeArgs, CalleeArgsContextIdx, *Function, Builder);
@@ -1122,6 +1184,9 @@
     ALOGV("Expanding simple reduce kernel %s", Function->getName().str().c_str());
 
     llvm::DataLayout DL(Module);
+    if (Module->getTargetTriple() == DEFAULT_X86_TRIPLE_STRING) {
+      DL.reset(X86_CUSTOM_DL_STRING);
+    }
 
     // TBAA Metadata
     llvm::MDNode *TBAARenderScriptDistinct, *TBAARenderScript, *TBAAAllocation;
@@ -1412,15 +1477,16 @@
         ExpandSpecialArguments(Signature, IndVar, Arg_p, Builder, CalleeArgs,
                                [](){}, LoopHeader->getTerminator());
 
+    llvm::SmallVector<llvm::Type*,  8> InTypes;
     llvm::SmallVector<llvm::Value*, 8> InBufPtrs;
     llvm::SmallVector<llvm::Value*, 8> InStructTempSlots;
     ExpandInputsLoopInvariant(Builder, LoopHeader, Arg_p, TBAAPointer, AccumulatorArgIter, NumInputs,
-                              InBufPtrs, InStructTempSlots);
+                              InTypes, InBufPtrs, InStructTempSlots);
 
     // Populate the actual call to the original accumulator.
     llvm::SmallVector<llvm::Value*, 8> RootArgs;
     RootArgs.push_back(Arg_accum);
-    ExpandInputsBody(Builder, Arg_x1, TBAAAllocation, NumInputs, InBufPtrs, InStructTempSlots,
+    ExpandInputsBody(Builder, Arg_x1, TBAAAllocation, NumInputs, InTypes, InBufPtrs, InStructTempSlots,
                      IndVar, RootArgs);
     finishArgList(RootArgs, CalleeArgs, CalleeArgsContextIdx, *FnAccumulator, Builder);
     Builder.CreateCall(FnAccumulator, RootArgs);
diff --git a/lib/Renderscript/RSX86TranslateGEPPass.cpp b/lib/Renderscript/RSX86TranslateGEPPass.cpp
new file mode 100644
index 0000000..75fc2ed
--- /dev/null
+++ b/lib/Renderscript/RSX86TranslateGEPPass.cpp
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2016, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bcc/Assert.h"
+#include "bcc/Config/Config.h"
+#include "bcc/Support/Log.h"
+#include "bcc/Renderscript/RSTransforms.h"
+
+#include <cstdlib>
+
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+#include <llvm/IR/Module.h>
+#include <llvm/Pass.h>
+#include <llvm/IR/GetElementPtrTypeIterator.h>
+
+namespace { // anonymous namespace
+
+/* This pass translates GEPs that index into structs or arrays of structs to
+ * GEPs with an int8* operand and a byte offset.  This translation is done to
+ * enforce on x86 the ARM alignment rule that 64-bit scalars be 8-byte aligned
+ * for structs with such scalars.
+ */
+class RSX86TranslateGEPPass : public llvm::FunctionPass {
+private:
+  static char ID;
+  llvm::LLVMContext *Context;
+  const llvm::DataLayout DL;
+
+  // Walk a GEP instruction and return true if any type indexed is a struct.
+  bool GEPIndexesStructType(const llvm::GetElementPtrInst *GEP) {
+    for (llvm::gep_type_iterator GTI = gep_type_begin(GEP),
+                                 GTE = gep_type_end(GEP);
+         GTI != GTE; ++GTI) {
+      if (llvm::dyn_cast<llvm::StructType>(*GTI)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Helper method to add two llvm::Value parameters
+  llvm::Value *incrementOffset(llvm::Value *accum, llvm::Value *incr,
+                               llvm::Instruction *InsertBefore) {
+    if (accum == nullptr)
+      return incr;
+    return llvm::BinaryOperator::CreateAdd(accum, incr, "", InsertBefore);
+  }
+
+  // Compute the byte offset for a GEP from the GEP's base pointer operand.
+  // Based on visitGetElementPtrInst in llvm/lib/Transforms/Scalar/SROA.cpp.
+  // The difference is that this function handles non-constant array indices and
+  // constructs a sequence of instructions to calculate the offset.  These
+  // instructions might not be the most efficient way to calculate this offset,
+  // but we rely on subsequent optimizations to do necessary fold/combine.
+  llvm::Value *computeGEPOffset(llvm::GetElementPtrInst *GEP) {
+    llvm::Value *Offset = nullptr;
+
+    for (llvm::gep_type_iterator GTI = gep_type_begin(GEP),
+                                 GTE = gep_type_end(GEP);
+         GTI != GTE; ++GTI) {
+      if (llvm::StructType *STy = llvm::dyn_cast<llvm::StructType>(*GTI)) {
+        llvm::ConstantInt *OpC = llvm::dyn_cast<llvm::ConstantInt>(GTI.getOperand());
+        if (!OpC) {
+          ALOGE("Operand for struct type is not constant!");
+          bccAssert(false);
+        }
+
+        // Offset = Offset + EltOffset for index into a struct
+        const llvm::StructLayout *SL = DL.getStructLayout(STy);
+        unsigned EltOffset = SL->getElementOffset(OpC->getZExtValue());
+        llvm::Value *Incr = llvm::ConstantInt::get(
+                                llvm::Type::getInt32Ty(*Context), EltOffset);
+        Offset = incrementOffset(Offset, Incr, GEP);
+      } else {
+        // Offset = Offset + Index * EltSize for index into an array or a vector
+        llvm::Value *EltSize = llvm::ConstantInt::get(
+                                 llvm::Type::getInt32Ty(*Context),
+                                 DL.getTypeAllocSize(GTI.getIndexedType()));
+        llvm::Value *Incr = llvm::BinaryOperator::CreateMul(
+                                GTI.getOperand() /* Index */,
+                                EltSize, "", GEP);
+        Offset = incrementOffset(Offset, Incr, GEP);
+      }
+    }
+
+    return Offset;
+  }
+
+  void translateGEP(llvm::GetElementPtrInst *GEP) {
+    // cast GEP pointer operand to int8*
+    llvm::CastInst *Int8Ptr = llvm::CastInst::CreatePointerCast(
+                                  GEP->getPointerOperand(),
+                                  llvm::Type::getInt8PtrTy(*Context),
+                                  "to.int8ptr",
+                                  GEP);
+    llvm::Value *Indices[1] = {computeGEPOffset(GEP)};
+
+    // index into the int8* based on the byte offset
+    llvm::GetElementPtrInst *Int8PtrGEP = llvm::GetElementPtrInst::Create(
+        llvm::Type::getInt8Ty(*Context), Int8Ptr, llvm::makeArrayRef(Indices),
+        "int8ptr.indexed", GEP);
+    Int8PtrGEP->setIsInBounds(GEP->isInBounds());
+
+    // cast the indexed int8* back to the type of the original GEP
+    llvm::CastInst *OutCast = llvm::CastInst::CreatePointerCast(
+        Int8PtrGEP, GEP->getType(), "to.orig.geptype", GEP);
+
+    GEP->replaceAllUsesWith(OutCast);
+  }
+
+public:
+  RSX86TranslateGEPPass()
+    : FunctionPass (ID), DL(X86_CUSTOM_DL_STRING) {
+  }
+
+  virtual void getAnalysisUsage(llvm::AnalysisUsage &AU) const override {
+    // This pass is run in isolation in a separate pass manager.  So setting
+    // AnalysisUsage is unnecessary.  Set just for completeness.
+    AU.setPreservesCFG();
+  }
+
+  virtual bool runOnFunction(llvm::Function &F) override {
+    bool changed = false;
+    Context = &F.getParent()->getContext();
+
+    // To avoid updating/deleting instructions while walking a BasicBlock's instructions,
+    // collect the GEPs that need to be translated and process them
+    // subsequently.
+    std::vector<llvm::GetElementPtrInst *> GEPsToHandle;
+
+    for (auto &BB: F) {
+      for (auto &I: BB) {
+        if (auto *GEP = llvm::dyn_cast<llvm::GetElementPtrInst>(&I)) {
+          if (GEPIndexesStructType(GEP)) {
+            GEPsToHandle.push_back(GEP);
+          }
+        }
+      }
+    }
+
+    for (auto *GEP: GEPsToHandle) {
+      // Translate GEPs and erase them
+      translateGEP(GEP);
+      changed = true;
+      GEP->eraseFromParent();
+    }
+
+    return changed;
+  }
+
+  virtual const char *getPassName() const override {
+    return "Translate GEPs on structs, intended for x86 target";
+  }
+};
+
+}
+
+char RSX86TranslateGEPPass::ID = 0;
+
+namespace bcc {
+
+llvm::FunctionPass *
+createRSX86TranslateGEPPass() {
+  return new RSX86TranslateGEPPass();
+}
+
+}