merge mozilla-inbound to mozilla-central a=merge
authorCarsten "Tomcat" Book <cbook@mozilla.com>
Tue, 16 Dec 2014 13:34:05 +0100
changeset 219913 365c02fb0c5fe829a1ddfc50d3dd3080a90d792f
parent 219854 a3030140d5df8385b6c0dee0faa54c13a3dd1368 (current diff)
parent 219912 b2649ad7d86e7278268fb33b05911e4864850bf3 (diff)
child 219914 249dbdbe09e0ed9d6abe081289a76beb55e4b847
push id10419
push usercbook@mozilla.com
push dateTue, 16 Dec 2014 12:45:27 +0000
treeherderfx-team@ec87657146eb [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone37.0a1
merge mozilla-inbound to mozilla-central a=merge
netwerk/test/httpserver/jar.mn
--- a/b2g/components/B2GAboutRedirector.js
+++ b/b2g/components/B2GAboutRedirector.js
@@ -47,23 +47,25 @@ B2GAboutRedirector.prototype = {
     let flags;
     let moduleInfo = this._getModuleInfo(aURI);
     if (moduleInfo.hide)
       flags = Ci.nsIAboutModule.HIDE_FROM_ABOUTABOUT;
 
     return flags | Ci.nsIAboutModule.ALLOW_SCRIPT;
   },
 
-  newChannel: function(aURI) {
+  newChannel: function(aURI, aLoadInfo) {
     let moduleInfo = this._getModuleInfo(aURI);
 
     var ios = Cc["@mozilla.org/network/io-service;1"].
               getService(Ci.nsIIOService);
 
-    var channel = ios.newChannel(moduleInfo.uri, null, null);
+    var newURI = ios.newURI(moduleInfo.uri, null, null);
+
+    var channel = ios.newChannelFromURIWithLoadInfo(newURI, aLoadInfo);
 
     if (!moduleInfo.privileged) {
       // Setting the owner to null means that we'll go through the normal
       // path in GetChannelPrincipal and create a codebase principal based
       // on the channel's originalURI
       channel.owner = null;
     }
 
--- a/build/clang-plugin/tests/TestNonHeapClass.cpp
+++ b/build/clang-plugin/tests/TestNonHeapClass.cpp
@@ -1,15 +1,15 @@
 #define MOZ_NONHEAP_CLASS __attribute__((annotate("moz_nonheap_class")))
 #define MOZ_STACK_CLASS __attribute__((annotate("moz_stack_class")))
 #include <stddef.h>
 
 struct MOZ_NONHEAP_CLASS NonHeap {
   int i;
-  void *operator new(size_t x) { return 0; }
+  void *operator new(size_t x) throw() { return 0; }
   void *operator new(size_t blah, char *buffer) { return buffer; }
 };
 
 template <class T>
 struct MOZ_NONHEAP_CLASS TemplateClass {
   T i;
 };
 
--- a/build/clang-plugin/tests/TestStackClass.cpp
+++ b/build/clang-plugin/tests/TestStackClass.cpp
@@ -1,14 +1,14 @@
 #define MOZ_STACK_CLASS __attribute__((annotate("moz_stack_class")))
 #include <stddef.h>
 
 struct MOZ_STACK_CLASS Stack {
   int i;
-  void *operator new(size_t x) { return 0; }
+  void *operator new(size_t x) throw() { return 0; }
   void *operator new(size_t blah, char *buffer) { return buffer; }
 };
 
 template <class T>
 struct MOZ_STACK_CLASS TemplateClass {
   T i;
 };
 
--- a/dom/bindings/BindingUtils.h
+++ b/dom/bindings/BindingUtils.h
@@ -20,16 +20,17 @@
 #include "mozilla/dom/Exceptions.h"
 #include "mozilla/dom/NonRefcountedDOMObject.h"
 #include "mozilla/dom/Nullable.h"
 #include "mozilla/dom/RootedDictionary.h"
 #include "mozilla/dom/workers/Workers.h"
 #include "mozilla/ErrorResult.h"
 #include "mozilla/Likely.h"
 #include "mozilla/MemoryReporting.h"
+#include "mozilla/CycleCollectedJSRuntime.h"
 #include "nsCycleCollector.h"
 #include "nsIXPConnect.h"
 #include "nsJSUtils.h"
 #include "nsISupportsImpl.h"
 #include "qsObjectHelper.h"
 #include "xpcpublic.h"
 #include "nsIVariant.h"
 #include "pldhash.h" // For PLDHashOperator
@@ -3074,16 +3075,38 @@ WrappedJSToDictionary(JSContext* aCx, ns
     return false;
   }
 
   JSAutoCompartment ac(aCx, obj);
   JS::Rooted<JS::Value> v(aCx, JS::ObjectValue(*obj));
   return aDictionary.Init(aCx, v);
 }
 
+template<class T>
+inline bool
+WrappedJSToDictionary(nsISupports* aObject, T& aDictionary)
+{
+  nsCOMPtr<nsIXPConnectWrappedJS> wrappedObj = do_QueryInterface(aObject);
+  NS_ENSURE_TRUE(wrappedObj, false);
+  JS::Rooted<JSObject*> obj(CycleCollectedJSRuntime::Get()->Runtime(),
+                            wrappedObj->GetJSObject());
+  NS_ENSURE_TRUE(obj, false);
+
+  nsIGlobalObject* global = xpc::NativeGlobal(obj);
+  NS_ENSURE_TRUE(global, false);
+
+  // we need this AutoEntryScript here because the spec requires us to execute
+  // getters when parsing a dictionary
+  AutoEntryScript aes(global);
+  aes.TakeOwnershipOfErrorReporting();
+
+  JS::Rooted<JS::Value> v(aes.cx(), JS::ObjectValue(*obj));
+  return aDictionary.Init(aes.cx(), v);
+}
+
 
 template<class T, class S>
 inline nsRefPtr<T>
 StrongOrRawPtr(already_AddRefed<S>&& aPtr)
 {
   return aPtr.template downcast<T>();
 }
 
--- a/dom/html/HTMLMediaElement.cpp
+++ b/dom/html/HTMLMediaElement.cpp
@@ -2022,17 +2022,18 @@ HTMLMediaElement::HTMLMediaElement(alrea
     mMediaSecurityVerified(false),
     mCORSMode(CORS_NONE),
     mHasAudio(false),
     mHasVideo(false),
     mDownloadSuspendedByCache(false),
     mAudioChannelFaded(false),
     mPlayingThroughTheAudioChannel(false),
     mDisableVideo(false),
-    mWaitingFor(MediaWaitingFor::None)
+    mWaitingFor(MediaWaitingFor::None),
+    mElementInTreeState(ELEMENT_NOT_INTREE)
 {
 #ifdef PR_LOGGING
   if (!gMediaElementLog) {
     gMediaElementLog = PR_NewLogModule("nsMediaElement");
   }
   if (!gMediaElementEventsLog) {
     gMediaElementEventsLog = PR_NewLogModule("nsMediaElementEvents");
   }
@@ -2474,31 +2475,38 @@ nsresult HTMLMediaElement::BindToTree(ns
     mAutoplayEnabled =
       IsAutoplayEnabled() && (!aDocument || !aDocument->IsStaticDocument()) &&
       !IsEditable();
     // The preload action depends on the value of the autoplay attribute.
     // It's value may have changed, so update it.
     UpdatePreloadAction();
   }
   if (mDecoder) {
-    mDecoder->SetDormantIfNecessary(false);
-  }
+    // When the MediaElement is binding to tree, the dormant status is
+    // aligned to document's hidden status.
+    nsIDocument* ownerDoc = OwnerDoc();
+    if (ownerDoc) {
+      mDecoder->SetDormantIfNecessary(ownerDoc->Hidden());
+    }
+  }
+  mElementInTreeState = ELEMENT_INTREE;
 
   return rv;
 }
 
 void HTMLMediaElement::UnbindFromTree(bool aDeep,
                                       bool aNullParent)
 {
   if (!mPaused && mNetworkState != nsIDOMHTMLMediaElement::NETWORK_EMPTY)
     Pause();
 
   if (mDecoder) {
     mDecoder->SetDormantIfNecessary(true);
   }
+  mElementInTreeState = ELEMENT_NOT_INTREE_HAD_INTREE;
 
   nsGenericHTMLElement::UnbindFromTree(aDeep, aNullParent);
 }
 
 /* static */
 CanPlayStatus
 HTMLMediaElement::GetCanPlay(const nsAString& aType)
 {
@@ -3556,17 +3564,25 @@ void HTMLMediaElement::SuspendOrResumeEl
 }
 
 void HTMLMediaElement::NotifyOwnerDocumentActivityChanged()
 {
   nsIDocument* ownerDoc = OwnerDoc();
 
   if (mDecoder) {
     mDecoder->SetElementVisibility(!ownerDoc->Hidden());
-    mDecoder->SetDormantIfNecessary(ownerDoc->Hidden());
+
+    if (mElementInTreeState == ELEMENT_NOT_INTREE_HAD_INTREE) {
+      mDecoder->SetDormantIfNecessary(true);
+    } else if (mElementInTreeState == ELEMENT_NOT_INTREE ||
+               mElementInTreeState == ELEMENT_INTREE) {
+      // The MediaElement had never been binded to tree, or in the tree now,
+      // align to document.
+      mDecoder->SetDormantIfNecessary(ownerDoc->Hidden());
+    }
   }
 
   // SetVisibilityState will update mMuted with MUTED_BY_AUDIO_CHANNEL via the
   // CanPlayChanged callback.
   if (UseAudioChannelService() && mPlayingThroughTheAudioChannel &&
       mAudioChannelAgent) {
     AutoNoJSAPI nojsapi;
     mAudioChannelAgent->SetVisibilityState(!ownerDoc->Hidden());
--- a/dom/html/HTMLMediaElement.h
+++ b/dom/html/HTMLMediaElement.h
@@ -1292,14 +1292,27 @@ protected:
 
   nsRefPtr<TextTrackManager> mTextTrackManager;
 
   nsRefPtr<AudioTrackList> mAudioTrackList;
 
   nsRefPtr<VideoTrackList> mVideoTrackList;
 
   MediaWaitingFor mWaitingFor;
+
+  enum ElementInTreeState {
+    // The MediaElement is not in the DOM tree now.
+    ELEMENT_NOT_INTREE,
+    // The MediaElement is in the DOM tree now.
+    ELEMENT_INTREE,
+    // The MediaElement is not in the DOM tree now but had been binded to the
+    // tree before.
+    ELEMENT_NOT_INTREE_HAD_INTREE
+  };
+
+  ElementInTreeState mElementInTreeState;
+
 };
 
 } // namespace dom
 } // namespace mozilla
 
 #endif // mozilla_dom_HTMLMediaElement_h
--- a/dom/media/MediaResource.h
+++ b/dom/media/MediaResource.h
@@ -160,16 +160,18 @@ public:
   {
     if (IsNull()) {
       return aByteRange;
     }
     return MediaByteRange(std::min(mStart, aByteRange.mStart),
                           std::max(mEnd, aByteRange.mEnd));
   }
 
+  int64_t Length() { return mEnd - mStart; }
+
   int64_t mStart, mEnd;
 };
 
 // Represents a section of contiguous media, with a start and end offset, and
 // a timestamp representing the start time.
 class TimestampedMediaByteRange : public MediaByteRange {
 public:
   TimestampedMediaByteRange() : MediaByteRange(), mStartTime(-1) {}
--- a/dom/media/fmp4/MP4Reader.cpp
+++ b/dom/media/fmp4/MP4Reader.cpp
@@ -1,15 +1,16 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:set ts=2 sw=2 sts=2 et cindent: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "MP4Reader.h"
+#include "MP4Stream.h"
 #include "MediaResource.h"
 #include "nsSize.h"
 #include "VideoUtils.h"
 #include "mozilla/dom/HTMLMediaElement.h"
 #include "ImageContainer.h"
 #include "Layers.h"
 #include "SharedThreadPool.h"
 #include "mozilla/Preferences.h"
@@ -57,73 +58,16 @@ TrackTypeToStr(TrackType aTrack)
   case kVideo:
     return "Video";
   default:
     return "Unknown";
   }
 }
 #endif
 
-class MP4Stream : public Stream {
-public:
-
-  explicit MP4Stream(MediaResource* aResource)
-    : mResource(aResource)
-  {
-    MOZ_COUNT_CTOR(MP4Stream);
-    MOZ_ASSERT(aResource);
-  }
-  virtual ~MP4Stream() {
-    MOZ_COUNT_DTOR(MP4Stream);
-  }
-
-  virtual bool ReadAt(int64_t aOffset, void* aBuffer, size_t aCount,
-                      size_t* aBytesRead) MOZ_OVERRIDE
-  {
-    uint32_t sum = 0;
-    uint32_t bytesRead = 0;
-    do {
-      uint64_t offset = aOffset + sum;
-      char* buffer = reinterpret_cast<char*>(aBuffer) + sum;
-      uint32_t toRead = aCount - sum;
-      nsresult rv = mResource->ReadAt(offset, buffer, toRead, &bytesRead);
-      if (NS_FAILED(rv)) {
-        return false;
-      }
-      sum += bytesRead;
-    } while (sum < aCount && bytesRead > 0);
-    *aBytesRead = sum;
-    return true;
-  }
-
-  virtual bool CachedReadAt(int64_t aOffset, void* aBuffer, size_t aCount,
-                            size_t* aBytesRead) MOZ_OVERRIDE
-  {
-    nsresult rv = mResource->ReadFromCache(reinterpret_cast<char*>(aBuffer),
-                                           aOffset, aCount);
-    if (NS_FAILED(rv)) {
-      *aBytesRead = 0;
-      return false;
-    }
-    *aBytesRead = aCount;
-    return true;
-  }
-
-  virtual bool Length(int64_t* aSize) MOZ_OVERRIDE
-  {
-    if (mResource->GetLength() < 0)
-      return false;
-    *aSize = mResource->GetLength();
-    return true;
-  }
-
-private:
-  RefPtr<MediaResource> mResource;
-};
-
 MP4Reader::MP4Reader(AbstractMediaDecoder* aDecoder)
   : MediaDecoderReader(aDecoder)
   , mAudio(MediaData::AUDIO_DATA, Preferences::GetUint("media.mp4-audio-decode-ahead", 2))
   , mVideo(MediaData::VIDEO_DATA, Preferences::GetUint("media.mp4-video-decode-ahead", 2))
   , mLastReportedNumDecodedFrames(0)
   , mLayersBackendType(layers::LayersBackend::LAYERS_NONE)
   , mDemuxerInitialized(false)
   , mIsEncrypted(false)
@@ -683,17 +627,19 @@ MP4Reader::PopSample(TrackType aTrack)
   }
 }
 
 nsresult
 MP4Reader::ResetDecode()
 {
   MOZ_ASSERT(GetTaskQueue()->IsCurrentThreadIn());
   Flush(kVideo);
+  mDemuxer->SeekVideo(0);
   Flush(kAudio);
+  mDemuxer->SeekAudio(0);
   return MediaDecoderReader::ResetDecode();
 }
 
 void
 MP4Reader::Output(TrackType aTrack, MediaData* aSample)
 {
 #ifdef LOG_SAMPLE_DECODE
   VLOG("Decoded %s sample time=%lld dur=%lld",
new file mode 100644
--- /dev/null
+++ b/dom/media/fmp4/MP4Stream.cpp
@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "MP4Stream.h"
+#include "MediaResource.h"
+
+namespace mozilla {
+
+MP4Stream::MP4Stream(MediaResource* aResource) : mResource(aResource)
+{
+  MOZ_COUNT_CTOR(MP4Stream);
+  MOZ_ASSERT(aResource);
+}
+
+MP4Stream::~MP4Stream()
+{
+  MOZ_COUNT_DTOR(MP4Stream);
+}
+
+bool
+MP4Stream::ReadAt(int64_t aOffset, void* aBuffer, size_t aCount,
+                  size_t* aBytesRead)
+{
+  uint32_t sum = 0;
+  uint32_t bytesRead = 0;
+  do {
+    uint64_t offset = aOffset + sum;
+    char* buffer = reinterpret_cast<char*>(aBuffer) + sum;
+    uint32_t toRead = aCount - sum;
+    nsresult rv = mResource->ReadAt(offset, buffer, toRead, &bytesRead);
+    if (NS_FAILED(rv)) {
+      return false;
+    }
+    sum += bytesRead;
+  } while (sum < aCount && bytesRead > 0);
+  *aBytesRead = sum;
+  return true;
+}
+
+bool
+MP4Stream::CachedReadAt(int64_t aOffset, void* aBuffer, size_t aCount,
+                        size_t* aBytesRead)
+{
+  nsresult rv = mResource->ReadFromCache(reinterpret_cast<char*>(aBuffer),
+                                         aOffset, aCount);
+  if (NS_FAILED(rv)) {
+    *aBytesRead = 0;
+    return false;
+  }
+  *aBytesRead = aCount;
+  return true;
+}
+
+bool
+MP4Stream::Length(int64_t* aSize)
+{
+  if (mResource->GetLength() < 0)
+    return false;
+  *aSize = mResource->GetLength();
+  return true;
+}
+}
new file mode 100644
--- /dev/null
+++ b/dom/media/fmp4/MP4Stream.h
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MP4_STREAM_H_
+#define MP4_STREAM_H_
+
+#include "mp4_demuxer/mp4_demuxer.h"
+
+namespace mozilla {
+
+class MediaResource;
+
+class MP4Stream : public mp4_demuxer::Stream {
+public:
+  explicit MP4Stream(MediaResource* aResource);
+  virtual ~MP4Stream();
+  virtual bool ReadAt(int64_t aOffset, void* aBuffer, size_t aCount,
+                      size_t* aBytesRead) MOZ_OVERRIDE;
+  virtual bool CachedReadAt(int64_t aOffset, void* aBuffer, size_t aCount,
+                            size_t* aBytesRead) MOZ_OVERRIDE;
+  virtual bool Length(int64_t* aSize) MOZ_OVERRIDE;
+
+private:
+  nsRefPtr<MediaResource> mResource;
+};
+
+}
+
+#endif
--- a/dom/media/fmp4/moz.build
+++ b/dom/media/fmp4/moz.build
@@ -2,23 +2,25 @@
 # vim: set filetype=python:
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 EXPORTS += [
     'MP4Decoder.h',
     'MP4Reader.h',
+    'MP4Stream.h',
     'PlatformDecoderModule.h',
     'SharedDecoderManager.h',
 ]
 
 UNIFIED_SOURCES += [
     'BlankDecoderModule.cpp',
     'MP4Decoder.cpp',
+    'MP4Stream.cpp',
     'PlatformDecoderModule.cpp',
     'SharedDecoderManager.cpp',
 ]
 
 SOURCES += [
     'MP4Reader.cpp',
 ]
 
--- a/dom/media/gmp/GMPDecryptorParent.cpp
+++ b/dom/media/gmp/GMPDecryptorParent.cpp
@@ -11,18 +11,21 @@
 namespace mozilla {
 namespace gmp {
 
 GMPDecryptorParent::GMPDecryptorParent(GMPParent* aPlugin)
   : mIsOpen(false)
   , mShuttingDown(false)
   , mPlugin(aPlugin)
   , mCallback(nullptr)
+#ifdef DEBUG
+  , mGMPThread(aPlugin->GMPThread())
+#endif
 {
-  MOZ_ASSERT(mPlugin);
+  MOZ_ASSERT(mPlugin && mGMPThread);
 }
 
 GMPDecryptorParent::~GMPDecryptorParent()
 {
 }
 
 nsresult
 GMPDecryptorParent::Init(GMPDecryptorProxyCallback* aCallback)
@@ -307,32 +310,32 @@ GMPDecryptorParent::RecvDecrypted(const 
   mCallback->Decrypted(aId, aErr, aBuffer);
   return true;
 }
 
 // Note: may be called via Terminated()
 void
 GMPDecryptorParent::Close()
 {
-  MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
+  MOZ_ASSERT(mGMPThread == NS_GetCurrentThread());
   // Consumer is done with us; we can shut down.  No more callbacks should
   // be made to mCallback. Note: do this before Shutdown()!
   mCallback = nullptr;
   // Let Shutdown mark us as dead so it knows if we had been alive
 
   // In case this is the last reference
   nsRefPtr<GMPDecryptorParent> kungfudeathgrip(this);
-  NS_RELEASE(kungfudeathgrip);
+  this->Release();
   Shutdown();
 }
 
 void
 GMPDecryptorParent::Shutdown()
 {
-  MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
+  MOZ_ASSERT(mGMPThread == NS_GetCurrentThread());
 
   if (mShuttingDown) {
     return;
   }
   mShuttingDown = true;
 
   // Notify client we're gone!  Won't occur after Close()
   if (mCallback) {
--- a/dom/media/gmp/GMPDecryptorParent.h
+++ b/dom/media/gmp/GMPDecryptorParent.h
@@ -104,14 +104,17 @@ private:
 
   virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
   virtual bool Recv__delete__() MOZ_OVERRIDE;
 
   bool mIsOpen;
   bool mShuttingDown;
   nsRefPtr<GMPParent> mPlugin;
   GMPDecryptorProxyCallback* mCallback;
+#ifdef DEBUG
+  nsIThread* const mGMPThread;
+#endif
 };
 
 } // namespace gmp
 } // namespace mozilla
 
 #endif // GMPDecryptorChild_h_
new file mode 100644
--- /dev/null
+++ b/dom/media/gtest/TestMP4Demuxer.cpp
@@ -0,0 +1,328 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "gtest/gtest.h"
+#include "mp4_demuxer/mp4_demuxer.h"
+#include "MP4Stream.h"
+#include "mozilla/ArrayUtils.h"
+#include "MockMediaResource.h"
+
+using namespace mozilla;
+using namespace mp4_demuxer;
+
+class MP4DemuxerBinding
+{
+public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MP4DemuxerBinding);
+
+  nsRefPtr<MockMediaResource> resource;
+  nsAutoPtr<MP4Demuxer> demuxer;
+
+  explicit MP4DemuxerBinding(const char* aFileName = "dash_dashinit.mp4")
+    : resource(new MockMediaResource(aFileName))
+    , demuxer(new MP4Demuxer(new MP4Stream(resource)))
+  {
+    EXPECT_EQ(NS_OK, resource->Open(nullptr));
+  }
+
+private:
+  virtual ~MP4DemuxerBinding()
+  {
+  }
+};
+
+TEST(MP4Demuxer, Seek)
+{
+  nsRefPtr<MP4DemuxerBinding> b = new MP4DemuxerBinding();
+  MP4Demuxer* d = b->demuxer;
+
+  EXPECT_TRUE(d->Init());
+
+  nsTArray<nsAutoPtr<MP4Sample>> samples;
+  MP4Sample* sample;
+  while (!!(sample = d->DemuxVideoSample())) {
+    samples.AppendElement(sample);
+    if (samples.Length() >= 2) {
+      EXPECT_LT(samples[samples.Length() - 2]->decode_timestamp,
+                samples[samples.Length() - 1]->decode_timestamp);
+    }
+  }
+  Microseconds keyFrame = 0;
+  for (size_t i = 0; i < samples.Length(); i++) {
+    if (samples[i]->is_sync_point) {
+      keyFrame = samples[i]->decode_timestamp;
+    }
+    d->SeekVideo(samples[i]->composition_timestamp);
+    sample = d->DemuxVideoSample();
+    EXPECT_EQ(keyFrame, sample->decode_timestamp);
+  }
+}
+
+static nsCString
+ToCryptoString(CryptoSample& aCrypto)
+{
+  nsCString res;
+  if (aCrypto.valid) {
+    res.AppendPrintf("%d %d ", aCrypto.mode, aCrypto.iv_size);
+    for (size_t i = 0; i < aCrypto.key.Length(); i++) {
+      res.AppendPrintf("%02x", aCrypto.key[i]);
+    }
+    res.Append(" ");
+    for (size_t i = 0; i < aCrypto.iv.Length(); i++) {
+      res.AppendPrintf("%02x", aCrypto.iv[i]);
+    }
+    EXPECT_EQ(aCrypto.plain_sizes.Length(), aCrypto.encrypted_sizes.Length());
+    for (size_t i = 0; i < aCrypto.plain_sizes.Length(); i++) {
+      res.AppendPrintf(" %d,%d", aCrypto.plain_sizes[i],
+                       aCrypto.encrypted_sizes[i]);
+    }
+  } else {
+    res.Append("no crypto");
+  }
+  return res;
+}
+
+TEST(MP4Demuxer, CENC)
+{
+  nsRefPtr<MP4DemuxerBinding> b = new MP4DemuxerBinding("short-cenc.mp4");
+  MP4Demuxer* d = b->demuxer;
+
+  EXPECT_TRUE(d->Init());
+
+  const char* video[] = {
+    "1 16 7e571d017e571d017e571d017e571d01 00000000000000000000000000000000 5,686 5,388",
+    "1 16 7e571d017e571d017e571d017e571d01 00000000000000000000000000000044 5,717",
+    "1 16 7e571d017e571d017e571d017e571d01 00000000000000000000000000000071 5,613",
+    "1 16 7e571d017e571d017e571d017e571d01 00000000000000000000000000000098 5,196",
+    "1 16 7e571d017e571d017e571d017e571d01 000000000000000000000000000000a5 5,213",
+    "1 16 7e571d017e571d017e571d017e571d01 000000000000000000000000000000b3 5,213",
+    "1 16 7e571d017e571d017e571d017e571d01 000000000000000000000000000000c1 5,384",
+    "1 16 7e571d017e571d017e571d017e571d01 000000000000000000000000000000d9 5,256",
+    "1 16 7e571d017e571d017e571d017e571d01 000000000000000000000000000000e9 5,245",
+    "1 16 7e571d017e571d017e571d017e571d01 000000000000000000000000000000f9 5,251",
+  };
+
+  MP4Sample* sample;
+  size_t i = 0;
+  while (!!(sample = d->DemuxVideoSample())) {
+    nsCString text = ToCryptoString(sample->crypto);
+    EXPECT_STREQ(video[i++], text.get());
+  }
+  EXPECT_EQ(ArrayLength(video), i);
+
+  const char* audio[] = {
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000000 0,371",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000018 0,372",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000030 0,371",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000048 0,372",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000060 0,371",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000078 0,372",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000090 0,371",
+    "1 16 7e571d027e571d027e571d027e571d02 000000000000000000000000000000a8 0,372",
+    "1 16 7e571d027e571d027e571d027e571d02 000000000000000000000000000000c0 0,371",
+    "1 16 7e571d027e571d027e571d027e571d02 000000000000000000000000000000d8 0,372",
+    "1 16 7e571d027e571d027e571d027e571d02 000000000000000000000000000000f0 0,371",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000108 0,372",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000120 0,371",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000138 0,372",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000150 0,371",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000168 0,372",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000180 0,371",
+    "1 16 7e571d027e571d027e571d027e571d02 00000000000000000000000000000198 0,372",
+    "1 16 7e571d027e571d027e571d027e571d02 000000000000000000000000000001b0 0,371",
+    "1 16 7e571d027e571d027e571d027e571d02 000000000000000000000000000001c8 0,372",
+    "1 16 7e571d027e571d027e571d027e571d02 000000000000000000000000000001e0 0,371",
+  };
+
+  i = 0;
+  while (!!(sample = d->DemuxAudioSample())) {
+    nsCString text = ToCryptoString(sample->crypto);
+    EXPECT_STREQ(audio[i++], text.get());
+  }
+  EXPECT_EQ(ArrayLength(audio), i);
+}
+
+TEST(MP4Demuxer, CENCFrag)
+{
+  nsRefPtr<MP4DemuxerBinding> b = new MP4DemuxerBinding("gizmo-frag.mp4");
+  MP4Demuxer* d = b->demuxer;
+
+  EXPECT_TRUE(d->Init());
+
+  const char* video[] = {
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000000 5,684 5,16980",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000450 5,1826",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000004c3 5,1215",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000050f 5,1302",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000561 5,939",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000059c 5,763",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000005cc 5,672",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000005f6 5,748",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000625 5,1025",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000666 5,730",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000694 5,897",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000006cd 5,643",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000006f6 5,556",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000719 5,527",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000073a 5,606",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000760 5,701",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000078c 5,531",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000007ae 5,562",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000007d2 5,576",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000007f6 5,514",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000817 5,404",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000831 5,635",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000859 5,433",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000875 5,478",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000893 5,474",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000008b1 5,462",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000008ce 5,473",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000008ec 5,437",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000908 5,418",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000923 5,475",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000941 5,23133",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000ee7 5,475",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f05 5,402",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f1f 5,415",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f39 5,408",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f53 5,442",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f6f 5,385",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f88 5,368",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000f9f 5,354",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000fb6 5,400",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000fcf 5,399",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000fe8 5,1098",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000102d 5,1508",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000108c 5,1345",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000010e1 5,1945",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000115b 5,1824",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000011cd 5,2133",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000001253 5,2486",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000012ef 5,1739",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000135c 5,1836",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000013cf 5,2367",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000001463 5,2571",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000001504 5,3008",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000015c0 5,3255",
+    "1 16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000168c 5,3225",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000001756 5,3118",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000001819 5,2407",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000018b0 5,2400",
+    "1 16 7e571d037e571d037e571d037e571d03 00000000000000000000000000001946 5,2158",
+    "1 16 7e571d037e571d037e571d037e571d03 000000000000000000000000000019cd 5,2392",
+  };
+
+  MP4Sample* sample;
+  size_t i = 0;
+  while (!!(sample = d->DemuxVideoSample())) {
+    nsCString text = ToCryptoString(sample->crypto);
+    EXPECT_STREQ(video[i++], text.get());
+  }
+  EXPECT_EQ(ArrayLength(video), i);
+
+  const char* audio[] = {
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000000 0,281",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000012 0,257",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000023 0,246",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000033 0,257",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000044 0,260",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000055 0,260",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000066 0,272",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000077 0,280",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000089 0,284",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000009b 0,290",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000000ae 0,278",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000000c0 0,268",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000000d1 0,307",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000000e5 0,290",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000000f8 0,304",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000010b 0,316",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000011f 0,308",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000133 0,301",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000146 0,318",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000015a 0,311",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000016e 0,303",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000181 0,325",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000196 0,334",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000001ab 0,344",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000001c1 0,344",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000001d7 0,387",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000001f0 0,396",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000209 0,368",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000220 0,373",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000238 0,425",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000253 0,428",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000026e 0,426",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000289 0,427",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000002a4 0,424",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000002bf 0,447",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000002db 0,446",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000002f7 0,442",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000313 0,444",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000032f 0,374",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000347 0,405",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000361 0,372",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000379 0,395",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000392 0,435",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000003ae 0,426",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000003c9 0,430",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000003e4 0,390",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000003fd 0,335",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000412 0,339",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000428 0,352",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000043e 0,364",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000455 0,398",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000046e 0,451",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000048b 0,448",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000004a7 0,436",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000004c3 0,424",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000004de 0,428",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000004f9 0,413",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000513 0,430",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000052e 0,450",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000054b 0,386",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000564 0,320",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000578 0,347",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000058e 0,382",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000005a6 0,437",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000005c2 0,387",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000005db 0,340",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000005f1 0,337",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000607 0,389",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000620 0,428",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000063b 0,426",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000656 0,446",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000672 0,456",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000068f 0,468",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000006ad 0,468",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000006cb 0,463",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000006e8 0,467",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000706 0,460",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000723 0,446",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000073f 0,453",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000075c 0,448",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000778 0,446",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000794 0,439",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000007b0 0,436",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000007cc 0,441",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000007e8 0,465",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000806 0,448",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000822 0,448",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000083e 0,469",
+    "1 16 7e571d047e571d047e571d047e571d04 0000000000000000000000000000085c 0,431",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000877 0,437",
+    "1 16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000893 0,474",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000008b1 0,436",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000008cd 0,433",
+    "1 16 7e571d047e571d047e571d047e571d04 000000000000000000000000000008e9 0,481",
+  };
+
+  i = 0;
+  while (!!(sample = d->DemuxAudioSample())) {
+    nsCString text = ToCryptoString(sample->crypto);
+    EXPECT_STREQ(audio[i++], text.get());
+  }
+  EXPECT_EQ(ArrayLength(audio), i);
+}
new file mode 100644
index 0000000000000000000000000000000000000000..d19068f36de613d822c3cebaeffd3ef5601f183e
GIT binary patch
literal 80388
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
afuH2OV;W7#&iNgtb6s`Rhwm;>`2PU00sLG5
--- a/dom/media/gtest/moz.build
+++ b/dom/media/gtest/moz.build
@@ -1,33 +1,37 @@
 # -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-UNIFIED_SOURCES += [
+SOURCES += [
     'MockMediaResource.cpp',
     'TestAudioCompactor.cpp',
     'TestGMPCrossOrigin.cpp',
+    'TestMP4Demuxer.cpp',
     'TestMP4Reader.cpp',
     'TestTrackEncoder.cpp',
     'TestVideoSegment.cpp',
     'TestWebMBuffered.cpp',
 ]
 
 if CONFIG['MOZ_WEBM_ENCODER']:
-    UNIFIED_SOURCES += [
+    SOURCES += [
         'TestVideoTrackEncoder.cpp',
         'TestVorbisTrackEncoder.cpp',
         'TestWebMWriter.cpp',
     ]
 
 TEST_HARNESS_FILES.gtest += [
+    '../test/gizmo-frag.mp4',
     '../test/gizmo.mp4',
+    '../test/short-cenc.mp4',
+    'dash_dashinit.mp4',
     'mediasource_test.mp4',
     'test.webm',
 ]
 
 include('/ipc/chromium/chromium-config.mozbuild')
 
 LOCAL_INCLUDES += [
     '/dom/media',
new file mode 100644
index 0000000000000000000000000000000000000000..f6980663c221f47b4bb849dd9b761aa6c81f5483
GIT binary patch
literal 152132
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
--- a/dom/plugins/ipc/PluginModuleParent.cpp
+++ b/dom/plugins/ipc/PluginModuleParent.cpp
@@ -1399,24 +1399,16 @@ PluginModuleParent::NP_Initialize(NPNets
             return NS_ERROR_FAILURE;
         }
         else if (*error != NPERR_NO_ERROR) {
             Close();
             return NS_OK;
         }
         TimeStamp callNpInitEnd = TimeStamp::Now();
         mTimeBlocked += (callNpInitEnd - callNpInitStart);
-        /** mTimeBlocked measures the time that the main thread has been blocked
-         *  on plugin module initialization. As implemented, this is the sum of
-         *  plugin-container launch + NP_Initialize
-         */
-        Telemetry::Accumulate(Telemetry::BLOCKED_ON_PLUGIN_MODULE_INIT_MS,
-                              GetHistogramKey(),
-                              static_cast<uint32_t>(mTimeBlocked.ToMilliseconds()));
-        mTimeBlocked = TimeDuration();
     }
 
     SetPluginFuncs(pFuncs);
 
     return NS_OK;
 }
 #else
 nsresult
@@ -1467,27 +1459,16 @@ PluginModuleChromeParent::NP_Initialize(
                                                           iconPath)))
         unused << SendSetAudioSessionData(id, sessionName, iconPath);
 #endif
 
 #ifdef MOZ_CRASHREPORTER_INJECTOR
     InitializeInjector();
 #endif
 
