diff --git a/lib/Target/JSBackend/CallHandlers.h b/lib/Target/JSBackend/CallHandlers.h
index 50702e36f40..e6ad8f5f8ec 100644
--- a/lib/Target/JSBackend/CallHandlers.h
+++ b/lib/Target/JSBackend/CallHandlers.h
@@ -314,16 +314,21 @@ DEF_CALL_HANDLER(llvm_nacl_atomic_store_i32, {
   return "HEAP32[" + getValueAsStr(CI->getOperand(0)) + ">>2]=" + getValueAsStr(CI->getOperand(1));
 })
 
-#define CMPXCHG_HANDLER(name) \
+#define CMPXCHG_HANDLER(name, HeapName) \
 DEF_CALL_HANDLER(name, { \
   const Value *P = CI->getOperand(0); \
-  return getLoad(CI, P, CI->getType(), 0) + ';' + \
-         "if ((" + getCast(getJSName(CI), CI->getType()) + ") == " + getValueAsCastParenStr(CI->getOperand(1)) + ") " + \
-            getStore(CI, P, CI->getType(), getValueAsStr(CI->getOperand(2)), 0); \
+  if (EnablePthreads) { \
+    return getAssign(CI) + "Atomics_compareExchange(" HeapName ", " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ", " + getValueAsStr(CI->getOperand(2)) + ")"; \
+  } else { \
+    return getLoad(CI, P, CI->getType(), 0) + ';' + \
+             "if ((" + getCast(getJSName(CI), CI->getType()) + ") == " + getValueAsCastParenStr(CI->getOperand(1)) + ") " + \
+                getStore(CI, P, CI->getType(), getValueAsStr(CI->getOperand(2)), 0); \
+  } \
 })
-CMPXCHG_HANDLER(llvm_nacl_atomic_cmpxchg_i8);
-CMPXCHG_HANDLER(llvm_nacl_atomic_cmpxchg_i16);
-CMPXCHG_HANDLER(llvm_nacl_atomic_cmpxchg_i32);
+
+CMPXCHG_HANDLER(llvm_nacl_atomic_cmpxchg_i8, "HEAP8");
+CMPXCHG_HANDLER(llvm_nacl_atomic_cmpxchg_i16, "HEAP16");
+CMPXCHG_HANDLER(llvm_nacl_atomic_cmpxchg_i32, "HEAP32");
 
 #define UNROLL_LOOP_MAX 8
 #define WRITE_LOOP_MAX 128
@@ -549,6 +554,145 @@ DEF_CALL_HANDLER(emscripten_asm_const_double, {
   return getAssign(CI) + getCast(handleAsmConst(CI), Type::getDoubleTy(CI->getContext()));
 })
 
+/* TODO: Uncomment once https://bugzilla.mozilla.org/show_bug.cgi?id=1141986 is implemented!
+
+DEF_CALL_HANDLER(emscripten_atomic_exchange_u8, {
+  return getAssign(CI) + "Atomics_exchange(HEAP8, " + getValueAsStr(CI->getOperand(0)) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_exchange_u16, {
+  return getAssign(CI) + "Atomics_exchange(HEAP16, " + getShiftedPtr(CI->getOperand(0), 2) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_exchange_u32, {
+  return getAssign(CI) + "Atomics_exchange(HEAP32, " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_exchange_f32, {
+  return getAssign(CI) + "Atomics_exchange(HEAPF32, " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_exchange_f64, {
+  return getAssign(CI) + "Atomics_exchange(HEAPF64, " + getShiftedPtr(CI->getOperand(0), 8) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+*/
+
+DEF_CALL_HANDLER(emscripten_atomic_cas_u8, {
+  return getAssign(CI) + "Atomics_compareExchange(HEAP8, " + getValueAsStr(CI->getOperand(0)) + ", " + getValueAsStr(CI->getOperand(1)) + ", " + getValueAsStr(CI->getOperand(2)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_cas_u16, {
+  return getAssign(CI) + "Atomics_compareExchange(HEAP16, " + getShiftedPtr(CI->getOperand(0), 2) + ", " + getValueAsStr(CI->getOperand(1)) + ", " + getValueAsStr(CI->getOperand(2)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_cas_u32, {
+  return getAssign(CI) + "Atomics_compareExchange(HEAP32, " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ", " + getValueAsStr(CI->getOperand(2)) + ")";
+})
+
+DEF_CALL_HANDLER(emscripten_atomic_load_u8, {
+  return getAssign(CI) + "Atomics_load(HEAP8, " + getValueAsStr(CI->getOperand(0)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_load_u16, {
+  return getAssign(CI) + "Atomics_load(HEAP16, " + getShiftedPtr(CI->getOperand(0), 2) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_load_u32, {
+  return getAssign(CI) + "Atomics_load(HEAP32, " + getShiftedPtr(CI->getOperand(0), 4) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_load_f32, {
+  // TODO: If https://bugzilla.mozilla.org/show_bug.cgi?id=1131613 is implemented, we could use the commented out version. Until then,
+  // we must emulate manually.
+  return getAssign(CI) + (PreciseF32 ? "Math_fround(" : "+") + "__Atomics_load_f32_emulated(" + getShiftedPtr(CI->getOperand(0), 4) + (PreciseF32 ? "))" : ")");
+//  return getAssign(CI) + "Atomics_load(HEAPF32, " + getShiftedPtr(CI->getOperand(0), 4) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_load_f64, {
+  // TODO: If https://bugzilla.mozilla.org/show_bug.cgi?id=1131624 is implemented, we could use the commented out version. Until then,
+  // we must emulate manually.
+  return getAssign(CI) + "+_emscripten_atomic_load_f64(" + getShiftedPtr(CI->getOperand(0), 8) + ")";
+//  return getAssign(CI) + "Atomics_load(HEAPF64, " + getShiftedPtr(CI->getOperand(0), 8) + ")";
+})
+
+DEF_CALL_HANDLER(emscripten_atomic_store_u8, {
+  return getAssign(CI) + "Atomics_store(HEAP8, " + getValueAsStr(CI->getOperand(0)) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_store_u16, {
+  return getAssign(CI) + "Atomics_store(HEAP16, " + getShiftedPtr(CI->getOperand(0), 2) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_store_u32, {
+  return getAssign(CI) + "Atomics_store(HEAP32, " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_store_f32, {
+  // TODO: If https://bugzilla.mozilla.org/show_bug.cgi?id=1131613 is implemented, we could use the commented out version. Until then,
+  // we must emulate manually.
+  return getAssign(CI) + "_emscripten_atomic_store_f32(" + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+//  return getAssign(CI) + "Atomics_store(HEAPF32, " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_store_f64, {
+  // TODO: If https://bugzilla.mozilla.org/show_bug.cgi?id=1131624 is implemented, we could use the commented out version. Until then,
+  // we must emulate manually.
+  return getAssign(CI) + "+_emscripten_atomic_store_f64(" + getShiftedPtr(CI->getOperand(0), 8) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+//  return getAssign(CI) + "Atomics_store(HEAPF64, " + getShiftedPtr(CI->getOperand(0), 8) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+
+DEF_CALL_HANDLER(emscripten_atomic_add_u8, {
+  return getAssign(CI) + "Atomics_add(HEAP8, " + getValueAsStr(CI->getOperand(0)) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_add_u16, {
+  return getAssign(CI) + "Atomics_add(HEAP16, " + getShiftedPtr(CI->getOperand(0), 2) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_add_u32, {
+  return getAssign(CI) + "Atomics_add(HEAP32, " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_add_f32, {
+  errs() << "emcc: warning: float32 atomic add is not supported!" << CI->getParent()->getParent()->getName() << ":" << *CI << "\n";
+  return getAssign(CI) + "Atomics_add(HEAPF32, " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_add_f64, {
+  errs() << "emcc: warning: float64 atomic add is not supported!" << CI->getParent()->getParent()->getName() << ":" << *CI << "\n";
+  return getAssign(CI) + "Atomics_add(HEAPF64, " + getShiftedPtr(CI->getOperand(0), 8) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+
+DEF_CALL_HANDLER(emscripten_atomic_sub_u8, {
+  return getAssign(CI) + "Atomics_sub(HEAP8, " + getValueAsStr(CI->getOperand(0)) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_sub_u16, {
+  return getAssign(CI) + "Atomics_sub(HEAP16, " + getShiftedPtr(CI->getOperand(0), 2) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_sub_u32, {
+  return getAssign(CI) + "Atomics_sub(HEAP32, " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_sub_f32, {
+  errs() << "emcc: warning: float32 atomic sub is not supported!" << CI->getParent()->getParent()->getName() << ":" << *CI << "\n";
+  return getAssign(CI) + "Atomics_sub(HEAPF32, " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_sub_f64, {
+  errs() << "emcc: warning: float64 atomic sub is not supported!" << CI->getParent()->getParent()->getName() << ":" << *CI << "\n";
+  return getAssign(CI) + "Atomics_sub(HEAPF64, " + getShiftedPtr(CI->getOperand(0), 8) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+
+DEF_CALL_HANDLER(emscripten_atomic_and_u8, {
+  return getAssign(CI) + "Atomics_and(HEAP8, " + getValueAsStr(CI->getOperand(0)) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_and_u16, {
+  return getAssign(CI) + "Atomics_and(HEAP16, " + getShiftedPtr(CI->getOperand(0), 2) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_and_u32, {
+  return getAssign(CI) + "Atomics_and(HEAP32, " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+
+DEF_CALL_HANDLER(emscripten_atomic_or_u8, {
+  return getAssign(CI) + "Atomics_or(HEAP8, " + getValueAsStr(CI->getOperand(0)) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_or_u16, {
+  return getAssign(CI) + "Atomics_or(HEAP16, " + getShiftedPtr(CI->getOperand(0), 2) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_or_u32, {
+  return getAssign(CI) + "Atomics_or(HEAP32, " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+
+DEF_CALL_HANDLER(emscripten_atomic_xor_u8, {
+  return getAssign(CI) + "Atomics_xor(HEAP8, " + getValueAsStr(CI->getOperand(0)) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_xor_u16, {
+  return getAssign(CI) + "Atomics_xor(HEAP16, " + getShiftedPtr(CI->getOperand(0), 2) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+DEF_CALL_HANDLER(emscripten_atomic_xor_u32, {
+  return getAssign(CI) + "Atomics_xor(HEAP32, " + getShiftedPtr(CI->getOperand(0), 4) + ", " + getValueAsStr(CI->getOperand(1)) + ")";
+})
+
 #define DEF_BUILTIN_HANDLER(name, to) \
 DEF_CALL_HANDLER(name, { \
   return CH___default__(CI, #to); \
@@ -637,6 +781,7 @@ DEF_BUILTIN_HANDLER(emscripten_int32x4_greaterThanOrEqual, SIMD_int32x4_greaterT
 DEF_BUILTIN_HANDLER(emscripten_int32x4_select, SIMD_int32x4_select);
 DEF_BUILTIN_HANDLER(emscripten_int32x4_fromFloat32x4Bits, SIMD_int32x4_fromFloat32x4Bits);
 DEF_BUILTIN_HANDLER(emscripten_int32x4_fromFloat32x4, SIMD_int32x4_fromFloat32x4);
+DEF_BUILTIN_HANDLER(emscripten_atomic_fence, Atomics_fence);
 
 // Setups
 
@@ -727,6 +872,56 @@ void setupCallHandlers() {
   SETUP_CALL_HANDLER(emscripten_asm_const_int);
   SETUP_CALL_HANDLER(emscripten_asm_const_double);
 
+/* TODO: Uncomment once https://bugzilla.mozilla.org/show_bug.cgi?id=1141986 is implemented!
+  SETUP_CALL_HANDLER(emscripten_atomic_exchange_u8);
+  SETUP_CALL_HANDLER(emscripten_atomic_exchange_u16);
+  SETUP_CALL_HANDLER(emscripten_atomic_exchange_u32);
+  SETUP_CALL_HANDLER(emscripten_atomic_exchange_f32);
+  SETUP_CALL_HANDLER(emscripten_atomic_exchange_f64);
+*/
+
+  SETUP_CALL_HANDLER(emscripten_atomic_cas_u8);
+  SETUP_CALL_HANDLER(emscripten_atomic_cas_u16);
+  SETUP_CALL_HANDLER(emscripten_atomic_cas_u32);
+
+  SETUP_CALL_HANDLER(emscripten_atomic_load_u8);
+  SETUP_CALL_HANDLER(emscripten_atomic_load_u16);
+  SETUP_CALL_HANDLER(emscripten_atomic_load_u32);
+  SETUP_CALL_HANDLER(emscripten_atomic_load_f32);
+  SETUP_CALL_HANDLER(emscripten_atomic_load_f64);
+
+  SETUP_CALL_HANDLER(emscripten_atomic_store_u8);
+  SETUP_CALL_HANDLER(emscripten_atomic_store_u16);
+  SETUP_CALL_HANDLER(emscripten_atomic_store_u32);
+  SETUP_CALL_HANDLER(emscripten_atomic_store_f32);
+  SETUP_CALL_HANDLER(emscripten_atomic_store_f64);
+
+  SETUP_CALL_HANDLER(emscripten_atomic_add_u8);
+  SETUP_CALL_HANDLER(emscripten_atomic_add_u16);
+  SETUP_CALL_HANDLER(emscripten_atomic_add_u32);
+  SETUP_CALL_HANDLER(emscripten_atomic_add_f32);
+  SETUP_CALL_HANDLER(emscripten_atomic_add_f64);
+
+  SETUP_CALL_HANDLER(emscripten_atomic_sub_u8);
+  SETUP_CALL_HANDLER(emscripten_atomic_sub_u16);
+  SETUP_CALL_HANDLER(emscripten_atomic_sub_u32);
+  SETUP_CALL_HANDLER(emscripten_atomic_sub_f32);
+  SETUP_CALL_HANDLER(emscripten_atomic_sub_f64);
+
+  SETUP_CALL_HANDLER(emscripten_atomic_and_u8);
+  SETUP_CALL_HANDLER(emscripten_atomic_and_u16);
+  SETUP_CALL_HANDLER(emscripten_atomic_and_u32);
+
+  SETUP_CALL_HANDLER(emscripten_atomic_or_u8);
+  SETUP_CALL_HANDLER(emscripten_atomic_or_u16);
+  SETUP_CALL_HANDLER(emscripten_atomic_or_u32);
+
+  SETUP_CALL_HANDLER(emscripten_atomic_xor_u8);
+  SETUP_CALL_HANDLER(emscripten_atomic_xor_u16);
+  SETUP_CALL_HANDLER(emscripten_atomic_xor_u32);
+
+  SETUP_CALL_HANDLER(emscripten_atomic_fence);
+
   SETUP_CALL_HANDLER(abs);
   SETUP_CALL_HANDLER(labs);
   SETUP_CALL_HANDLER(cos);
diff --git a/lib/Target/JSBackend/JSBackend.cpp b/lib/Target/JSBackend/JSBackend.cpp
index 2035563106d..a364c6e2c37 100644
--- a/lib/Target/JSBackend/JSBackend.cpp
+++ b/lib/Target/JSBackend/JSBackend.cpp
@@ -68,6 +68,11 @@ PreciseF32("emscripten-precise-f32",
            cl::desc("Enables Math.fround usage to implement precise float32 semantics and performance (see emscripten PRECISE_F32 option)"),
            cl::init(false));
 
+static cl::opt<bool>
+EnablePthreads("emscripten-enable-pthreads",
+           cl::desc("Enables compilation targeting JavaScript Shared Array Buffer and Atomics API to implement support for pthreads-based multithreading"),
+           cl::init(false));
+
 static cl::opt<bool>
 WarnOnUnaligned("emscripten-warn-unaligned",
                 cl::desc("Warns about unaligned loads and stores (which can negatively affect performance)"),
@@ -495,8 +500,30 @@ namespace {
     }
 
     std::string getPtrLoad(const Value* Ptr);
-    std::string getHeapAccess(const std::string& Name, unsigned Bytes, bool Integer=true);
+
+    /// Given a pointer to memory, returns the HEAP object and index to that object that is used to access that memory.
+    /// @param Ptr [in] The heap object.
+    /// @param HeapName [out] Receives the name of the HEAP object used to perform the memory acess.
+    /// @return The index to the heap HeapName for the memory access.
+    std::string getHeapNameAndIndex(const Value *Ptr, const char **HeapName);
+
+    // Like getHeapNameAndIndex(), but uses the given memory operation size instead of the one from Ptr.
+    std::string getHeapNameAndIndex(const Value *Ptr, const char **HeapName, unsigned Bytes);
+
+    /// Like getHeapNameAndIndex(), but for global variables only.
+    std::string getHeapNameAndIndexToGlobal(const GlobalVariable *GV, const char **HeapName);
+
+    /// Like getHeapNameAndIndex(), but for pointers represented in string expression form.
+    static std::string getHeapNameAndIndexToPtr(const std::string& Ptr, unsigned Bytes, bool Integer, const char **HeapName);
+
+    std::string getShiftedPtr(const Value *Ptr, unsigned Bytes);
+
+    /// Returns a string expression for accessing the given memory address.
     std::string getPtrUse(const Value* Ptr);
+
+    /// Like getPtrUse(), but for pointers represented in string expression form.
+    static std::string getHeapAccess(const std::string& Name, unsigned Bytes, bool Integer=true);
+
     std::string getConstant(const Constant*, AsmCast sign=ASM_SIGNED);
     std::string getConstantVector(Type *ElementType, std::string x, std::string y, std::string z, std::string w);
     std::string getValueAsStr(const Value*, AsmCast sign=ASM_SIGNED);
@@ -840,18 +867,111 @@ std::string JSWriter::getIMul(const Value *V1, const Value *V2) {
   return "Math_imul(" + getValueAsStr(V1) + ", " + getValueAsStr(V2) + ")|0"; // unknown or too large, emit imul
 }
 
+static inline const char *getHeapName(int Bytes, int Integer)
+{
+  switch (Bytes) {
+    default: llvm_unreachable("Unsupported type");
+    case 8: return "HEAPF64";
+    case 4: return Integer ? "HEAP32" : "HEAPF32";
+    case 2: return "HEAP16";
+    case 1: return "HEAP8";
+  }
+}
+
+static inline int getHeapShift(int Bytes)
+{
+  switch (Bytes) {
+    default: llvm_unreachable("Unsupported type");
+    case 8: return 3;
+    case 4: return 2;
+    case 2: return 1;
+    case 1: return 0;
+  }
+}
+
+static inline const char *getHeapShiftStr(int Bytes)
+{
+  switch (Bytes) {
+    default: llvm_unreachable("Unsupported type");
+    case 8: return ">>3";
+    case 4: return ">>2";
+    case 2: return ">>1";
+    case 1: return ">>0";
+  }
+}
+
+std::string JSWriter::getHeapNameAndIndexToGlobal(const GlobalVariable *GV, const char **HeapName)
+{
+  Type *t = cast<PointerType>(GV->getType())->getElementType();
+  unsigned Bytes = DL->getTypeAllocSize(t);
+  unsigned Addr = getGlobalAddress(GV->getName().str());
+  *HeapName = getHeapName(Bytes, t->isIntegerTy() || t->isPointerTy());
+  return relocateGlobal(utostr(Addr >> getHeapShift(Bytes)));
+}
+
+std::string JSWriter::getHeapNameAndIndexToPtr(const std::string& Ptr, unsigned Bytes, bool Integer, const char **HeapName)
+{
+  *HeapName = getHeapName(Bytes, Integer);
+  return Ptr + getHeapShiftStr(Bytes);
+}
+
+std::string JSWriter::getHeapNameAndIndex(const Value *Ptr, const char **HeapName, unsigned Bytes)
+{
+  Type *t = cast<PointerType>(Ptr->getType())->getElementType();
+
+  if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Ptr)) {
+    return getHeapNameAndIndexToGlobal(GV, HeapName);
+  } else {
+    return getHeapNameAndIndexToPtr(getValueAsStr(Ptr), Bytes, t->isIntegerTy() || t->isPointerTy(), HeapName);
+  }
+}
+
+std::string JSWriter::getHeapNameAndIndex(const Value *Ptr, const char **HeapName)
+{
+  Type *t = cast<PointerType>(Ptr->getType())->getElementType();
+  unsigned Bytes = DL->getTypeAllocSize(t);
+  return getHeapNameAndIndex(Ptr, HeapName, Bytes);
+}
+
+static const char *heapNameToAtomicTypeName(const char *HeapName)
+{
+  if (!strcmp(HeapName, "HEAPF32")) return "f32";
+  if (!strcmp(HeapName, "HEAPF64")) return "f64";
+  return "";
+}
+
 std::string JSWriter::getLoad(const Instruction *I, const Value *P, Type *T, unsigned Alignment, char sep) {
   std::string Assign = getAssign(I);
   unsigned Bytes = DL->getTypeAllocSize(T);
   std::string text;
   if (Bytes <= Alignment || Alignment == 0) {
-    text = Assign + getPtrLoad(P);
+    if (EnablePthreads && cast<LoadInst>(I)->isVolatile()) {
+      const char *HeapName;
+      std::string Index = getHeapNameAndIndex(P, &HeapName);
+      if (!strcmp(HeapName, "HEAPF32") || !strcmp(HeapName, "HEAPF64")) {
+        bool fround = PreciseF32 && !strcmp(HeapName, "HEAPF32");
+        // TODO: If https://bugzilla.mozilla.org/show_bug.cgi?id=1131613 and https://bugzilla.mozilla.org/show_bug.cgi?id=1131624 are
+        // implemented, we could remove the emulation, but until then we must emulate manually.
+        text = Assign + (fround ? "Math_fround(" : "+") + "_emscripten_atomic_load_" + heapNameToAtomicTypeName(HeapName) + "(" + getValueAsStr(P) + (fround ? "))" : ")");
+      } else {
+        text = Assign + "Atomics_load(" + HeapName + ',' + Index + ')';
+      }
+    } else {
+      text = Assign + getPtrLoad(P);
+    }
     if (isAbsolute(P)) {
       // loads from an absolute constants are either intentional segfaults (int x = *((int*)0)), or code problems
       text += "; abort() /* segfault, load from absolute addr */";
     }
   } else {
     // unaligned in some manner
+
+    if (EnablePthreads && cast<LoadInst>(I)->isVolatile()) {
+      errs() << "emcc: warning: unable to implement unaligned volatile load as atomic in " << I->getParent()->getParent()->getName() << ":" << *I << " | ";
+      emitDebugInfo(errs(), I);
+      errs() << "\n";
+    }
+
     if (WarnOnUnaligned) {
       errs() << "emcc: warning: unaligned load in  " << I->getParent()->getParent()->getName() << ":" << *I << " | ";
       emitDebugInfo(errs(), I);
@@ -943,10 +1063,33 @@ std::string JSWriter::getStore(const Instruction *I, const Value *P, Type *T, co
   unsigned Bytes = DL->getTypeAllocSize(T);
   std::string text;
   if (Bytes <= Alignment || Alignment == 0) {
-    text = getPtrUse(P) + " = " + VS;
+    if (EnablePthreads && cast<StoreInst>(I)->isVolatile()) {
+      const char *HeapName;
+      std::string Index = getHeapNameAndIndex(P, &HeapName);
+      if (!strcmp(HeapName, "HEAPF32") || !strcmp(HeapName, "HEAPF64")) {
+        // TODO: If https://bugzilla.mozilla.org/show_bug.cgi?id=1131613 and https://bugzilla.mozilla.org/show_bug.cgi?id=1131624 are
+        // implemented, we could remove the emulation, but until then we must emulate manually.
+        text = std::string("_emscripten_atomic_store_") + heapNameToAtomicTypeName(HeapName) + "(" + getValueAsStr(P) + ',' + VS + ')';
+        if (PreciseF32 && !strcmp(HeapName, "HEAPF32"))
+          text = "Math_fround(" + text + ")";
+        else
+          text = "+" + text;
+      } else {
+        text = std::string("Atomics_store(") + HeapName + ',' + Index + ',' + VS + ')';
+      }
+    } else {
+      text = getPtrUse(P) + " = " + VS;
+    }
     if (Alignment == 536870912) text += "; abort() /* segfault */";
   } else {
     // unaligned in some manner
+
+    if (EnablePthreads && cast<StoreInst>(I)->isVolatile()) {
+      errs() << "emcc: warning: unable to implement unaligned volatile store as atomic in " << I->getParent()->getParent()->getName() << ":" << *I << " | ";
+      emitDebugInfo(errs(), I);
+      errs() << "\n";
+    }
+
     if (WarnOnUnaligned) {
       errs() << "emcc: warning: unaligned store in " << I->getParent()->getParent()->getName() << ":" << *I << " | ";
       emitDebugInfo(errs(), I);
@@ -1055,45 +1198,20 @@ std::string JSWriter::getPtrLoad(const Value* Ptr) {
 }
 
 std::string JSWriter::getHeapAccess(const std::string& Name, unsigned Bytes, bool Integer) {
-  switch (Bytes) {
-  default: llvm_unreachable("Unsupported type");
-  case 8: return "HEAPF64[" + Name + ">>3]";
-  case 4: {
-    if (Integer) {
-      return "HEAP32[" + Name + ">>2]";
-    } else {
-      return "HEAPF32[" + Name + ">>2]";
-    }
-  }
-  case 2: return "HEAP16[" + Name + ">>1]";
-  case 1: return "HEAP8[" + Name + ">>0]";
-  }
+  const char *HeapName = 0;
+  std::string Index = getHeapNameAndIndexToPtr(Name, Bytes, Integer, &HeapName);
+  return std::string(HeapName) + '[' + Index + ']';
+}
+
+std::string JSWriter::getShiftedPtr(const Value *Ptr, unsigned Bytes) {
+  const char *HeapName = 0; // unused
+  return getHeapNameAndIndex(Ptr, &HeapName, Bytes);
 }
 
 std::string JSWriter::getPtrUse(const Value* Ptr) {
-  Type *t = cast<PointerType>(Ptr->getType())->getElementType();
-  unsigned Bytes = DL->getTypeAllocSize(t);
-  if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Ptr)) {
-    unsigned Addr = getGlobalAddress(GV->getName().str());
-    if (Relocatable) {
-      return getHeapAccess(relocateGlobal(utostr(Addr)), Bytes, t->isIntegerTy() || t->isPointerTy());
-    }
-    switch (Bytes) {
-    default: llvm_unreachable("Unsupported type");
-    case 8: return "HEAPF64[" + utostr(Addr >> 3) + "]";
-    case 4: {
-      if (t->isIntegerTy() || t->isPointerTy()) {
-        return "HEAP32[" + utostr(Addr >> 2) + "]";
-      } else {
-        assert(t->isFloatingPointTy());
-        return "HEAPF32[" + utostr(Addr >> 2) + "]";
-      }
-    }
-    case 2: return "HEAP16[" + utostr(Addr >> 1) + "]";
-    case 1: return "HEAP8[" + utostr(Addr) + "]";
-    }
-  }
-  return getHeapAccess(getValueAsStr(Ptr), Bytes, t->isIntegerTy() || t->isPointerTy());
+  const char *HeapName = 0;
+  std::string Index = getHeapNameAndIndex(Ptr, &HeapName);
+  return std::string(HeapName) + '[' + Index + ']';
 }
 
 std::string JSWriter::getConstant(const Constant* CV, AsmCast sign) {
@@ -1871,7 +1989,7 @@ void JSWriter::generateExpression(const User *I, raw_string_ostream& Code) {
   if (!generateSIMDExpression(I, Code)) switch (Operator::getOpcode(I)) {
   default: {
     I->dump();
-    error("Invalid instruction");
+    error("Invalid instruction in JSWriter::generateExpression");
     break;
   }
   case Instruction::Ret: {
@@ -2270,26 +2388,67 @@ void JSWriter::generateExpression(const User *I, raw_string_ostream& Code) {
     const Value *P = rmwi->getOperand(0);
     const Value *V = rmwi->getOperand(1);
     std::string VS = getValueAsStr(V);
-    Code << getLoad(rmwi, P, I->getType(), 0) << ';';
-    // Most bitcasts are no-ops for us. However, the exception is int to float and float to int
-    switch (rmwi->getOperation()) {
-      case AtomicRMWInst::Xchg: Code << getStore(rmwi, P, I->getType(), VS, 0); break;
-      case AtomicRMWInst::Add:  Code << getStore(rmwi, P, I->getType(), "((" + getJSName(I) + '+' + VS + ")|0)", 0); break;
-      case AtomicRMWInst::Sub:  Code << getStore(rmwi, P, I->getType(), "((" + getJSName(I) + '-' + VS + ")|0)", 0); break;
-      case AtomicRMWInst::And:  Code << getStore(rmwi, P, I->getType(), "(" + getJSName(I) + '&' + VS + ")", 0); break;
-      case AtomicRMWInst::Nand: Code << getStore(rmwi, P, I->getType(), "(~(" + getJSName(I) + '&' + VS + "))", 0); break;
-      case AtomicRMWInst::Or:   Code << getStore(rmwi, P, I->getType(), "(" + getJSName(I) + '|' + VS + ")", 0); break;
-      case AtomicRMWInst::Xor:  Code << getStore(rmwi, P, I->getType(), "(" + getJSName(I) + '^' + VS + ")", 0); break;
-      case AtomicRMWInst::Max:
-      case AtomicRMWInst::Min:
-      case AtomicRMWInst::UMax:
-      case AtomicRMWInst::UMin:
-      case AtomicRMWInst::BAD_BINOP: llvm_unreachable("Bad atomic operation");
+
+    if (EnablePthreads) {
+      std::string Assign = getAssign(rmwi);
+      unsigned Bytes = DL->getTypeAllocSize(T);
+      std::string text;
+      const char *HeapName;
+      std::string Index = getHeapNameAndIndex(P, &HeapName);
+      const char *atomicFunc = 0;
+      switch (rmwi->getOperation()) {
+        case AtomicRMWInst::Xchg: atomicFunc = "exchange"; break;
+        case AtomicRMWInst::Add:  atomicFunc = "add"; break;
+        case AtomicRMWInst::Sub:  atomicFunc = "sub"; break;
+        case AtomicRMWInst::And:  atomicFunc = "and"; break;
+        case AtomicRMWInst::Or:   atomicFunc = "or"; break;
+        case AtomicRMWInst::Xor:  atomicFunc = "xor"; break;
+        case AtomicRMWInst::Nand: // TODO
+        case AtomicRMWInst::Max:
+        case AtomicRMWInst::Min:
+        case AtomicRMWInst::UMax:
+        case AtomicRMWInst::UMin:
+        case AtomicRMWInst::BAD_BINOP: llvm_unreachable("Bad atomic operation");
+      }
+      if (!strcmp(HeapName, "HEAPF32") || !strcmp(HeapName, "HEAPF64")) {
+        // TODO: If https://bugzilla.mozilla.org/show_bug.cgi?id=1131613 and https://bugzilla.mozilla.org/show_bug.cgi?id=1131624 are
+        // implemented, we could remove the emulation, but until then we must emulate manually.
+        bool fround = PreciseF32 && !strcmp(HeapName, "HEAPF32");
+        Code << Assign << (fround ? "Math_fround(" : "+") << "_emscripten_atomic_" << atomicFunc << "_" << heapNameToAtomicTypeName(HeapName) << "(" << getValueAsStr(P) << ", " << VS << (fround ? "))" : ")"); break;
+
+      // TODO: Remove the following two lines once https://bugzilla.mozilla.org/show_bug.cgi?id=1141986 is implemented!
+      } else if (rmwi->getOperation() == AtomicRMWInst::Xchg && !strcmp(HeapName, "HEAP32")) {
+        Code << Assign << "_emscripten_atomic_exchange_u32(" << getValueAsStr(P) << ", " << VS << ")|0"; break;
+
+      } else {
+        Code << Assign << "Atomics_" << atomicFunc << "(" << HeapName << ", " << Index << ", " << VS << ")"; break;
+      }
+    } else {
+      Code << getLoad(rmwi, P, I->getType(), 0) << ';';
+      // Most bitcasts are no-ops for us. However, the exception is int to float and float to int
+      switch (rmwi->getOperation()) {
+        case AtomicRMWInst::Xchg: Code << getStore(rmwi, P, I->getType(), VS, 0); break;
+        case AtomicRMWInst::Add:  Code << getStore(rmwi, P, I->getType(), "((" + getJSName(I) + '+' + VS + ")|0)", 0); break;
+        case AtomicRMWInst::Sub:  Code << getStore(rmwi, P, I->getType(), "((" + getJSName(I) + '-' + VS + ")|0)", 0); break;
+        case AtomicRMWInst::And:  Code << getStore(rmwi, P, I->getType(), "(" + getJSName(I) + '&' + VS + ")", 0); break;
+        case AtomicRMWInst::Nand: Code << getStore(rmwi, P, I->getType(), "(~(" + getJSName(I) + '&' + VS + "))", 0); break;
+        case AtomicRMWInst::Or:   Code << getStore(rmwi, P, I->getType(), "(" + getJSName(I) + '|' + VS + ")", 0); break;
+        case AtomicRMWInst::Xor:  Code << getStore(rmwi, P, I->getType(), "(" + getJSName(I) + '^' + VS + ")", 0); break;
+        case AtomicRMWInst::Max:
+        case AtomicRMWInst::Min:
+        case AtomicRMWInst::UMax:
+        case AtomicRMWInst::UMin:
+        case AtomicRMWInst::BAD_BINOP: llvm_unreachable("Bad atomic operation");
+      }
     }
     break;
   }
-  case Instruction::Fence: // no threads, so nothing to do here
-    Code << "/* fence */";
+  case Instruction::Fence:
+    if (EnablePthreads) {
+      Code << "Atomics_fence()";
+    } else {
+      Code << "/* fence */"; // no threads, so nothing to do here
+    }
     break;
   }
 
@@ -2649,8 +2808,11 @@ void JSWriter::printModuleBody() {
 
   assert(GlobalData32.size() == 0 && GlobalData8.size() == 0); // FIXME when we use optimal constant alignments
 
-  // TODO fix commas
+  if (EnablePthreads) {
+    Out << "if (!ENVIRONMENT_IS_PTHREAD) {\n";
+  }
   Out << "/* memory initializer */ allocate([";
+  // TODO fix commas
   printCommaSeparated(GlobalData64);
   if (GlobalData64.size() > 0 && GlobalData32.size() + GlobalData8.size() > 0) {
     Out << ",";
@@ -2660,7 +2822,10 @@ void JSWriter::printModuleBody() {
     Out << ",";
   }
   printCommaSeparated(GlobalData8);
-  Out << "], \"i8\", ALLOC_NONE, Runtime.GLOBAL_BASE);";
+  Out << "], \"i8\", ALLOC_NONE, Runtime.GLOBAL_BASE);\n";
+  if (EnablePthreads) {
+    Out << "}\n";
+  }
 
   // Emit metadata for emcc driver
   Out << "\n\n// EMSCRIPTEN_METADATA\n";
diff --git a/lib/Transforms/NaCl/ExpandI64.cpp b/lib/Transforms/NaCl/ExpandI64.cpp
index a6050800fb3..a5dd202eebb 100644
--- a/lib/Transforms/NaCl/ExpandI64.cpp
+++ b/lib/Transforms/NaCl/ExpandI64.cpp
@@ -104,6 +104,8 @@ namespace {
 
     Function *Add, *Sub, *Mul, *SDiv, *UDiv, *SRem, *URem, *LShr, *AShr, *Shl, *GetHigh, *SetHigh, *FtoILow, *FtoIHigh, *DtoILow, *DtoIHigh, *SItoF, *UItoF, *SItoD, *UItoD, *BItoD, *BDtoILow, *BDtoIHigh;
 
+    Function *AtomicAdd, *AtomicSub, *AtomicAnd, *AtomicOr, *AtomicXor;
+
     void ensureFuncs();
     unsigned getNumChunks(Type *T);
 
@@ -112,7 +114,7 @@ namespace {
     ExpandI64() : ModulePass(ID) {
       initializeExpandI64Pass(*PassRegistry::getPassRegistry());
 
-      Add = Sub = Mul = SDiv = UDiv = SRem = URem = LShr = AShr = Shl = GetHigh = SetHigh = NULL;
+      Add = Sub = Mul = SDiv = UDiv = SRem = URem = LShr = AShr = Shl = GetHigh = SetHigh = AtomicAdd = AtomicSub = AtomicAnd = AtomicOr = AtomicXor = NULL;
     }
 
     virtual bool runOnModule(Module &M);
@@ -929,6 +931,42 @@ bool ExpandI64::splitInst(Instruction *I) {
       }
       break;
     }
+    case Instruction::AtomicRMW: {
+      const AtomicRMWInst *rmwi = cast<AtomicRMWInst>(I);
+      ChunksVec Chunks32Bit = getChunks(I->getOperand(1));
+      unsigned Num = getNumChunks(I->getType());
+      assert(Num == 2 && "Only know how to handle 32-bit and 64-bit AtomicRMW instructions!");
+      ensureFuncs();
+      Value *Low = NULL, *High = NULL;
+      Function *F = NULL;
+      switch (rmwi->getOperation()) {
+        case AtomicRMWInst::Add: F = AtomicAdd; break;
+        case AtomicRMWInst::Sub: F = AtomicSub; break;
+        case AtomicRMWInst::And: F = AtomicAnd; break;
+        case AtomicRMWInst::Or: F = AtomicOr; break;
+        case AtomicRMWInst::Xor: F = AtomicXor; break;
+        case AtomicRMWInst::Xchg:
+        case AtomicRMWInst::Nand:
+        case AtomicRMWInst::Max:
+        case AtomicRMWInst::Min:
+        case AtomicRMWInst::UMax:
+        case AtomicRMWInst::UMin:
+        default: llvm_unreachable("Bad atomic operation");
+      }
+      SmallVector<Value *, 3> Args;
+      Args.push_back(new BitCastInst(I->getOperand(0), Type::getInt8PtrTy(TheModule->getContext()), "", I));
+      Args.push_back(Chunks32Bit[0]);
+      Args.push_back(Chunks32Bit[1]);
+      Low = CopyDebug(CallInst::Create(F, Args, "", I), I);
+      High = CopyDebug(CallInst::Create(GetHigh, "", I), I);
+      Chunks.push_back(Low);
+      Chunks.push_back(High);
+      break;
+    }
+    case Instruction::AtomicCmpXchg: {
+      assert(0 && "64-bit compare-and-exchange (__sync_bool_compare_and_swap & __sync_val_compare_and_swap) are not supported! Please directly call emscripten_atomic_cas_u64() instead in order to emulate!");
+      break;
+    }
     default: {
       I->dump();
       assert(0 && "some i64 thing we can't legalize yet");
@@ -979,6 +1017,12 @@ void ExpandI64::ensureFuncs() {
 
   Type *i32 = Type::getInt32Ty(TheModule->getContext());
 
+  AtomicAdd = TheModule->getFunction("_emscripten_atomic_fetch_and_add_u64");
+  AtomicSub = TheModule->getFunction("_emscripten_atomic_fetch_and_sub_u64");
+  AtomicAnd = TheModule->getFunction("_emscripten_atomic_fetch_and_and_u64");
+  AtomicOr = TheModule->getFunction("_emscripten_atomic_fetch_and_or_u64");
+  AtomicXor = TheModule->getFunction("_emscripten_atomic_fetch_and_xor_u64");
+
   SmallVector<Type*, 4> FourArgTypes;
   FourArgTypes.push_back(i32);
   FourArgTypes.push_back(i32);