-    /** This Accumulate must be placed below the call to InitializeInjector()
-     *  because mTimeBlocked is modified in that function.
-     *  mTimeBlocked measures the time that the main thread has been blocked
-     *  on plugin module initialization. As implemented, this is the sum of
-     *  plugin-container launch + toolhelp32 snapshot + NP_Initialize
-     */
-    Telemetry::Accumulate(Telemetry::BLOCKED_ON_PLUGIN_MODULE_INIT_MS,
-                          GetHistogramKey(),
-                          static_cast<uint32_t>(mTimeBlocked.ToMilliseconds()));
-    mTimeBlocked = TimeDuration();
-
     return NS_OK;
 }
 #endif
 
 nsresult
 PluginModuleParent::NP_Shutdown(NPError* error)
 {
     PLUGIN_LOG_DEBUG_METHOD;
@@ -1569,16 +1550,26 @@ PluginModuleParent::NPP_New(NPMIMEType p
 
     if (mShutdown) {
         *error = NPERR_GENERIC_ERROR;
         return NS_ERROR_FAILURE;
     }
 
     if (mPluginName.IsEmpty()) {
         GetPluginDetails(mPluginName, mPluginVersion);
+        /** mTimeBlocked measures the time that the main thread has been blocked
+         *  on plugin module initialization. As implemented, this is the sum of
+         *  plugin-container launch + toolhelp32 snapshot + NP_Initialize.
+         *  We don't accumulate its value until here because the plugin info
+         *  is not available until *after* NP_Initialize.
+         */
+        Telemetry::Accumulate(Telemetry::BLOCKED_ON_PLUGIN_MODULE_INIT_MS,
+                              GetHistogramKey(),
+                              static_cast<uint32_t>(mTimeBlocked.ToMilliseconds()));
+        mTimeBlocked = TimeDuration();
     }
 
     // create the instance on the other side
     InfallibleTArray<nsCString> names;
     InfallibleTArray<nsCString> values;
 
     for (int i = 0; i < argc; ++i) {
         names.AppendElement(NullableString(argn[i]));
--- a/gfx/layers/composite/TextureHost.h
+++ b/gfx/layers/composite/TextureHost.h
@@ -170,23 +170,45 @@ protected:
  * equivalent of a RefPtr<TextureSource>, that calls AddCompositableRef and
  * ReleaseCompositableRef in addition to the usual AddRef and Release.
  */
 template<typename T>
 class CompositableTextureRef {
 public:
   CompositableTextureRef() {}
 
+  explicit CompositableTextureRef(const CompositableTextureRef& aOther)
+  {
+    *this = aOther;
+  }
+
+  explicit CompositableTextureRef(T* aOther)
+  {
+    *this = aOther;
+  }
+
   ~CompositableTextureRef()
   {
     if (mRef) {
       mRef->ReleaseCompositableRef();
     }
   }
 
+  CompositableTextureRef& operator=(const CompositableTextureRef& aOther)
+  {
+    if (aOther.get()) {
+      aOther->AddCompositableRef();
+    }
+    if (mRef) {
+      mRef->ReleaseCompositableRef();
+    }
+    mRef = aOther.get();
+    return *this;
+  }
+
   CompositableTextureRef& operator=(const TemporaryRef<T>& aOther)
   {
     RefPtr<T> temp = aOther;
     if (temp) {
       temp->AddCompositableRef();
     }
     if (mRef) {
       mRef->ReleaseCompositableRef();
--- a/gfx/layers/composite/TiledContentHost.cpp
+++ b/gfx/layers/composite/TiledContentHost.cpp
@@ -36,17 +36,18 @@ TiledLayerBufferComposite::TiledLayerBuf
 /* static */ void
 TiledLayerBufferComposite::RecycleCallback(TextureHost* textureHost, void* aClosure)
 {
   textureHost->CompositorRecycle();
 }
 
 TiledLayerBufferComposite::TiledLayerBufferComposite(ISurfaceAllocator* aAllocator,
                                                      const SurfaceDescriptorTiles& aDescriptor,
-                                                     const nsIntRegion& aOldPaintedRegion)
+                                                     const nsIntRegion& aOldPaintedRegion,
+                                                     Compositor* aCompositor)
 {
   mIsValid = true;
   mHasDoubleBufferedTiles = false;
   mValidRegion = aDescriptor.validRegion();
   mPaintedRegion = aDescriptor.paintedRegion();
   mRetainedWidth = aDescriptor.retainedWidth();
   mRetainedHeight = aDescriptor.retainedHeight();
   mResolution = aDescriptor.resolution();
@@ -56,18 +57,18 @@ TiledLayerBufferComposite::TiledLayerBuf
   nsIntRegion oldPaintedRegion(aOldPaintedRegion);
   oldPaintedRegion.And(oldPaintedRegion, mValidRegion);
   mPaintedRegion.Or(mPaintedRegion, oldPaintedRegion);
 
   bool isSameProcess = aAllocator->IsSameProcess();
 
   const InfallibleTArray<TileDescriptor>& tiles = aDescriptor.tiles();
   for(size_t i = 0; i < tiles.Length(); i++) {
-    RefPtr<TextureHost> texture;
-    RefPtr<TextureHost> textureOnWhite;
+    CompositableTextureHostRef texture;
+    CompositableTextureHostRef textureOnWhite;
     const TileDescriptor& tileDesc = tiles[i];
     switch (tileDesc.type()) {
       case TileDescriptor::TTexturedTileDescriptor : {
         texture = TextureHost::AsTextureHost(tileDesc.get_TexturedTileDescriptor().textureParent());
         MaybeTexture onWhite = tileDesc.get_TexturedTileDescriptor().textureOnWhite();
         if (onWhite.type() == MaybeTexture::TPTextureParent) {
           textureOnWhite = TextureHost::AsTextureHost(onWhite.get_PTextureParent());
         }
@@ -89,17 +90,31 @@ TiledLayerBufferComposite::TiledLayerBuf
           }
           sharedLock = reinterpret_cast<gfxMemorySharedReadLock*>(ipcLock.get_uintptr_t());
           if (sharedLock) {
             // The corresponding AddRef is in TiledClient::GetTileDescriptor
             sharedLock->Release();
           }
         }
 
-        mRetainedTiles.AppendElement(TileHost(sharedLock, texture, textureOnWhite));
+        CompositableTextureSourceRef textureSource;
+        CompositableTextureSourceRef textureSourceOnWhite;
+        if (texture) {
+          texture->SetCompositor(aCompositor);
+          texture->PrepareTextureSource(textureSource);
+        }
+        if (textureOnWhite) {
+          textureOnWhite->SetCompositor(aCompositor);
+          textureOnWhite->PrepareTextureSource(textureSourceOnWhite);
+        }
+        mRetainedTiles.AppendElement(TileHost(sharedLock,
+                                              texture.get(),
+                                              textureOnWhite.get(),
+                                              textureSource.get(),
+                                              textureSourceOnWhite.get()));
         break;
       }
       default:
         NS_WARNING("Unrecognised tile descriptor type");
         // Fall through
       case TileDescriptor::TPlaceholderTileDescriptor :
         mRetainedTiles.AppendElement(GetPlaceholderTile());
         break;
@@ -125,16 +140,18 @@ void
 TiledLayerBufferComposite::ReleaseTextureHosts()
 {
   if (!IsValid()) {
     return;
   }
   for (size_t i = 0; i < mRetainedTiles.Length(); i++) {
     mRetainedTiles[i].mTextureHost = nullptr;
     mRetainedTiles[i].mTextureHostOnWhite = nullptr;
+    mRetainedTiles[i].mTextureSource = nullptr;
+    mRetainedTiles[i].mTextureSourceOnWhite = nullptr;
   }
 }
 
 void
 TiledLayerBufferComposite::Upload()
 {
   if(!IsValid()) {
     return;
@@ -316,18 +333,20 @@ TiledContentHost::UseTiledLayerBuffer(IS
       // situation that the client starts rendering new content before we get
       // to composite the new buffer.
       if (mLowPrecisionTiledBuffer.HasDoubleBufferedTiles()) {
         mOldLowPrecisionTiledBuffer = mLowPrecisionTiledBuffer;
         mOldLowPrecisionTiledBuffer.ReleaseTextureHosts();
       }
     }
     mLowPrecisionTiledBuffer =
-      TiledLayerBufferComposite(aAllocator, aTiledDescriptor,
-                                mLowPrecisionTiledBuffer.GetPaintedRegion());
+      TiledLayerBufferComposite(aAllocator,
+                                aTiledDescriptor,
+                                mLowPrecisionTiledBuffer.GetPaintedRegion(),
+                                mCompositor);
     if (!mLowPrecisionTiledBuffer.IsValid()) {
       // Something bad happened. Stop here, return false (kills the child process),
       // and do as little work as possible on the received data as it appears
       // to be corrupted.
       mPendingLowPrecisionUpload = false;
       mPendingUpload = false;
       return false;
     }
@@ -336,18 +355,20 @@ TiledContentHost::UseTiledLayerBuffer(IS
       mTiledBuffer.ReadUnlock();
     } else {
       mPendingUpload = true;
       if (mTiledBuffer.HasDoubleBufferedTiles()) {
         mOldTiledBuffer = mTiledBuffer;
         mOldTiledBuffer.ReleaseTextureHosts();
       }
     }
-    mTiledBuffer = TiledLayerBufferComposite(aAllocator, aTiledDescriptor,
-                                             mTiledBuffer.GetPaintedRegion());
+    mTiledBuffer = TiledLayerBufferComposite(aAllocator,
+                                             aTiledDescriptor,
+                                             mTiledBuffer.GetPaintedRegion(),
+                                             mCompositor);
     if (!mTiledBuffer.IsValid()) {
       // Something bad happened. Stop here, return false (kills the child process),
       // and do as little work as possible on the received data as it appears
       // to be corrupted.
       mPendingLowPrecisionUpload = false;
       mPendingUpload = false;
       return false;
     }
@@ -472,24 +493,26 @@ TiledContentHost::RenderTile(const TileH
 
   AutoLockTextureHost autoLock(aTile.mTextureHost);
   AutoLockTextureHost autoLockOnWhite(aTile.mTextureHostOnWhite);
   if (autoLock.Failed() ||
       autoLockOnWhite.Failed()) {
     NS_WARNING("Failed to lock tile");
     return;
   }
-  RefPtr<TextureSource> source = aTile.mTextureHost->GetTextureSources();
-  RefPtr<TextureSource> sourceOnWhite =
-    aTile.mTextureHostOnWhite ? aTile.mTextureHostOnWhite->GetTextureSources() : nullptr;
-  if (!source || (aTile.mTextureHostOnWhite && !sourceOnWhite)) {
+
+  if (!aTile.mTextureHost->BindTextureSource(aTile.mTextureSource)) {
     return;
   }
 
-  RefPtr<TexturedEffect> effect = CreateTexturedEffect(source, sourceOnWhite, aFilter, true);
+  if (aTile.mTextureHostOnWhite && !aTile.mTextureHostOnWhite->BindTextureSource(aTile.mTextureSourceOnWhite)) {
+    return;
+  }
+
+  RefPtr<TexturedEffect> effect = CreateTexturedEffect(aTile.mTextureSource, aTile.mTextureSourceOnWhite, aFilter, true);
   if (!effect) {
     return;
   }
 
   aEffectChain.mPrimaryEffect = effect;
 
   nsIntRegionRectIterator it(aScreenRegion);
   for (const nsIntRect* rect = it.Next(); rect != nullptr; rect = it.Next()) {
--- a/gfx/layers/composite/TiledContentHost.h
+++ b/gfx/layers/composite/TiledContentHost.h
@@ -57,33 +57,41 @@ public:
   // essentially, this is a sentinel used to represent an invalid or blank
   // tile.
   TileHost()
   {}
 
   // Constructs a TileHost from a gfxSharedReadLock and TextureHost.
   TileHost(gfxSharedReadLock* aSharedLock,
                TextureHost* aTextureHost,
-               TextureHost* aTextureHostOnWhite)
+               TextureHost* aTextureHostOnWhite,
+               TextureSource* aSource,
+               TextureSource* aSourceOnWhite)
     : mSharedLock(aSharedLock)
     , mTextureHost(aTextureHost)
     , mTextureHostOnWhite(aTextureHostOnWhite)
+    , mTextureSource(aSource)
+    , mTextureSourceOnWhite(aSourceOnWhite)
   {}
 
   TileHost(const TileHost& o) {
     mTextureHost = o.mTextureHost;
     mTextureHostOnWhite = o.mTextureHostOnWhite;
+    mTextureSource = o.mTextureSource;
+    mTextureSourceOnWhite = o.mTextureSourceOnWhite;
     mSharedLock = o.mSharedLock;
   }
   TileHost& operator=(const TileHost& o) {
     if (this == &o) {
       return *this;
     }
     mTextureHost = o.mTextureHost;
     mTextureHostOnWhite = o.mTextureHostOnWhite;
+    mTextureSource = o.mTextureSource;
+    mTextureSourceOnWhite = o.mTextureSourceOnWhite;
     mSharedLock = o.mSharedLock;
     return *this;
   }
 
   bool operator== (const TileHost& o) const {
     return mTextureHost == o.mTextureHost;
   }
   bool operator!= (const TileHost& o) const {
@@ -94,32 +102,35 @@ public:
 
   void ReadUnlock() {
     if (mSharedLock) {
       mSharedLock->ReadUnlock();
     }
   }
 
   RefPtr<gfxSharedReadLock> mSharedLock;
-  RefPtr<TextureHost> mTextureHost;
-  RefPtr<TextureHost> mTextureHostOnWhite;
+  CompositableTextureHostRef mTextureHost;
+  CompositableTextureHostRef mTextureHostOnWhite;
+  mutable CompositableTextureSourceRef mTextureSource;
+  mutable CompositableTextureSourceRef mTextureSourceOnWhite;
 };
 
 class TiledLayerBufferComposite
   : public TiledLayerBuffer<TiledLayerBufferComposite, TileHost>
 {
   friend class TiledLayerBuffer<TiledLayerBufferComposite, TileHost>;
 
 public:
   typedef TiledLayerBuffer<TiledLayerBufferComposite, TileHost>::Iterator Iterator;
 
   TiledLayerBufferComposite();
   TiledLayerBufferComposite(ISurfaceAllocator* aAllocator,
                             const SurfaceDescriptorTiles& aDescriptor,
-                            const nsIntRegion& aOldPaintedRegion);
+                            const nsIntRegion& aOldPaintedRegion,
+                            Compositor* aCompositor);
 
   TileHost GetPlaceholderTile() const { return TileHost(); }
 
   // Stores the absolute resolution of the containing frame, calculated
   // by the sum of the resolutions of all parent layers' FrameMetrics.
   const CSSToParentLayerScale& GetFrameResolution() { return mFrameResolution; }
 
   void ReadUnlock();
--- a/image/src/VectorImage.cpp
+++ b/image/src/VectorImage.cpp
@@ -245,19 +245,19 @@ public:
                      const IntSize& aSize,
                      uint32_t aImageFlags)
     : mSVGDocumentWrapper(aSVGDocumentWrapper)
     , mViewport(aViewport)
     , mSize(aSize)
     , mImageFlags(aImageFlags)
   {}
   virtual bool operator()(gfxContext* aContext,
-                            const gfxRect& aFillRect,
-                            const GraphicsFilter& aFilter,
-                            const gfxMatrix& aTransform);
+                          const gfxRect& aFillRect,
+                          const GraphicsFilter& aFilter,
+                          const gfxMatrix& aTransform);
 private:
   nsRefPtr<SVGDocumentWrapper> mSVGDocumentWrapper;
   const nsIntRect              mViewport;
   const IntSize                mSize;
   uint32_t                     mImageFlags;
 };
 
 // Based loosely on nsSVGIntegrationUtils' PaintFrameCallback::operator()
@@ -751,23 +751,21 @@ struct SVGDrawingParameters
   nsIntSize                     viewportSize;
   float                         animationTime;
   uint32_t                      flags;
   gfxFloat                      opacity;
 };
 
 //******************************************************************************
 /* [noscript] void draw(in gfxContext aContext,
+ *                      [const] in nsIntSize aSize,
+ *                      [const] in ImageRegion aRegion,
+ *                      in uint32_t aWhichFrame,
  *                      in gfxGraphicsFilter aFilter,
- *                      [const] in gfxMatrix aUserSpaceToImageSpace,
- *                      [const] in gfxRect aFill,
- *                      [const] in nsIntRect aSubimage,
- *                      [const] in nsIntSize aViewportSize,
- *                      [const] in SVGImageContext aSVGContext,
- *                      in uint32_t aWhichFrame,
+ *                      [const] in MaybeSVGImageContext aSVGContext,
  *                      in uint32_t aFlags); */
 NS_IMETHODIMP
 VectorImage::Draw(gfxContext* aContext,
                   const nsIntSize& aSize,
                   const ImageRegion& aRegion,
                   uint32_t aWhichFrame,
                   GraphicsFilter aFilter,
                   const Maybe<SVGImageContext>& aSVGContext,
--- a/js/src/dtoa.c
+++ b/js/src/dtoa.c
@@ -3241,8 +3241,9 @@ dtoa
 #endif
 	Bfree(PASS_STATE b);
 	*s = 0;
 	*decpt = k + 1;
 	if (rve)
 		*rve = s;
 	return s0;
 	}
+#undef CONST
--- a/js/src/frontend/Parser.cpp
+++ b/js/src/frontend/Parser.cpp
@@ -1645,17 +1645,17 @@ Parser<ParseHandler>::functionArguments(
                  * local variables initialized from properties of a single
                  * anonymous positional parameter, so here we must tweak our
                  * binder and its data.
                  */
                 BindData<ParseHandler> data(context);
                 data.pn = ParseHandler::null();
                 data.op = JSOP_DEFVAR;
                 data.binder = bindDestructuringArg;
-                Node lhs = destructuringExpr(&data, tt);
+                Node lhs = destructuringExprWithoutYield(&data, tt, JSMSG_YIELD_IN_DEFAULT);
                 if (!lhs)
                     return false;
 
                 /*
                  * Synthesize a destructuring assignment from the single
                  * anonymous positional parameter into the destructuring
                  * left-hand-side expression and accumulate it in list.
                  */
@@ -3500,16 +3500,31 @@ Parser<ParseHandler>::destructuringExpr(
         return null();
     if (!checkDestructuring(data, pn))
         return null();
     return pn;
 }
 
 template <typename ParseHandler>
 typename ParseHandler::Node
+Parser<ParseHandler>::destructuringExprWithoutYield(BindData<ParseHandler> *data, TokenKind tt,
+                                                    unsigned msg)
+{
+    uint32_t startYieldOffset = pc->lastYieldOffset;
+    Node res = destructuringExpr(data, tt);
+    if (res && pc->lastYieldOffset != startYieldOffset) {
+        reportWithOffset(ParseError, false, pc->lastYieldOffset,
+                         msg, js_yield_str);
+        return null();
+    }
+    return res;
+}
+
+template <typename ParseHandler>
+typename ParseHandler::Node
 Parser<ParseHandler>::pushLexicalScope(HandleStaticBlockObject blockObj, StmtInfoPC *stmt)
 {
     MOZ_ASSERT(blockObj);
 
     ObjectBox *blockbox = newObjectBox(blockObj);
     if (!blockbox)
         return null();
 
--- a/js/src/frontend/Parser.h
+++ b/js/src/frontend/Parser.h
@@ -608,16 +608,17 @@ class Parser : private JS::AutoGCRooter,
     Node comprehensionFor(GeneratorKind comprehensionKind);
     Node comprehension(GeneratorKind comprehensionKind);
     Node arrayComprehension(uint32_t begin);
     Node generatorComprehension(uint32_t begin);
 
     bool argumentList(Node listNode, bool *isSpread);
     Node letBlock(LetContext letContext);
     Node destructuringExpr(BindData<ParseHandler> *data, TokenKind tt);
+    Node destructuringExprWithoutYield(BindData<ParseHandler> *data, TokenKind tt, unsigned msg);
 
     Node identifierName();
 
     bool matchLabel(MutableHandle<PropertyName*> label);
 
     bool allowsForEachIn() {
 #if !JS_HAS_FOR_EACH_IN
         return false;
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/debug/Frame-eval-25.js
@@ -0,0 +1,17 @@
+// |jit-test| error: TypeError
+//
+// Make sure we can recover missing arguments even when it gets assigned to
+// another slot.
+
+load(libdir + "evalInFrame.js");
+
+function h() {
+  evalInFrame(1, "a.push(0)");
+}
+
+function f() {
+  var a = arguments;
+  h();
+}
+
+f();
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/debug/bug1108556.js
@@ -0,0 +1,10 @@
+// |jit-test| error: ReferenceError
+
+var g = newGlobal();
+g.parent = this;
+g.eval("new Debugger(parent).onExceptionUnwind = function () { hits++; };");
+evaluate('\
+var fe="v";\
+for (i=0; String.fromCharCode(0x004E); i++)\
+  fe += fe;\
+', { compileAndGo : true });
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/debug/bug1109328.js
@@ -0,0 +1,7 @@
+try {
+    gcslice(0)(""());
+} catch (e) {}
+g = newGlobal()
+g.parent = this
+g.eval("Debugger(parent).onExceptionUnwind=(function(){})");
+gcparam("maxBytes", gcparam("gcBytes"));
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/debug/bug1109915.js
@@ -0,0 +1,17 @@
+var evalInFrame = (function (global) {
+  var dbgGlobal = newGlobal();
+  var dbg = new dbgGlobal.Debugger();
+  return function evalInFrame(upCount, code) {
+    dbg.addDebuggee(global);
+    var frame = dbg.getNewestFrame().older;
+    var completion = frame.eval(code);
+  };
+})(this);
+function g1(x, args) {}
+function f1(x, y, o) {
+    for (var i=0; i<50; i++) {
+        o.apply(evalInFrame(0, "x"), x);
+    }
+}
+var o1 = {apply: g1};
+assertEq(f1(3, 5, o1), undefined);
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/debug/bug1111199.js
@@ -0,0 +1,17 @@
+g = newGlobal()
+g.parent = this
+g.eval("Debugger(parent).onExceptionUnwind=(function(){})")
+try {
+function f(code) {
+    n = parseInt('', 0);
+    return g("try{}catch(e){}", n)
+}
+function g(s, n) {
+    s2 = s + s
+    d = (n - (function  ()  {
+            return "" + this.id + eval.id;
+        } )().abstract) / 2
+    m = g(s2, d)
+}
+f("switch(''){default:break;}")
+} catch(exc1) {}
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/parser/yield-in-formal-destructuring.js
@@ -0,0 +1,2 @@
+// |jit-test| error: SyntaxError
+function d([{ [yield]: {} } ]) f
--- a/js/src/jit/BaselineBailouts.cpp
+++ b/js/src/jit/BaselineBailouts.cpp
@@ -1023,38 +1023,39 @@ InitFromBailout(JSContext *cx, HandleScr
         } else {
             // If needed, initialize BaselineBailoutInfo's valueR0 and/or valueR1 with the
             // top stack values.
             //
             // Note that we use the 'maybe' variant of nativeCodeForPC because
             // of exception propagation for debug mode. See note below.
             PCMappingSlotInfo slotInfo;
             uint8_t *nativeCodeForPC = baselineScript->maybeNativeCodeForPC(script, pc, &slotInfo);
-            unsigned numUnsynced;
+            unsigned numUnsynced = slotInfo.numUnsynced();
 
-            if (excInfo && excInfo->propagatingIonExceptionForDebugMode()) {
+            if (excInfo && excInfo->propagatingIonExceptionForDebugMode() && resumeAfter) {
                 // When propagating an exception for debug mode, set the
-                // return address as the return-from-IC for the throw, so that
-                // Debugger hooks report the correct pc offset of the throwing
-                // op instead of its successor.
+                // return address as the return-from-IC for the throwing op,
+                // so that Debugger hooks report the correct pc offset of the
+                // throwing op instead of its successor.
+                //
+                // This should not be done if we are at a resume-at point, as
+                // might be the case when propagating an exception thrown from
+                // an interrupt handler. That interrupt could have happened to
+                // interrupt at a loop head, which would have no ICEntry at
+                // that point.
                 //
                 // Note that we never resume into this address, it is set for
                 // the sake of frame iterators giving the correct answer.
                 ICEntry &icEntry = baselineScript->anyKindICEntryFromPCOffset(iter.pcOffset());
                 nativeCodeForPC = baselineScript->returnAddressForIC(icEntry);
-
-                // The pc after the throwing PC could be unreachable, in which
-                // case we have no native code for it and no slot info. But in
-                // that case, there are definitely no unsynced slots.
-                numUnsynced = nativeCodeForPC ? slotInfo.numUnsynced() : 0;
             } else {
                 MOZ_ASSERT(nativeCodeForPC);
-                numUnsynced = slotInfo.numUnsynced();
             }
 
+            MOZ_ASSERT(nativeCodeForPC);
             MOZ_ASSERT(numUnsynced <= 2);
             PCMappingSlotInfo::SlotLocation loc1, loc2;
             if (numUnsynced > 0) {
                 loc1 = slotInfo.topSlotLocation();
                 JitSpew(JitSpew_BaselineBailouts, "      Popping top stack value into %d.",
                         (int) loc1);
                 builder.popValueInto(loc1);
             }
--- a/js/src/jit/BaselineCompiler.cpp
+++ b/js/src/jit/BaselineCompiler.cpp
@@ -749,16 +749,18 @@ BaselineCompiler::emitDebugTrap()
 {
     MOZ_ASSERT(compileDebugInstrumentation_);
     MOZ_ASSERT(frame.numUnsyncedSlots() == 0);
 
     bool enabled = script->stepModeEnabled() || script->hasBreakpointsAt(pc);
 
     // Emit patchable call to debug trap handler.
     JitCode *handler = cx->runtime()->jitRuntime()->debugTrapHandler(cx);
+    if (!handler)
+        return false;
     mozilla::DebugOnly<CodeOffsetLabel> offset = masm.toggledCall(handler, enabled);
 
 #ifdef DEBUG
     // Patchable call offset has to match the pc mapping offset.
     PCMappingEntry &entry = pcMappingEntries_.back();
     MOZ_ASSERT((&offset)->offset() == entry.nativeOffset);
 #endif
 
--- a/js/src/jit/BaselineDebugModeOSR.cpp
+++ b/js/src/jit/BaselineDebugModeOSR.cpp
@@ -212,17 +212,17 @@ CollectJitStackScripts(JSContext *cx, co
                         return false;
                 } else {
                     // Otherwise, we are in the middle of handling an
                     // exception. This happens since we could have bailed out
                     // in place from Ion after a throw, settling on the pc
                     // *after* the bytecode that threw the exception, which
                     // may have no ICEntry.
                     MOZ_ASSERT(iter.baselineFrame()->isDebuggerHandlingException());
-                    jsbytecode *pc = script->baselineScript()->pcForReturnAddress(script, retAddr);
+                    jsbytecode *pc = script->baselineScript()->pcForNativeAddress(script, retAddr);
                     if (!entries.append(DebugModeOSREntry(script, script->pcToOffset(pc))))
                         return false;
                 }
             }
 
             if (entries.back().needsRecompileInfo()) {
                 if (!entries.back().allocateRecompileInfo(cx))
                     return false;
@@ -680,16 +680,17 @@ RecompileBaselineScriptForDebugMode(JSCo
     _(GetElem_NativePrototypeCallNative)        \
     _(GetElem_NativePrototypeCallScripted)      \
     _(GetProp_CallScripted)                     \
     _(GetProp_CallNative)                       \
     _(GetProp_CallNativePrototype)              \
     _(GetProp_CallDOMProxyNative)               \
     _(GetProp_CallDOMProxyWithGenerationNative) \
     _(GetProp_DOMProxyShadowed)                 \
+    _(GetProp_Generic)                          \
     _(SetProp_CallScripted)                     \
     _(SetProp_CallNative)
 
 #if JS_HAS_NO_SUCH_METHOD
 #define PATCHABLE_NSM_ICSTUB_KIND_LIST(_)       \
     _(GetElem_Dense)                            \
     _(GetElem_Arguments)                        \
     _(GetProp_NativePrototype)                  \
--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -7843,16 +7843,23 @@ ICGetProp_ArgumentsCallee::Compiler::gen
 
     EmitEnterTypeMonitorIC(masm);
 
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
 }
 
+/* static */ ICGetProp_Generic *
+ICGetProp_Generic::Clone(JSContext *cx, ICStubSpace *space, ICStub *firstMonitorStub,
+                         ICGetProp_Generic &other)
+{
+    return New(space, other.jitCode(), firstMonitorStub);
+}
+
 static bool
 DoGetPropGeneric(JSContext *cx, BaselineFrame *frame, ICGetProp_Generic *stub, MutableHandleValue val, MutableHandleValue res)
 {
     jsbytecode *pc = stub->getChainFallback()->icEntry()->pc(frame->script());
     JSOp op = JSOp(*pc);
     RootedPropertyName name(cx, frame->script()->getName(pc));
     return ComputeGetPropResult(cx, frame, op, name, val, res);
 }
--- a/js/src/jit/BaselineIC.h
+++ b/js/src/jit/BaselineIC.h
@@ -4191,16 +4191,19 @@ class ICGetProp_Generic : public ICMonit
   public:
     static inline ICGetProp_Generic *New(ICStubSpace *space, JitCode *code, ICStub *firstMonitorStub)
     {
         if(!code)
             return nullptr;
         return space->allocate<ICGetProp_Generic>(code, firstMonitorStub);
     }
 
+    static ICGetProp_Generic *Clone(JSContext *cx, ICStubSpace *space, ICStub *firstMonitorStub,
+                                    ICGetProp_Generic &other);
+
     class Compiler : public ICStubCompiler {
       protected:
         bool generateStubCode(MacroAssembler &masm);
         ICStub *firstMonitorStub_;
       public:
         explicit Compiler(JSContext *cx, ICStub *firstMonitorStub)
           : ICStubCompiler(cx, ICStub::GetProp_Generic),
             firstMonitorStub_(firstMonitorStub)
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -9761,21 +9761,19 @@ CodeGenerator::visitInterruptCheck(LInte
     AbsoluteAddress interruptAddr(GetJitContext()->runtime->addressOfInterruptUint32());
     masm.branch32(Assembler::NotEqual, interruptAddr, Imm32(0), ool->entry());
     masm.bind(ool->rejoin());
 }
 
 void
 CodeGenerator::visitAsmJSInterruptCheck(LAsmJSInterruptCheck *lir)
 {
-    Register scratch = ToRegister(lir->scratch());
-    masm.movePtr(AsmJSImmPtr(AsmJSImm_RuntimeInterruptUint32), scratch);
-    masm.load32(Address(scratch, 0), scratch);
     Label rejoin;
-    masm.branch32(Assembler::Equal, scratch, Imm32(0), &rejoin);
+    masm.branch32(Assembler::Equal, AsmJSAbsoluteAddress(AsmJSImm_RuntimeInterruptUint32),
+                  Imm32(0), &rejoin);
     {
         uint32_t stackFixup = ComputeByteAlignment(masm.framePushed() + sizeof(AsmJSFrame),
                                                    ABIStackAlignment);
         masm.reserveStack(stackFixup);
         masm.call(lir->funcDesc(), lir->interruptExit());
         masm.freeStack(stackFixup);
     }
     masm.bind(&rejoin);
--- a/js/src/jit/JitFrameIterator.h
+++ b/js/src/jit/JitFrameIterator.h
@@ -582,17 +582,17 @@ class InlineFrameIterator
     uint32_t numActualArgs_;
 
     struct Nop {
         void operator()(const Value &v) { }
     };
 
   private:
     void findNextFrame();
-    JSObject *computeScopeChain(Value scopeChainValue) const;
+    JSObject *computeScopeChain(Value scopeChainValue, bool *hasCallObj = nullptr) const;
 
   public:
     InlineFrameIterator(ThreadSafeContext *cx, const JitFrameIterator *iter);
     InlineFrameIterator(JSRuntime *rt, const JitFrameIterator *iter);
     InlineFrameIterator(ThreadSafeContext *cx, const InlineFrameIterator *iter);
 
     bool more() const {
         return frame_ && framesRead_ < frameCount_;
@@ -614,29 +614,29 @@ class InlineFrameIterator
         if (more())
             return numActualArgs_;
 
         return frame_->numActualArgs();
     }
 
     template <class ArgOp, class LocalOp>
     void readFrameArgsAndLocals(ThreadSafeContext *cx, ArgOp &argOp, LocalOp &localOp,
-                                JSObject **scopeChain, Value *rval,
+                                JSObject **scopeChain, bool *hasCallObj, Value *rval,
                                 ArgumentsObject **argsObj, Value *thisv,
                                 ReadFrameArgsBehavior behavior,
                                 MaybeReadFallback &fallback) const
     {
         SnapshotIterator s(si_);
 
         // Read frame slots common to both function and global frames.
         Value scopeChainValue;
         s.readCommonFrameSlots(&scopeChainValue, rval);
 
         if (scopeChain)
-            *scopeChain = computeScopeChain(scopeChainValue);
+            *scopeChain = computeScopeChain(scopeChainValue, hasCallObj);
 
         // Read arguments, which only function frames have.
         if (isFunctionFrame()) {
             unsigned nactual = numActualArgs();
             unsigned nformal = callee()->nargs();
 
             // Get the non overflown arguments, which are taken from the inlined
             // frame, because it will have the updated value when JSOP_SETARG is
@@ -695,17 +695,18 @@ class InlineFrameIterator
     }
 
     template <class Op>
     void unaliasedForEachActual(JSContext *cx, Op op,
                                 ReadFrameArgsBehavior behavior,
                                 MaybeReadFallback &fallback) const
     {
         Nop nop;
-        readFrameArgsAndLocals(cx, op, nop, nullptr, nullptr, nullptr, nullptr, behavior, fallback);
+        readFrameArgsAndLocals(cx, op, nop, nullptr, nullptr, nullptr,
+                               nullptr, nullptr, behavior, fallback);
     }
 
     JSScript *script() const {
         return script_;
     }
     jsbytecode *pc() const {
         return pc_;
     }
--- a/js/src/jit/JitFrames.cpp
+++ b/js/src/jit/JitFrames.cpp
@@ -412,20 +412,20 @@ CloseLiveIterator(JSContext *cx, const I
 
 static void
 HandleExceptionIon(JSContext *cx, const InlineFrameIterator &frame, ResumeFromException *rfe,
                    bool *overrecursed, bool *poppedLastSPSFrameOut)
 {
     RootedScript script(cx, frame.script());
     jsbytecode *pc = frame.pc();
 
-    if (cx->compartment()->isDebuggee()) {
-        // We need to bail when we are the debuggee of a Debugger with a live
-        // onExceptionUnwind hook, or if a Debugger has observed this frame
-        // (e.g., for onPop).
+    if (cx->compartment()->isDebuggee() && cx->isExceptionPending()) {
+        // We need to bail when there is a catchable exception, and we are the
+        // debuggee of a Debugger with a live onExceptionUnwind hook, or if a
+        // Debugger has observed this frame (e.g., for onPop).
         bool shouldBail = Debugger::hasLiveHook(cx->global(), Debugger::OnExceptionUnwind);
         if (!shouldBail) {
             JitActivation *act = cx->mainThread().activation()->asJit();
             RematerializedFrame *rematFrame =
                 act->lookupRematerializedFrame(frame.frame().fp(), frame.frameNo());
             shouldBail = rematFrame && rematFrame->isDebuggee();
         }
 
@@ -2340,20 +2340,23 @@ InlineFrameIterator::findNextFrame()
         MOZ_ASSERT(!si_.moreFrames());
         frameCount_ = i;
     }
 
     framesRead_++;
 }
 
 JSObject *
-InlineFrameIterator::computeScopeChain(Value scopeChainValue) const
+InlineFrameIterator::computeScopeChain(Value scopeChainValue, bool *hasCallObj) const
 {
-    if (scopeChainValue.isObject())
+    if (scopeChainValue.isObject()) {
+        if (hasCallObj)
+            *hasCallObj = isFunctionFrame() && callee()->isHeavyweight();
         return &scopeChainValue.toObject();
+    }
 
     // Note we can hit this case even for heavyweight functions, in case we
     // are walking the frame during the function prologue, before the scope
     // chain has been initialized.
     if (isFunctionFrame())
         return callee()->environment();
 
     // Ion does not handle scripts that are not compile-and-go.
--- a/js/src/jit/LIR-Common.h
+++ b/js/src/jit/LIR-Common.h
@@ -442,16 +442,19 @@ class LSimdBinaryBitwiseX4 : public LIns
         return getOperand(0);
     }
     const LAllocation *rhs() {
         return getOperand(1);
     }
     MSimdBinaryBitwise::Operation operation() const {
         return mir_->toSimdBinaryBitwise()->operation();
     }
+    MIRType type() const {
+        return mir_->type();
+    }
 };
 
 class LSimdShift : public LInstructionHelper<1, 2, 0>
 {
   public:
     LIR_HEADER(SimdShift)
     LSimdShift(const LAllocation &vec, const LAllocation &val) {
         setOperand(0, vec);
@@ -1158,33 +1161,27 @@ class LCheckOverRecursedPar : public LIn
         return getTemp(0);
     }
 
     MCheckOverRecursedPar *mir() const {
         return mir_->toCheckOverRecursedPar();
     }
 };
 
-class LAsmJSInterruptCheck : public LInstructionHelper<0, 0, 1>
+class LAsmJSInterruptCheck : public LInstructionHelper<0, 0, 0>
 {
     Label *interruptExit_;
     const CallSiteDesc &funcDesc_;
 
   public:
     LIR_HEADER(AsmJSInterruptCheck);
 
-    LAsmJSInterruptCheck(const LDefinition &scratch, Label *interruptExit,
-                         const CallSiteDesc &funcDesc)
+    LAsmJSInterruptCheck(Label *interruptExit, const CallSiteDesc &funcDesc)
       : interruptExit_(interruptExit), funcDesc_(funcDesc)
     {
-        setTemp(0, scratch);
-    }
-
-    const LDefinition *scratch() {
-        return getTemp(0);
     }
 
     bool isCall() const {
         return true;
     }
 
     Label *interruptExit() const {
         return interruptExit_;
--- a/js/src/jit/Lowering.cpp
+++ b/js/src/jit/Lowering.cpp
@@ -2289,18 +2289,17 @@ LIRGenerator::visitInterruptCheck(MInter
     assignSafepoint(lir, ins);
 }
 
 void
 LIRGenerator::visitAsmJSInterruptCheck(MAsmJSInterruptCheck *ins)
 {
     gen->setPerformsCall();
 
-    LAsmJSInterruptCheck *lir = new(alloc()) LAsmJSInterruptCheck(temp(),
-                                                                  ins->interruptExit(),
+    LAsmJSInterruptCheck *lir = new(alloc()) LAsmJSInterruptCheck(ins->interruptExit(),
                                                                   ins->funcDesc());
     add(lir, ins);
 }
 
 void
 LIRGenerator::visitInterruptCheckPar(MInterruptCheckPar *ins)
 {
     LInterruptCheckPar *lir =
--- a/js/src/jit/RematerializedFrame.cpp
+++ b/js/src/jit/RematerializedFrame.cpp
@@ -35,35 +35,35 @@ RematerializedFrame::RematerializedFrame
     top_(top),
     pc_(iter.pc()),
     frameNo_(iter.frameNo()),
     numActualArgs_(numActualArgs),
     script_(iter.script())
 {
     CopyValueToRematerializedFrame op(slots_);
     MaybeReadFallback fallback(MagicValue(JS_OPTIMIZED_OUT));
-    iter.readFrameArgsAndLocals(cx, op, op, &scopeChain_, &returnValue_,
+    iter.readFrameArgsAndLocals(cx, op, op, &scopeChain_, &hasCallObj_, &returnValue_,
                                 &argsObj_, &thisValue_, ReadFrame_Actuals,
                                 fallback);
 }
 
 /* static */ RematerializedFrame *
 RematerializedFrame::New(JSContext *cx, uint8_t *top, InlineFrameIterator &iter)
 {
     unsigned numFormals = iter.isFunctionFrame() ? iter.callee()->nargs() : 0;
-    unsigned numActualArgs = Max(numFormals, iter.numActualArgs());
+    unsigned argSlots = Max(numFormals, iter.numActualArgs());
     size_t numBytes = sizeof(RematerializedFrame) +
-        (numActualArgs + iter.script()->nfixed()) * sizeof(Value) -
+        (argSlots + iter.script()->nfixed()) * sizeof(Value) -
         sizeof(Value); // 1 Value included in sizeof(RematerializedFrame)
 
     void *buf = cx->pod_calloc<uint8_t>(numBytes);
     if (!buf)
         return nullptr;
 
-    return new (buf) RematerializedFrame(cx, top, numActualArgs, iter);
+    return new (buf) RematerializedFrame(cx, top, iter.numActualArgs(), iter);
 }
 
 /* static */ bool
 RematerializedFrame::RematerializeInlineFrames(JSContext *cx, uint8_t *top,
                                                InlineFrameIterator &iter,
                                                Vector<RematerializedFrame *> &frames)
 {
     if (!frames.resize(iter.frameCount()))
@@ -134,16 +134,17 @@ bool
 RematerializedFrame::initFunctionScopeObjects(JSContext *cx)
 {
     MOZ_ASSERT(isNonEvalFunctionFrame());
     MOZ_ASSERT(fun()->isHeavyweight());
     CallObject *callobj = CallObject::createForFunction(cx, this);
     if (!callobj)
         return false;
     pushOnScopeChain(*callobj);
+    hasCallObj_ = true;
     return true;
 }
 
 void
 RematerializedFrame::mark(JSTracer *trc)
 {
     gc::MarkScriptRoot(trc, &script_, "remat ion frame script");
     gc::MarkObjectRoot(trc, &scopeChain_, "remat ion frame scope chain");
--- a/js/src/jit/RematerializedFrame.h
+++ b/js/src/jit/RematerializedFrame.h
@@ -24,16 +24,19 @@ namespace jit {
 class RematerializedFrame
 {
     // See DebugScopes::updateLiveScopes.
     bool prevUpToDate_;
 
     // Propagated to the Baseline frame once this is popped.
     bool isDebuggee_;
 
+    // Has a call object been pushed?
+    bool hasCallObj_;
+
     // The fp of the top frame associated with this possibly inlined frame.
     uint8_t *top_;
 
     // The bytecode at the time of rematerialization.
     jsbytecode *pc_;
 
     size_t frameNo_;
     unsigned numActualArgs_;
@@ -102,19 +105,18 @@ class RematerializedFrame
 
     JSObject *scopeChain() const {
         return scopeChain_;
     }
     void pushOnScopeChain(ScopeObject &scope);
     bool initFunctionScopeObjects(JSContext *cx);
 
     bool hasCallObj() const {
-        return maybeFun() &&
-               fun()->isHeavyweight() &&
-               scopeChain()->is<CallObject>();
+        MOZ_ASSERT(fun()->isHeavyweight());
+        return hasCallObj_;
     }
     CallObject &callObj() const;
 
     bool hasArgsObj() const {
         return !!argsObj_;
     }
     ArgumentsObject &argsObj() const {
         MOZ_ASSERT(hasArgsObj());
--- a/js/src/jit/arm/MacroAssembler-arm.h
+++ b/js/src/jit/arm/MacroAssembler-arm.h
@@ -1093,16 +1093,21 @@ class MacroAssemblerARMCompat : public M
         ma_cmp(secondScratchReg_, rhs);
         ma_b(label, cond);
     }
     void branch32(Condition cond, AbsoluteAddress lhs, Register rhs, Label *label) {
         loadPtr(lhs, secondScratchReg_); // ma_cmp will use the scratch register.
         ma_cmp(secondScratchReg_, rhs);
         ma_b(label, cond);
     }
+    void branch32(Condition cond, AsmJSAbsoluteAddress addr, Imm32 imm, Label *label) {
+        loadPtr(addr, ScratchRegister);
+        ma_cmp(ScratchRegister, imm);
+        ma_b(label, cond);
+    }
 
     void loadUnboxedValue(Address address, MIRType type, AnyRegister dest) {
         if (dest.isFloat())
             loadInt32OrDouble(Operand(address), dest.fpu());
         else
             ma_ldr(address, dest.gpr());
     }
 
--- a/js/src/jit/mips/MacroAssembler-mips.h
+++ b/js/src/jit/mips/MacroAssembler-mips.h
@@ -836,16 +836,21 @@ public:
     void branch32(Condition cond, AbsoluteAddress lhs, Imm32 rhs, Label *label) {
         loadPtr(lhs, SecondScratchReg); // ma_b might use scratch
         ma_b(SecondScratchReg, rhs, label, cond);
     }
     void branch32(Condition cond, AbsoluteAddress lhs, Register rhs, Label *label) {
         loadPtr(lhs, ScratchRegister);
         ma_b(ScratchRegister, rhs, label, cond);
     }
+    void branch32(Condition cond, AsmJSAbsoluteAddress addr, Imm32 imm,
+                  Label *label) {
+        loadPtr(addr, ScratchRegister);
+        ma_b(ScratchRegister, imm, label, cond);
+    }
 
     void loadUnboxedValue(Address address, MIRType type, AnyRegister dest) {
         if (dest.isFloat())
             loadInt32OrDouble(address, dest.fpu());
         else
             ma_lw(dest.gpr(), address);
     }
 
--- a/js/src/jit/none/Lowering-none.h
+++ b/js/src/jit/none/Lowering-none.h
@@ -85,16 +85,18 @@ class LIRGeneratorNone : public LIRGener
     void visitAsmJSAtomicBinopHeap(MAsmJSAtomicBinopHeap *ins) { MOZ_CRASH(); }
 
     LTableSwitch *newLTableSwitch(LAllocation, LDefinition, MTableSwitch *) { MOZ_CRASH(); }
     LTableSwitchV *newLTableSwitchV(MTableSwitch *) { MOZ_CRASH(); }
     void visitSimdTernaryBitwise(MSimdTernaryBitwise *ins) { MOZ_CRASH(); }
     void visitSimdSplatX4(MSimdSplatX4 *ins) { MOZ_CRASH(); }
     void visitSimdValueX4(MSimdValueX4 *lir) { MOZ_CRASH(); }
     void visitSubstr(MSubstr *) { MOZ_CRASH(); }
+    void visitSimdBinaryArith(js::jit::MSimdBinaryArith*) { MOZ_CRASH(); }
+
 
 };
 
 typedef LIRGeneratorNone LIRGeneratorSpecific;
 
 } // namespace jit
 } // namespace js
 
--- a/js/src/jit/shared/Assembler-x86-shared.cpp
+++ b/js/src/jit/shared/Assembler-x86-shared.cpp
@@ -11,16 +11,19 @@
 #elif defined(JS_CODEGEN_X64)
 # include "jit/x64/MacroAssembler-x64.h"
 #else
 # error "Wrong architecture. Only x86 and x64 should build this file!"
 #endif
 
 #ifdef _MSC_VER
 # include <intrin.h> // for __cpuid
+# if defined(_M_X64) && (_MSC_FULL_VER >= 160040219)
+#  include <immintrin.h> // for _xgetbv
+# endif
 #endif
 
 using namespace js;
 using namespace js::jit;
 
 void
 AssemblerX86Shared::copyJumpRelocationTable(uint8_t *dest)
 {
@@ -136,16 +139,40 @@ AssemblerX86Shared::InvertCondition(Cond
     }
 }
 
 CPUInfo::SSEVersion CPUInfo::maxSSEVersion = UnknownSSE;
 CPUInfo::SSEVersion CPUInfo::maxEnabledSSEVersion = UnknownSSE;
 bool CPUInfo::avxPresent = false;
 bool CPUInfo::avxEnabled = true;
 
+static uintptr_t
+ReadXGETBV()
+{
+    // We use a variety of low-level mechanisms to get at the xgetbv
+    // instruction, including spelling out the xgetbv instruction as bytes,
+    // because older compilers and assemblers may not recognize the instruction
+    // by name.
+    size_t xcr0EAX = 0;
+#if defined(_XCR_XFEATURE_ENABLED_MASK)
+    xcr0EAX = _xgetbv(_XCR_XFEATURE_ENABLED_MASK);
+#elif defined(__GNUC__)
+    // xgetbv returns its results in %eax and %edx, and for our purposes here,
+    // we're only interested in the %eax value.
+    asm(".byte 0x0f, 0x01, 0xd0" : "=a"(xcr0EAX) : "c"(0) : "%edx");
+#elif defined(_MSC_VER) && defined(_M_IX86)
+    __asm {
+        xor ecx, ecx
+        _asm _emit 0x0f _asm _emit 0x01 _asm _emit 0xd0
+        mov xcr0EAX, eax
+    }
+#endif
+    return xcr0EAX;
+}
+
 void
 CPUInfo::SetSSEVersion()
 {
     int flagsEDX = 0;
     int flagsECX = 0;
 
 #ifdef _MSC_VER
     int cpuinfo[4];
@@ -197,9 +224,17 @@ CPUInfo::SetSSEVersion()
     else                          maxSSEVersion = NoSSE;
 
     if (maxEnabledSSEVersion != UnknownSSE)
         maxSSEVersion = Min(maxSSEVersion, maxEnabledSSEVersion);
 
     static const int AVXBit = 1 << 28;
     static const int XSAVEBit = 1 << 27;
     avxPresent = (flagsECX & AVXBit) && (flagsECX & XSAVEBit) && avxEnabled;
+
+    // If the hardware supports AVX, check whether the OS supports it too.
+    if (avxPresent) {
+        size_t xcr0EAX = ReadXGETBV();
+        static const int xcr0SSEBit = 1 << 1;
+        static const int xcr0AVXBit = 1 << 2;
+        avxPresent = (xcr0EAX & xcr0SSEBit) && (xcr0EAX & xcr0AVXBit);
+    }
 }
--- a/js/src/jit/shared/Assembler-x86-shared.h
+++ b/js/src/jit/shared/Assembler-x86-shared.h
@@ -243,17 +243,17 @@ class AssemblerX86Shared : public Assemb
         Signed = X86Assembler::ConditionS,
         NotSigned = X86Assembler::ConditionNS,
         Zero = X86Assembler::ConditionE,
         NonZero = X86Assembler::ConditionNE,
         Parity = X86Assembler::ConditionP,
         NoParity = X86Assembler::ConditionNP
     };
 
-    // If this bit is set, the ucomisd operands have to be inverted.
+    // If this bit is set, the vucomisd operands have to be inverted.
     static const int DoubleConditionBitInvert = 0x10;
 
     // Bit set when a DoubleCondition does not map to a single x86 condition.
     // The macro assembler has to special-case these conditions.
     static const int DoubleConditionBitSpecial = 0x20;
     static const int DoubleConditionBits = DoubleConditionBitInvert | DoubleConditionBitSpecial;
 
     enum DoubleCondition {
@@ -627,23 +627,23 @@ class AssemblerX86Shared : public Assemb
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
     void movdqa(FloatRegister src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
         masm.movdqa_rr(src.code(), dest.code());
     }
-    void cvtss2sd(FloatRegister src, FloatRegister dest) {
+    void vcvtss2sd(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.cvtss2sd_rr(src.code(), dest.code());
+        masm.vcvtss2sd_rr(src1.code(), src0.code(), dest.code());
     }
-    void cvtsd2ss(FloatRegister src, FloatRegister dest) {
+    void vcvtsd2ss(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.cvtsd2ss_rr(src.code(), dest.code());
+        masm.vcvtsd2ss_rr(src1.code(), src0.code(), dest.code());
     }
     void movzbl(const Operand &src, Register dest) {
         switch (src.kind()) {
           case Operand::MEM_REG_DISP:
             masm.movzbl_mr(src.disp(), src.base(), dest.code());
             break;
           case Operand::MEM_SCALE:
             masm.movzbl_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
@@ -975,134 +975,117 @@ class AssemblerX86Shared : public Assemb
 
     static bool HasSSE2() { return CPUInfo::IsSSE2Present(); }
     static bool HasSSE3() { return CPUInfo::IsSSE3Present(); }
     static bool HasSSE41() { return CPUInfo::IsSSE41Present(); }
     static bool SupportsFloatingPoint() { return CPUInfo::IsSSE2Present(); }
     static bool SupportsSimd() { return CPUInfo::IsSSE2Present(); }
     static bool HasAVX() { return CPUInfo::IsAVXPresent(); }
 
-    // The below cmpl methods switch the lhs and rhs when it invokes the
-    // macroassembler to conform with intel standard.  When calling this
-    // function put the left operand on the left as you would expect.
-    void cmpl(Register lhs, Register rhs) {
+    void cmpl(Register rhs, Register lhs) {
         masm.cmpl_rr(rhs.code(), lhs.code());
     }
-    void cmpl(Register lhs, const Operand &rhs) {
+    void cmpl(const Operand &rhs, Register lhs) {
         switch (rhs.kind()) {
           case Operand::REG:
             masm.cmpl_rr(rhs.reg(), lhs.code());
             break;
           case Operand::MEM_REG_DISP:
             masm.cmpl_mr(rhs.disp(), rhs.base(), lhs.code());
             break;
-          default:
-            MOZ_CRASH("unexpected operand kind");
-        }
-    }
-    void cmpl(Register src, Imm32 imm) {
-        masm.cmpl_ir(imm.value, src.code());
-    }
-    void cmpl(const Operand &op, Imm32 imm) {
-        switch (op.kind()) {
-          case Operand::REG:
-            masm.cmpl_ir(imm.value, op.reg());
-            break;
-          case Operand::MEM_REG_DISP:
-            masm.cmpl_im(imm.value, op.disp(), op.base());
-            break;
-          case Operand::MEM_SCALE:
-            masm.cmpl_im(imm.value, op.disp(), op.base(), op.index(), op.scale());
-            break;
           case Operand::MEM_ADDRESS32:
-            masm.cmpl_im(imm.value, op.address());
+            masm.cmpl_mr(rhs.address(), lhs.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void cmpl(const Operand &lhs, Register rhs) {
+    void cmpl(Register rhs, const Operand &lhs) {
         switch (lhs.kind()) {
           case Operand::REG:
             masm.cmpl_rr(rhs.code(), lhs.reg());
             break;
           case Operand::MEM_REG_DISP:
             masm.cmpl_rm(rhs.code(), lhs.disp(), lhs.base());
             break;
           case Operand::MEM_ADDRESS32:
             masm.cmpl_rm(rhs.code(), lhs.address());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void cmpl(const Operand &op, ImmWord imm) {
-        switch (op.kind()) {
+    void cmpl(Imm32 rhs, Register lhs) {
+        masm.cmpl_ir(rhs.value, lhs.code());
+    }
+    void cmpl(Imm32 rhs, const Operand &lhs) {
+        switch (lhs.kind()) {
           case Operand::REG:
-            masm.cmpl_ir(imm.value, op.reg());
+            masm.cmpl_ir(rhs.value, lhs.reg());
             break;
           case Operand::MEM_REG_DISP:
-            masm.cmpl_im(imm.value, op.disp(), op.base());
+            masm.cmpl_im(rhs.value, lhs.disp(), lhs.base());
+            break;
+          case Operand::MEM_SCALE:
+            masm.cmpl_im(rhs.value, lhs.disp(), lhs.base(), lhs.index(), lhs.scale());
             break;
           case Operand::MEM_ADDRESS32:
-            masm.cmpl_im(imm.value, op.address());
+            masm.cmpl_im(rhs.value, lhs.address());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void cmpl(const Operand &op, ImmPtr imm) {
-        cmpl(op, ImmWord(uintptr_t(imm.value)));
-    }
-    CodeOffsetLabel cmplWithPatch(Register lhs, Imm32 rhs) {
-        masm.cmpl_ir_force32(rhs.value, lhs.code());
+    CodeOffsetLabel cmplWithPatch(Imm32 rhs, Register lhs) {
+        masm.cmpl_i32r(rhs.value, lhs.code());
         return CodeOffsetLabel(masm.currentOffset());
     }
-    void cmpw(Register lhs, Register rhs) {
-        masm.cmpw_rr(lhs.code(), rhs.code());
+    void cmpw(Register rhs, Register lhs) {
+        masm.cmpw_rr(rhs.code(), lhs.code());
     }
     void setCC(Condition cond, Register r) {
         masm.setCC_r(static_cast<X86Assembler::Condition>(cond), r.code());
     }
-    void testb(Register lhs, Register rhs) {
+    void testb(Register rhs, Register lhs) {
+        MOZ_ASSERT(GeneralRegisterSet(Registers::SingleByteRegs).has(rhs));
         MOZ_ASSERT(GeneralRegisterSet(Registers::SingleByteRegs).has(lhs));
-        MOZ_ASSERT(GeneralRegisterSet(Registers::SingleByteRegs).has(rhs));
         masm.testb_rr(rhs.code(), lhs.code());
     }
-    void testw(Register lhs, Register rhs) {
-        masm.testw_rr(rhs.code(), lhs.code());
+    void testw(Register rhs, Register lhs) {
+        masm.testw_rr(lhs.code(), rhs.code());
     }
-    void testl(Register lhs, Register rhs) {
-        masm.testl_rr(rhs.code(), lhs.code());
+    void testl(Register rhs, Register lhs) {
+        masm.testl_rr(lhs.code(), rhs.code());
     }
-    void testl(Register lhs, Imm32 rhs) {
-        masm.testl_i32r(rhs.value, lhs.code());
+    void testl(Imm32 rhs, Register lhs) {
+        masm.testl_ir(rhs.value, lhs.code());
     }
-    void testl(const Operand &lhs, Imm32 rhs) {
+    void testl(Imm32 rhs, const Operand &lhs) {
         switch (lhs.kind()) {
           case Operand::REG:
-            masm.testl_i32r(rhs.value, lhs.reg());
+            masm.testl_ir(rhs.value, lhs.reg());
             break;
           case Operand::MEM_REG_DISP:
             masm.testl_i32m(rhs.value, lhs.disp(), lhs.base());
             break;
           case Operand::MEM_ADDRESS32:
             masm.testl_i32m(rhs.value, lhs.address());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
             break;
         }
     }
 
     void addl(Imm32 imm, Register dest) {
         masm.addl_ir(imm.value, dest.code());
     }
-    void addl_wide(Imm32 imm, Register dest) {
-        masm.addl_ir_wide(imm.value, dest.code());
+    CodeOffsetLabel addlWithPatch(Imm32 imm, Register dest) {
+        masm.addl_i32r(imm.value, dest.code());
+        return CodeOffsetLabel(masm.currentOffset());
     }
     void addl(Imm32 imm, const Operand &op) {
         switch (op.kind()) {
           case Operand::REG:
             masm.addl_ir(imm.value, op.reg());
             break;
           case Operand::MEM_REG_DISP:
             masm.addl_im(imm.value, op.disp(), op.base());
@@ -1269,23 +1252,23 @@ class AssemblerX86Shared : public Assemb
     }
     void bsr(const Register &src, const Register &dest) {
         masm.bsr_rr(src.code(), dest.code());
     }
     void imull(Register multiplier) {
         masm.imull_r(multiplier.code());
     }
     void imull(Imm32 imm, Register dest) {
-        masm.imull_i32r(dest.code(), imm.value, dest.code());
+        masm.imull_ir(imm.value, dest.code(), dest.code());
     }
     void imull(Register src, Register dest) {
         masm.imull_rr(src.code(), dest.code());
     }
     void imull(Imm32 imm, Register src, Register dest) {
-        masm.imull_i32r(src.code(), imm.value, dest.code());
+        masm.imull_ir(imm.value, src.code(), dest.code());
     }
     void imull(const Operand &src, Register dest) {
         switch (src.kind()) {
           case Operand::REG:
             masm.imull_rr(src.reg(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
             masm.imull_mr(src.disp(), src.base(), dest.code());
@@ -1436,17 +1419,17 @@ class AssemblerX86Shared : public Assemb
             masm.lock_xaddl_rm(srcdest.code(), mem.disp(), mem.base(), mem.index(), mem.scale());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
 
     void push(const Imm32 imm) {
-        masm.push_i32(imm.value);
+        masm.push_i(imm.value);
     }
 
     void push(const Operand &src) {
         switch (src.kind()) {
           case Operand::REG:
             masm.push_r(src.reg());
             break;
           case Operand::MEM_REG_DISP:
@@ -1579,123 +1562,123 @@ class AssemblerX86Shared : public Assemb
         MOZ_ASSERT(HasSSE2());
         masm.psrld_rr(src.code(), dest.code());
     }
     void psrld(Imm32 count, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
         masm.psrld_ir(count.value, dest.code());
     }
 
-    void cvtsi2sd(const Operand &src, FloatRegister dest) {
+    void vcvtsi2sd(const Operand &src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        switch (src.kind()) {
+        switch (src1.kind()) {
           case Operand::REG:
-            masm.cvtsi2sd_rr(src.reg(), dest.code());
+            masm.vcvtsi2sd_rr(src1.reg(), src0.code(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.cvtsi2sd_mr(src.disp(), src.base(), dest.code());
+            masm.vcvtsi2sd_mr(src1.disp(), src1.base(), src0.code(), dest.code());
             break;
           case Operand::MEM_SCALE:
-            masm.cvtsi2sd_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
+            masm.vcvtsi2sd_mr(src1.disp(), src1.base(), src1.index(), src1.scale(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void cvttsd2si(FloatRegister src, Register dest) {
+    void vcvttsd2si(FloatRegister src, Register dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.cvttsd2si_rr(src.code(), dest.code());
+        masm.vcvttsd2si_rr(src.code(), dest.code());
     }
-    void cvttss2si(FloatRegister src, Register dest) {
+    void vcvttss2si(FloatRegister src, Register dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.cvttss2si_rr(src.code(), dest.code());
+        masm.vcvttss2si_rr(src.code(), dest.code());
     }
-    void cvtsi2ss(const Operand &src, FloatRegister dest) {
+    void vcvtsi2ss(const Operand &src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        switch (src.kind()) {
+        switch (src1.kind()) {
           case Operand::REG:
-            masm.cvtsi2ss_rr(src.reg(), dest.code());
+            masm.vcvtsi2ss_rr(src1.reg(), src0.code(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.cvtsi2ss_mr(src.disp(), src.base(), dest.code());
+            masm.vcvtsi2ss_mr(src1.disp(), src1.base(), src0.code(), dest.code());
             break;
           case Operand::MEM_SCALE:
-            masm.cvtsi2ss_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
+            masm.vcvtsi2ss_mr(src1.disp(), src1.base(), src1.index(), src1.scale(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void cvtsi2ss(Register src, FloatRegister dest) {
+    void vcvtsi2ss(Register src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.cvtsi2ss_rr(src.code(), dest.code());
+        masm.vcvtsi2ss_rr(src1.code(), src0.code(), dest.code());
     }
-    void cvtsi2sd(Register src, FloatRegister dest) {
+    void vcvtsi2sd(Register src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.cvtsi2sd_rr(src.code(), dest.code());
+        masm.vcvtsi2sd_rr(src1.code(), src0.code(), dest.code());
     }
-    void cvttps2dq(FloatRegister src, FloatRegister dest) {
+    void vcvttps2dq(FloatRegister src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.cvttps2dq_rr(src.code(), dest.code());
+        masm.vcvttps2dq_rr(src.code(), dest.code());
     }
-    void cvtdq2ps(FloatRegister src, FloatRegister dest) {
+    void vcvtdq2ps(FloatRegister src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.cvtdq2ps_rr(src.code(), dest.code());
+        masm.vcvtdq2ps_rr(src.code(), dest.code());
     }
-    void movmskpd(FloatRegister src, Register dest) {
+    void vmovmskpd(FloatRegister src, Register dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.movmskpd_rr(src.code(), dest.code());
+        masm.vmovmskpd_rr(src.code(), dest.code());
     }
-    void movmskps(FloatRegister src, Register dest) {
+    void vmovmskps(FloatRegister src, Register dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.movmskps_rr(src.code(), dest.code());
+        masm.vmovmskps_rr(src.code(), dest.code());
     }
-    void ptest(FloatRegister lhs, FloatRegister rhs) {
+    void vptest(FloatRegister rhs, FloatRegister lhs) {
         MOZ_ASSERT(HasSSE41());
-        masm.ptest_rr(rhs.code(), lhs.code());
+        masm.vptest_rr(rhs.code(), lhs.code());
     }
-    void ucomisd(FloatRegister lhs, FloatRegister rhs) {
+    void vucomisd(FloatRegister rhs, FloatRegister lhs) {
         MOZ_ASSERT(HasSSE2());
-        masm.ucomisd_rr(rhs.code(), lhs.code());
+        masm.vucomisd_rr(rhs.code(), lhs.code());
     }
-    void ucomiss(FloatRegister lhs, FloatRegister rhs) {
+    void vucomiss(FloatRegister rhs, FloatRegister lhs) {
         MOZ_ASSERT(HasSSE2());
-        masm.ucomiss_rr(rhs.code(), lhs.code());
+        masm.vucomiss_rr(rhs.code(), lhs.code());
     }
-    void pcmpeqw(FloatRegister lhs, FloatRegister rhs) {
+    void vpcmpeqw(FloatRegister rhs, FloatRegister lhs, FloatRegister dst) {
         MOZ_ASSERT(HasSSE2());
-        masm.pcmpeqw_rr(rhs.code(), lhs.code());
+        masm.vpcmpeqw_rr(rhs.code(), lhs.code(), dst.code());
     }
-    void pcmpeqd(const Operand &src, FloatRegister dest) {
+    void vpcmpeqd(const Operand &rhs, FloatRegister lhs, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        switch (src.kind()) {
+        switch (rhs.kind()) {
           case Operand::FPREG:
-            masm.pcmpeqd_rr(src.fpu(), dest.code());
+            masm.vpcmpeqd_rr(rhs.fpu(), lhs.code(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.pcmpeqd_mr(src.disp(), src.base(), dest.code());
+            masm.vpcmpeqd_mr(rhs.disp(), rhs.base(), lhs.code(), dest.code());
             break;
           case Operand::MEM_ADDRESS32:
-            masm.pcmpeqd_mr(src.address(), dest.code());
+            masm.vpcmpeqd_mr(rhs.address(), lhs.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void pcmpgtd(const Operand &src, FloatRegister dest) {
+    void vpcmpgtd(const Operand &rhs, FloatRegister lhs, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        switch (src.kind()) {
+        switch (rhs.kind()) {
           case Operand::FPREG:
-            masm.pcmpgtd_rr(src.fpu(), dest.code());
+            masm.vpcmpgtd_rr(rhs.fpu(), lhs.code(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.pcmpgtd_mr(src.disp(), src.base(), dest.code());
+            masm.vpcmpgtd_mr(rhs.disp(), rhs.base(), lhs.code(), dest.code());
             break;
           case Operand::MEM_ADDRESS32:
-            masm.pcmpgtd_mr(src.address(), dest.code());
+            masm.vpcmpgtd_mr(rhs.address(), lhs.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
     void vcmpps(uint8_t order, const Operand &src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
         switch (src1.kind()) {
@@ -1722,99 +1705,99 @@ class AssemblerX86Shared : public Assemb
         vcmpps(X86Assembler::ConditionCmp_LE, src1, src0, dest);
     }
     void vcmpunordps(const Operand &src1, FloatRegister src0, FloatRegister dest) {
         vcmpps(X86Assembler::ConditionCmp_UNORD, src1, src0, dest);
     }
     void vcmpneqps(const Operand &src1, FloatRegister src0, FloatRegister dest) {
         vcmpps(X86Assembler::ConditionCmp_NEQ, src1, src0, dest);
     }
-    void rcpps(const Operand &src, FloatRegister dest) {
+    void vrcpps(const Operand &src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
         switch (src.kind()) {
           case Operand::FPREG:
-            masm.rcpps_rr(src.fpu(), dest.code());
+            masm.vrcpps_rr(src.fpu(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.rcpps_mr(src.disp(), src.base(), dest.code());
+            masm.vrcpps_mr(src.disp(), src.base(), dest.code());
             break;
           case Operand::MEM_ADDRESS32:
-            masm.rcpps_mr(src.address(), dest.code());
+            masm.vrcpps_mr(src.address(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void sqrtps(const Operand &src, FloatRegister dest) {
+    void vsqrtps(const Operand &src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
         switch (src.kind()) {
           case Operand::FPREG:
-            masm.sqrtps_rr(src.fpu(), dest.code());
+            masm.vsqrtps_rr(src.fpu(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.sqrtps_mr(src.disp(), src.base(), dest.code());
+            masm.vsqrtps_mr(src.disp(), src.base(), dest.code());
             break;
           case Operand::MEM_ADDRESS32:
-            masm.sqrtps_mr(src.address(), dest.code());
+            masm.vsqrtps_mr(src.address(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void rsqrtps(const Operand &src, FloatRegister dest) {
+    void vrsqrtps(const Operand &src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
         switch (src.kind()) {
           case Operand::FPREG:
-            masm.rsqrtps_rr(src.fpu(), dest.code());
+            masm.vrsqrtps_rr(src.fpu(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.rsqrtps_mr(src.disp(), src.base(), dest.code());
+            masm.vrsqrtps_mr(src.disp(), src.base(), dest.code());
             break;
           case Operand::MEM_ADDRESS32:
-            masm.rsqrtps_mr(src.address(), dest.code());
+            masm.vrsqrtps_mr(src.address(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void movd(Register src, FloatRegister dest) {
+    void vmovd(Register src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.movd_rr(src.code(), dest.code());
+        masm.vmovd_rr(src.code(), dest.code());
     }
-    void movd(FloatRegister src, Register dest) {
+    void vmovd(FloatRegister src, Register dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.movd_rr(src.code(), dest.code());
+        masm.vmovd_rr(src.code(), dest.code());
     }
-    void paddd(const Operand &src, FloatRegister dest) {
+    void vpaddd(const Operand &src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        switch (src.kind()) {
+        switch (src1.kind()) {
           case Operand::FPREG:
-            masm.paddd_rr(src.fpu(), dest.code());
+            masm.vpaddd_rr(src1.fpu(), src0.code(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.paddd_mr(src.disp(), src.base(), dest.code());
+            masm.vpaddd_mr(src1.disp(), src1.base(), src0.code(), dest.code());
             break;
           case Operand::MEM_ADDRESS32:
-            masm.paddd_mr(src.address(), dest.code());
+            masm.vpaddd_mr(src1.address(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void psubd(const Operand &src, FloatRegister dest) {
+    void vpsubd(const Operand &src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        switch (src.kind()) {
+        switch (src1.kind()) {
           case Operand::FPREG:
-            masm.psubd_rr(src.fpu(), dest.code());
+            masm.vpsubd_rr(src1.fpu(), src0.code(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.psubd_mr(src.disp(), src.base(), dest.code());
+            masm.vpsubd_mr(src1.disp(), src1.base(), src0.code(), dest.code());
             break;
           case Operand::MEM_ADDRESS32:
-            masm.psubd_mr(src.address(), dest.code());
+            masm.vpsubd_mr(src1.address(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
     void pmuludq(FloatRegister src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
         masm.pmuludq_rr(src.code(), dest.code());
@@ -1926,85 +1909,162 @@ class AssemblerX86Shared : public Assemb
             break;
           case Operand::MEM_ADDRESS32:
             masm.vminps_mr(src1.address(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void andps(const Operand &src, FloatRegister dest) {
+    void vandps(const Operand &src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        switch (src.kind()) {
+        switch (src1.kind()) {
           case Operand::FPREG:
-            masm.andps_rr(src.fpu(), dest.code());
+            masm.vandps_rr(src1.fpu(), src0.code(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.andps_mr(src.disp(), src.base(), dest.code());
+            masm.vandps_mr(src1.disp(), src1.base(), src0.code(), dest.code());
             break;
           case Operand::MEM_ADDRESS32:
-            masm.andps_mr(src.address(), dest.code());
+            masm.vandps_mr(src1.address(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void andnps(const Operand &src, FloatRegister dest) {
+    void vandnps(const Operand &src1, FloatRegister src0, FloatRegister dest) {
         // Negates bits of dest and then applies AND
         MOZ_ASSERT(HasSSE2());
-        switch (src.kind()) {
+        switch (src1.kind()) {
           case Operand::FPREG:
-            masm.andnps_rr(src.fpu(), dest.code());
+            masm.vandnps_rr(src1.fpu(), src0.code(), dest.code());
+            break;
+          case Operand::MEM_REG_DISP:
+            masm.vandnps_mr(src1.disp(), src1.base(), src0.code(), dest.code());
+            break;
+          case Operand::MEM_ADDRESS32:
+            masm.vandnps_mr(src1.address(), src0.code(), dest.code());
+            break;
+          default:
+            MOZ_CRASH("unexpected operand kind");
+        }
+    }
+    void vorps(const Operand &src1, FloatRegister src0, FloatRegister dest) {
+        MOZ_ASSERT(HasSSE2());
+        switch (src1.kind()) {
+          case Operand::FPREG:
+            masm.vorps_rr(src1.fpu(), src0.code(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.andnps_mr(src.disp(), src.base(), dest.code());
+            masm.vorps_mr(src1.disp(), src1.base(), src0.code(), dest.code());
             break;
           case Operand::MEM_ADDRESS32:
-            masm.andnps_mr(src.address(), dest.code());
+            masm.vorps_mr(src1.address(), src0.code(), dest.code());
+            break;
+          default:
+            MOZ_CRASH("unexpected operand kind");
+        }
+    }
+    void vxorps(const Operand &src1, FloatRegister src0, FloatRegister dest) {
+        MOZ_ASSERT(HasSSE2());
+        switch (src1.kind()) {
+          case Operand::FPREG:
+            masm.vxorps_rr(src1.fpu(), src0.code(), dest.code());
+            break;
+          case Operand::MEM_REG_DISP:
+            masm.vxorps_mr(src1.disp(), src1.base(), src0.code(), dest.code());
+            break;
+          case Operand::MEM_ADDRESS32:
+            masm.vxorps_mr(src1.address(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void orps(const Operand &src, FloatRegister dest) {
+    void vpand(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        switch (src.kind()) {
+        masm.vpand_rr(src1.code(), src0.code(), dest.code());
+    }
+    void vpand(const Operand &src1, FloatRegister src0, FloatRegister dest) {
+        MOZ_ASSERT(HasSSE2());
+        switch (src1.kind()) {
           case Operand::FPREG:
-            masm.orps_rr(src.fpu(), dest.code());
+            masm.vpand_rr(src1.fpu(), src0.code(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.orps_mr(src.disp(), src.base(), dest.code());
+            masm.vpand_mr(src1.disp(), src1.base(), src0.code(), dest.code());
             break;
           case Operand::MEM_ADDRESS32:
-            masm.orps_mr(src.address(), dest.code());
+            masm.vpand_mr(src1.address(), src0.code(), dest.code());
+            break;
+          default:
+            MOZ_CRASH("unexpected operand kind");
+        }
+    }
+    void vpor(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
+        MOZ_ASSERT(HasSSE2());
+        masm.vpor_rr(src1.code(), src0.code(), dest.code());
+    }
+    void vpor(const Operand &src1, FloatRegister src0, FloatRegister dest) {
+        MOZ_ASSERT(HasSSE2());
+        switch (src1.kind()) {
+          case Operand::FPREG:
+            masm.vpor_rr(src1.fpu(), src0.code(), dest.code());
+            break;
+          case Operand::MEM_REG_DISP:
+            masm.vpor_mr(src1.disp(), src1.base(), src0.code(), dest.code());
+            break;
+          case Operand::MEM_ADDRESS32:
+            masm.vpor_mr(src1.address(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void xorps(const Operand &src, FloatRegister dest) {
+    void vpxor(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        switch (src.kind()) {
+        masm.vpxor_rr(src1.code(), src0.code(), dest.code());
+    }
+    void vpxor(const Operand &src1, FloatRegister src0, FloatRegister dest) {
+        MOZ_ASSERT(HasSSE2());
+        switch (src1.kind()) {
           case Operand::FPREG:
-            masm.xorps_rr(src.fpu(), dest.code());
+            masm.vpxor_rr(src1.fpu(), src0.code(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.xorps_mr(src.disp(), src.base(), dest.code());
+            masm.vpxor_mr(src1.disp(), src1.base(), src0.code(), dest.code());
             break;
           case Operand::MEM_ADDRESS32:
-            masm.xorps_mr(src.address(), dest.code());
+            masm.vpxor_mr(src1.address(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void pxor(FloatRegister src, FloatRegister dest) {
+    void vpandn(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
+        MOZ_ASSERT(HasSSE2());
+        masm.vpandn_rr(src1.code(), src0.code(), dest.code());
+    }
+    void vpandn(const Operand &src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.pxor_rr(src.code(), dest.code());
+        switch (src1.kind()) {
+          case Operand::FPREG:
+            masm.vpandn_rr(src1.fpu(), src0.code(), dest.code());
+            break;
+          case Operand::MEM_REG_DISP:
+            masm.vpandn_mr(src1.disp(), src1.base(), src0.code(), dest.code());
+            break;
+          case Operand::MEM_ADDRESS32:
+            masm.vpandn_mr(src1.address(), src0.code(), dest.code());
+            break;
+          default:
+            MOZ_CRASH("unexpected operand kind");
+        }
     }
+
     void pshufd(uint32_t mask, FloatRegister src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
         masm.pshufd_irr(mask, src.code(), dest.code());
     }
     void pshufd(uint32_t mask, const Operand &src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
         switch (src.kind()) {
           case Operand::FPREG:
@@ -2015,31 +2075,31 @@ class AssemblerX86Shared : public Assemb
             break;
           case Operand::MEM_ADDRESS32:
             masm.pshufd_imr(mask, src.address(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void movhlps(FloatRegister src, FloatRegister dest) {
+    void vmovhlps(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.movhlps_rr(src.code(), dest.code());
+        masm.vmovhlps_rr(src1.code(), src0.code(), dest.code());
     }
-    void movlhps(FloatRegister src, FloatRegister dest) {
+    void vmovlhps(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.movlhps_rr(src.code(), dest.code());
+        masm.vmovlhps_rr(src1.code(), src0.code(), dest.code());
     }
-    void unpcklps(FloatRegister src, FloatRegister dest) {
+    void vunpcklps(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.unpcklps_rr(src.code(), dest.code());
+        masm.vunpcklps_rr(src1.code(), src0.code(), dest.code());
     }
-    void unpckhps(FloatRegister src, FloatRegister dest) {
+    void vunpckhps(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.unpckhps_rr(src.code(), dest.code());
+        masm.vunpckhps_rr(src1.code(), src0.code(), dest.code());
     }
     void shufps(uint32_t mask, FloatRegister src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
         masm.shufps_irr(mask, src.code(), dest.code());
     }
     void shufps(uint32_t mask, const Operand &src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
         switch (src.kind()) {
@@ -2193,47 +2253,47 @@ class AssemblerX86Shared : public Assemb
             break;
           case Operand::MEM_REG_DISP:
             masm.vdivss_mr(src1.disp(), src1.base(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void xorpd(FloatRegister src, FloatRegister dest) {
+    void vxorpd(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.xorpd_rr(src.code(), dest.code());
+        masm.vxorpd_rr(src1.code(), src0.code(), dest.code());
     }
-    void xorps(FloatRegister src, FloatRegister dest) {
+    void vxorps(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.xorps_rr(src.code(), dest.code());
+        masm.vxorps_rr(src1.code(), src0.code(), dest.code());
     }
-    void orpd(FloatRegister src, FloatRegister dest) {
+    void vorpd(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.orpd_rr(src.code(), dest.code());
+        masm.vorpd_rr(src1.code(), src0.code(), dest.code());
     }
-    void orps(FloatRegister src, FloatRegister dest) {
+    void vorps(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.orps_rr(src.code(), dest.code());
+        masm.vorps_rr(src1.code(), src0.code(), dest.code());
     }
-    void andpd(FloatRegister src, FloatRegister dest) {
+    void vandpd(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.andpd_rr(src.code(), dest.code());
+        masm.vandpd_rr(src1.code(), src0.code(), dest.code());
     }
-    void andps(FloatRegister src, FloatRegister dest) {
+    void vandps(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.andps_rr(src.code(), dest.code());
+        masm.vandps_rr(src1.code(), src0.code(), dest.code());
     }
-    void sqrtsd(FloatRegister src, FloatRegister dest) {
+    void vsqrtsd(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.sqrtsd_rr(src.code(), dest.code());
+        masm.vsqrtsd_rr(src1.code(), src0.code(), dest.code());
     }
-    void sqrtss(FloatRegister src, FloatRegister dest) {
+    void vsqrtss(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.sqrtss_rr(src.code(), dest.code());
+        masm.vsqrtss_rr(src1.code(), src0.code(), dest.code());
     }
     void roundsd(X86Assembler::RoundingMode mode, FloatRegister src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE41());
         masm.roundsd_rr(mode, src.code(), dest.code());
     }
     void roundss(X86Assembler::RoundingMode mode, FloatRegister src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE41());
         masm.roundss_rr(mode, src.code(), dest.code());
@@ -2285,91 +2345,91 @@ class AssemblerX86Shared : public Assemb
             break;
           case Operand::MEM_REG_DISP:
             masm.vblendvps_mr(mask.code(), src1.disp(), src1.base(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void movsldup(FloatRegister src, FloatRegister dest) {
+    void vmovsldup(FloatRegister src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE3());
-        masm.movsldup_rr(src.code(), dest.code());
+        masm.vmovsldup_rr(src.code(), dest.code());
     }
-    void movsldup(const Operand &src, FloatRegister dest) {
+    void vmovsldup(const Operand &src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE3());
         switch (src.kind()) {
           case Operand::FPREG:
-            masm.movsldup_rr(src.fpu(), dest.code());
+            masm.vmovsldup_rr(src.fpu(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.movsldup_mr(src.disp(), src.base(), dest.code());
+            masm.vmovsldup_mr(src.disp(), src.base(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void movshdup(FloatRegister src, FloatRegister dest) {
+    void vmovshdup(FloatRegister src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE3());
-        masm.movshdup_rr(src.code(), dest.code());
+        masm.vmovshdup_rr(src.code(), dest.code());
     }
-    void movshdup(const Operand &src, FloatRegister dest) {
+    void vmovshdup(const Operand &src, FloatRegister dest) {
         MOZ_ASSERT(HasSSE3());
         switch (src.kind()) {
           case Operand::FPREG:
-            masm.movshdup_rr(src.fpu(), dest.code());
+            masm.vmovshdup_rr(src.fpu(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.movshdup_mr(src.disp(), src.base(), dest.code());
+            masm.vmovshdup_mr(src.disp(), src.base(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void minsd(FloatRegister src, FloatRegister dest) {
+    void vminsd(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.minsd_rr(src.code(), dest.code());
+        masm.vminsd_rr(src1.code(), src0.code(), dest.code());
     }
-    void minsd(const Operand &src, FloatRegister dest) {
+    void vminsd(const Operand &src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        switch (src.kind()) {
+        switch (src1.kind()) {
           case Operand::FPREG:
-            masm.minsd_rr(src.fpu(), dest.code());
+            masm.vminsd_rr(src1.fpu(), src0.code(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.minsd_mr(src.disp(), src.base(), dest.code());
+            masm.vminsd_mr(src1.disp(), src1.base(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void minss(FloatRegister src, FloatRegister dest) {
+    void vminss(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.minss_rr(src.code(), dest.code());
+        masm.vminss_rr(src1.code(), src0.code(), dest.code());
     }
-    void maxsd(FloatRegister src, FloatRegister dest) {
+    void vmaxsd(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.maxsd_rr(src.code(), dest.code());
+        masm.vmaxsd_rr(src1.code(), src0.code(), dest.code());
     }
-    void maxsd(const Operand &src, FloatRegister dest) {
+    void vmaxsd(const Operand &src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        switch (src.kind()) {
+        switch (src1.kind()) {
           case Operand::FPREG:
-            masm.maxsd_rr(src.fpu(), dest.code());
+            masm.vmaxsd_rr(src1.fpu(), src0.code(), dest.code());
             break;
           case Operand::MEM_REG_DISP:
-            masm.maxsd_mr(src.disp(), src.base(), dest.code());
+            masm.vmaxsd_mr(src1.disp(), src1.base(), src0.code(), dest.code());
             break;
           default:
             MOZ_CRASH("unexpected operand kind");
         }
     }
-    void maxss(FloatRegister src, FloatRegister dest) {
+    void vmaxss(FloatRegister src1, FloatRegister src0, FloatRegister dest) {
         MOZ_ASSERT(HasSSE2());
-        masm.maxss_rr(src.code(), dest.code());
+        masm.vmaxss_rr(src1.code(), src0.code(), dest.code());
     }
     void fisttp(const Operand &dest) {
         MOZ_ASSERT(HasSSE3());
         switch (dest.kind()) {
           case Operand::MEM_REG_DISP:
             masm.fisttp_m(dest.disp(), dest.base());
             break;
           default:
--- a/js/src/jit/shared/BaseAssembler-x86-shared.h
+++ b/js/src/jit/shared/BaseAssembler-x86-shared.h
@@ -259,16 +259,18 @@ private:
 #endif
 #ifdef JS_CODEGEN_X64
         OP_MOVSXD_GvEv                  = 0x63,
 #endif
         PRE_OPERAND_SIZE                = 0x66,
         PRE_SSE_66                      = 0x66,
         OP_PUSH_Iz                      = 0x68,
         OP_IMUL_GvEvIz                  = 0x69,
+        OP_PUSH_Ib                      = 0x6a,
+        OP_IMUL_GvEvIb                  = 0x6b,
         OP_GROUP1_EbIb                  = 0x80,
         OP_GROUP1_EvIz                  = 0x81,
         OP_GROUP1_EvIb                  = 0x83,
         OP_TEST_EbGb                    = 0x84,
         OP_TEST_EvGv                    = 0x85,
         OP_XCHG_GvEv                    = 0x87,
         OP_MOV_EbGv                     = 0x88,
         OP_MOV_EvGv                     = 0x89,
@@ -379,17 +381,20 @@ private:
         OP2_MOVZX_GvEb      = 0xB6,
         OP2_MOVZX_GvEw      = 0xB7,
         OP2_XADD_EbGb       = 0xC0,
         OP2_XADD_EvGv       = 0xC1,
         OP2_CMPPS_VpsWps    = 0xC2,
         OP2_PEXTRW_GdUdIb   = 0xC5,
         OP2_SHUFPS_VpsWpsIb = 0xC6,
         OP2_PSRLD_VdqWdq    = 0xD2,
+        OP2_PANDDQ_VdqWdq   = 0xDB,
+        OP2_PANDNDQ_VdqWdq  = 0xDF,
         OP2_PSRAD_VdqWdq    = 0xE2,
+        OP2_PORDQ_VdqWdq    = 0xEB,
         OP2_PXORDQ_VdqWdq   = 0xEF,
         OP2_PSLLD_VdqWdq    = 0xF2,
         OP2_PMULUDQ_VdqWdq  = 0xF4,
         OP2_PSUBD_VdqWdq    = 0xFA,
         OP2_PADDD_VdqWdq    = 0xFE
     } TwoByteOpcodeID;
 
     typedef enum {
@@ -558,19 +563,31 @@ public:
     }
 
     void pop_r(RegisterID reg)
     {
         spew("pop        %s", nameIReg(reg));
         m_formatter.oneByteOp(OP_POP_EAX, reg);
     }
 
-    void push_i32(int imm)
+    void push_i(int imm)
     {
         spew("push       %s$0x%x", PRETTY_PRINT_OFFSET(imm));
+        if (CAN_SIGN_EXTEND_8_32(imm)) {
+            m_formatter.oneByteOp(OP_PUSH_Ib);
+            m_formatter.immediate8(imm);
+        } else {
+            m_formatter.oneByteOp(OP_PUSH_Iz);
+            m_formatter.immediate32(imm);
+        }
+    }
+
+    void push_i32(int imm)
+    {
+        spew("push       %s$0x%04x", PRETTY_PRINT_OFFSET(imm));
         m_formatter.oneByteOp(OP_PUSH_Iz);
         m_formatter.immediate32(imm);
     }
 
     void push_m(int offset, RegisterID base)
     {
         spew("push       %s0x%x(%s)", PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.oneByteOp(OP_GROUP5_Ev, offset, base, GROUP5_OP_PUSH);
@@ -636,20 +653,20 @@ public:
         if (CAN_SIGN_EXTEND_8_32(imm)) {
             m_formatter.oneByteOp(OP_GROUP1_EvIb, dst, GROUP1_OP_ADD);
             m_formatter.immediate8(imm);
         } else {
             m_formatter.oneByteOp(OP_GROUP1_EvIz, dst, GROUP1_OP_ADD);
             m_formatter.immediate32(imm);
         }
     }
-    void addl_ir_wide(int imm, RegisterID dst)
+    void addl_i32r(int imm, RegisterID dst)
     {
         // 32-bit immediate always, for patching.
-        spew("addl       $0x%x, %s", imm, nameIReg(4,dst));
+        spew("addl       $0x%04x, %s", imm, nameIReg(4,dst));
         m_formatter.oneByteOp(OP_GROUP1_EvIz, dst, GROUP1_OP_ADD);
         m_formatter.immediate32(imm);
     }
 
     void addl_im(int imm, int offset, RegisterID base)
     {
         spew("addl       $%d, %s0x%x(%s)",
              imm, PRETTY_PRINT_OFFSET(offset), nameIReg(base));
@@ -760,54 +777,40 @@ public:
     {
         spew("lock xaddl %s, %s0x%x(%s,%s,%d)",
             nameIReg(4, srcdest), PRETTY_PRINT_OFFSET(offset),
             nameIReg(base), nameIReg(index), 1<<scale);
         m_formatter.oneByteOp(PRE_LOCK);
         m_formatter.twoByteOp(OP2_XADD_EvGv, offset, base, index, scale, srcdest);
     }
 
-    void paddd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("paddd      %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PADDD_VdqWdq, (RegisterID)src, (RegisterID)dst);
-    }
-    void paddd_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("paddd      %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PADDD_VdqWdq, offset, base, (RegisterID)dst);
-    }
-    void paddd_mr(const void* address, XMMRegisterID dst)
-    {
-        spew("paddd      %p, %s", address, nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PADDD_VdqWdq, address, (RegisterID)dst);
-    }
-
-    void psubd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("psubd      %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PSUBD_VdqWdq, (RegisterID)src, (RegisterID)dst);
-    }
-    void psubd_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("psubd      %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PSUBD_VdqWdq, offset, base, (RegisterID)dst);
-    }
-    void psubd_mr(const void* address, XMMRegisterID dst)
-    {
-        spew("psubd      %p, %s", address, nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PSUBD_VdqWdq, address, (RegisterID)dst);
+    void vpaddd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpaddd", VEX_PD, OP2_PADDD_VdqWdq, src1, src0, dst);
+    }
+    void vpaddd_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpaddd", VEX_PD, OP2_PADDD_VdqWdq, offset, base, src0, dst);
+    }
+    void vpaddd_mr(const void* address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpaddd", VEX_PD, OP2_PADDD_VdqWdq, address, src0, dst);
+    }
+
+    void vpsubd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpsubd", VEX_PD, OP2_PSUBD_VdqWdq, src1, src0, dst);
+    }
+    void vpsubd_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpsubd", VEX_PD, OP2_PSUBD_VdqWdq, offset, base, src0, dst);
+    }
+    void vpsubd_mr(const void* address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpsubd", VEX_PD, OP2_PSUBD_VdqWdq, address, src0, dst);
     }
 
     void pmuludq_rr(XMMRegisterID src, XMMRegisterID dst)
     {
         spew("pmuludq     %s, %s", nameFPReg(src), nameFPReg(dst));
         m_formatter.prefix(PRE_SSE_66);
         m_formatter.twoByteOp(OP2_PMULUDQ_VdqWdq, (RegisterID)src, (RegisterID)dst);
     }
@@ -1434,21 +1437,26 @@ public:
 
     void imull_mr(int offset, RegisterID base, RegisterID dst)
     {
         spew("imull      %s0x%x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(4,dst));
         m_formatter.twoByteOp(OP2_IMUL_GvEv, offset, base, dst);
     }
 
-    void imull_i32r(RegisterID src, int32_t value, RegisterID dst)
+    void imull_ir(int32_t value, RegisterID src, RegisterID dst)
     {
         spew("imull      $%d, %s, %s", value, nameIReg(4, src), nameIReg(4, dst));
-        m_formatter.oneByteOp(OP_IMUL_GvEvIz, src, dst);
-        m_formatter.immediate32(value);
+        if (CAN_SIGN_EXTEND_8_32(value)) {
+            m_formatter.oneByteOp(OP_IMUL_GvEvIb, src, dst);
+            m_formatter.immediate8(value);
+        } else {
+            m_formatter.oneByteOp(OP_IMUL_GvEvIz, src, dst);
+            m_formatter.immediate32(value);
+        }
     }
 
     void idivl_r(RegisterID divisor)
     {
         spew("idivl      %s", nameIReg(4, divisor));
         m_formatter.oneByteOp(OP_GROUP3_Ev, divisor, GROUP3_OP_IDIV);
     }
 
@@ -1523,365 +1531,413 @@ public:
         spew("cmpxchg32  %s, %s0x%x(%s,%s,%d)",
              nameIReg(src), PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(index), 1<<scale);
         m_formatter.twoByteOp(OP2_CMPXCHG_GvEw, offset, base, index, scale, src);
     }
 
 
     // Comparisons:
 
-    void cmpl_rr(RegisterID src, RegisterID dst)
-    {
-        spew("cmpl       %s, %s", nameIReg(4, src), nameIReg(4, dst));
-        m_formatter.oneByteOp(OP_CMP_GvEv, src, dst);
-    }
-
-    void cmpl_rm(RegisterID src, int offset, RegisterID base)
+    void cmpl_rr(RegisterID rhs, RegisterID lhs)
+    {
+        spew("cmpl       %s, %s", nameIReg(4, rhs), nameIReg(4, lhs));
+        m_formatter.oneByteOp(OP_CMP_GvEv, rhs, lhs);
+    }
+
+    void cmpl_rm(RegisterID rhs, int offset, RegisterID base)
     {
         spew("cmpl       %s, %s0x%x(%s)",
-             nameIReg(4, src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
-        m_formatter.oneByteOp(OP_CMP_EvGv, offset, base, src);
-    }
-
-    void cmpl_mr(int offset, RegisterID base, RegisterID src)
+             nameIReg(4, rhs), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
+        m_formatter.oneByteOp(OP_CMP_EvGv, offset, base, rhs);
+    }
+
+    void cmpl_mr(int offset, RegisterID base, RegisterID lhs)
     {
         spew("cmpl       %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(src));
-        m_formatter.oneByteOp(OP_CMP_GvEv, offset, base, src);
-    }
-
-    void cmpl_ir(int imm, RegisterID dst)
-    {
-        if (imm == 0) {
-            testl_rr(dst, dst);
+             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(4, lhs));
+        m_formatter.oneByteOp(OP_CMP_GvEv, offset, base, lhs);
+    }
+
+    void cmpl_mr(const void *address, RegisterID lhs)
+    {
+        spew("cmpl       %p, %s", address, nameIReg(4, lhs));
+        m_formatter.oneByteOp(OP_CMP_GvEv, address, lhs);
+    }
+
+    void cmpl_ir(int rhs, RegisterID lhs)
+    {
+        if (rhs == 0) {
+            testl_rr(lhs, lhs);
             return;
         }
 
-        spew("cmpl       $0x%x, %s", imm, nameIReg(4, dst));
-        if (CAN_SIGN_EXTEND_8_32(imm)) {
-            m_formatter.oneByteOp(OP_GROUP1_EvIb, dst, GROUP1_OP_CMP);
-            m_formatter.immediate8(imm);
+        spew("cmpl       $0x%x, %s", rhs, nameIReg(4, lhs));
+        if (CAN_SIGN_EXTEND_8_32(rhs)) {
+            m_formatter.oneByteOp(OP_GROUP1_EvIb, lhs, GROUP1_OP_CMP);
+            m_formatter.immediate8(rhs);
         } else {
-            m_formatter.oneByteOp(OP_GROUP1_EvIz, dst, GROUP1_OP_CMP);
-            m_formatter.immediate32(imm);
+            m_formatter.oneByteOp(OP_GROUP1_EvIz, lhs, GROUP1_OP_CMP);
+            m_formatter.immediate32(rhs);
         }
     }
 
-    void cmpl_ir_force32(int imm, RegisterID dst)
-    {
-        spew("cmpl       $0x%x, %s", imm, nameIReg(4, dst));
-        m_formatter.oneByteOp(OP_GROUP1_EvIz, dst, GROUP1_OP_CMP);
-        m_formatter.immediate32(imm);
-    }
-
-    void cmpl_im(int imm, int offset, RegisterID base)
+    void cmpl_i32r(int rhs, RegisterID lhs)
+    {
+        spew("cmpl       $0x%04x, %s", rhs, nameIReg(4, lhs));
+        m_formatter.oneByteOp(OP_GROUP1_EvIz, lhs, GROUP1_OP_CMP);
+        m_formatter.immediate32(rhs);
+    }
+
+    void cmpl_im(int rhs, int offset, RegisterID base)
     {
         spew("cmpl       $0x%x, %s0x%x(%s)",
-             imm, PRETTY_PRINT_OFFSET(offset), nameIReg(base));
-        if (CAN_SIGN_EXTEND_8_32(imm)) {
+             rhs, PRETTY_PRINT_OFFSET(offset), nameIReg(base));
+        if (CAN_SIGN_EXTEND_8_32(rhs)) {
             m_formatter.oneByteOp(OP_GROUP1_EvIb, offset, base, GROUP1_OP_CMP);
-            m_formatter.immediate8(imm);
+            m_formatter.immediate8(rhs);
         } else {
             m_formatter.oneByteOp(OP_GROUP1_EvIz, offset, base, GROUP1_OP_CMP);
-            m_formatter.immediate32(imm);
+            m_formatter.immediate32(rhs);
         }
     }
 
-    void cmpb_im(int imm, int offset, RegisterID base)
+    void cmpb_im(int rhs, int offset, RegisterID base)
     {
         m_formatter.oneByteOp(OP_GROUP1_EbIb, offset, base, GROUP1_OP_CMP);
-        m_formatter.immediate8(imm);
-    }
-
-    void cmpb_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
+        m_formatter.immediate8(rhs);
+    }
+
+    void cmpb_im(int rhs, int offset, RegisterID base, RegisterID index, int scale)
     {
         m_formatter.oneByteOp(OP_GROUP1_EbIb, offset, base, index, scale, GROUP1_OP_CMP);
-        m_formatter.immediate8(imm);
-    }
-
-    void cmpl_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
+        m_formatter.immediate8(rhs);
+    }
+
+    void cmpl_im(int rhs, int offset, RegisterID base, RegisterID index, int scale)
     {
         spew("cmpl       $%d, %d(%s,%s,%d)",
-             imm, offset, nameIReg(base), nameIReg(index), 1<<scale);
-        if (CAN_SIGN_EXTEND_8_32(imm)) {
+             rhs, offset, nameIReg(base), nameIReg(index), 1<<scale);
+        if (CAN_SIGN_EXTEND_8_32(rhs)) {
             m_formatter.oneByteOp(OP_GROUP1_EvIb, offset, base, index, scale, GROUP1_OP_CMP);
-            m_formatter.immediate8(imm);
+            m_formatter.immediate8(rhs);
         } else {
             m_formatter.oneByteOp(OP_GROUP1_EvIz, offset, base, index, scale, GROUP1_OP_CMP);
-            m_formatter.immediate32(imm);
+            m_formatter.immediate32(rhs);
+        }
+    }
+
+    MOZ_WARN_UNUSED_RESULT JmpSrc
+    cmpl_im_disp32(int rhs, int offset, RegisterID base)
+    {
+        spew("cmpl       $0x%x, %s0x%04x(%s)",
+             rhs, PRETTY_PRINT_OFFSET(offset), nameIReg(base));
+        JmpSrc r;
+        if (CAN_SIGN_EXTEND_8_32(rhs)) {
+            m_formatter.oneByteOp_disp32(OP_GROUP1_EvIb, offset, base, GROUP1_OP_CMP);
+            r = JmpSrc(m_formatter.size());
+            m_formatter.immediate8(rhs);
+        } else {
+            m_formatter.oneByteOp_disp32(OP_GROUP1_EvIz, offset, base, GROUP1_OP_CMP);
+            r = JmpSrc(m_formatter.size());
+            m_formatter.immediate32(rhs);
         }
-    }
-
-    void cmpl_im_force32(int imm, int offset, RegisterID base)
-    {
-        spew("cmpl       $0x%x, %s0x%x(%s)",
-             imm, PRETTY_PRINT_OFFSET(offset), nameIReg(base));
+        return r;
+    }
+
+    MOZ_WARN_UNUSED_RESULT JmpSrc
+    cmpl_im_disp32(int rhs, const void *addr)
+    {
+        spew("cmpl       $0x%x, %p", rhs, addr);
+        JmpSrc r;
+        if (CAN_SIGN_EXTEND_8_32(rhs)) {
+            m_formatter.oneByteOp_disp32(OP_GROUP1_EvIb, addr, GROUP1_OP_CMP);
+            r = JmpSrc(m_formatter.size());
+            m_formatter.immediate8(rhs);
+        } else {
+            m_formatter.oneByteOp_disp32(OP_GROUP1_EvIz, addr, GROUP1_OP_CMP);
+            r = JmpSrc(m_formatter.size());
+            m_formatter.immediate32(rhs);
+        }
+        return r;
+    }
+
+    void cmpl_i32m(int rhs, int offset, RegisterID base)
+    {
+        spew("cmpl       $0x%04x, %s0x%x(%s)",
+             rhs, PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.oneByteOp(OP_GROUP1_EvIz, offset, base, GROUP1_OP_CMP);
-        m_formatter.immediate32(imm);
+        m_formatter.immediate32(rhs);
+    }
+
+    void cmpl_i32m(int rhs, const void *addr)
+    {
+        spew("cmpl       $0x%04x, %p", rhs, addr);
+        m_formatter.oneByteOp(OP_GROUP1_EvIz, addr, GROUP1_OP_CMP);
+        m_formatter.immediate32(rhs);
     }
 
 #ifdef JS_CODEGEN_X64
-    void cmpq_rr(RegisterID src, RegisterID dst)
-    {
-        spew("cmpq       %s, %s", nameIReg(8, src), nameIReg(8, dst));
-        m_formatter.oneByteOp64(OP_CMP_GvEv, src, dst);
-    }
-
-    void cmpq_rm(RegisterID src, int offset, RegisterID base)
-    {
-        spew("cmpq       %s, %d(%s)", nameIReg(8, src), offset, nameIReg(8, base));
-        m_formatter.oneByteOp64(OP_CMP_EvGv, offset, base, src);
-    }
-
-    void cmpq_mr(int offset, RegisterID base, RegisterID src)
-    {
-        spew("cmpq       %d(%s), %s", offset, nameIReg(8, base), nameIReg(8, src));
-        m_formatter.oneByteOp64(OP_CMP_GvEv, offset, base, src);
-    }
-
-    void cmpq_ir(int imm, RegisterID dst)
-    {
-        if (imm == 0) {
-            testq_rr(dst, dst);
+    void cmpq_rr(RegisterID rhs, RegisterID lhs)
+    {
+        spew("cmpq       %s, %s", nameIReg(8, rhs), nameIReg(8, lhs));
+        m_formatter.oneByteOp64(OP_CMP_GvEv, rhs, lhs);
+    }
+
+    void cmpq_rm(RegisterID rhs, int offset, RegisterID base)
+    {
+        spew("cmpq       %s, %d(%s)", nameIReg(8, rhs), offset, nameIReg(8, base));
+        m_formatter.oneByteOp64(OP_CMP_EvGv, offset, base, rhs);
+    }
+
+    void cmpq_mr(int offset, RegisterID base, RegisterID lhs)
+    {
+        spew("cmpq       %d(%s), %s", offset, nameIReg(8, base), nameIReg(8, lhs));
+        m_formatter.oneByteOp64(OP_CMP_GvEv, offset, base, lhs);
+    }
+
+    void cmpq_ir(int rhs, RegisterID lhs)
+    {
+        if (rhs == 0) {
+            testq_rr(lhs, lhs);
             return;
         }
 
-        spew("cmpq       $%d, %s", imm, nameIReg(8, dst));
-        if (CAN_SIGN_EXTEND_8_32(imm)) {
-            m_formatter.oneByteOp64(OP_GROUP1_EvIb, dst, GROUP1_OP_CMP);
-            m_formatter.immediate8(imm);
+        spew("cmpq       $%d, %s", rhs, nameIReg(8, lhs));
+        if (CAN_SIGN_EXTEND_8_32(rhs)) {
+            m_formatter.oneByteOp64(OP_GROUP1_EvIb, lhs, GROUP1_OP_CMP);
+            m_formatter.immediate8(rhs);
         } else {
-            m_formatter.oneByteOp64(OP_GROUP1_EvIz, dst, GROUP1_OP_CMP);
-            m_formatter.immediate32(imm);
+            m_formatter.oneByteOp64(OP_GROUP1_EvIz, lhs, GROUP1_OP_CMP);
+            m_formatter.immediate32(rhs);
         }
     }
 
-    void cmpq_im(int imm, int offset, RegisterID base)
+    void cmpq_im(int rhs, int offset, RegisterID base)
     {
         spew("cmpq       $%d, %s0x%x(%s)",
-             imm, PRETTY_PRINT_OFFSET(offset), nameIReg(base));
-        if (CAN_SIGN_EXTEND_8_32(imm)) {
+             rhs, PRETTY_PRINT_OFFSET(offset), nameIReg(base));
+        if (CAN_SIGN_EXTEND_8_32(rhs)) {
             m_formatter.oneByteOp64(OP_GROUP1_EvIb, offset, base, GROUP1_OP_CMP);
-            m_formatter.immediate8(imm);
+            m_formatter.immediate8(rhs);
         } else {
             m_formatter.oneByteOp64(OP_GROUP1_EvIz, offset, base, GROUP1_OP_CMP);
-            m_formatter.immediate32(imm);
+            m_formatter.immediate32(rhs);
         }
     }
 
-    void cmpq_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
+    void cmpq_im(int rhs, int offset, RegisterID base, RegisterID index, int scale)
     {
         FIXME_INSN_PRINTING;
-        if (CAN_SIGN_EXTEND_8_32(imm)) {
+        if (CAN_SIGN_EXTEND_8_32(rhs)) {
             m_formatter.oneByteOp64(OP_GROUP1_EvIb, offset, base, index, scale, GROUP1_OP_CMP);
-            m_formatter.immediate8(imm);
+            m_formatter.immediate8(rhs);
         } else {
             m_formatter.oneByteOp64(OP_GROUP1_EvIz, offset, base, index, scale, GROUP1_OP_CMP);
-            m_formatter.immediate32(imm);
+            m_formatter.immediate32(rhs);
         }
     }
-    void cmpq_im(int imm, const void* addr)
-    {
-        spew("cmpq       $0x%x, %p", imm, addr);
-        if (CAN_SIGN_EXTEND_8_32(imm)) {
+    void cmpq_im(int rhs, const void* addr)
+    {
+        spew("cmpq       $0x%x, %p", rhs, addr);
+        if (CAN_SIGN_EXTEND_8_32(rhs)) {
             m_formatter.oneByteOp64(OP_GROUP1_EvIb, addr, GROUP1_OP_CMP);
-            m_formatter.immediate8(imm);
+            m_formatter.immediate8(rhs);
         } else {
             m_formatter.oneByteOp64(OP_GROUP1_EvIz, addr, GROUP1_OP_CMP);
-            m_formatter.immediate32(imm);
+            m_formatter.immediate32(rhs);
         }
     }
-    void cmpq_rm(RegisterID reg, const void* addr)
-    {
-        spew("cmpq       %s, %p", nameIReg(8, reg), addr);
-        m_formatter.oneByteOp64(OP_CMP_EvGv, addr, reg);
+    void cmpq_rm(RegisterID rhs, const void* addr)
+    {
+        spew("cmpq       %s, %p", nameIReg(8, rhs), addr);
+        m_formatter.oneByteOp64(OP_CMP_EvGv, addr, rhs);
     }
 #endif
-    void cmpl_rm(RegisterID reg, const void* addr)
-    {
-        spew("cmpl       %s, %p", nameIReg(4, reg), addr);
-        m_formatter.oneByteOp(OP_CMP_EvGv, addr, reg);
-    }
-
-    void cmpl_rm_force32(RegisterID reg, const void* addr)
-    {
-        spew("cmpl       %s, %p", nameIReg(4, reg), addr);
-        m_formatter.oneByteOp_disp32(OP_CMP_EvGv, addr, reg);
-    }
-
-    void cmpl_im(int imm, const void* addr)
-    {
-        spew("cmpl       $0x%x, %p", imm, addr);
-        if (CAN_SIGN_EXTEND_8_32(imm)) {
+    void cmpl_rm(RegisterID rhs, const void* addr)
+    {
+        spew("cmpl       %s, %p", nameIReg(4, rhs), addr);
+        m_formatter.oneByteOp(OP_CMP_EvGv, addr, rhs);
+    }
+
+    void cmpl_rm_disp32(RegisterID rhs, const void* addr)
+    {
+        spew("cmpl       %s, %p", nameIReg(4, rhs), addr);
+        m_formatter.oneByteOp_disp32(OP_CMP_EvGv, addr, rhs);
+    }
+
+    void cmpl_im(int rhs, const void* addr)
+    {
+        spew("cmpl       $0x%x, %p", rhs, addr);
+        if (CAN_SIGN_EXTEND_8_32(rhs)) {
             m_formatter.oneByteOp(OP_GROUP1_EvIb, addr, GROUP1_OP_CMP);
-            m_formatter.immediate8(imm);
+            m_formatter.immediate8(rhs);
         } else {
             m_formatter.oneByteOp(OP_GROUP1_EvIz, addr, GROUP1_OP_CMP);
-            m_formatter.immediate32(imm);
+            m_formatter.immediate32(rhs);
         }
     }
 
-    void cmpw_rr(RegisterID src, RegisterID dst)
-    {
-        spew("cmpw       %s, %s", nameIReg(2, src), nameIReg(2, dst));
+    void cmpw_rr(RegisterID rhs, RegisterID lhs)
+    {
+        spew("cmpw       %s, %s", nameIReg(2, rhs), nameIReg(2, lhs));
         m_formatter.prefix(PRE_OPERAND_SIZE);
-        m_formatter.oneByteOp(OP_CMP_GvEv, src, dst);
-    }
-
-    void cmpw_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
+        m_formatter.oneByteOp(OP_CMP_GvEv, rhs, lhs);
+    }
+
+    void cmpw_rm(RegisterID rhs, int offset, RegisterID base, RegisterID index, int scale)
     {
         FIXME_INSN_PRINTING;
         m_formatter.prefix(PRE_OPERAND_SIZE);
-        m_formatter.oneByteOp(OP_CMP_EvGv, offset, base, index, scale, src);
+        m_formatter.oneByteOp(OP_CMP_EvGv, offset, base, index, scale, rhs);
     }
 
     void cmpw_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
     {
         FIXME_INSN_PRINTING;
         if (CAN_SIGN_EXTEND_8_32(imm)) {
             m_formatter.prefix(PRE_OPERAND_SIZE);
             m_formatter.oneByteOp(OP_GROUP1_EvIb, offset, base, index, scale, GROUP1_OP_CMP);
             m_formatter.immediate8(imm);
         } else {
             m_formatter.prefix(PRE_OPERAND_SIZE);
             m_formatter.oneByteOp(OP_GROUP1_EvIz, offset, base, index, scale, GROUP1_OP_CMP);
             m_formatter.immediate16(imm);
         }
     }
 
-    void testl_rr(RegisterID src, RegisterID dst)
-    {
-        spew("testl      %s, %s", nameIReg(4,src), nameIReg(4,dst));
-        m_formatter.oneByteOp(OP_TEST_EvGv, dst, src);
-    }
-
-    void testb_rr(RegisterID src, RegisterID dst)
-    {
-        spew("testb      %s, %s", nameIReg(1,src), nameIReg(1,dst));
-        m_formatter.oneByteOp(OP_TEST_EbGb, dst, src);
-    }
-
-    void testl_i32r(int imm, RegisterID dst)
+    void testl_rr(RegisterID rhs, RegisterID lhs)
+    {
+        spew("testl      %s, %s", nameIReg(4, rhs), nameIReg(4, lhs));
+        m_formatter.oneByteOp(OP_TEST_EvGv, lhs, rhs);
+    }
+
+    void testb_rr(RegisterID rhs, RegisterID lhs)
+    {
+        spew("testb      %s, %s", nameIReg(1, rhs), nameIReg(1, lhs));
+        m_formatter.oneByteOp(OP_TEST_EbGb, lhs, rhs);
+    }
+
+    void testl_ir(int rhs, RegisterID lhs)
     {
         // If the mask fits in an 8-bit immediate, we can use testb with an
         // 8-bit subreg.
-        if (CAN_ZERO_EXTEND_8_32(imm) && X86Registers::hasSubregL(dst)) {
-            testb_i8r(imm, dst);
+        if (CAN_ZERO_EXTEND_8_32(rhs) && X86Registers::hasSubregL(lhs)) {
+            testb_i8r(rhs, lhs);
             return;
         }
         // If the mask is a subset of 0xff00, we can use testb with an h reg, if
         // one happens to be available.
-        if (CAN_ZERO_EXTEND_8H_32(imm) && X86Registers::hasSubregH(dst)) {
-            testb_i8r_norex(imm >> 8, X86Registers::getSubregH(dst));
+        if (CAN_ZERO_EXTEND_8H_32(rhs) && X86Registers::hasSubregH(lhs)) {
+            testb_i8r_norex(rhs >> 8, X86Registers::getSubregH(lhs));
             return;
         }
-        spew("testl      $0x%x, %s", imm, nameIReg(dst));
-        m_formatter.oneByteOp(OP_GROUP3_EvIz, dst, GROUP3_OP_TEST);
-        m_formatter.immediate32(imm);
-    }
-
-    void testl_i32m(int imm, int offset, RegisterID base)
+        spew("testl      $0x%x, %s", rhs, nameIReg(4, lhs));
+        m_formatter.oneByteOp(OP_GROUP3_EvIz, lhs, GROUP3_OP_TEST);
+        m_formatter.immediate32(rhs);
+    }
+
+    void testl_i32m(int rhs, int offset, RegisterID base)
     {
         spew("testl      $0x%x, %s0x%x(%s)",
-             imm, PRETTY_PRINT_OFFSET(offset), nameIReg(base));
+             rhs, PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.oneByteOp(OP_GROUP3_EvIz, offset, base, GROUP3_OP_TEST);
-        m_formatter.immediate32(imm);
-    }
-
-    void testl_i32m(int imm, const void *addr)
-    {
-        spew("testl      $0x%x, %p", imm, addr);
+        m_formatter.immediate32(rhs);
+    }
+
+    void testl_i32m(int rhs, const void *addr)
+    {
+        spew("testl      $0x%x, %p", rhs, addr);
         m_formatter.oneByteOp(OP_GROUP3_EvIz, addr, GROUP3_OP_TEST);
-        m_formatter.immediate32(imm);
-    }
-
-    void testb_im(int imm, int offset, RegisterID base)
+        m_formatter.immediate32(rhs);
+    }
+
+    void testb_im(int rhs, int offset, RegisterID base)
     {
         FIXME_INSN_PRINTING;
         m_formatter.oneByteOp(OP_GROUP3_EbIb, offset, base, GROUP3_OP_TEST);
-        m_formatter.immediate8(imm);
-    }
-
-    void testb_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
+        m_formatter.immediate8(rhs);
+    }
+
+    void testb_im(int rhs, int offset, RegisterID base, RegisterID index, int scale)
     {
         FIXME_INSN_PRINTING;
         m_formatter.oneByteOp(OP_GROUP3_EbIb, offset, base, index, scale, GROUP3_OP_TEST);
-        m_formatter.immediate8(imm);
-    }
-
-    void testl_i32m(int imm, int offset, RegisterID base, RegisterID index, int scale)
+        m_formatter.immediate8(rhs);
+    }
+
+    void testl_i32m(int rhs, int offset, RegisterID base, RegisterID index, int scale)
     {
         FIXME_INSN_PRINTING;
         m_formatter.oneByteOp(OP_GROUP3_EvIz, offset, base, index, scale, GROUP3_OP_TEST);
-        m_formatter.immediate32(imm);
+        m_formatter.immediate32(rhs);
     }
 
 #ifdef JS_CODEGEN_X64
-    void testq_rr(RegisterID src, RegisterID dst)
-    {
-        spew("testq      %s, %s", nameIReg(8,src), nameIReg(8,dst));
-        m_formatter.oneByteOp64(OP_TEST_EvGv, dst, src);
-    }
-
-    void testq_i32r(int imm, RegisterID dst)
+    void testq_rr(RegisterID rhs, RegisterID lhs)
+    {
+        spew("testq      %s, %s", nameIReg(8, rhs), nameIReg(8, lhs));
+        m_formatter.oneByteOp64(OP_TEST_EvGv, lhs, rhs);
+    }
+
+    void testq_ir(int rhs, RegisterID lhs)
     {
         // If the mask fits in a 32-bit immediate, we can use testl with a
         // 32-bit subreg.
-        if (CAN_ZERO_EXTEND_32_64(imm)) {
-            testl_i32r(imm, dst);
+        if (CAN_ZERO_EXTEND_32_64(rhs)) {
+            testl_ir(rhs, lhs);
             return;
         }
-        spew("testq      $0x%x, %s", imm, nameIReg(dst));
-        m_formatter.oneByteOp64(OP_GROUP3_EvIz, dst, GROUP3_OP_TEST);
-        m_formatter.immediate32(imm);
-    }
-
-    void testq_i32m(int imm, int offset, RegisterID base)
+        spew("testq      $0x%x, %s", rhs, nameIReg(8, lhs));
+        m_formatter.oneByteOp64(OP_GROUP3_EvIz, lhs, GROUP3_OP_TEST);
+        m_formatter.immediate32(rhs);
+    }
+
+    void testq_i32m(int rhs, int offset, RegisterID base)
     {
         spew("testq      $0x%x, %s0x%x(%s)",
-             imm, PRETTY_PRINT_OFFSET(offset), nameIReg(base));
+             rhs, PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.oneByteOp64(OP_GROUP3_EvIz, offset, base, GROUP3_OP_TEST);
-        m_formatter.immediate32(imm);
-    }
-
-    void testq_i32m(int imm, int offset, RegisterID base, RegisterID index, int scale)
+        m_formatter.immediate32(rhs);
+    }
+
+    void testq_i32m(int rhs, int offset, RegisterID base, RegisterID index, int scale)
     {
         FIXME_INSN_PRINTING;
         m_formatter.oneByteOp64(OP_GROUP3_EvIz, offset, base, index, scale, GROUP3_OP_TEST);
-        m_formatter.immediate32(imm);
+        m_formatter.immediate32(rhs);
     }
 #endif
 
-    void testw_rr(RegisterID src, RegisterID dst)
+    void testw_rr(RegisterID rhs, RegisterID lhs)
     {
         FIXME_INSN_PRINTING;
         m_formatter.prefix(PRE_OPERAND_SIZE);
-        m_formatter.oneByteOp(OP_TEST_EvGv, dst, src);
-    }
-
-    void testb_i8r(int imm, RegisterID dst)
-    {
-        spew("testb      $0x%x, %s", imm, nameIReg(1,dst));
-        m_formatter.oneByteOp8(OP_GROUP3_EbIb, dst, GROUP3_OP_TEST);
-        m_formatter.immediate8(imm);
+        m_formatter.oneByteOp(OP_TEST_EvGv, lhs, rhs);
+    }
+
+    void testb_i8r(int rhs, RegisterID lhs)
+    {
+        spew("testb      $0x%x, %s", rhs, nameIReg(1, lhs));
+        m_formatter.oneByteOp8(OP_GROUP3_EbIb, lhs, GROUP3_OP_TEST);
+        m_formatter.immediate8(rhs);
     }
 
     // Like testb_i8r, but never emits a REX prefix. This may be used to
     // reference ah..bh.
-    void testb_i8r_norex(int imm, RegisterID dst)
-    {
-        spew("testb      $0x%x, %s", imm, nameIReg(1,dst));
-        m_formatter.oneByteOp8_norex(OP_GROUP3_EbIb, dst, GROUP3_OP_TEST);
-        m_formatter.immediate8(imm);
-    }
-
-    void setCC_r(Condition cond, RegisterID dst)
-    {
-        spew("set%s      %s", nameCC(cond), nameIReg(1,dst));
-        m_formatter.twoByteOp8(setccOpcode(cond), dst, (GroupOpcodeID)0);
+    void testb_i8r_norex(int rhs, RegisterID lhs)
+    {
+        spew("testb      $0x%x, %s", rhs, nameIReg(1, lhs));
+        m_formatter.oneByteOp8_norex(OP_GROUP3_EbIb, lhs, GROUP3_OP_TEST);
+        m_formatter.immediate8(rhs);
+    }
+
+    void setCC_r(Condition cond, RegisterID lhs)
+    {
+        spew("set%s      %s", nameCC(cond), nameIReg(1, lhs));
+        m_formatter.twoByteOp8(setccOpcode(cond), lhs, (GroupOpcodeID)0);
     }
 
     void sete_r(RegisterID dst)
     {
         setCC_r(ConditionE, dst);
     }
 
     void setz_r(RegisterID dst)
@@ -1932,17 +1988,17 @@ public:
         spew("movw       %s, %s0x%x(%s)",
              nameIReg(2,src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.prefix(PRE_OPERAND_SIZE);
         m_formatter.oneByteOp(OP_MOV_EvGv, offset, base, src);
     }
 
     void movw_rm_disp32(RegisterID src, int offset, RegisterID base)
     {
-        spew("movw       %s, %s0x%x(%s)",
+        spew("movw       %s, %s0x%04x(%s)",
              nameIReg(2,src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.prefix(PRE_OPERAND_SIZE);
         m_formatter.oneByteOp_disp32(OP_MOV_EvGv, offset, base, src);
     }
 
     void movw_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
     {
         spew("movw       %s, %d(%s,%s,%d)",
@@ -1962,17 +2018,17 @@ public:
     {
         spew("movl       %s, %s0x%x(%s)",
              nameIReg(4,src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.oneByteOp(OP_MOV_EvGv, offset, base, src);
     }
 
     void movl_rm_disp32(RegisterID src, int offset, RegisterID base)
     {
-        spew("movl       %s, %s0x%x(%s)",
+        spew("movl       %s, %s0x%04x(%s)",
              nameIReg(4,src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.oneByteOp_disp32(OP_MOV_EvGv, offset, base, src);
     }
 
     void movl_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
     {
         spew("movl       %s, %d(%s,%s,%d)",
              nameIReg(4, src), offset, nameIReg(base), nameIReg(index), 1<<scale);
@@ -1994,26 +2050,26 @@ public:
     {
         spew("movl       %s0x%x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(4, dst));
         m_formatter.oneByteOp(OP_MOV_GvEv, offset, base, dst);
     }
 
     void movl_mr_disp32(int offset, RegisterID base, RegisterID dst)
     {
-        spew("movl       %s0x%x(%s), %s",
+        spew("movl       %s0x%04x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(4,dst));
         m_formatter.oneByteOp_disp32(OP_MOV_GvEv, offset, base, dst);
     }
 
     void movl_mr(const void* base, RegisterID index, int scale, RegisterID dst)
     {
         int32_t disp = addressImmediate(base);
 
-        spew("movl       %d(,%s,%d), %s", disp, nameIReg(index), 1<<scale, nameIReg(dst));
+        spew("movl       0x%x(,%s,%d), %s", disp, nameIReg(index), 1<<scale, nameIReg(4, dst));
         m_formatter.oneByteOp_disp32(OP_MOV_GvEv, disp, index, scale, dst);
     }
 
     void movl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
     {
         spew("movl       %d(%s,%s,%d), %s",
              offset, nameIReg(base), nameIReg(index), 1<<scale, nameIReg(4, dst));
         m_formatter.oneByteOp(OP_MOV_GvEv, offset, base, index, scale, dst);
@@ -2300,17 +2356,17 @@ public:
     {
         spew("movb       %s, %s0x%x(%s)",
              nameIReg(1, src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.oneByteOp8(OP_MOV_EbGv, offset, base, src);
     }
 
     void movb_rm_disp32(RegisterID src, int offset, RegisterID base)
     {
-        spew("movb       %s, %s0x%x(%s)",
+        spew("movb       %s, %s0x%04x(%s)",
              nameIReg(1, src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.oneByteOp8_disp32(OP_MOV_EbGv, offset, base, src);
     }
 
     void movb_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
     {
         spew("movb       %s, %d(%s,%s,%d)",
              nameIReg(1, src), offset, nameIReg(base), nameIReg(index), 1<<scale);
@@ -2341,17 +2397,17 @@ public:
     {
         spew("movzbl     %s0x%x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(4, dst));
         m_formatter.twoByteOp(OP2_MOVZX_GvEb, offset, base, dst);
     }
 
     void movzbl_mr_disp32(int offset, RegisterID base, RegisterID dst)
     {
-        spew("movzbl     %s0x%x(%s), %s",
+        spew("movzbl     %s0x%04x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(4, dst));
         m_formatter.twoByteOp_disp32(OP2_MOVZX_GvEb, offset, base, dst);
     }
 
     void movzbl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
     {
         spew("movzbl     %d(%s,%s,%d), %s",
              offset, nameIReg(base), nameIReg(index), 1<<scale, nameIReg(dst));
@@ -2374,17 +2430,17 @@ public:
     {
         spew("movsbl     %s0x%x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(4, dst));
         m_formatter.twoByteOp(OP2_MOVSX_GvEb, offset, base, dst);
     }
 
     void movsbl_mr_disp32(int offset, RegisterID base, RegisterID dst)
     {
-        spew("movsbl     %s0x%x(%s), %s",
+        spew("movsbl     %s0x%04x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(4, dst));
         m_formatter.twoByteOp_disp32(OP2_MOVSX_GvEb, offset, base, dst);
     }
 
     void movsbl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
     {
         spew("movsbl     %d(%s,%s,%d), %s",
              offset, nameIReg(base), nameIReg(index), 1<<scale, nameIReg(dst));
@@ -2407,17 +2463,17 @@ public:
     {
         spew("movzwl     %s0x%x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(4, dst));
         m_formatter.twoByteOp(OP2_MOVZX_GvEw, offset, base, dst);
     }
 
     void movzwl_mr_disp32(int offset, RegisterID base, RegisterID dst)
     {
-        spew("movzwl     %s0x%x(%s), %s",
+        spew("movzwl     %s0x%04x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(4, dst));
         m_formatter.twoByteOp_disp32(OP2_MOVZX_GvEw, offset, base, dst);
     }
 
     void movzwl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
     {
         spew("movzwl     %d(%s,%s,%d), %s",
              offset, nameIReg(base), nameIReg(index), 1<<scale, nameIReg(dst));
@@ -2440,17 +2496,17 @@ public:
     {
         spew("movswl     %s0x%x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(4, dst));
         m_formatter.twoByteOp(OP2_MOVSX_GvEw, offset, base, dst);
     }
 
     void movswl_mr_disp32(int offset, RegisterID base, RegisterID dst)
     {
-        spew("movswl     %s0x%x(%s), %s",
+        spew("movswl     %s0x%04x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(4, dst));
         m_formatter.twoByteOp_disp32(OP2_MOVSX_GvEw, offset, base, dst);
     }
 
     void movswl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
     {
         spew("movswl     %d(%s,%s,%d), %s",
              offset, nameIReg(base), nameIReg(index), 1<<scale, nameIReg(dst));
@@ -2657,65 +2713,45 @@ public:
         JmpSrc r = m_formatter.immediateRel32();
         spew("j%s        ((%d))",
              nameCC(cond), r.m_offset);
         return r;
     }
 
     // SSE operations:
 
-    void pcmpeqw_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("pcmpeqw    %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PCMPEQW, (RegisterID)src, (RegisterID)dst); /* right order ? */
-    }
-
-    void pcmpeqd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("pcmpeqd    %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PCMPEQD_VdqWdq, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void pcmpeqd_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("pcmpeqd    %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PCMPEQD_VdqWdq, offset, base, (RegisterID)dst);
-    }
-
-    void pcmpeqd_mr(const void* address, XMMRegisterID dst)
-    {
-        spew("pcmpeqd    %p, %s", address, nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PCMPEQD_VdqWdq, address, (RegisterID)dst);
-    }
-
-    void pcmpgtd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("pcmpgtd    %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PCMPGTD_VdqWdq, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void pcmpgtd_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("pcmpgtd    %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PCMPGTD_VdqWdq, offset, base, (RegisterID)dst);
-    }
-
-    void pcmpgtd_mr(const void* address, XMMRegisterID dst)
-    {
-        spew("pcmpgtd    %p, %s",  address, nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PCMPGTD_VdqWdq, address, (RegisterID)dst);
+    void vpcmpeqw_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpcmpeqw", VEX_PD, OP2_PCMPEQW, src1, src0, dst);
+    }
+
+    void vpcmpeqd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpcmpeqd", VEX_PD, OP2_PCMPEQD_VdqWdq, src1, src0, dst);
+    }
+    void vpcmpeqd_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpcmpeqd", VEX_PD, OP2_PCMPEQD_VdqWdq, offset, base, src0, dst);
+    }
+    void vpcmpeqd_mr(const void* address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpcmpeqd", VEX_PD, OP2_PCMPEQD_VdqWdq, address, src0, dst);
+    }
+
+    void vpcmpgtd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpcmpgtd", VEX_PD, OP2_PCMPGTD_VdqWdq, src1, src0, dst);
+    }
+    void vpcmpgtd_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpcmpgtd", VEX_PD, OP2_PCMPGTD_VdqWdq, offset, base, src0, dst);
+    }
+    void vpcmpgtd_mr(const void* address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpcmpgtd", VEX_PD, OP2_PCMPGTD_VdqWdq, address, src0, dst);
     }
 
     void vcmpps_rr(uint8_t order, XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
     {
         twoByteOpSimd("vcmpps", VEX_PS, OP2_CMPPS_VpsWps, src1, src0, dst);
         m_formatter.immediate8(order);
     }
     void vcmpps_mr(uint8_t order, int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
@@ -2724,65 +2760,44 @@ public:
         m_formatter.immediate8(order);
     }
     void vcmpps_mr(uint8_t order, const void* address, XMMRegisterID src0, XMMRegisterID dst)
     {
         twoByteOpSimd("vcmpps", VEX_PS, OP2_CMPPS_VpsWps, address, src0, dst);
         m_formatter.immediate8(order);
     }
 
-    void rcpps_rr(XMMRegisterID src, XMMRegisterID dst){
-        spew("rcpps      %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_RCPPS_VpsWps, (RegisterID)src, (RegisterID)dst);
-    }
-    void rcpps_mr(int offset, RegisterID base, XMMRegisterID dst){
-        spew("rcpps      %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_RCPPS_VpsWps, offset, base, (RegisterID)dst);
-    }
-    void rcpps_mr(const void* address, XMMRegisterID dst){
-        spew("rcpps      %p, %s", address, nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_RCPPS_VpsWps, address, (RegisterID)dst);
-    }
-
-    void rsqrtps_rr(XMMRegisterID src, XMMRegisterID dst){
-        spew("rsqrtps    %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_RSQRTPS_VpsWps, (RegisterID)src, (RegisterID)dst);
-    }
-    void rsqrtps_mr(int offset, RegisterID base, XMMRegisterID dst){
-        spew("rsqrtps    %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_RSQRTPS_VpsWps, offset, base, (RegisterID)dst);
-    }
-    void rsqrtps_mr(const void* address, XMMRegisterID dst){
-        spew("rsqrtps    %p, %s", address, nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_RSQRTPS_VpsWps, address, (RegisterID)dst);
-    }
-
-    void sqrtps_rr(XMMRegisterID src, XMMRegisterID dst){
-        spew("sqrtps     %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_SQRTPS_VpsWps, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void sqrtps_mr(int offset, RegisterID base, XMMRegisterID dst){
-        spew("sqrtps     %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_SQRTPS_VpsWps, offset, base, (RegisterID)dst);
-    }
-
-    void sqrtps_mr(const void* address, XMMRegisterID dst){
-        spew("sqrtps     %p, %s", address, nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_SQRTPS_VpsWps, address, (RegisterID)dst);
-    }
-
-    void addsd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("addsd      %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)src, (RegisterID)dst);
+    void vrcpps_rr(XMMRegisterID src, XMMRegisterID dst) {
+        twoByteOpSimd("vrcpps", VEX_PS, OP2_RCPPS_VpsWps, src, X86Registers::invalid_xmm, dst);
+    }
+    void vrcpps_mr(int offset, RegisterID base, XMMRegisterID dst) {
+        twoByteOpSimd("vrcpps", VEX_PS, OP2_RCPPS_VpsWps, offset, base, X86Registers::invalid_xmm, dst);
+    }
+    void vrcpps_mr(const void* address, XMMRegisterID dst) {
+        twoByteOpSimd("vrcpps", VEX_PS, OP2_RCPPS_VpsWps, address, X86Registers::invalid_xmm, dst);
+    }
+
+    void vrsqrtps_rr(XMMRegisterID src, XMMRegisterID dst) {
+        twoByteOpSimd("vrsqrtps", VEX_PS, OP2_RSQRTPS_VpsWps, src, X86Registers::invalid_xmm, dst);
+    }
+    void vrsqrtps_mr(int offset, RegisterID base, XMMRegisterID dst) {
+        twoByteOpSimd("vrsqrtps", VEX_PS, OP2_RSQRTPS_VpsWps, offset, base, X86Registers::invalid_xmm, dst);
+    }
+    void vrsqrtps_mr(const void* address, XMMRegisterID dst) {
+        twoByteOpSimd("vrsqrtps", VEX_PS, OP2_RSQRTPS_VpsWps, address, X86Registers::invalid_xmm, dst);
+    }
+
+    void vsqrtps_rr(XMMRegisterID src, XMMRegisterID dst) {
+        twoByteOpSimd("vsqrtps", VEX_PS, OP2_SQRTPS_VpsWps, src, X86Registers::invalid_xmm, dst);
+    }
+    void vsqrtps_mr(int offset, RegisterID base, XMMRegisterID dst) {
+        twoByteOpSimd("vsqrtps", VEX_PS, OP2_SQRTPS_VpsWps, offset, base, X86Registers::invalid_xmm, dst);
+    }
+    void vsqrtps_mr(const void* address, XMMRegisterID dst) {
+        twoByteOpSimd("vsqrtps", VEX_PS, OP2_SQRTPS_VpsWps, address, X86Registers::invalid_xmm, dst);
     }
 
     void vaddsd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
     {
         twoByteOpSimd("vaddsd", VEX_SD, OP2_ADDSD_VsdWsd, src1, src0, dst);
     }
 
     void vaddss_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
@@ -2804,167 +2819,168 @@ public:
     {
         twoByteOpSimd("vaddsd", VEX_SD, OP2_ADDSD_VsdWsd, address, src0, dst);
     }
     void vaddss_mr(const void* address, XMMRegisterID src0, XMMRegisterID dst)
     {
         twoByteOpSimd("vaddss", VEX_SS, OP2_ADDSD_VsdWsd, address, src0, dst);
     }
 
-    void cvtss2sd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("cvtss2sd   %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_CVTSS2SD_VsdEd, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void cvtsd2ss_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("cvtsd2ss   %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp(OP2_CVTSD2SS_VsdEd, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void cvtsi2ss_rr(RegisterID src, XMMRegisterID dst)
-    {
-        spew("cvtsi2ss   %s, %s", nameIReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, src, (RegisterID)dst);
-    }
-
-    void cvtsi2sd_rr(RegisterID src, XMMRegisterID dst)
-    {
-        spew("cvtsi2sd   %s, %s", nameIReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, src, (RegisterID)dst);
-    }
-
-    void cvttps2dq_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("cvttps2dq  %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_CVTTPS2DQ_VdqWps, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void cvtdq2ps_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("cvtdq2ps   %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_CVTDQ2PS_VpsWdq, (RegisterID)src, (RegisterID)dst);
+    void vcvtss2sd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vcvtss2sd", VEX_SS, OP2_CVTSS2SD_VsdEd, src1, src0, dst);
+    }
+
+    void vcvtsd2ss_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vcvtsd2ss", VEX_SD, OP2_CVTSD2SS_VsdEd, src1, src0, dst);
+    }
+
+    void vcvtsi2ss_rr(RegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpInt32Simd("vcvtsi2ss", VEX_SS, OP2_CVTSI2SD_VsdEd, src1, src0, dst);
+    }
+
+    void vcvtsi2sd_rr(RegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpInt32Simd("vcvtsi2sd", VEX_SD, OP2_CVTSI2SD_VsdEd, src1, src0, dst);
+    }
+
+    void vcvttps2dq_rr(XMMRegisterID src, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vcvttps2dq", VEX_SS, OP2_CVTTPS2DQ_VdqWps, src, X86Registers::invalid_xmm, dst);
+    }
+
+    void vcvtdq2ps_rr(XMMRegisterID src, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vcvtdq2ps", VEX_PS, OP2_CVTDQ2PS_VpsWdq, src, X86Registers::invalid_xmm, dst);
     }
 
 #ifdef JS_CODEGEN_X64
-    void cvtsq2sd_rr(RegisterID src, XMMRegisterID dst)
-    {
-        spew("cvtsq2sd   %s, %s", nameIReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp64(OP2_CVTSI2SD_VsdEd, src, (RegisterID)dst);
-    }
-    void cvtsq2ss_rr(RegisterID src, XMMRegisterID dst)
-    {
-        spew("cvtsq2ss   %s, %s", nameIReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp64(OP2_CVTSI2SD_VsdEd, src, (RegisterID)dst);
+    void vcvtsq2sd_rr(RegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpInt64Simd("vcvtsi2sd", VEX_SD, OP2_CVTSI2SD_VsdEd, src1, src0, dst);
+    }
+    void vcvtsq2ss_rr(RegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpInt64Simd("vcvtsi2ss", VEX_SS, OP2_CVTSI2SD_VsdEd, src1, src0, dst);
     }
 #endif
 
-    void cvtsi2sd_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("cvtsi2sd   %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, offset, base, (RegisterID)dst);
-    }
-
-    void cvtsi2sd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
-    {
-        spew("cvtsi2sd   %d(%s,%s,%d), %s",
-             offset, nameIReg(base), nameIReg(index), 1<<scale, nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, offset, base, index, scale, (RegisterID)dst);
-    }
-
-    void cvtsi2ss_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("cvtsi2ss   %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, offset, base, (RegisterID)dst);
-    }
-
-    void cvtsi2ss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
-    {
-        spew("cvtsi2ss   %d(%s,%s,%d), %s",
-             offset, nameIReg(base), nameIReg(index), 1<<scale, nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, offset, base, index, scale, (RegisterID)dst);
+    void vcvtsi2sd_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vcvtsi2sd", VEX_SD, OP2_CVTSI2SD_VsdEd, offset, base, src0, dst);
+    }
+
+    void vcvtsi2sd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vcvtsi2sd", VEX_SD, OP2_CVTSI2SD_VsdEd, offset, base, index, scale, src0, dst);
+    }
+
+    void vcvtsi2ss_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vcvtsi2ss", VEX_SS, OP2_CVTSI2SD_VsdEd, offset, base, src0, dst);
+    }
+
+    void vcvtsi2ss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vcvtsi2ss", VEX_SS, OP2_CVTSI2SD_VsdEd, offset, base, index, scale, src0, dst);
     }
 
 #ifdef JS_CODEGEN_X86
-    void cvtsi2sd_mr(const void* address, XMMRegisterID dst)
-    {
-        spew("cvtsi2sd   %p, %s", address, nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, address, (RegisterID)dst);
+    void vcvtsi2sd_mr(const void* address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vcvtsi2sd", VEX_SD, OP2_CVTSI2SD_VsdEd, address, src0, dst);
     }
 #endif
 
-    void cvttsd2si_rr(XMMRegisterID src, RegisterID dst)
-    {
-        spew("cvttsd2si  %s, %s", nameFPReg(src), nameIReg(4, dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp(OP2_CVTTSD2SI_GdWsd, (RegisterID)src, dst);
-    }
-
-    void cvttss2si_rr(XMMRegisterID src, RegisterID dst)
-    {
-        spew("cvttss2si  %s, %s", nameFPReg(src), nameIReg(4, dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_CVTTSD2SI_GdWsd, (RegisterID)src, dst);
+    void vcvttsd2si_rr(XMMRegisterID src, RegisterID dst)
+    {
+        twoByteOpSimdInt32("vcvttsd2si", VEX_SD, OP2_CVTTSD2SI_GdWsd, src, dst);
+    }
+
+    void vcvttss2si_rr(XMMRegisterID src, RegisterID dst)
+    {
+        twoByteOpSimdInt32("vcvttss2si", VEX_SS, OP2_CVTTSD2SI_GdWsd, src, dst);
     }
 
 #ifdef JS_CODEGEN_X64
-    void cvttsd2sq_rr(XMMRegisterID src, RegisterID dst)
-    {
-        spew("cvttsd2si  %s, %s", nameFPReg(src), nameIReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp64(OP2_CVTTSD2SI_GdWsd, (RegisterID)src, dst);
-    }
-
-    void cvttss2sq_rr(XMMRegisterID src, RegisterID dst)
-    {
-        spew("cvttss2si  %s, %s", nameFPReg(src), nameIReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp64(OP2_CVTTSD2SI_GdWsd, (RegisterID)src, dst);
+    void vcvttsd2sq_rr(XMMRegisterID src, RegisterID dst)
+    {
+        twoByteOpSimdInt64("vcvttsd2si", VEX_SD, OP2_CVTTSD2SI_GdWsd, src, dst);
+    }
+
+    void vcvttss2sq_rr(XMMRegisterID src, RegisterID dst)
+    {
+        twoByteOpSimdInt64("vcvttss2si", VEX_SS, OP2_CVTTSD2SI_GdWsd, src, dst);
     }
 #endif
 
-    void unpcklps_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("unpcklps   %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_UNPCKLPS_VsdWsd, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void unpckhps_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("unpckhps   %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_UNPCKHPS_VsdWsd, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void movd_rr(RegisterID src, XMMRegisterID dst)
-    {
-        spew("movd       %s, %s", nameIReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_MOVD_VdEd, src, (RegisterID)dst);
-    }
-
-    void pxor_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("pxor       %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_PXORDQ_VdqWdq, (RegisterID)src, (RegisterID)dst);
+    void vunpcklps_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vunpcklps", VEX_PS, OP2_UNPCKLPS_VsdWsd, src1, src0, dst);
+    }
+
+    void vunpckhps_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vunpckhps", VEX_PS, OP2_UNPCKHPS_VsdWsd, src1, src0, dst);
+    }
+
+    void vmovd_rr(RegisterID src, XMMRegisterID dst)
+    {
+        movdOpSimd(src, dst);
+    }
+
+    void vpand_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpand", VEX_PD, OP2_PANDDQ_VdqWdq, src1, src0, dst);
+    }
+    void vpand_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpand", VEX_PD, OP2_PANDDQ_VdqWdq, offset, base, src0, dst);
+    }
+    void vpand_mr(const void *address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpand", VEX_PD, OP2_PANDDQ_VdqWdq, address, src0, dst);
+    }
+    void vpor_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpor", VEX_PD, OP2_PORDQ_VdqWdq, src1, src0, dst);
+    }
+    void vpor_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpor", VEX_PD, OP2_PORDQ_VdqWdq, offset, base, src0, dst);
+    }
+    void vpor_mr(const void *address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpor", VEX_PD, OP2_PORDQ_VdqWdq, address, src0, dst);
+    }
+    void vpxor_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpxor", VEX_PD, OP2_PXORDQ_VdqWdq, src1, src0, dst);
+    }
+    void vpxor_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpxor", VEX_PD, OP2_PXORDQ_VdqWdq, offset, base, src0, dst);
+    }
+    void vpxor_mr(const void *address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpxor", VEX_PD, OP2_PXORDQ_VdqWdq, address, src0, dst);
+    }
+    void vpandn_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpandn", VEX_PD, OP2_PANDNDQ_VdqWdq, src1, src0, dst);
+    }
+    void vpandn_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpandn", VEX_PD, OP2_PANDNDQ_VdqWdq, offset, base, src0, dst);
+    }
+    void vpandn_mr(const void *address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vpandn", VEX_PD, OP2_PANDNDQ_VdqWdq, address, src0, dst);
     }
 
     void pshufd_irr(uint32_t mask, XMMRegisterID src, XMMRegisterID dst)
     {
         MOZ_ASSERT(mask < 256);
         spew("pshufd     0x%x, %s, %s", mask, nameFPReg(src), nameFPReg(dst));
         m_formatter.prefix(PRE_SSE_66);
         m_formatter.twoByteOp(OP2_PSHUFD_VdqWdqIb, (RegisterID)src, (RegisterID)dst);
@@ -3008,26 +3024,24 @@ public:
 
     void shufps_imr(uint32_t mask, const void* address, XMMRegisterID dst)
     {
         spew("shufps     %x, %p, %s", mask, address, nameFPReg(dst));
         m_formatter.twoByteOp(OP2_SHUFPS_VpsWpsIb, address, (RegisterID)dst);
         m_formatter.immediate8(uint8_t(mask));
     }
 
-    void movhlps_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("movhlps    %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_MOVHLPS_VqUq, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void movlhps_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("movlhps    %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_MOVLHPS_VqUq, (RegisterID)src, (RegisterID)dst);
+    void vmovhlps_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vmovhlps", VEX_PS, OP2_MOVHLPS_VqUq, src1, src0, dst);
+    }
+
+    void vmovlhps_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vmovlhps", VEX_PS, OP2_MOVLHPS_VqUq, src1, src0, dst);
     }
 
     void psrldq_ir(int shift, XMMRegisterID dest)
     {
         spew("psrldq     $%d, %s", shift, nameFPReg(dest));
         m_formatter.prefix(PRE_SSE_66);
         m_formatter.twoByteOp(OP2_PSRLDQ_Vd, (RegisterID)dest, (RegisterID)3);
         m_formatter.immediate8(shift);
@@ -3089,40 +3103,33 @@ public:
     void psrld_ir(int32_t count, XMMRegisterID dst)
     {
         spew("psrld      $%d, %s", count, nameFPReg(dst));
         m_formatter.prefix(PRE_SSE_66);
         m_formatter.twoByteOp(OP2_PSRLD_UdqIb, (RegisterID)dst, (RegisterID)2);
         m_formatter.immediate8(int8_t(count));
     }
 
-    void movmskpd_rr(XMMRegisterID src, RegisterID dst)
-    {
-        spew("movmskpd   %s, %s", nameFPReg(src), nameIReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_MOVMSKPD_EdVd, (RegisterID)src, dst);
-    }
-
-    void movmskps_rr(XMMRegisterID src, RegisterID dst)
-    {
-        spew("movmskps   %s, %s", nameFPReg(src), nameIReg(dst));
-        m_formatter.twoByteOp(OP2_MOVMSKPD_EdVd, (RegisterID)src, dst);
-    }
-
-    void ptest_rr(XMMRegisterID rhs, XMMRegisterID lhs) {
-        spew("ptest      %s, %s", nameFPReg(lhs), nameFPReg(rhs));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.threeByteOp(OP3_PTEST_VdVd, ESCAPE_PTEST, (RegisterID)lhs, (RegisterID)rhs);
-    }
-
-    void movd_rr(XMMRegisterID src, RegisterID dst)
-    {
-        spew("movd       %s, %s", nameFPReg(src), nameIReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_MOVD_EdVd, dst, (RegisterID)src);
+    void vmovmskpd_rr(XMMRegisterID src, RegisterID dst)
+    {
+        twoByteOpSimdInt32("vmovmskpd", VEX_PD, OP2_MOVMSKPD_EdVd, src, dst);
+    }
+
+    void vmovmskps_rr(XMMRegisterID src, RegisterID dst)
+    {
+        twoByteOpSimdInt32("vmovmskps", VEX_PS, OP2_MOVMSKPD_EdVd, src, dst);
+    }
+
+    void vptest_rr(XMMRegisterID rhs, XMMRegisterID lhs) {
+        threeByteOpSimd("vptest", VEX_PD, OP3_PTEST_VdVd, ESCAPE_PTEST, rhs, X86Registers::invalid_xmm, lhs);
+    }
+
+    void vmovd_rr(XMMRegisterID src, RegisterID dst)
+    {
+        movdOpSimd(src, dst);
     }
 
 #ifdef JS_CODEGEN_X64
     void movq_rr(XMMRegisterID src, RegisterID dst)
     {
         spew("movq       %s, %s", nameFPReg(src), nameIReg(dst));
         m_formatter.prefix(PRE_SSE_66);
         m_formatter.twoByteOp64(OP2_MOVD_EdVd, dst, (RegisterID)src);
@@ -3141,49 +3148,49 @@ public:
         spew("movsd      %s, %s0x%x(%s)",
              nameFPReg(src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.prefix(PRE_SSE_F2);
         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, offset, base, (RegisterID)src);
     }
 
     void movsd_rm_disp32(XMMRegisterID src, int offset, RegisterID base)
     {
-        spew("movsd      %s, %s0x%x(%s)",
+        spew("movsd      %s, %s0x%04x(%s)",
              nameFPReg(src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.prefix(PRE_SSE_F2);
         m_formatter.twoByteOp_disp32(OP2_MOVSD_WsdVsd, offset, base, (RegisterID)src);
     }
 
     void movss_rm(XMMRegisterID src, int offset, RegisterID base)
     {
         spew("movss      %s, %s0x%x(%s)",
              nameFPReg(src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.prefix(PRE_SSE_F3);
         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, offset, base, (RegisterID)src);
     }
 
     void movss_rm_disp32(XMMRegisterID src, int offset, RegisterID base)
     {
-        spew("movss      %s, %s0x%x(%s)",
+        spew("movss      %s, %s0x%04x(%s)",
              nameFPReg(src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.prefix(PRE_SSE_F3);
         m_formatter.twoByteOp_disp32(OP2_MOVSD_WsdVsd, offset, base, (RegisterID)src);
     }
 
     void movss_mr(int offset, RegisterID base, XMMRegisterID dst)
     {
         spew("movss      %s0x%x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
         m_formatter.prefix(PRE_SSE_F3);
         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, offset, base, (RegisterID)dst);
     }
 
     void movss_mr_disp32(int offset, RegisterID base, XMMRegisterID dst)
     {
-        spew("movss      %s0x%x(%s), %s",
+        spew("movss      %s0x%04x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
         m_formatter.prefix(PRE_SSE_F3);
         m_formatter.twoByteOp_disp32(OP2_MOVSD_VsdWsd, offset, base, (RegisterID)dst);
     }
 
     void movsd_rm(XMMRegisterID src, int offset, RegisterID base, RegisterID index, int scale)
     {
         spew("movsd      %s, %d(%s,%s,%d)",
@@ -3213,17 +3220,17 @@ public:
         spew("movsd      %s0x%x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
         m_formatter.prefix(PRE_SSE_F2);
         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, offset, base, (RegisterID)dst);
     }
 
     void movsd_mr_disp32(int offset, RegisterID base, XMMRegisterID dst)
     {
-        spew("movsd      %s0x%x(%s), %s",
+        spew("movsd      %s0x%04x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
         m_formatter.prefix(PRE_SSE_F2);
         m_formatter.twoByteOp_disp32(OP2_MOVSD_VsdWsd, offset, base, (RegisterID)dst);
     }
 
     void movsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
     {
         spew("movsd      %d(%s,%s,%d), %s",
@@ -3395,17 +3402,17 @@ public:
     void movups_rm(XMMRegisterID src, int offset, RegisterID base)
     {
         spew("movups     %s, %s0x%x(%s)",
              nameFPReg(src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.twoByteOp(OP2_MOVPS_WpsVps, offset, base, (RegisterID)src);
     }
     void movups_rm_disp32(XMMRegisterID src, int offset, RegisterID base)
     {
-        spew("movups     %s, %s0x%x(%s)",
+        spew("movups     %s, %s0x%04x(%s)",
              nameFPReg(src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.twoByteOp_disp32(OP2_MOVPS_WpsVps, offset, base, (RegisterID)src);
     }
     void movups_rm(XMMRegisterID src, int offset, RegisterID base, RegisterID index, int scale)
     {
         spew("movups     %s, %d(%s,%s,%d)",
              nameFPReg(src), offset, nameIReg(base), nameIReg(index), 1<<scale);
         m_formatter.twoByteOp(OP2_MOVPS_WpsVps, offset, base, index, scale, (RegisterID)src);
@@ -3413,17 +3420,17 @@ public:
     void movups_mr(int offset, RegisterID base, XMMRegisterID dst)
     {
         spew("movups     %s0x%x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
         m_formatter.twoByteOp(OP2_MOVPS_VpsWps, offset, base, (RegisterID)dst);
     }
     void movups_mr_disp32(int offset, RegisterID base, XMMRegisterID dst)
     {
-        spew("movups     %s0x%x(%s), %s",
+        spew("movups     %s0x%04x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
         m_formatter.twoByteOp_disp32(OP2_MOVPS_VpsWps, offset, base, (RegisterID)dst);
     }
     void movups_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
     {
         spew("movups     %d(%s,%s,%d), %s",
              offset, nameIReg(base), nameIReg(index), 1<<scale, nameFPReg(dst));
         m_formatter.twoByteOp(OP2_MOVPS_VpsWps, offset, base, index, scale, (RegisterID)dst);
@@ -3471,17 +3478,17 @@ public:
         spew("movdqu     %s, %s0x%x(%s)",
              nameFPReg(src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.prefix(PRE_SSE_F3);
         m_formatter.twoByteOp(OP2_MOVDQ_WdqVdq, offset, base, (RegisterID)src);
     }
 
     void movdqu_rm_disp32(XMMRegisterID src, int offset, RegisterID base)
     {
-        spew("movdqu     %s, %s0x%x(%s)",
+        spew("movdqu     %s, %s0x%04x(%s)",
              nameFPReg(src), PRETTY_PRINT_OFFSET(offset), nameIReg(base));
         m_formatter.prefix(PRE_SSE_F3);
         m_formatter.twoByteOp_disp32(OP2_MOVDQ_WdqVdq, offset, base, (RegisterID)src);
     }
 
     void movdqu_rm(XMMRegisterID src, int offset, RegisterID base, RegisterID index, int scale)
     {
         spew("movdqu     %s, %d(%s,%s,%d)",
@@ -3495,17 +3502,17 @@ public:
         spew("movdqu     %s0x%x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
         m_formatter.prefix(PRE_SSE_F3);
         m_formatter.twoByteOp(OP2_MOVDQ_VdqWdq, offset, base, (RegisterID)dst);
     }
 
     void movdqu_mr_disp32(int offset, RegisterID base, XMMRegisterID dst)
     {
-        spew("movdqu     %s0x%x(%s), %s",
+        spew("movdqu     %s0x%04x(%s), %s",
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
         m_formatter.prefix(PRE_SSE_F3);
         m_formatter.twoByteOp_disp32(OP2_MOVDQ_VdqWdq, offset, base, (RegisterID)dst);
     }
 
     void movdqu_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
     {
         spew("movdqu     %d(%s,%s,%d), %s",
@@ -3596,35 +3603,29 @@ public:
         twoByteOpSimd("vsubsd", VEX_SD, OP2_SUBSD_VsdWsd, offset, base, src0, dst);
     }
 
     void vsubss_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
     {
         twoByteOpSimd("vsubss", VEX_SS, OP2_SUBSD_VsdWsd, offset, base, src0, dst);
     }
 
-    void ucomiss_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("ucomiss    %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void ucomisd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("ucomisd    %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void ucomisd_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("ucomisd    %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, offset, base, (RegisterID)dst);
+    void vucomiss_rr(XMMRegisterID rhs, XMMRegisterID lhs)
+    {
+        twoByteOpSimdFlags("vucomiss", VEX_PS, OP2_UCOMISD_VsdWsd, rhs, lhs);
+    }
+
+    void vucomisd_rr(XMMRegisterID rhs, XMMRegisterID lhs)
+    {
+        twoByteOpSimdFlags("vucomisd", VEX_PD, OP2_UCOMISD_VsdWsd, rhs, lhs);
+    }
+
+    void vucomisd_mr(int offset, RegisterID base, XMMRegisterID lhs)
+    {
+        twoByteOpSimdFlags("vucomisd", VEX_PD, OP2_UCOMISD_VsdWsd, offset, base, lhs);
     }
 
     void vdivsd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
     {
         twoByteOpSimd("vdivsd", VEX_SD, OP2_DIVSD_VsdWsd, src1, src0, dst);
     }
 
     void vdivss_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
@@ -3637,125 +3638,99 @@ public:
         twoByteOpSimd("vdivsd", VEX_SD, OP2_DIVSD_VsdWsd, offset, base, src0, dst);
     }
 
     void vdivss_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
     {
         twoByteOpSimd("vdivss", VEX_SS, OP2_DIVSD_VsdWsd, offset, base, src0, dst);
     }
 
-    void xorpd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("xorpd      %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_XORPD_VpdWpd, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void orpd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("orpd       %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_ORPD_VpdWpd, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void andpd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("andpd      %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_66);
-        m_formatter.twoByteOp(OP2_ANDPD_VpdWpd, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void andps_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("andps      %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_ANDPS_VpsWps, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void andps_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("andps      %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_ANDPS_VpsWps, offset, base, (RegisterID)dst);
-    }
-
-    void andps_mr(const void* address, XMMRegisterID dst)
-    {
-        spew("andps      %p, %s", address, nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_ANDPS_VpsWps, address, (RegisterID)dst);
-    }
-
-    void andnps_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("andnps     %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_ANDNPS_VpsWps, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void andnps_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("andnps     %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_ANDNPS_VpsWps, offset, base, (RegisterID)dst);
-    }
-
-    void andnps_mr(const void* address, XMMRegisterID dst)
-    {
-        spew("andnps     %p, %s", address, nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_ANDPS_VpsWps, address, (RegisterID)dst);
-    }
-
-    void orps_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("orps       %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_ORPS_VpsWps, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void orps_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("orps       %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_ORPS_VpsWps, offset, base, (RegisterID)dst);
-    }
-
-    void orps_mr(const void* address, XMMRegisterID dst)
-    {
-        spew("orps       %p, %s", address, nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_ORPS_VpsWps, address, (RegisterID)dst);
-    }
-
-    void xorps_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("xorps      %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_XORPS_VpsWps, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void xorps_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("xorps      %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_XORPS_VpsWps, offset, base, (RegisterID)dst);
-    }
-
-    void xorps_mr(const void* address, XMMRegisterID dst)
-    {
-        spew("xorps      %p, %s", address, nameFPReg(dst));
-        m_formatter.twoByteOp(OP2_XORPS_VpsWps, address, (RegisterID)dst);
-    }
-
-    void sqrtsd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("sqrtsd     %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp(OP2_SQRTSD_VsdWsd, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void sqrtss_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("sqrtss     %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_SQRTSS_VssWss, (RegisterID)src, (RegisterID)dst);
+    void vxorpd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vxorpd", VEX_PD, OP2_XORPD_VpdWpd, src1, src0, dst);
+    }
+
+    void vorpd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vorpd", VEX_PD, OP2_ORPD_VpdWpd, src1, src0, dst);
+    }
+
+    void vandpd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vandpd", VEX_PD, OP2_ANDPD_VpdWpd, src1, src0, dst);
+    }
+
+    void vandps_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vandps", VEX_PS, OP2_ANDPS_VpsWps, src1, src0, dst);
+    }
+
+    void vandps_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vandps", VEX_PS, OP2_ANDPS_VpsWps, offset, base, src0, dst);
+    }
+
+    void vandps_mr(const void* address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vandps", VEX_PS, OP2_ANDPS_VpsWps, address, src0, dst);
+    }
+
+    void vandnps_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vandnps", VEX_PS, OP2_ANDNPS_VpsWps, src1, src0, dst);
+    }
+
+    void vandnps_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vandnps", VEX_PS, OP2_ANDNPS_VpsWps, offset, base, src0, dst);
+    }
+
+    void vandnps_mr(const void* address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vandnps", VEX_PS, OP2_ANDNPS_VpsWps, address, src0, dst);
+    }
+
+    void vorps_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vorps", VEX_PS, OP2_ORPS_VpsWps, src1, src0, dst);
+    }
+
+    void vorps_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vorps", VEX_PS, OP2_ORPS_VpsWps, offset, base, src0, dst);
+    }
+
+    void vorps_mr(const void* address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vorps", VEX_PS, OP2_ORPS_VpsWps, address, src0, dst);
+    }
+
+    void vxorps_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vxorps", VEX_PS, OP2_XORPS_VpsWps, src1, src0, dst);
+    }
+
+    void vxorps_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vxorps", VEX_PS, OP2_XORPS_VpsWps, offset, base, src0, dst);
+    }
+
+    void vxorps_mr(const void* address, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vxorps", VEX_PS, OP2_XORPS_VpsWps, address, src0, dst);
+    }
+
+    void vsqrtsd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vsqrtsd", VEX_SD, OP2_SQRTSD_VsdWsd, src1, src0, dst);
+    }
+
+    void vsqrtss_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vsqrtss", VEX_SS, OP2_SQRTSS_VssWss, src1, src0, dst);
     }
 
     void roundsd_rr(RoundingMode mode, XMMRegisterID src, XMMRegisterID dst)
     {
         spew("roundsd    $%d, %s, %s", (int)mode, nameFPReg(src), nameFPReg(dst));
         m_formatter.prefix(PRE_SSE_66);
         m_formatter.threeByteOp(OP3_ROUNDSD_VsdWsd, ESCAPE_ROUNDSD, (RegisterID)src, (RegisterID)dst);
         m_formatter.immediate8(mode);
@@ -3834,88 +3809,60 @@ public:
 
     void vblendvps_rr(XMMRegisterID mask, XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst) {
         vblendvOpSimd(mask, src1, src0, dst);
     }
     void vblendvps_mr(XMMRegisterID mask, int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst) {
         vblendvOpSimd(mask, offset, base, src0, dst);
     }
 
-    void movsldup_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("movsldup   %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_MOVSLDUP_VpsWps, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void movsldup_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("movsldup   %s0x%x(%s), %s", PRETTY_PRINT_OFFSET(offset), nameIReg(base),
-             nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_MOVSLDUP_VpsWps, offset, base, (RegisterID)dst);
-    }
-
-    void movshdup_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("movshdup   %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_MOVSHDUP_VpsWps, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void movshdup_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("movshdup   %s0x%x(%s), %s", PRETTY_PRINT_OFFSET(offset), nameIReg(base),
-             nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_MOVSHDUP_VpsWps, offset, base, (RegisterID)dst);
-    }
-
-    void minsd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("minsd      %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp(OP2_MINSD_VsdWsd, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void minsd_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("minsd      %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp(OP2_MINSD_VsdWsd, offset, base, (RegisterID)dst);
-    }
-
-    void minss_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("minss      %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_MINSS_VssWss, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void maxsd_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("maxsd      %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp(OP2_MAXSD_VsdWsd, (RegisterID)src, (RegisterID)dst);
-    }
-
-    void maxsd_mr(int offset, RegisterID base, XMMRegisterID dst)
-    {
-        spew("maxsd      %s0x%x(%s), %s",
-             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F2);
-        m_formatter.twoByteOp(OP2_MAXSD_VsdWsd, offset, base, (RegisterID)dst);
-    }
-
-    void maxss_rr(XMMRegisterID src, XMMRegisterID dst)
-    {
-        spew("maxss      %s, %s", nameFPReg(src), nameFPReg(dst));
-        m_formatter.prefix(PRE_SSE_F3);
-        m_formatter.twoByteOp(OP2_MAXSS_VssWss, (RegisterID)src, (RegisterID)dst);
+    void vmovsldup_rr(XMMRegisterID src, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vmovsldup", VEX_SS, OP2_MOVSLDUP_VpsWps, src, X86Registers::invalid_xmm, dst);
+    }
+    void vmovsldup_mr(int offset, RegisterID base, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vmovsldup", VEX_SS, OP2_MOVSLDUP_VpsWps, offset, base, X86Registers::invalid_xmm, dst);
+    }
+
+    void vmovshdup_rr(XMMRegisterID src, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vmovshdup", VEX_SS, OP2_MOVSHDUP_VpsWps, src, X86Registers::invalid_xmm, dst);
+    }
+    void vmovshdup_mr(int offset, RegisterID base, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vmovshdup", VEX_SS, OP2_MOVSHDUP_VpsWps, offset, base, X86Registers::invalid_xmm, dst);
+    }
+
+    void vminsd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vminsd", VEX_SD, OP2_MINSD_VsdWsd, src1, src0, dst);
+    }
+    void vminsd_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vminsd", VEX_SD, OP2_MINSD_VsdWsd, offset, base, src0, dst);
+    }
+
+    void vminss_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vminss", VEX_SS, OP2_MINSS_VssWss, src1, src0, dst);
+    }
+
+    void vmaxsd_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vmaxsd", VEX_SD, OP2_MAXSD_VsdWsd, src1, src0, dst);
+    }
+    void vmaxsd_mr(int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vmaxsd", VEX_SD, OP2_MAXSD_VsdWsd, offset, base, src0, dst);
+    }
+
+    void vmaxss_rr(XMMRegisterID src1, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        twoByteOpSimd("vmaxss", VEX_SS, OP2_MAXSS_VssWss, src1, src0, dst);
     }
 
     // Misc instructions:
 
     void int3()
     {
         spew("int3");
         m_formatter.oneByteOp(OP_INT3);
@@ -4267,17 +4214,17 @@ public:
 private:
     // Methods for encoding SIMD instructions via either legacy SSE encoding or
     // VEX encoding.
 
     bool useLegacySSEEncoding(XMMRegisterID src0, XMMRegisterID dst)
     {
         // If we don't have AVX or it's disabled, use the legacy SSE encoding.
         if (!useVEX_) {
-            MOZ_ASSERT(src0 == dst);
+            MOZ_ASSERT(src0 == X86Registers::invalid_xmm || src0 == dst);
             return true;
         }
 
         // If src0 is the same as the output register, we might as well use
         // the legacy SSE encoding, since it is smaller. However, this is only
         // beneficial as long as we're not using ymm registers anywhere.
         return src0 == dst;
     }
@@ -4291,201 +4238,308 @@ private:
             MOZ_ASSERT(src0 == dst);
             MOZ_ASSERT(mask == X86Registers::xmm0);
             return true;
         }
 
         return src0 == dst && mask == X86Registers::xmm0;
     }
 
+    bool useLegacySSEEncodingForOtherOutput()
+    {
+        return !useVEX_;
+    }
+
     const char *legacySSEOpName(const char *name)
     {
         MOZ_ASSERT(name[0] == 'v');
         return name + 1;
     }
 
 #ifdef JS_CODEGEN_X64
     void twoByteRipOpSimd(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
                           int ripOffset, XMMRegisterID src0, XMMRegisterID dst)
     {
         if (useLegacySSEEncoding(src0, dst)) {
-            spew("%-11s?%+d(%%rip), %s", legacySSEOpName(name), ripOffset, nameFPReg(src0));
+            spew("%-11s?%+d(%%rip), %s", legacySSEOpName(name), ripOffset, nameFPReg(dst));
             m_formatter.legacySSEPrefix(ty);
-            m_formatter.twoByteRipOp(opcode, ripOffset, src0);
+            m_formatter.twoByteRipOp(opcode, ripOffset, dst);
             return;
         }
 
         spew("%-11s?%+d(%%rip), %s, %s", name, ripOffset, nameFPReg(src0), nameFPReg(dst));
         m_formatter.twoByteRipOpVex(ty, opcode, ripOffset, src0, dst);
     }
 #endif
 
     void twoByteOpSimd(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
                        XMMRegisterID rm, XMMRegisterID src0, XMMRegisterID dst)
     {
         if (useLegacySSEEncoding(src0, dst)) {
-            spew("%-11s%s, %s", legacySSEOpName(name), nameFPReg(rm), nameFPReg(src0));
+            spew("%-11s%s, %s", legacySSEOpName(name), nameFPReg(rm), nameFPReg(dst));
             m_formatter.legacySSEPrefix(ty);
-            m_formatter.twoByteOp(opcode, (RegisterID)rm, src0);
+            m_formatter.twoByteOp(opcode, (RegisterID)rm, dst);
             return;
         }
 
         spew("%-11s%s, %s, %s", name, nameFPReg(rm), nameFPReg(src0), nameFPReg(dst));
         m_formatter.twoByteOpVex(ty, opcode, (RegisterID)rm, src0, dst);
     }
 
     void twoByteOpSimd(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
                        int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
     {
         if (useLegacySSEEncoding(src0, dst)) {
             spew("%-11s%s0x%x(%s), %s", legacySSEOpName(name),
-                 PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(src0));
+                 PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
             m_formatter.legacySSEPrefix(ty);
-            m_formatter.twoByteOp(opcode, offset, base, src0);
+            m_formatter.twoByteOp(opcode, offset, base, dst);
             return;
         }
 
         spew("%-11s%s0x%x(%s), %s, %s", name,
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(src0), nameFPReg(dst));
         m_formatter.twoByteOpVex(ty, opcode, offset, base, src0, dst);
     }
 
     void twoByteOpSimd_disp32(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
                               int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
     {
         if (useLegacySSEEncoding(src0, dst)) {
-            spew("%-11s%s0x%x(%s), %s", legacySSEOpName(name),
-                 PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(src0));
+            spew("%-11s%s0x%04x(%s), %s", legacySSEOpName(name),
+                 PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
             m_formatter.legacySSEPrefix(ty);
-            m_formatter.twoByteOp_disp32(opcode, offset, base, src0);
+            m_formatter.twoByteOp_disp32(opcode, offset, base, dst);
             return;
         }
 
-        spew("%-11s%s0x%x(%s), %s, %s", name,
+        spew("%-11s%s0x%04x(%s), %s, %s", name,
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(src0), nameFPReg(dst));
         m_formatter.twoByteOpVex_disp32(ty, opcode, offset, base, src0, dst);
     }
 
     void twoByteOpSimd(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
                        int offset, RegisterID base, RegisterID index, int scale,
                        XMMRegisterID src0, XMMRegisterID dst)
     {
         if (useLegacySSEEncoding(src0, dst)) {
             spew("%-11s%s0x%x(%s,%s,%d), %s", legacySSEOpName(name),
                  PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameIReg(index), scale,
-                 nameFPReg(src0));
+                 nameFPReg(dst));
             m_formatter.legacySSEPrefix(ty);
-            m_formatter.twoByteOp(opcode, offset, base, index, scale, src0);
+            m_formatter.twoByteOp(opcode, offset, base, index, scale, dst);
             return;
         }
 
         spew("%-11s%s0x%x(%s,%s,%d), %s, %s", name, PRETTY_PRINT_OFFSET(offset), nameIReg(base),
              nameIReg(index), scale, nameFPReg(src0), nameFPReg(dst));
         m_formatter.twoByteOpVex(ty, opcode, offset, base, index, scale, src0, dst);
     }
 
     void twoByteOpSimd(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
                        const void* address, XMMRegisterID src0, XMMRegisterID dst)
     {
         if (useLegacySSEEncoding(src0, dst)) {
-            spew("%-11s%p, %s", legacySSEOpName(name), address, nameFPReg(src0));
+            spew("%-11s%p, %s", legacySSEOpName(name), address, nameFPReg(dst));
             m_formatter.legacySSEPrefix(ty);
-            m_formatter.twoByteOp(opcode, address, src0);
+            m_formatter.twoByteOp(opcode, address, dst);
             return;
         }
 
         spew("%-11s%p, %s, %s", name, address, nameFPReg(src0), nameFPReg(dst));
         m_formatter.twoByteOpVex(ty, opcode, address, src0, dst);
     }
 
+    void twoByteOpInt32Simd(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
+                            RegisterID rm, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        if (useLegacySSEEncoding(src0, dst)) {
+            spew("%-11s%s, %s", legacySSEOpName(name), nameIReg(4, rm), nameFPReg(dst));
+            m_formatter.legacySSEPrefix(ty);
+            m_formatter.twoByteOp(opcode, rm, dst);
+            return;
+        }
+
+        spew("%-11s%s, %s, %s", name, nameIReg(4, rm), nameFPReg(src0), nameFPReg(dst));
+        m_formatter.twoByteOpVex(ty, opcode, rm, src0, dst);
+    }
+
+#ifdef JS_CODEGEN_X64
+    void twoByteOpInt64Simd(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
+                            RegisterID rm, XMMRegisterID src0, XMMRegisterID dst)
+    {
+        if (useLegacySSEEncoding(src0, dst)) {
+            spew("%-11s%s, %s", legacySSEOpName(name), nameIReg(rm), nameFPReg(dst));
+            m_formatter.legacySSEPrefix(ty);
+            m_formatter.twoByteOp64(opcode, rm, dst);
+            return;
+        }
+
+        spew("%-11s%s, %s, %s", name, nameIReg(rm), nameFPReg(src0), nameFPReg(dst));
+        m_formatter.twoByteOpVex64(ty, opcode, rm, src0, dst);
+    }
+#endif
+
+    void twoByteOpSimdInt32(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
+                            XMMRegisterID rm, RegisterID dst)
+    {
+        if (useLegacySSEEncodingForOtherOutput()) {
+            spew("%-11s%s, %s", legacySSEOpName(name), nameFPReg(rm), nameIReg(4, dst));
+            m_formatter.legacySSEPrefix(ty);
+            m_formatter.twoByteOp(opcode, (RegisterID)rm, dst);
+            return;
+        }
+
+        spew("%-11s%s, %s", name, nameFPReg(rm), nameIReg(4, dst));
+        m_formatter.twoByteOpVex(ty, opcode, (RegisterID)rm, X86Registers::invalid_xmm, dst);
+    }
+
+#ifdef JS_CODEGEN_X64
+    void twoByteOpSimdInt64(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
+                            XMMRegisterID rm, RegisterID dst)
+    {
+        if (useLegacySSEEncodingForOtherOutput()) {
+            spew("%-11s%s, %s", legacySSEOpName(name), nameFPReg(rm), nameIReg(dst));
+            m_formatter.legacySSEPrefix(ty);
+            m_formatter.twoByteOp64(opcode, (RegisterID)rm, dst);
+            return;
+        }
+
+        spew("%-11s%s, %s", name, nameFPReg(rm), nameIReg(dst));
+        m_formatter.twoByteOpVex64(ty, opcode, (RegisterID)rm, X86Registers::invalid_xmm, (XMMRegisterID)dst);
+    }
+#endif
+
+    void twoByteOpSimdFlags(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
+                            XMMRegisterID rm, XMMRegisterID reg)
+    {
+        if (useLegacySSEEncodingForOtherOutput()) {
+            spew("%-11s%s, %s", legacySSEOpName(name), nameFPReg(rm), nameFPReg(reg));
+            m_formatter.legacySSEPrefix(ty);
+            m_formatter.twoByteOp(opcode, (RegisterID)rm, reg);
+            return;
+        }
+
+        spew("%-11s%s, %s", name, nameFPReg(rm), nameFPReg(reg));
+        m_formatter.twoByteOpVex(ty, opcode, (RegisterID)rm, X86Registers::invalid_xmm, (XMMRegisterID)reg);
+    }
+
+    void twoByteOpSimdFlags(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
+                            int offset, RegisterID base, XMMRegisterID reg)
+    {
+        if (useLegacySSEEncodingForOtherOutput()) {
+            spew("%-11s%s0x%x(%s), %s", legacySSEOpName(name),
+                 PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(reg));
+            m_formatter.legacySSEPrefix(ty);
+            m_formatter.twoByteOp(opcode, offset, base, reg);
+            return;
+        }
+
+        spew("%-11s%s0x%x(%s), %s", name,
+             PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(reg));
+        m_formatter.twoByteOpVex(ty, opcode, offset, base, X86Registers::invalid_xmm, (XMMRegisterID)reg);
+    }
+
     void threeByteOpSimd(const char *name, VexOperandType ty, ThreeByteOpcodeID opcode,
                          ThreeByteEscape escape,
                          XMMRegisterID rm, XMMRegisterID src0, XMMRegisterID dst)
     {
         if (useLegacySSEEncoding(src0, dst)) {
-            spew("%-11s%s, %s", legacySSEOpName(name), nameFPReg(rm), nameFPReg(src0));
+            spew("%-11s%s, %s", legacySSEOpName(name), nameFPReg(rm), nameFPReg(dst));
             m_formatter.legacySSEPrefix(ty);
-            m_formatter.threeByteOp(opcode, escape, (RegisterID)rm, src0);
+            m_formatter.threeByteOp(opcode, escape, (RegisterID)rm, dst);
             return;
         }
 
         spew("%-11s%s, %s, %s", name, nameFPReg(rm), nameFPReg(src0), nameFPReg(dst));
         m_formatter.threeByteOpVex(ty, opcode, escape, (RegisterID)rm, src0, dst);
     }
 
     void threeByteOpSimd(const char *name, VexOperandType ty, ThreeByteOpcodeID opcode,
                          ThreeByteEscape escape,
                          int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
     {
         if (useLegacySSEEncoding(src0, dst)) {
             spew("%-11s%s0x%x(%s), %s", legacySSEOpName(name),
-                 PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(src0));
+                 PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
             m_formatter.legacySSEPrefix(ty);
-            m_formatter.threeByteOp(opcode, escape, offset, base, src0);
+            m_formatter.threeByteOp(opcode, escape, offset, base, dst);
             return;
         }
 
         spew("%-11s%s0x%x(%s), %s, %s", name,
              PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(src0), nameFPReg(dst));
         m_formatter.threeByteOpVex(ty, opcode, escape, offset, base, src0, dst);
     }
 
     // Blendv is a three-byte op, but the VEX encoding has a different opcode
     // than the SSE encoding, so we handle it specially.
     void vblendvOpSimd(XMMRegisterID mask, XMMRegisterID rm, XMMRegisterID src0, XMMRegisterID dst)
     {
         if (useLegacySSEEncodingForVblendv(mask, src0, dst)) {
-            spew("blendvps   %s, %s", nameFPReg(rm), nameFPReg(src0));
+            spew("blendvps   %s, %s", nameFPReg(rm), nameFPReg(dst));
             // Even though a "ps" instruction, vblendv is encoded with the "pd" prefix.
             m_formatter.legacySSEPrefix(VEX_PD);
-            m_formatter.threeByteOp(OP3_BLENDVPS_VdqWdq, ESCAPE_BLENDVPS, (RegisterID)rm, src0);
+            m_formatter.threeByteOp(OP3_BLENDVPS_VdqWdq, ESCAPE_BLENDVPS, (RegisterID)rm, dst);
             return;
         }
 
         spew("vblendvps  %s, %s, %s, %s",
              nameFPReg(mask), nameFPReg(rm), nameFPReg(src0), nameFPReg(dst));
         // Even though a "ps" instruction, vblendv is encoded with the "pd" prefix.
         m_formatter.vblendvOpVex(VEX_PD, OP3_VBLENDVPS_VdqWdq, ESCAPE_VBLENDVPS,
                                  mask, (RegisterID)rm, src0, dst);
     }
 
     void vblendvOpSimd(XMMRegisterID mask, int offset, RegisterID base, XMMRegisterID src0, XMMRegisterID dst)
     {
         if (useLegacySSEEncodingForVblendv(mask, src0, dst)) {
             spew("blendvps   %s0x%x(%s), %s",
-                 PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(src0));
+                 PRETTY_PRINT_OFFSET(offset), nameIReg(base), nameFPReg(dst));
             // Even though a "ps" instruction, vblendv is encoded with the "pd" prefix.
             m_formatter.legacySSEPrefix(VEX_PD);
-            m_formatter.threeByteOp(OP3_BLENDVPS_VdqWdq, ESCAPE_BLENDVPS, offset, base, src0);
+            m_formatter.threeByteOp(OP3_BLENDVPS_VdqWdq, ESCAPE_BLENDVPS, offset, base, dst);
             return;
         }
 
         spew("vblendvps  %s, %s0x%x(%s), %s, %s",
              nameFPReg(mask), PRETTY_PRINT_OFFSET(offset), nameIReg(base),
              nameFPReg(src0), nameFPReg(dst));
         // Even though a "ps" instruction, vblendv is encoded with the "pd" prefix.
         m_formatter.vblendvOpVex(VEX_PD, OP3_VBLENDVPS_VdqWdq, ESCAPE_VBLENDVPS,
                                  mask, offset, base, src0, dst);
     }
 
-#ifdef JS_CODEGEN_X64
-    void twoByteOpSimd64(const char *name, VexOperandType ty, TwoByteOpcodeID opcode,
-                         XMMRegisterID rm, XMMRegisterID src0, XMMRegisterID dst)
-    {
-        if (useLegacySSEEncoding(src0, dst)) {
-            spew("%-11s%s, %s", legacySSEOpName(name), nameFPReg(rm), nameFPReg(src0));
-            m_formatter.legacySSEPrefix(ty);
-            m_formatter.twoByteOp64(opcode, (RegisterID)rm, src0);
+    // XMM-to-GPR movd is a two-byte op, but the operands are encoded in reverse
+    // order, so we handle it specially.
+    void movdOpSimd(XMMRegisterID src, RegisterID dst) {
+        if (useLegacySSEEncodingForOtherOutput()) {
+            spew("movd       %s, %s", nameFPReg(src), nameIReg(4, dst));
+            m_formatter.prefix(PRE_SSE_66);
+            m_formatter.twoByteOp(OP2_MOVD_EdVd, dst, (RegisterID)src);
             return;
         }
 
-        spew("%-11s%s, %s, %s", name, nameFPReg(rm), nameFPReg(src0), nameFPReg(dst));
-        m_formatter.twoByteOpVex64(ty, opcode, (RegisterID)rm, src0, dst);
-    }
-#endif
+        spew("vmovd      %s, %s", nameFPReg(src), nameIReg(4, dst));
+        m_formatter.twoByteOpVex(VEX_PD, OP2_MOVD_EdVd, dst, X86Registers::invalid_xmm, src);
+    }
+
+    // GPR-to-XMM movd is a two-byte op, but it doesn't have an extra XMM
+    // input, so we handle it specially.
+    void movdOpSimd(RegisterID src, XMMRegisterID dst) {
+        if (useLegacySSEEncodingForOtherOutput()) {
+            spew("movd       %s, %s", nameIReg(4, src), nameFPReg(dst));
+            m_formatter.prefix(PRE_SSE_66);
+            m_formatter.twoByteOp(OP2_MOVD_VdEd, src, dst);
+            return;
+        }
+
+        spew("vmovd      %s, %s", nameIReg(4, src), nameFPReg(dst));
+        m_formatter.twoByteOpVex(VEX_PD, OP2_MOVD_VdEd, src, X86Registers::invalid_xmm, dst);
+    }
 
     static int32_t getInt32(void* where)
     {
         return reinterpret_cast<int32_t*>(where)[-1];
     }
 
     class X86InstructionFormatter {
 
@@ -5315,24 +5369,31 @@ private:
         {
             memoryModRM_disp32(address, reg);
         }
 
         void threeOpVex(VexOperandType p, int r, int x, int b, int m, int w, int v, int l,
                         int opcode)
         {
             m_buffer.ensureSpace(maxInstructionSize);
-            // Three byte VEX.
-            m_buffer.putByteUnchecked(0xC4);
-            m_buffer.putByteUnchecked(((r << 7) | (x << 6) | (b << 5) | m) ^ 0xe0);
 
             if (v == X86Registers::invalid_xmm)
                 v = XMMRegisterID(0);
 
-            m_buffer.putByteUnchecked(((w << 7) | (v << 3) | (l << 2) | p) ^ 0x78);
+            if (x == 0 && b == 0 && m == 1 && w == 0) {
+                // Two byte VEX.
+                m_buffer.putByteUnchecked(0xC5);
+                m_buffer.putByteUnchecked(((r << 7) | (v << 3) | (l << 2) | p) ^ 0xf8);
+            } else {
+                // Three byte VEX.
+                m_buffer.putByteUnchecked(0xC4);
+                m_buffer.putByteUnchecked(((r << 7) | (x << 6) | (b << 5) | m) ^ 0xe0);
+                m_buffer.putByteUnchecked(((w << 7) | (v << 3) | (l << 2) | p) ^ 0x78);
+            }
+
             m_buffer.putByteUnchecked(opcode);
         }
 
         AssemblerBuffer m_buffer;
     } m_formatter;
 
     bool useVEX_;
 };
--- a/js/src/jit/shared/CodeGenerator-x86-shared.cpp
+++ b/js/src/jit/shared/CodeGenerator-x86-shared.cpp
@@ -111,74 +111,74 @@ CodeGeneratorX86Shared::visitFloat32(LFl
 }
 
 void
 CodeGeneratorX86Shared::visitTestIAndBranch(LTestIAndBranch *test)
 {
     const LAllocation *opd = test->input();
 
     // Test the operand
-    masm.testl(ToRegister(opd), ToRegister(opd));
+    masm.test32(ToRegister(opd), ToRegister(opd));
     emitBranch(Assembler::NonZero, test->ifTrue(), test->ifFalse());
 }
 
 void
 CodeGeneratorX86Shared::visitTestDAndBranch(LTestDAndBranch *test)
 {
     const LAllocation *opd = test->input();
 
-    // ucomisd flags:
+    // vucomisd flags:
     //             Z  P  C
     //            ---------
     //      NaN    1  1  1
     //        >    0  0  0
     //        <    0  0  1
     //        =    1  0  0
     //
     // NaN is falsey, so comparing against 0 and then using the Z flag is
     // enough to determine which branch to take.
     masm.zeroDouble(ScratchDoubleReg);
-    masm.ucomisd(ToFloatRegister(opd), ScratchDoubleReg);
+    masm.vucomisd(ScratchDoubleReg, ToFloatRegister(opd));
     emitBranch(Assembler::NotEqual, test->ifTrue(), test->ifFalse());
 }
 
 void
 CodeGeneratorX86Shared::visitTestFAndBranch(LTestFAndBranch *test)
 {
     const LAllocation *opd = test->input();
-    // ucomiss flags are the same as doubles; see comment above
+    // vucomiss flags are the same as doubles; see comment above
     masm.zeroFloat32(ScratchFloat32Reg);
-    masm.ucomiss(ToFloatRegister(opd), ScratchFloat32Reg);
+    masm.vucomiss(ScratchFloat32Reg, ToFloatRegister(opd));
     emitBranch(Assembler::NotEqual, test->ifTrue(), test->ifFalse());
 }
 
 void
 CodeGeneratorX86Shared::visitBitAndAndBranch(LBitAndAndBranch *baab)
 {
     if (baab->right()->isConstant())
-        masm.testl(ToRegister(baab->left()), Imm32(ToInt32(baab->right())));
+        masm.test32(ToRegister(baab->left()), Imm32(ToInt32(baab->right())));
     else
-        masm.testl(ToRegister(baab->left()), ToRegister(baab->right()));
+        masm.test32(ToRegister(baab->left()), ToRegister(baab->right()));
     emitBranch(Assembler::NonZero, baab->ifTrue(), baab->ifFalse());
 }
 
 void
 CodeGeneratorX86Shared::emitCompare(MCompare::CompareType type, const LAllocation *left, const LAllocation *right)
 {
 #ifdef JS_CODEGEN_X64
     if (type == MCompare::Compare_Object) {
-        masm.cmpq(ToRegister(left), ToOperand(right));
+        masm.cmpPtr(ToRegister(left), ToOperand(right));
         return;
     }
 #endif
 
     if (right->isConstant())
-        masm.cmpl(ToRegister(left), Imm32(ToInt32(right)));
+        masm.cmp32(ToRegister(left), Imm32(ToInt32(right)));
     else
-        masm.cmpl(ToRegister(left), ToOperand(right));
+        masm.cmp32(ToRegister(left), ToOperand(right));
 }
 
 void
 CodeGeneratorX86Shared::visitCompare(LCompare *comp)
 {
     MCompare *mir = comp->mir();
     emitCompare(mir->compareType(), comp->left(), comp->right());
     masm.emitSet(JSOpToCondition(mir->compareType(), comp->jsop()), ToRegister(comp->output()));
@@ -223,17 +223,17 @@ CodeGeneratorX86Shared::visitCompareF(LC
 
     masm.compareFloat(cond, lhs, rhs);
     masm.emitSet(Assembler::ConditionFromDoubleCondition(cond), ToRegister(comp->output()), nanCond);
 }
 
 void
 CodeGeneratorX86Shared::visitNotI(LNotI *ins)
 {
-    masm.cmpl(ToRegister(ins->input()), Imm32(0));
+    masm.cmp32(ToRegister(ins->input()), Imm32(0));
     masm.emitSet(Assembler::Equal, ToRegister(ins->output()));
 }
 
 void
 CodeGeneratorX86Shared::visitNotD(LNotD *ins)
 {
     FloatRegister opd = ToFloatRegister(ins->input());
 
@@ -487,170 +487,170 @@ CodeGeneratorX86Shared::visitMinMaxD(LMi
     FloatRegister second = ToFloatRegister(ins->second());
 #ifdef DEBUG
     FloatRegister output = ToFloatRegister(ins->output());
     MOZ_ASSERT(first == output);
 #endif
 
     Label done, nan, minMaxInst;
 
-    // Do a ucomisd to catch equality and NaNs, which both require special
+    // Do a vucomisd to catch equality and NaNs, which both require special
     // handling. If the operands are ordered and inequal, we branch straight to
     // the min/max instruction. If we wanted, we could also branch for less-than
     // or greater-than here instead of using min/max, however these conditions
     // will sometimes be hard on the branch predictor.
-    masm.ucomisd(first, second);
+    masm.vucomisd(second, first);
     masm.j(Assembler::NotEqual, &minMaxInst);
     if (!ins->mir()->range() || ins->mir()->range()->canBeNaN())
         masm.j(Assembler::Parity, &nan);
 
     // Ordered and equal. The operands are bit-identical unless they are zero
     // and negative zero. These instructions merge the sign bits in that
     // case, and are no-ops otherwise.
     if (ins->mir()->isMax())
-        masm.andpd(second, first);
+        masm.vandpd(second, first, first);
     else
-        masm.orpd(second, first);
+        masm.vorpd(second, first, first);
     masm.jump(&done);
 
     // x86's min/max are not symmetric; if either operand is a NaN, they return
     // the read-only operand. We need to return a NaN if either operand is a
     // NaN, so we explicitly check for a NaN in the read-write operand.
     if (!ins->mir()->range() || ins->mir()->range()->canBeNaN()) {
         masm.bind(&nan);
-        masm.ucomisd(first, first);
+        masm.vucomisd(first, first);
         masm.j(Assembler::Parity, &done);
     }
 
     // When the values are inequal, or second is NaN, x86's min and max will
     // return the value we need.
     masm.bind(&minMaxInst);
     if (ins->mir()->isMax())
-        masm.maxsd(second, first);
+        masm.vmaxsd(second, first, first);
     else
-        masm.minsd(second, first);
+        masm.vminsd(second, first, first);
 
     masm.bind(&done);
 }
 
 void
 CodeGeneratorX86Shared::visitMinMaxF(LMinMaxF *ins)
 {
     FloatRegister first = ToFloatRegister(ins->first());
     FloatRegister second = ToFloatRegister(ins->second());
 #ifdef DEBUG
     FloatRegister output = ToFloatRegister(ins->output());
     MOZ_ASSERT(first == output);
 #endif
 
     Label done, nan, minMaxInst;
 
-    // Do a ucomiss to catch equality and NaNs, which both require special
+    // Do a vucomiss to catch equality and NaNs, which both require special
     // handling. If the operands are ordered and inequal, we branch straight to
     // the min/max instruction. If we wanted, we could also branch for less-than
     // or greater-than here instead of using min/max, however these conditions
     // will sometimes be hard on the branch predictor.
-    masm.ucomiss(first, second);
+    masm.vucomiss(second, first);
     masm.j(Assembler::NotEqual, &minMaxInst);
     if (!ins->mir()->range() || ins->mir()->range()->canBeNaN())
         masm.j(Assembler::Parity, &nan);
 
     // Ordered and equal. The operands are bit-identical unless they are zero
     // and negative zero. These instructions merge the sign bits in that
     // case, and are no-ops otherwise.
     if (ins->mir()->isMax())
-        masm.andps(second, first);
+        masm.vandps(second, first, first);
     else
-        masm.orps(second, first);
+        masm.vorps(second, first, first);
     masm.jump(&done);
 
     // x86's min/max are not symmetric; if either operand is a NaN, they return
     // the read-only operand. We need to return a NaN if either operand is a
     // NaN, so we explicitly check for a NaN in the read-write operand.
     if (!ins->mir()->range() || ins->mir()->range()->canBeNaN()) {
         masm.bind(&nan);
-        masm.ucomiss(first, first);
+        masm.vucomiss(first, first);
         masm.j(Assembler::Parity, &done);
     }
 
     // When the values are inequal, or second is NaN, x86's min and max will
     // return the value we need.
     masm.bind(&minMaxInst);
     if (ins->mir()->isMax())
-        masm.maxss(second, first);
+        masm.vmaxss(second, first, first);
     else
-        masm.minss(second, first);
+        masm.vminss(second, first, first);
 
     masm.bind(&done);
 }
 
 void
 CodeGeneratorX86Shared::visitAbsD(LAbsD *ins)
 {
     FloatRegister input = ToFloatRegister(ins->input());
     MOZ_ASSERT(input == ToFloatRegister(ins->output()));
     // Load a value which is all ones except for the sign bit.
     masm.loadConstantDouble(SpecificNaN<double>(0, FloatingPoint<double>::kSignificandBits),
                             ScratchDoubleReg);
-    masm.andpd(ScratchDoubleReg, input);
+    masm.vandpd(ScratchDoubleReg, input, input);
 }
 
 void
 CodeGeneratorX86Shared::visitAbsF(LAbsF *ins)
 {
     FloatRegister input = ToFloatRegister(ins->input());
     MOZ_ASSERT(input == ToFloatRegister(ins->output()));
     // Same trick as visitAbsD above.
     masm.loadConstantFloat32(SpecificNaN<float>(0, FloatingPoint<float>::kSignificandBits),
                              ScratchFloat32Reg);
-    masm.andps(ScratchFloat32Reg, input);
+    masm.vandps(ScratchFloat32Reg, input, input);
 }
 
 void
 CodeGeneratorX86Shared::visitClzI(LClzI *ins)
 {
     Register input = ToRegister(ins->input());
     Register output = ToRegister(ins->output());
 
     // bsr is undefined on 0
     Label done, nonzero;
     if (!ins->mir()->operandIsNeverZero()) {
-        masm.testl(input, input);
+        masm.test32(input, input);
         masm.j(Assembler::NonZero, &nonzero);
         masm.move32(Imm32(32), output);
         masm.jump(&done);
     }
 
     masm.bind(&nonzero);
     masm.bsr(input, output);
     masm.xor32(Imm32(0x1F), output);
     masm.bind(&done);
 }
 
 void
 CodeGeneratorX86Shared::visitSqrtD(LSqrtD *ins)
 {
     FloatRegister input = ToFloatRegister(ins->input());
     FloatRegister output = ToFloatRegister(ins->output());
-    masm.sqrtsd(input, output);
+    masm.vsqrtsd(input, output, output);
 }
 
 void
 CodeGeneratorX86Shared::visitSqrtF(LSqrtF *ins)
 {
     FloatRegister input = ToFloatRegister(ins->input());
     FloatRegister output = ToFloatRegister(ins->output());
-    masm.sqrtss(input, output);
+    masm.vsqrtss(input, output, output);
 }
 
 void
 CodeGeneratorX86Shared::visitPowHalfD(LPowHalfD *ins)
 {
     FloatRegister input = ToFloatRegister(ins->input());
-    MOZ_ASSERT(input == ToFloatRegister(ins->output()));
+    FloatRegister output = ToFloatRegister(ins->output());
 
     Label done, sqrt;
 
     if (!ins->mir()->operandIsNeverNegativeInfinity()) {
         // Branch if not -Infinity.
         masm.loadConstantDouble(NegativeInfinity<double>(), ScratchDoubleReg);
 
         Assembler::DoubleCondition cond = Assembler::DoubleNotEqualOrUnordered;
@@ -667,17 +667,17 @@ CodeGeneratorX86Shared::visitPowHalfD(LP
     }
 
     if (!ins->mir()->operandIsNeverNegativeZero()) {
         // Math.pow(-0, 0.5) == 0 == Math.pow(0, 0.5). Adding 0 converts any -0 to 0.
         masm.zeroDouble(ScratchDoubleReg);
         masm.addDouble(ScratchDoubleReg, input);
     }
 
-    masm.sqrtsd(input, input);
+    masm.vsqrtsd(input, output, output);
 
     masm.bind(&done);
 }
 
 class OutOfLineUndoALUOperation : public OutOfLineCodeBase<CodeGeneratorX86Shared>
 {
     LInstruction *ins_;
 
@@ -791,17 +791,17 @@ CodeGeneratorX86Shared::visitMulI(LMulI 
     MMul *mul = ins->mir();
     MOZ_ASSERT_IF(mul->mode() == MMul::Integer, !mul->canBeNegativeZero() && !mul->canOverflow());
 
     if (rhs->isConstant()) {
         // Bailout on -0.0
         int32_t constant = ToInt32(rhs);
         if (mul->canBeNegativeZero() && constant <= 0) {
             Assembler::Condition bailoutCond = (constant == 0) ? Assembler::Signed : Assembler::Equal;
-            masm.testl(ToRegister(lhs), ToRegister(lhs));
+            masm.test32(ToRegister(lhs), ToRegister(lhs));
             bailoutIf(bailoutCond, ins->snapshot());
         }
 
         switch (constant) {
           case -1:
             masm.negl(ToOperand(lhs));
             break;
           case 0:
@@ -835,17 +835,17 @@ CodeGeneratorX86Shared::visitMulI(LMulI 
         if (mul->canOverflow())
             bailoutIf(Assembler::Overflow, ins->snapshot());
 
         if (mul->canBeNegativeZero()) {
             // Jump to an OOL path if the result is 0.
             MulNegativeZeroCheck *ool = new(alloc()) MulNegativeZeroCheck(ins);
             addOutOfLineCode(ool, mul);
 
-            masm.testl(ToRegister(lhs), ToRegister(lhs));
+            masm.test32(ToRegister(lhs), ToRegister(lhs));
             masm.j(Assembler::Zero, ool->entry());
             masm.bind(ool->rejoin());
         }
     }
 }
 
 class ReturnZero : public OutOfLineCodeBase<CodeGeneratorX86Shared>
 {
@@ -885,41 +885,41 @@ CodeGeneratorX86Shared::visitUDivOrMod(L
     ReturnZero *ool = nullptr;
 
     // Put the lhs in eax.
     if (lhs != eax)
         masm.mov(lhs, eax);
 
     // Prevent divide by zero.
     if (ins->canBeDivideByZero()) {
-        masm.testl(rhs, rhs);
+        masm.test32(rhs, rhs);
         if (ins->mir()->isTruncated()) {
             if (!ool)
                 ool = new(alloc()) ReturnZero(output);
             masm.j(Assembler::Zero, ool->entry());
         } else {
             bailoutIf(Assembler::Zero, ins->snapshot());
         }
     }
 
     // Zero extend the lhs into edx to make (edx:eax), since udiv is 64-bit.
     masm.mov(ImmWord(0), edx);
     masm.udiv(rhs);
 
     // If the remainder is > 0, bailout since this must be a double.
     if (ins->mir()->isDiv() && !ins->mir()->toDiv()->canTruncateRemainder()) {
         Register remainder = ToRegister(ins->remainder());
-        masm.testl(remainder, remainder);
+        masm.test32(remainder, remainder);
         bailoutIf(Assembler::NonZero, ins->snapshot());
     }
 
     // Unsigned div or mod can return a value that's not a signed int32.
     // If our users aren't expecting that, bail.
     if (!ins->mir()->isTruncated()) {
-        masm.testl(output, output);
+        masm.test32(output, output);
         bailoutIf(Assembler::Signed, ins->snapshot());
     }
 
     if (ool) {
         addOutOfLineCode(ool, ins->mir());
         masm.bind(ool->rejoin());
     }
 }
@@ -953,24 +953,24 @@ CodeGeneratorX86Shared::visitDivPowTwoI(
     MDiv *mir = ins->mir();
 
     // We use defineReuseInput so these should always be the same, which is
     // convenient since all of our instructions here are two-address.
     MOZ_ASSERT(lhs == output);
 
     if (!mir->isTruncated() && negativeDivisor) {
         // 0 divided by a negative number must return a double.
-        masm.testl(lhs, lhs);
+        masm.test32(lhs, lhs);
         bailoutIf(Assembler::Zero, ins->snapshot());
     }
 
     if (shift != 0) {
         if (!mir->isTruncated()) {
             // If the remainder is != 0, bailout since this must be a double.
-            masm.testl(lhs, Imm32(UINT32_MAX >> (32 - shift)));
+            masm.test32(lhs, Imm32(UINT32_MAX >> (32 - shift)));
             bailoutIf(Assembler::NonZero, ins->snapshot());
         }
 
         // Adjust the value so that shifting produces a correctly rounded result
         // when the numerator is negative. See 10-1 "Signed Division by a Known
         // Power of 2" in Henry S. Warren, Jr.'s Hacker's Delight.
         if (mir->canBeNegativeDividend()) {
             Register lhsCopy = ToRegister(ins->numeratorCopy());
@@ -1039,34 +1039,34 @@ CodeGeneratorX86Shared::visitDivOrModCon
         masm.addl(lhs, eax);
     }
 
     if (!ins->mir()->isTruncated()) {
         if (isDiv) {
             // This is a division op. Multiply the obtained value by d to check if
             // the correct answer is an integer. This cannot overflow, since |d| > 1.
             masm.imull(Imm32(d), edx, eax);
-            masm.cmpl(lhs, eax);
+            masm.cmp32(lhs, eax);
             bailoutIf(Assembler::NotEqual, ins->snapshot());
 
             // If lhs is zero and the divisor is negative, the answer should have
             // been -0.
             if (d < 0) {
-                masm.testl(lhs, lhs);
+                masm.test32(lhs, lhs);
                 bailoutIf(Assembler::Zero, ins->snapshot());
             }
         } else if (ins->canBeNegativeDividend()) {
             // This is a mod op. If the computed value is zero and lhs
             // is negative, the answer should have been -0.
             Label done;
 
-            masm.cmpl(lhs, Imm32(0));
+            masm.cmp32(lhs, Imm32(0));
             masm.j(Assembler::GreaterThanOrEqual, &done);
 
-            masm.testl(eax, eax);
+            masm.test32(eax, eax);
             bailoutIf(Assembler::Zero, ins->snapshot());
 
             masm.bind(&done);
         }
     }
 }
 
 void
@@ -1089,64 +1089,64 @@ CodeGeneratorX86Shared::visitDivI(LDivI 
 
     // Put the lhs in eax, for either the negative overflow case or the regular
     // divide case.
     if (lhs != eax)
         masm.mov(lhs, eax);
 
     // Handle divide by zero.
     if (mir->canBeDivideByZero()) {
-        masm.testl(rhs, rhs);
+        masm.test32(rhs, rhs);
         if (mir->canTruncateInfinities()) {
             // Truncated division by zero is zero (Infinity|0 == 0)
             if (!ool)
                 ool = new(alloc()) ReturnZero(output);
             masm.j(Assembler::Zero, ool->entry());
         } else {
             MOZ_ASSERT(mir->fallible());
             bailoutIf(Assembler::Zero, ins->snapshot());
         }
     }
 
     // Handle an integer overflow exception from -2147483648 / -1.
     if (mir->canBeNegativeOverflow()) {
         Label notmin;
-        masm.cmpl(lhs, Imm32(INT32_MIN));
+        masm.cmp32(lhs, Imm32(INT32_MIN));
         masm.j(Assembler::NotEqual, &notmin);
-        masm.cmpl(rhs, Imm32(-1));
+        masm.cmp32(rhs, Imm32(-1));
         if (mir->canTruncateOverflow()) {
             // (-INT32_MIN)|0 == INT32_MIN and INT32_MIN is already in the
             // output register (lhs == eax).
             masm.j(Assembler::Equal, &done);
         } else {
             MOZ_ASSERT(mir->fallible());
             bailoutIf(Assembler::Equal, ins->snapshot());
         }
         masm.bind(&notmin);
     }
 
     // Handle negative 0.
     if (!mir->canTruncateNegativeZero() && mir->canBeNegativeZero()) {
         Label nonzero;
-        masm.testl(lhs, lhs);
+        masm.test32(lhs, lhs);
         masm.j(Assembler::NonZero, &nonzero);
-        masm.cmpl(rhs, Imm32(0));
+        masm.cmp32(rhs, Imm32(0));
         bailoutIf(Assembler::LessThan, ins->snapshot());
         masm.bind(&nonzero);
     }
 
     // Sign extend the lhs into edx to make (edx:eax), since idiv is 64-bit.
     if (lhs != eax)
         masm.mov(lhs, eax);
     masm.cdq();
     masm.idiv(rhs);
 
     if (!mir->canTruncateRemainder()) {
         // If the remainder is > 0, bailout since this must be a double.
-        masm.testl(remainder, remainder);
+        masm.test32(remainder, remainder);
         bailoutIf(Assembler::NonZero, ins->snapshot());
     }
 
     masm.bind(&done);
 
     if (ool) {
         addOutOfLineCode(ool, mir);
         masm.bind(ool->rejoin());
@@ -1217,17 +1217,17 @@ class ModOverflowCheck : public OutOfLin
     Register rhs() const {
         return rhs_;
     }
 };
 
 void
 CodeGeneratorX86Shared::visitModOverflowCheck(ModOverflowCheck *ool)
 {
-    masm.cmpl(ool->rhs(), Imm32(-1));
+    masm.cmp32(ool->rhs(), Imm32(-1));
     if (ool->ins()->mir()->isTruncated()) {
         masm.j(Assembler::NotEqual, ool->rejoin());
         masm.mov(ImmWord(0), edx);
         masm.jmp(ool->done());
     } else {
         bailoutIf(Assembler::Equal, ool->ins()->snapshot());
         masm.jmp(ool->rejoin());
     }
@@ -1251,17 +1251,17 @@ CodeGeneratorX86Shared::visitModI(LModI 
     ModOverflowCheck *overflow = nullptr;
 
     // Set up eax in preparation for doing a div.
     if (lhs != eax)
         masm.mov(lhs, eax);
 
     // Prevent divide by zero.
     if (ins->mir()->canBeDivideByZero()) {
-        masm.testl(rhs, rhs);
+        masm.test32(rhs, rhs);
         if (ins->mir()->isTruncated()) {
             if (!ool)
                 ool = new(alloc()) ReturnZero(edx);
             masm.j(Assembler::Zero, ool->entry());
         } else {
             bailoutIf(Assembler::Zero, ins->snapshot());
         }
     }
@@ -1303,26 +1303,26 @@ CodeGeneratorX86Shared::visitModI(LModI 
     // Otherwise, we have to beware of two special cases:
     if (ins->mir()->canBeNegativeDividend()) {
         masm.jump(&done);
 
         masm.bind(&negative);
 
         // Prevent an integer overflow exception from -2147483648 % -1
         Label notmin;
-        masm.cmpl(lhs, Imm32(INT32_MIN));
+        masm.cmp32(lhs, Imm32(INT32_MIN));
         overflow = new(alloc()) ModOverflowCheck(ins, rhs);
         masm.j(Assembler::Equal, overflow->entry());
         masm.bind(overflow->rejoin());
         masm.cdq();
         masm.idiv(rhs);
 
         if (!ins->mir()->isTruncated()) {
             // A remainder of 0 means that the rval must be -0, which is a double.
-            masm.testl(remainder, remainder);
+            masm.test32(remainder, remainder);
             bailoutIf(Assembler::Zero, ins->snapshot());
         }
     }
 
     masm.bind(&done);
 
     if (overflow) {
         addOutOfLineCode(overflow, ins->mir());
@@ -1391,17 +1391,17 @@ CodeGeneratorX86Shared::visitShiftI(LShi
             if (shift)
                 masm.sarl(Imm32(shift), lhs);
             break;
           case JSOP_URSH:
             if (shift) {
                 masm.shrl(Imm32(shift), lhs);
             } else if (ins->mir()->toUrsh()->fallible()) {
                 // x >>> 0 can overflow.
-                masm.testl(lhs, lhs);
+                masm.test32(lhs, lhs);
                 bailoutIf(Assembler::Signed, ins->snapshot());
             }
             break;
           default:
             MOZ_CRASH("Unexpected shift op");
         }
     } else {
         MOZ_ASSERT(ToRegister(rhs) == ecx);
@@ -1411,17 +1411,17 @@ CodeGeneratorX86Shared::visitShiftI(LShi
             break;
           case JSOP_RSH:
             masm.sarl_cl(lhs);
             break;
           case JSOP_URSH:
             masm.shrl_cl(lhs);
             if (ins->mir()->toUrsh()->fallible()) {
                 // x >>> 0 can overflow.
-                masm.testl(lhs, lhs);
+                masm.test32(lhs, lhs);
                 bailoutIf(Assembler::Signed, ins->snapshot());
             }
             break;
           default:
             MOZ_CRASH("Unexpected shift op");
         }
     }
 }
@@ -1509,17 +1509,17 @@ CodeGeneratorX86Shared::emitTableSwitchD
     Label *defaultcase = skipTrivialBlocks(mir->getDefault())->lir()->label();
 
     // Lower value with low value
     if (mir->low() != 0)
         masm.subl(Imm32(mir->low()), index);
 
     // Jump to default case if input is out of range
     int32_t cases = mir->numCases();
-    masm.cmpl(index, Imm32(cases));
+    masm.cmp32(index, Imm32(cases));
     masm.j(AssemblerX86Shared::AboveOrEqual, defaultcase);
 
     // To fill in the CodeLabels for the case entries, we need to first
     // generate the case entries (we don't yet know their offsets in the
     // instruction stream).
     OutOfLineTableSwitch *ool = new(alloc()) OutOfLineTableSwitch(mir);
     addOutOfLineCode(ool, mir);
 
@@ -1705,17 +1705,17 @@ CodeGeneratorX86Shared::visitCeil(LCeil 
     Label bailout, lessThanMinusOne;
 
     // Bail on ]-1; -0] range
     masm.loadConstantDouble(-1, scratch);
     masm.branchDouble(Assembler::DoubleLessThanOrEqualOrUnordered, input,
                       scratch, &lessThanMinusOne);
 
     // Test for remaining values with the sign bit set, i.e. ]-1; -0]
-    masm.movmskpd(input, output);
+    masm.vmovmskpd(input, output);
     masm.branchTest32(Assembler::NonZero, output, Imm32(1), &bailout);
     bailoutFrom(&bailout, lir->snapshot());
 
     if (AssemblerX86Shared::HasSSE41()) {
         // x <= -1 or x > -0
         masm.bind(&lessThanMinusOne);
         // Round toward +Infinity.
         masm.roundsd(X86Assembler::RoundUp, input, scratch);
@@ -1757,17 +1757,17 @@ CodeGeneratorX86Shared::visitCeilF(LCeil
     Label bailout, lessThanMinusOne;
 
     // Bail on ]-1; -0] range
     masm.loadConstantFloat32(-1.f, scratch);
     masm.branchFloat(Assembler::DoubleLessThanOrEqualOrUnordered, input,
                      scratch, &lessThanMinusOne);
 
     // Test for remaining values with the sign bit set, i.e. ]-1; -0]
-    masm.movmskps(input, output);
+    masm.vmovmskps(input, output);
     masm.branchTest32(Assembler::NonZero, output, Imm32(1), &bailout);
     bailoutFrom(&bailout, lir->snapshot());
 
     if (AssemblerX86Shared::HasSSE41()) {
         // x <= -1 or x > -0
         masm.bind(&lessThanMinusOne);
         // Round toward +Infinity.
         masm.roundss(X86Assembler::RoundUp, input, scratch);
@@ -1847,17 +1847,17 @@ CodeGeneratorX86Shared::visitRound(LRoun
         masm.addDouble(input, temp);
         masm.roundsd(X86Assembler::RoundDown, temp, scratch);
 
         // Truncate.
         bailoutCvttsd2si(scratch, output, lir->snapshot());
 
         // If the result is positive zero, then the actual result is -0. Bail.
         // Otherwise, the truncation will have produced the correct negative integer.
-        masm.testl(output, output);
+        masm.test32(output, output);
         bailoutIf(Assembler::Zero, lir->snapshot());
     } else {
         masm.addDouble(input, temp);
 
         // Round toward -Infinity without the benefit of ROUNDSD.
         {
             // If input + 0.5 >= 0, input is a negative number >= -0.5 and the result is -0.
             masm.compareDouble(Assembler::DoubleGreaterThanOrEqual, temp, scratch);
@@ -1930,17 +1930,17 @@ CodeGeneratorX86Shared::visitRoundF(LRou
         masm.addFloat32(input, temp);
         masm.roundss(X86Assembler::RoundDown, temp, scratch);
 
         // Truncate.
         bailoutCvttss2si(scratch, output, lir->snapshot());
 
         // If the result is positive zero, then the actual result is -0. Bail.
         // Otherwise, the truncation will have produced the correct negative integer.
-        masm.testl(output, output);
+        masm.test32(output, output);
         bailoutIf(Assembler::Zero, lir->snapshot());
     } else {
         masm.addFloat32(input, temp);
         // Round toward -Infinity without the benefit of ROUNDSS.
         {
             // If input + 0.5 >= 0, input is a negative number >= -0.5 and the result is -0.
             masm.compareFloat(Assembler::DoubleGreaterThanOrEqual, temp, scratch);
             bailoutIf(Assembler::DoubleGreaterThanOrEqual, lir->snapshot());
@@ -2085,17 +2085,17 @@ CodeGeneratorX86Shared::visitFloat32x4To
 
 void
 CodeGeneratorX86Shared::visitSimdValueInt32x4(LSimdValueInt32x4 *ins)
 {
     MOZ_ASSERT(ins->mir()->type() == MIRType_Int32x4);
 
     FloatRegister output = ToFloatRegister(ins->output());
     if (AssemblerX86Shared::HasSSE41()) {
-        masm.movd(ToRegister(ins->getOperand(0)), output);
+        masm.vmovd(ToRegister(ins->getOperand(0)), output);
         for (size_t i = 1; i < 4; ++i) {
             Register r = ToRegister(ins->getOperand(i));
             masm.pinsrd(i, r, output);
         }
         return;
     }
 
     masm.reserveStack(Simd128DataSize);
@@ -2114,34 +2114,34 @@ CodeGeneratorX86Shared::visitSimdValueFl
 
     FloatRegister r0 = ToFloatRegister(ins->getOperand(0));
     MOZ_ASSERT(r0 == ToFloatRegister(ins->output())); // defineReuseInput(0)
 
     FloatRegister r1 = ToFloatRegister(ins->getTemp(0));
     FloatRegister r2 = ToFloatRegister(ins->getOperand(2));
     FloatRegister r3 = ToFloatRegister(ins->getOperand(3));
 
-    masm.unpcklps(r3, r1);
-    masm.unpcklps(r2, r0);
-    masm.unpcklps(r1, r0);
+    masm.vunpcklps(r3, r1, r1);
+    masm.vunpcklps(r2, r0, r0);
+    masm.vunpcklps(r1, r0, r0);
 }
 
 void
 CodeGeneratorX86Shared::visitSimdSplatX4(LSimdSplatX4 *ins)
 {
     FloatRegister output = ToFloatRegister(ins->output());
 
     MSimdSplatX4 *mir = ins->mir();
     MOZ_ASSERT(IsSimdType(mir->type()));
     JS_STATIC_ASSERT(sizeof(float) == sizeof(int32_t));
 
     switch (mir->type()) {
       case MIRType_Int32x4: {
         Register r = ToRegister(ins->getOperand(0));
-        masm.movd(r, output);
+        masm.vmovd(r, output);
         masm.pshufd(0, output, output);
         break;
       }
       case MIRType_Float32x4: {
         FloatRegister r = ToFloatRegister(ins->getOperand(0));
         MOZ_ASSERT(r == output);
         masm.shufps(0, r, output);
         break;
@@ -2195,18 +2195,18 @@ CodeGeneratorX86Shared::visitSimdInsertE
 {
     FloatRegister vector = ToFloatRegister(ins->vector());
     Register value = ToRegister(ins->value());
     FloatRegister output = ToFloatRegister(ins->output());
     MOZ_ASSERT(vector == output); // defineReuseInput(0)
 
     unsigned component = unsigned(ins->lane());
 
-    // Note that, contrarily to float32x4, we cannot use movd if the inserted
-    // value goes into the first component, as movd clears out the higher lanes
+    // Note that, contrarily to float32x4, we cannot use vmovd if the inserted
+    // value goes into the first component, as vmovd clears out the higher lanes
     // of the output.
     if (AssemblerX86Shared::HasSSE41()) {
         masm.pinsrd(component, value, output);
         return;
     }
 
     masm.reserveStack(Simd128DataSize);
     masm.storeAlignedInt32x4(vector, Address(StackPointer, 0));
@@ -2247,17 +2247,17 @@ CodeGeneratorX86Shared::visitSimdInsertE
 
 void
 CodeGeneratorX86Shared::visitSimdSignMaskX4(LSimdSignMaskX4 *ins)
 {
     FloatRegister input = ToFloatRegister(ins->input());
     Register output = ToRegister(ins->output());
 
     // For Float32x4 and Int32x4.
-    masm.movmskps(input, output);
+    masm.vmovmskps(input, output);
 }
 
 void
 CodeGeneratorX86Shared::visitSimdSwizzleI(LSimdSwizzleI *ins)
 {
     FloatRegister input = ToFloatRegister(ins->input());
     FloatRegister output = ToFloatRegister(ins->output());
 
@@ -2278,48 +2278,48 @@ CodeGeneratorX86Shared::visitSimdSwizzle
 
     uint32_t x = ins->laneX();
     uint32_t y = ins->laneY();
     uint32_t z = ins->laneZ();
     uint32_t w = ins->laneW();
 
     if (AssemblerX86Shared::HasSSE3()) {
         if (ins->lanesMatch(0, 0, 2, 2)) {
-            masm.movsldup(input, output);
+            masm.vmovsldup(input, output);
             return;
         }
         if (ins->lanesMatch(1, 1, 3, 3)) {
-            masm.movshdup(input, output);
+            masm.vmovshdup(input, output);
             return;
         }
     }
 
     // TODO Here and below, arch specific lowering could identify this pattern
     // and use defineReuseInput to avoid this move (bug 1084404)
     if (ins->lanesMatch(2, 3, 2, 3)) {
-        masm.movaps(input, output);
-        masm.movhlps(input, output);
+        FloatRegister inputCopy = masm.reusedInputFloat32x4(input, output);
+        masm.vmovhlps(input, inputCopy, output);
         return;
     }
 
     if (ins->lanesMatch(0, 1, 0, 1)) {
-        masm.movaps(input, output);
-        masm.movlhps(input, output);
+        FloatRegister inputCopy = masm.reusedInputFloat32x4(input, output);
+        masm.vmovlhps(input, inputCopy, output);
         return;
     }
 
     if (ins->lanesMatch(0, 0, 1, 1)) {
-        masm.movaps(input, output);
-        masm.unpcklps(input, output);
+        FloatRegister inputCopy = masm.reusedInputFloat32x4(input, output);
+        masm.vunpcklps(input, inputCopy, output);
         return;
     }
 
     if (ins->lanesMatch(2, 2, 3, 3)) {
-        masm.movaps(input, output);
-        masm.unpckhps(input, output);
+        FloatRegister inputCopy = masm.reusedInputFloat32x4(input, output);
+        masm.vunpckhps(input, inputCopy, output);
         return;
     }
 
     uint32_t mask = MacroAssembler::ComputeShuffleMask(x, y, z, w);
     masm.shuffleFloat32(mask, input, output);
 }
 
 void
@@ -2442,50 +2442,62 @@ CodeGeneratorX86Shared::visitSimdShuffle
     }
 
     // Two elements from one vector, two other elements from the other
     MOZ_ASSERT(numLanesFromLHS == 2);
 
     // TODO Here and below, symmetric case would be more handy to avoid a move,
     // but can't be reached because operands would get swapped (bug 1084404).
     if (ins->lanesMatch(2, 3, 6, 7)) {
-        masm.movaps(rhs, ScratchSimdReg);
-        masm.movhlps(lhs, ScratchSimdReg);
-        masm.movaps(ScratchSimdReg, out);
+        if (AssemblerX86Shared::HasAVX()) {
+            masm.vmovhlps(lhs, rhs, out);
+        } else {
+            masm.movaps(rhs, ScratchSimdReg);
+            masm.vmovhlps(lhs, ScratchSimdReg, ScratchSimdReg);
+            masm.movaps(ScratchSimdReg, out);
+        }
         return;
     }
 
     if (ins->lanesMatch(0, 1, 4, 5)) {
-        masm.movlhps(rhs, lhs);
+        masm.vmovlhps(rhs, lhs, out);
         return;
     }
 
     if (ins->lanesMatch(0, 4, 1, 5)) {
-        masm.unpcklps(rhs, lhs);
+        masm.vunpcklps(rhs, lhs, out);
         return;
     }
 
     // TODO swapped case would be better (bug 1084404)
     if (ins->lanesMatch(4, 0, 5, 1)) {
-        masm.movaps(rhs, ScratchSimdReg);
-        masm.unpcklps(lhs, ScratchSimdReg);
-        masm.movaps(ScratchSimdReg, out);
+        if (AssemblerX86Shared::HasAVX()) {
+            masm.vunpcklps(lhs, rhs, out);
+        } else {
+            masm.movaps(rhs, ScratchSimdReg);
+            masm.vunpcklps(lhs, ScratchSimdReg, ScratchSimdReg);
+            masm.movaps(ScratchSimdReg, out);
+        }
         return;
     }
 
     if (ins->lanesMatch(2, 6, 3, 7)) {
-        masm.unpckhps(rhs, lhs);
+        masm.vunpckhps(rhs, lhs, lhs);
         return;
     }
 
     // TODO swapped case would be better (bug 1084404)
     if (ins->lanesMatch(6, 2, 7, 3)) {
-        masm.movaps(rhs, ScratchSimdReg);
-        masm.unpckhps(lhs, ScratchSimdReg);
-        masm.movaps(ScratchSimdReg, out);
+        if (AssemblerX86Shared::HasAVX()) {
+            masm.vunpckhps(lhs, rhs, out);
+        } else {
+            masm.movaps(rhs, ScratchSimdReg);
+            masm.vunpckhps(lhs, ScratchSimdReg, ScratchSimdReg);
+            masm.movaps(ScratchSimdReg, out);
+        }
         return;
     }
 
     // In one shufps
     if (x < 4 && y < 4) {
         mask = MacroAssembler::ComputeShuffleMask(x, y, z % 4, w % 4);
         masm.shufps(mask, rhs, out);
         return;
@@ -2611,25 +2623,25 @@ CodeGeneratorX86Shared::visitSimdBinaryC
     MOZ_CRASH("unexpected SIMD op");
 }
 
 void
 CodeGeneratorX86Shared::visitSimdBinaryArithIx4(LSimdBinaryArithIx4 *ins)
 {
     FloatRegister lhs = ToFloatRegister(ins->lhs());
     Operand rhs = ToOperand(ins->rhs());
-    MOZ_ASSERT(ToFloatRegister(ins->output()) == lhs);
+    FloatRegister output = ToFloatRegister(ins->output());
 
     MSimdBinaryArith::Operation op = ins->operation();
     switch (op) {
       case MSimdBinaryArith::Add:
-        masm.packedAddInt32(rhs, lhs);
+        masm.vpaddd(rhs, lhs, output);
         return;
       case MSimdBinaryArith::Sub:
-        masm.packedSubInt32(rhs, lhs);
+        masm.vpsubd(rhs, lhs, output);
         return;
       case MSimdBinaryArith::Mul: {
         if (AssemblerX86Shared::HasSSE41()) {
             masm.pmulld(rhs, lhs);
             return;
         }
 
         masm.loadAlignedInt32x4(rhs, ScratchSimdReg);
@@ -2690,88 +2702,88 @@ CodeGeneratorX86Shared::visitSimdBinaryA
         FloatRegister lhsCopy = masm.reusedInputFloat32x4(lhs, ScratchSimdReg);
         masm.vcmpunordps(rhs, lhsCopy, ScratchSimdReg);
 
         FloatRegister tmp = ToFloatRegister(ins->temp());
         FloatRegister rhsCopy = masm.reusedInputAlignedFloat32x4(rhs, tmp);
         masm.vmaxps(Operand(lhs), rhsCopy, tmp);
         masm.vmaxps(rhs, lhs, output);
 
-        masm.andps(tmp, output);
-        masm.orps(ScratchSimdReg, output); // or in the all-ones NaNs
+        masm.vandps(tmp, output, output);
+        masm.vorps(ScratchSimdReg, output, output); // or in the all-ones NaNs
         return;
       }
       case MSimdBinaryArith::Min: {
         FloatRegister rhsCopy = masm.reusedInputAlignedFloat32x4(rhs, ScratchSimdReg);
         masm.vminps(Operand(lhs), rhsCopy, ScratchSimdReg);
         masm.vminps(rhs, lhs, output);
-        masm.orps(ScratchSimdReg, output); // NaN or'd with arbitrary bits is NaN
+        masm.vorps(ScratchSimdReg, output, output); // NaN or'd with arbitrary bits is NaN
         return;
       }
       case MSimdBinaryArith::MinNum: {
         FloatRegister tmp = ToFloatRegister(ins->temp());
-        masm.loadConstantInt32x4(SimdConstant::SplatX4(int32_t(0x80000000)), ScratchSimdReg);
-        masm.movdqa(ScratchSimdReg, tmp);
+        masm.loadConstantInt32x4(SimdConstant::SplatX4(int32_t(0x80000000)), tmp);
 
         FloatRegister mask = ScratchSimdReg;
-        masm.pcmpeqd(Operand(lhs), mask);
-        masm.andps(tmp, mask);
+        FloatRegister tmpCopy = masm.reusedInputFloat32x4(tmp, ScratchSimdReg);
+        masm.vpcmpeqd(Operand(lhs), tmpCopy, mask);
+        masm.vandps(tmp, mask, mask);
 
         FloatRegister lhsCopy = masm.reusedInputFloat32x4(lhs, tmp);
         masm.vminps(rhs, lhsCopy, tmp);
-        masm.orps(mask, tmp);
+        masm.vorps(mask, tmp, tmp);
 
         FloatRegister rhsCopy = masm.reusedInputAlignedFloat32x4(rhs, mask);
         masm.vcmpneqps(rhs, rhsCopy, mask);
 
         if (AssemblerX86Shared::HasAVX()) {
             masm.vblendvps(mask, lhs, tmp, output);
         } else {
             // Emulate vblendvps.
             // With SSE.4.1 we could use blendvps, however it's awkward since
             // it requires the mask to be in xmm0.
             if (lhs != output)
                 masm.movaps(lhs, output);
-            masm.andps(Operand(mask), output);
-            masm.andnps(Operand(tmp), mask);
-            masm.orps(Operand(mask), output);
+            masm.vandps(Operand(mask), output, output);
+            masm.vandnps(Operand(tmp), mask, mask);
+            masm.vorps(Operand(mask), output, output);
         }
         return;
       }
       case MSimdBinaryArith::MaxNum: {
         FloatRegister mask = ScratchSimdReg;
         masm.loadConstantInt32x4(SimdConstant::SplatX4(0), mask);
-        masm.pcmpeqd(Operand(lhs), mask);
+        masm.vpcmpeqd(Operand(lhs), mask, mask);
 
         FloatRegister tmp = ToFloatRegister(ins->temp());
         masm.loadConstantInt32x4(SimdConstant::SplatX4(int32_t(0x80000000)), tmp);
-        masm.andps(tmp, mask);
+        masm.vandps(tmp, mask, mask);
 
         FloatRegister lhsCopy = masm.reusedInputFloat32x4(lhs, tmp);
         masm.vmaxps(rhs, lhsCopy, tmp);
-        masm.andnps(Operand(tmp), mask);
+        masm.vandnps(Operand(tmp), mask, mask);
 
         // Ensure tmp always contains the temporary result
         mask = tmp;
         tmp = ScratchSimdReg;
 
         FloatRegister rhsCopy = masm.reusedInputAlignedFloat32x4(rhs, mask);
         masm.vcmpneqps(rhs, rhsCopy, mask);
 
         if (AssemblerX86Shared::HasAVX()) {
             masm.vblendvps(mask, lhs, tmp, output);
         } else {
             // Emulate vblendvps.
             // With SSE.4.1 we could use blendvps, however it's awkward since
             // it requires the mask to be in xmm0.
             if (lhs != output)
                 masm.movaps(lhs, output);
-            masm.andps(Operand(mask), output);
-            masm.andnps(Operand(tmp), mask);
-            masm.orps(Operand(mask), output);
+            masm.vandps(Operand(mask), output, output);
+            masm.vandnps(Operand(tmp), mask, mask);
+            masm.vorps(Operand(mask), output, output);
         }
         return;
       }
     }
     MOZ_CRASH("unexpected SIMD op");
 }
 
 void
@@ -2779,17 +2791,17 @@ CodeGeneratorX86Shared::visitSimdUnaryAr
 {
     Operand in = ToOperand(ins->input());
     FloatRegister out = ToFloatRegister(ins->output());
 
     static const SimdConstant allOnes = SimdConstant::CreateX4(-1, -1, -1, -1);
 
     switch (ins->operation()) {
       case MSimdUnaryArith::neg:
-        masm.pxor(out, out);
+        masm.zeroInt32x4(out);
         masm.packedSubInt32(in, out);
         return;
       case MSimdUnaryArith::not_:
         masm.loadConstantInt32x4(allOnes, out);
         masm.bitwiseXorX4(in, out);
         return;
       case MSimdUnaryArith::abs:
       case MSimdUnaryArith::reciprocal:
@@ -2843,28 +2855,37 @@ CodeGeneratorX86Shared::visitSimdUnaryAr
     MOZ_CRASH("unexpected SIMD op");
 }
 
 void
 CodeGeneratorX86Shared::visitSimdBinaryBitwiseX4(LSimdBinaryBitwiseX4 *ins)
 {
     FloatRegister lhs = ToFloatRegister(ins->lhs());
     Operand rhs = ToOperand(ins->rhs());
-    MOZ_ASSERT(ToFloatRegister(ins->output()) == lhs);
+    FloatRegister output = ToFloatRegister(ins->output());
 
     MSimdBinaryBitwise::Operation op = ins->operation();
     switch (op) {
       case MSimdBinaryBitwise::and_:
-        masm.bitwiseAndX4(rhs, lhs);
+        if (ins->type() == MIRType_Float32x4)
+            masm.vandps(rhs, lhs, output);
+        else
+            masm.vpand(rhs, lhs, output);
         return;
       case MSimdBinaryBitwise::or_:
-        masm.bitwiseOrX4(rhs, lhs);
+        if (ins->type() == MIRType_Float32x4)
+            masm.vorps(rhs, lhs, output);
+        else
+            masm.vpor(rhs, lhs, output);
         return;
       case MSimdBinaryBitwise::xor_:
-        masm.bitwiseXorX4(rhs, lhs);
+        if (ins->type() == MIRType_Float32x4)
+            masm.vxorps(rhs, lhs, output);
+        else
+            masm.vpxor(rhs, lhs, output);
         return;
     }
     MOZ_CRASH("unexpected SIMD bitwise op");
 }
 
 void
 CodeGeneratorX86Shared::visitSimdShift(LSimdShift *ins)
 {
@@ -2891,17 +2912,17 @@ CodeGeneratorX86Shared::visitSimdShift(L
             masm.packedUnsignedRightShiftByScalar(count, out);
             return;
         }
         MOZ_CRASH("unexpected SIMD bitwise op");
     }
 
     MOZ_ASSERT(val->isRegister());
     FloatRegister tmp = ScratchFloat32Reg;
-    masm.movd(ToRegister(val), tmp);
+    masm.vmovd(ToRegister(val), tmp);
 
     switch (ins->operation()) {
       case MSimdShift::lsh:
         masm.packedLeftShiftByScalar(tmp, out);
         return;
       case MSimdShift::rsh:
         masm.packedRightShiftByScalar(tmp, out);
         return;
--- a/js/src/jit/shared/CodeGenerator-x86-shared.h
+++ b/js/src/jit/shared/CodeGenerator-x86-shared.h
@@ -95,27 +95,27 @@ class CodeGeneratorX86Shared : public Co
         masm.test32(lhs, rhs);
         bailoutIf(c, snapshot);
     }
     void bailoutIfFalseBool(Register reg, LSnapshot *snapshot) {
         masm.test32(reg, Imm32(0xFF));
         bailoutIf(Assembler::Zero, snapshot);
     }
     void bailoutCvttsd2si(FloatRegister src, Register dest, LSnapshot *snapshot) {
-        // cvttsd2si returns 0x80000000 on failure. Test for it by
+        // vcvttsd2si returns 0x80000000 on failure. Test for it by
         // subtracting 1 and testing overflow. The other possibility is to test
         // equality for INT_MIN after a comparison, but 1 costs fewer bytes to
         // materialize.
-        masm.cvttsd2si(src, dest);
+        masm.vcvttsd2si(src, dest);
         masm.cmp32(dest, Imm32(1));
         bailoutIf(Assembler::Overflow, snapshot);
     }
     void bailoutCvttss2si(FloatRegister src, Register dest, LSnapshot *snapshot) {
         // Same trick as explained in the above comment.
-        masm.cvttss2si(src, dest);
+        masm.vcvttss2si(src, dest);
         masm.cmp32(dest, Imm32(1));
         bailoutIf(Assembler::Overflow, snapshot);
     }
 
   protected:
     bool generatePrologue();
     bool generateEpilogue();
     bool generateOutOfLineCode();
--- a/js/src/jit/shared/Lowering-x86-shared.cpp
+++ b/js/src/jit/shared/Lowering-x86-shared.cpp
@@ -55,17 +55,17 @@ LIRGeneratorX86Shared::visitGuardObjectT
 }
 
 void
 LIRGeneratorX86Shared::visitPowHalf(MPowHalf *ins)
 {
     MDefinition *input = ins->input();
     MOZ_ASSERT(input->type() == MIRType_Double);
     LPowHalfD *lir = new(alloc()) LPowHalfD(useRegisterAtStart(input));
-    defineReuseInput(lir, ins, 0);
+    define(lir, ins);
 }
 
 void
 LIRGeneratorX86Shared::lowerForShift(LInstructionHelper<1, 2, 0> *ins, MDefinition *mir,
                                      MDefinition *lhs, MDefinition *rhs)
 {
     ins->setOperand(0, useRegisterAtStart(lhs));
 
@@ -91,39 +91,23 @@ void
 LIRGeneratorX86Shared::lowerForALU(LInstructionHelper<1, 2, 0> *ins, MDefinition *mir,
                                    MDefinition *lhs, MDefinition *rhs)
 {
     ins->setOperand(0, useRegisterAtStart(lhs));
     ins->setOperand(1, lhs != rhs ? useOrConstant(rhs) : useOrConstantAtStart(rhs));
     defineReuseInput(ins, mir, 0);
 }
 
-static bool
-UseAVXEncoding(MIRType type)
-{
-    if (!Assembler::HasAVX())
-        return false;
-
-    // TODO: For now, we just do this for floating-point types, until the rest
-    // of the assembler support is done.
-    if (IsFloatingPointType(type))
-        return true;
-    if (IsSimdType(type) && IsFloatingPointType(SimdTypeToScalarType(type)))
-        return true;
-
-    return false;
-}
-
 template<size_t Temps>
 void
 LIRGeneratorX86Shared::lowerForFPU(LInstructionHelper<1, 2, Temps> *ins, MDefinition *mir, MDefinition *lhs, MDefinition *rhs)
 {
     // Without AVX, we'll need to use the x86 encodings where one of the
     // inputs must be the same location as the output.
-    if (!UseAVXEncoding(mir->type())) {
+    if (!Assembler::HasAVX()) {
         ins->setOperand(0, useRegisterAtStart(lhs));
         ins->setOperand(1, lhs != rhs ? use(rhs) : useAtStart(rhs));
         defineReuseInput(ins, mir, 0);
     } else {
         ins->setOperand(0, useRegisterAtStart(lhs));
         ins->setOperand(1, useAtStart(rhs));
         define(ins, mir);
     }
--- a/js/src/jit/shared/MacroAssembler-x86-shared.cpp
+++ b/js/src/jit/shared/MacroAssembler-x86-shared.cpp
@@ -117,17 +117,17 @@ MacroAssembler::clampDoubleToUint8(Float
     loadConstantDouble(0.5, ScratchDoubleReg);
     addDouble(ScratchDoubleReg, input);
 
     Label outOfRange;
 
     // Truncate to int32 and ensure the result <= 255. This relies on the
     // processor setting output to a value > 255 for doubles outside the int32
     // range (for instance 0x80000000).
-    cvttsd2si(input, output);
+    vcvttsd2si(input, output);
     branch32(Assembler::Above, output, Imm32(255), &outOfRange);
     {
         // Check if we had a tie.
         convertInt32ToDouble(output, ScratchDoubleReg);
         branchDouble(DoubleNotEqual, input, ScratchDoubleReg, &done);
 
         // It was a tie. Mask out the ones bit to get an even value.
         // See also js_TypedArray_uint8_clamp_double.
@@ -212,37 +212,37 @@ MacroAssemblerX86Shared::branchNegativeZ
     // is equal to -0.0.
 
 #if defined(JS_CODEGEN_X86)
     Label nonZero;
 
     // if not already compared to zero
     if (maybeNonZero) {
         // Compare to zero. Lets through {0, -0}.
-        xorpd(ScratchDoubleReg, ScratchDoubleReg);
+        zeroDouble(ScratchDoubleReg);
 
         // If reg is non-zero, jump to nonZero.
         branchDouble(DoubleNotEqual, reg, ScratchDoubleReg, &nonZero);
     }
     // Input register is either zero or negative zero. Retrieve sign of input.
-    movmskpd(reg, scratch);
+    vmovmskpd(reg, scratch);
 
     // If reg is 1 or 3, input is negative zero.
     // If reg is 0 or 2, input is a normal zero.
     branchTest32(NonZero, scratch, Imm32(1), label);
 
     bind(&nonZero);
 #elif defined(JS_CODEGEN_X64)
     movq(reg, scratch);
-    cmpq(scratch, Imm32(1));
+    cmpq(Imm32(1), scratch);
     j(Overflow, label);
 #endif
 }
 
 void
 MacroAssemblerX86Shared::branchNegativeZeroFloat32(FloatRegister reg,
                                                    Register scratch,
                                                    Label *label)
 {
-    movd(reg, scratch);
-    cmpl(scratch, Imm32(1));
+    vmovd(reg, scratch);
+    cmp32(scratch, Imm32(1));
     j(Overflow, label);
 }
--- a/js/src/jit/shared/MacroAssembler-x86-shared.h
+++ b/js/src/jit/shared/MacroAssembler-x86-shared.h
@@ -33,19 +33,19 @@ class MacroAssemblerX86Shared : public A
     using Assembler::call;
 
     MacroAssemblerX86Shared()
       : framePushed_(0)
     { }
 
     void compareDouble(DoubleCondition cond, FloatRegister lhs, FloatRegister rhs) {
         if (cond & DoubleConditionBitInvert)
-            ucomisd(rhs, lhs);
+            vucomisd(lhs, rhs);
         else
-            ucomisd(lhs, rhs);
+            vucomisd(rhs, lhs);
     }
     void branchDouble(DoubleCondition cond, FloatRegister lhs, FloatRegister rhs, Label *label)
     {
         compareDouble(cond, lhs, rhs);
 
         if (cond == DoubleEqual) {
             Label unordered;
             j(Parity, &unordered);
@@ -60,19 +60,19 @@ class MacroAssemblerX86Shared : public A
         }
 
         MOZ_ASSERT(!(cond & DoubleConditionBitSpecial));
         j(ConditionFromDoubleCondition(cond), label);
     }
 
     void compareFloat(DoubleCondition cond, FloatRegister lhs, FloatRegister rhs) {
         if (cond & DoubleConditionBitInvert)
-            ucomiss(rhs, lhs);
+            vucomiss(lhs, rhs);
         else
-            ucomiss(lhs, rhs);
+            vucomiss(rhs, lhs);
     }
     void branchFloat(DoubleCondition cond, FloatRegister lhs, FloatRegister rhs, Label *label)
     {
         compareFloat(cond, lhs, rhs);
 
         if (cond == DoubleEqual) {
             Label unordered;
             j(Parity, &unordered);
@@ -128,51 +128,69 @@ class MacroAssemblerX86Shared : public A
     }
     void or32(Imm32 imm, const Address &dest) {
         orl(imm, Operand(dest));
     }
     void neg32(Register reg) {
         negl(reg);
     }
     void test32(Register lhs, Register rhs) {
-        testl(lhs, rhs);
+        testl(rhs, lhs);
     }
     void test32(const Address &addr, Imm32 imm) {
-        testl(Operand(addr), imm);
+        testl(imm, Operand(addr));
+    }
+    void test32(const Operand lhs, Imm32 imm) {
+        testl(imm, lhs);
     }
     void test32(Register lhs, Imm32 rhs) {
-        testl(lhs, rhs);
+        testl(rhs, lhs);
     }
     void cmp32(Register lhs, Imm32 rhs) {
-        cmpl(lhs, rhs);
+        cmpl(rhs, lhs);
     }
-    void cmp32(Register a, Register b) {
-        cmpl(a, b);
+    void cmp32(Register lhs, Register rhs) {
+        cmpl(rhs, lhs);
     }
     void cmp32(const Operand &lhs, Imm32 rhs) {
-        cmpl(lhs, rhs);
+        cmpl(rhs, lhs);
     }
     void cmp32(const Operand &lhs, Register rhs) {
-        cmpl(lhs, rhs);
+        cmpl(rhs, lhs);
+    }
+    void cmp32(Register lhs, const Operand &rhs) {
+        cmpl(rhs, lhs);
+    }
+    CodeOffsetLabel cmp32WithPatch(Register lhs, Imm32 rhs) {
+        return cmplWithPatch(rhs, lhs);
     }
     void add32(Register src, Register dest) {
         addl(src, dest);
     }
     void add32(Imm32 imm, Register dest) {
         addl(imm, dest);
     }
+    void add32(Imm32 imm, const Operand &dest) {
+        addl(imm, dest);
+    }
     void add32(Imm32 imm, const Address &dest) {
         addl(imm, Operand(dest));
     }
     void sub32(Imm32 imm, Register dest) {
         subl(imm, dest);
     }
+    void sub32(const Operand &src, Register dest) {
+        subl(src, dest);
+    }
     void sub32(Register src, Register dest) {
         subl(src, dest);
     }
+    void sub32(Register src, const Operand &dest) {
+        subl(src, dest);
+    }
     template <typename T>
     void branchAdd32(Condition cond, T src, Register dest, Label *label) {
         add32(src, dest);
         j(cond, label);
     }