Merge autoland to mozilla-central r=merge a=merge
authorNarcis Beleuzu <nbeleuzu@mozilla.com>
Fri, 12 Jan 2018 13:16:14 +0200
changeset 453228 c72e2f43eb636d2ca00651b4bf9b96b862c8950e
parent 453136 f7f5ba2214d2ce7b1ce9647b0e2540490a6098a8 (current diff)
parent 453210 285a70c630f6003c226dcb68725df137df243ae9 (diff)
child 453229 d2edd256c3aadb1cea48da0c8f62f725bd53cb76
push id1648
push usermtabara@mozilla.com
push dateThu, 01 Mar 2018 12:45:47 +0000
treeherdermozilla-release@cbb9688c2eeb [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge, merge
milestone59.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge autoland to mozilla-central r=merge a=merge
ipc/app/pie/moz.build
layout/style/CachedAnonBoxStyles.cpp
layout/style/CachedAnonBoxStyles.h
--- a/accessible/tests/mochitest/tree/test_tabbrowser.xul
+++ b/accessible/tests/mochitest/tree/test_tabbrowser.xul
@@ -110,37 +110,27 @@
             {
               // xul:tab ("about:license")
               role: ROLE_PAGETAB,
               children: [
                 {
                   // xul:text, i.e. the tab label text
                   role: ROLE_TEXT_LEAF,
                   children: []
-                },
-                {
-                  // xul:toolbarbutton ("Close Tab")
-                  role: ROLE_PUSHBUTTON,
-                  children: []
                 }
               ]
             },
             {
               // tab ("about:mozilla")
               role: ROLE_PAGETAB,
               children: [
                 {
                   // xul:text, i.e. the tab label text
                   role: ROLE_TEXT_LEAF,
                   children: []
-                },
-                {
-                  // xul:toolbarbutton ("Close Tab")
-                  role: ROLE_PUSHBUTTON,
-                  children: []
                 }
               ]
             },
             {
               // xul:toolbarbutton ("Open a new tab")
               role: ROLE_PUSHBUTTON,
               children: newTabChildren
             }
--- a/browser/base/content/tabbrowser.xml
+++ b/browser/base/content/tabbrowser.xml
@@ -7830,18 +7830,17 @@
     </handlers>
   </binding>
 
   <!-- close-tab-button binding
        This binding relies on the structure of the tabbrowser binding.
        Therefore it should only be used as a child of the tab or the tabs
        element (in both cases, when they are anonymous nodes of <tabbrowser>).
   -->
-  <binding id="tabbrowser-close-tab-button"
-           extends="chrome://global/content/bindings/toolbarbutton.xml#toolbarbutton-image">
+  <binding id="tabbrowser-close-tab-button">
     <handlers>
       <handler event="click" button="0"><![CDATA[
         var bindingParent = document.getBindingParent(this);
         var tabContainer = bindingParent.parentNode;
         tabContainer.tabbrowser.removeTab(bindingParent, {animate: true,
                 byMouse: event.mozInputSource == MouseEvent.MOZ_SOURCE_MOUSE});
         // This enables double-click protection for the tab container
         // (see tabbrowser-tabs 'click' handler).
@@ -7908,19 +7907,20 @@
             <xul:label class="tab-text tab-label"
                        xbl:inherits="xbl:text=label,accesskey,fadein,pinned,selected=visuallyselected,attention"
                        role="presentation"/>
           </xul:hbox>
           <xul:image xbl:inherits="soundplaying,soundplaying-scheduledremoval,pinned,muted,blocked,selected=visuallyselected,activemedia-blocked"
                      anonid="soundplaying-icon"
                      class="tab-icon-sound"
                      role="presentation"/>
-          <xul:toolbarbutton anonid="close-button"
-                             xbl:inherits="fadein,pinned,selected=visuallyselected"
-                             class="tab-close-button close-icon"/>
+          <xul:image anonid="close-button"
+                     xbl:inherits="fadein,pinned,selected=visuallyselected"
+                     class="tab-close-button close-icon"
+                     role="presentation"/>
         </xul:hbox>
       </xul:stack>
     </content>
 
     <implementation>
       <constructor><![CDATA[
         if (!("_lastAccessed" in this)) {
           this.updateLastAccessed();
--- a/browser/themes/osx/browser.css
+++ b/browser/themes/osx/browser.css
@@ -841,30 +841,16 @@ html|span.ac-emphasize-text-url {
 
 @media (min-resolution: 2dppx) {
   .tab-drop-indicator {
     list-style-image: url(chrome://browser/skin/tabbrowser/tabDragIndicator@2x.png);
     width: 12px;
   }
 }
 
-/**
- * In-tab close button
- */
-
-.tab-close-button > .toolbarbutton-icon {
-  margin-inline-end: 0px !important;
-}
-
-.tab-close-button {
-  border: none !important;
-  background: none;
-  cursor: default;
-}
-
 /* Bookmarks toolbar */
 #PlacesToolbarDropIndicator {
   list-style-image: url(chrome://browser/skin/places/toolbarDropMarker.png);
 }
 
 /* Bookmark drag and drop styles */
 
 .bookmark-item[dragover-into="true"] {
--- a/browser/themes/shared/tabs.inc.css
+++ b/browser/themes/shared/tabs.inc.css
@@ -355,17 +355,16 @@ tabbrowser {
 
 .tab-label {
   margin-inline-end: 0;
   margin-inline-start: 0;
 }
 
 .tab-close-button {
   margin-inline-end: -2px;
-  padding: 0;
   -moz-context-properties: fill, fill-opacity, stroke-opacity;
   stroke-opacity: var(--toolbarbutton-icon-fill-opacity);
 }
 
 :root[uidensity=touch] .tab-close-button {
   margin-inline-end: -@horizontalTabPadding@;
   padding: 10px calc(@horizontalTabPadding@ - 2px);
 }
--- a/browser/themes/windows/browser.css
+++ b/browser/themes/windows/browser.css
@@ -784,22 +784,16 @@ html|span.ac-emphasize-text-url {
 
 /* Tab DnD indicator */
 .tab-drop-indicator {
   list-style-image: url(chrome://browser/skin/tabbrowser/tabDragIndicator.png);
   margin-bottom: -9px;
   z-index: 3;
 }
 
-/* Tab close button */
-.tab-close-button {
-  -moz-appearance: none;
-  border: none;
-}
-
 /* All tabs menupopup */
 
 .alltabs-item[selected="true"] {
   font-weight: bold;
 }
 
 /* Bookmarks toolbar */
 #PlacesToolbarDropIndicator {
--- a/build/autoconf/compiler-opts.m4
+++ b/build/autoconf/compiler-opts.m4
@@ -193,20 +193,24 @@ if test "$GNU_CC" -a "$GCC_USE_GNU_LD" -
          if test "$GC_SECTIONS_BREAKS_DEBUG_RANGES" = no; then
              DSO_LDOPTS="$DSO_LDOPTS -Wl,--gc-sections"
          fi
     else
         DSO_LDOPTS="$DSO_LDOPTS -Wl,--gc-sections"
     fi
 fi
 
-# bionic in Android < 4.1 doesn't support PIE
 # On OSX, the linker defaults to building PIE programs when targeting OSX 10.7.
 # On other Unix systems, some file managers (Nautilus) can't start PIE programs
-MOZ_PIE=
+if test "$OS_TARGET" = Android; then
+    # bionic in Android >= 4.1 supports PIE, and we target those versions.
+    MOZ_PIE=1
+else
+    MOZ_PIE=
+fi
 
 MOZ_ARG_ENABLE_BOOL(pie,
 [  --enable-pie           Enable Position Independent Executables],
     MOZ_PIE=1,
     MOZ_PIE= )
 
 if test "$GNU_CC$CLANG_CC" -a -n "$MOZ_PIE"; then
     AC_MSG_CHECKING([for PIE support])
new file mode 100644
--- /dev/null
+++ b/build/debian-packages/valgrind-wheezy.diff
@@ -0,0 +1,4821 @@
+diff -Nru valgrind-3.13.0/debian/changelog valgrind-3.13.0/debian/changelog
+--- valgrind-3.13.0/debian/changelog	2017-07-24 08:41:05.000000000 +0900
++++ valgrind-3.13.0/debian/changelog	2018-01-11 17:08:25.000000000 +0900
+@@ -1,3 +1,13 @@
++valgrind (1:3.13.0-1.deb7moz1) wheezy; urgency=medium
++
++  * Mozilla backport for wheezy.
++  * debian/patches/valgrind-epochs.patch: Apply patch from Julian Seward that
++    allows us to write a suppression for a leak in a library that gets
++    unloaded before shutdown.
++    Ref: https://bugs.kde.org/show_bug.cgi?id=79362
++
++ -- Mike Hommey <glandium@debian.org>  Thu, 11 Jan 2018 17:08:25 +0900
++
+ valgrind (1:3.13.0-1) unstable; urgency=medium
+ 
+   * New upstream release
+diff -Nru valgrind-3.13.0/debian/patches/series valgrind-3.13.0/debian/patches/series
+--- valgrind-3.13.0/debian/patches/series	2017-07-24 08:41:05.000000000 +0900
++++ valgrind-3.13.0/debian/patches/series	2018-01-11 17:08:25.000000000 +0900
+@@ -4,3 +4,4 @@
+ 07_fix-spelling-in-binary.patch
+ 08_fix-spelling-in-manpage.patch
+ 09_fix-armhf-detect.patch
++valgrind-epochs.patch
+diff -Nru valgrind-3.13.0/debian/patches/valgrind-epochs.patch valgrind-3.13.0/debian/patches/valgrind-epochs.patch
+--- valgrind-3.13.0/debian/patches/valgrind-epochs.patch	1970-01-01 09:00:00.000000000 +0900
++++ valgrind-3.13.0/debian/patches/valgrind-epochs.patch	2018-01-11 17:08:25.000000000 +0900
+@@ -0,0 +1,4792 @@
++Index: valgrind-3.13.0/Makefile.am
++===================================================================
++--- valgrind-3.13.0.orig/Makefile.am
+++++ valgrind-3.13.0/Makefile.am
++@@ -16,6 +16,10 @@ EXP_TOOLS = 	exp-sgcheck \
++ 		exp-bbv \
++ 		exp-dhat
++ 
+++#TOOLS = none memcheck
+++#EXP_TOOLS =
+++
+++
++ # Put docs last because building the HTML is slow and we want to get
++ # everything else working before we try it.
++ SUBDIRS = \
++Index: valgrind-3.13.0/cachegrind/cg_main.c
++===================================================================
++--- valgrind-3.13.0.orig/cachegrind/cg_main.c
+++++ valgrind-3.13.0/cachegrind/cg_main.c
++@@ -210,12 +210,14 @@ static HChar* get_perm_string(const HCha
++ static void get_debug_info(Addr instr_addr, const HChar **dir,
++                            const HChar **file, const HChar **fn, UInt* line)
++ {
+++   DiEpoch ep = VG_(current_DiEpoch)();
++    Bool found_file_line = VG_(get_filename_linenum)(
+++                             ep,
++                              instr_addr, 
++                              file, dir,
++                              line
++                           );
++-   Bool found_fn        = VG_(get_fnname)(instr_addr, fn);
+++   Bool found_fn        = VG_(get_fnname)(ep, instr_addr, fn);
++ 
++    if (!found_file_line) {
++       *file = "???";
++Index: valgrind-3.13.0/callgrind/bb.c
++===================================================================
++--- valgrind-3.13.0.orig/callgrind/bb.c
+++++ valgrind-3.13.0/callgrind/bb.c
++@@ -199,7 +199,8 @@ obj_node* obj_of_address(Addr addr)
++   DebugInfo* di;
++   PtrdiffT offset;
++ 
++-  di = VG_(find_DebugInfo)(addr);
+++  DiEpoch ep = VG_(current_DiEpoch)();
+++  di = VG_(find_DebugInfo)(ep, addr);
++   obj = CLG_(get_obj_node)( di );
++ 
++   /* Update symbol offset in object if remapped */
++Index: valgrind-3.13.0/callgrind/dump.c
++===================================================================
++--- valgrind-3.13.0.orig/callgrind/dump.c
+++++ valgrind-3.13.0/callgrind/dump.c
++@@ -373,7 +373,8 @@ Bool get_debug_pos(BBCC* bbcc, Addr addr
++ 	found_file_line = debug_cache_info[cachepos];
++     }
++     else {
++-	found_file_line = VG_(get_filename_linenum)(addr,
+++        DiEpoch ep = VG_(current_DiEpoch)();
+++	found_file_line = VG_(get_filename_linenum)(ep, addr,
++ 						    &file,
++ 						    &dir,
++ 						    &(p->line));
++Index: valgrind-3.13.0/callgrind/fn.c
++===================================================================
++--- valgrind-3.13.0.orig/callgrind/fn.c
+++++ valgrind-3.13.0/callgrind/fn.c
++@@ -434,17 +434,18 @@ Bool CLG_(get_debug_info)(Addr instr_add
++   
++   CLG_DEBUG(6, "  + get_debug_info(%#lx)\n", instr_addr);
++ 
+++  DiEpoch ep = VG_(current_DiEpoch)();
++   if (pDebugInfo) {
++-      *pDebugInfo = VG_(find_DebugInfo)(instr_addr);
+++      *pDebugInfo = VG_(find_DebugInfo)(ep, instr_addr);
++ 
++       // for generated code in anonymous space, pSegInfo is 0
++    }
++ 
++-   found_file_line = VG_(get_filename_linenum)(instr_addr,
+++   found_file_line = VG_(get_filename_linenum)(ep, instr_addr,
++ 					       file,
++ 					       dir,
++ 					       &line);
++-   found_fn = VG_(get_fnname)(instr_addr, fn_name);
+++   found_fn = VG_(get_fnname)(ep, instr_addr, fn_name);
++ 
++    if (!found_file_line && !found_fn) {
++      CLG_(stat).no_debug_BBs++;
++@@ -503,6 +504,7 @@ fn_node* CLG_(get_fn_node)(BB* bb)
++     CLG_(get_debug_info)(bb_addr(bb),
++                          &dirname, &filename, &fnname, &line_num, &di);
++ 
+++    DiEpoch ep = VG_(current_DiEpoch)();
++     if (0 == VG_(strcmp)(fnname, "???")) {
++ 	int p;
++         static HChar buf[32];  // for sure large enough
++@@ -521,7 +523,7 @@ fn_node* CLG_(get_fn_node)(BB* bb)
++         fnname = buf;
++     }
++     else {
++-      if (VG_(get_fnname_if_entry)(bb_addr(bb), &fnname))
+++      if (VG_(get_fnname_if_entry)(ep, bb_addr(bb), &fnname))
++ 	bb->is_entry = 1;
++     }
++ 
++Index: valgrind-3.13.0/coregrind/m_addrinfo.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_addrinfo.c
+++++ valgrind-3.13.0/coregrind/m_addrinfo.c
++@@ -86,7 +86,7 @@ static ThreadId find_tid_with_stack_cont
++    return VG_INVALID_THREADID;
++ }
++ 
++-void VG_(describe_addr) ( Addr a, /*OUT*/AddrInfo* ai )
+++void VG_(describe_addr) ( DiEpoch ep, Addr a, /*OUT*/AddrInfo* ai )
++ {
++    VgSectKind sect;
++ 
++@@ -99,7 +99,7 @@ void VG_(describe_addr) ( Addr a, /*OUT*
++                     VG_(free), sizeof(HChar) );
++ 
++    (void) VG_(get_data_description)( ai->Addr.Variable.descr1,
++-                                     ai->Addr.Variable.descr2, a );
+++                                     ai->Addr.Variable.descr2, ep, a );
++    /* If there's nothing in descr1/2, free them.  Why is it safe to
++       VG_(indexXA) at zero here?  Because VG_(get_data_description)
++       guarantees to zero terminate descr1/2 regardless of the outcome
++@@ -127,7 +127,7 @@ void VG_(describe_addr) ( Addr a, /*OUT*
++       there. -- */
++    const HChar *name;
++    if (VG_(get_datasym_and_offset)(
++-             a, &name,
+++             ep, a, &name,
++              &ai->Addr.DataSym.offset )) {
++       ai->Addr.DataSym.name = VG_(strdup)("mc.da.dsname", name);
++       ai->tag = Addr_DataSym;
++@@ -148,6 +148,7 @@ void VG_(describe_addr) ( Addr a, /*OUT*
++             ai->tag            = Addr_Stack;
++             VG_(initThreadInfo)(&ai->Addr.Stack.tinfo);
++             ai->Addr.Stack.tinfo.tid = tid;
+++            ai->Addr.Stack.epoch = ep;
++             ai->Addr.Stack.IP = 0;
++             ai->Addr.Stack.frameNo = -1;
++             ai->Addr.Stack.stackPos = StackPos_stacked;
++@@ -196,9 +197,9 @@ void VG_(describe_addr) ( Addr a, /*OUT*
++          ai->Addr.Block.block_desc = aai.name;
++          ai->Addr.Block.block_szB = aai.block_szB;
++          ai->Addr.Block.rwoffset = aai.rwoffset;
++-         ai->Addr.Block.allocated_at = VG_(null_ExeContext)();
+++         ai->Addr.Block.allocated_at = VG_(null_ExeContextAndEpoch)();
++          VG_(initThreadInfo) (&ai->Addr.Block.alloc_tinfo);
++-         ai->Addr.Block.freed_at = VG_(null_ExeContext)();
+++         ai->Addr.Block.freed_at = VG_(null_ExeContextAndEpoch)();
++          return;
++       }
++    }
++@@ -248,6 +249,7 @@ void VG_(describe_addr) ( Addr a, /*OUT*
++          ai->tag  = Addr_Stack;
++          VG_(initThreadInfo)(&ai->Addr.Stack.tinfo);
++          ai->Addr.Stack.tinfo.tid = tid;
+++         ai->Addr.Stack.epoch = ep;
++          ai->Addr.Stack.IP = 0;
++          ai->Addr.Stack.frameNo = -1;
++          vg_assert (stackPos != StackPos_stacked);
++@@ -447,20 +449,24 @@ static void pp_addrinfo_WRK ( Addr a, co
++             Bool haslinenum;
++             PtrdiffT offset;
++ 
++-            if (VG_(get_inst_offset_in_function)( ai->Addr.Stack.IP,
+++            if (VG_(get_inst_offset_in_function)( ai->Addr.Stack.epoch,
+++                                                  ai->Addr.Stack.IP,
++                                                   &offset))
++-               haslinenum = VG_(get_linenum) (ai->Addr.Stack.IP - offset,
+++               haslinenum = VG_(get_linenum) (ai->Addr.Stack.epoch,
+++                                              ai->Addr.Stack.IP - offset,
++                                               &linenum);
++             else
++                haslinenum = False;
++ 
++-            hasfile = VG_(get_filename)(ai->Addr.Stack.IP, &file);
+++            hasfile = VG_(get_filename)(ai->Addr.Stack.epoch,
+++                                        ai->Addr.Stack.IP, &file);
++ 
++             HChar strlinenum[16] = "";   // large enough
++             if (hasfile && haslinenum)
++                VG_(sprintf)(strlinenum, "%u", linenum);
++ 
++-            hasfn = VG_(get_fnname)(ai->Addr.Stack.IP, &fn);
+++            hasfn = VG_(get_fnname)(ai->Addr.Stack.epoch,
+++                                    ai->Addr.Stack.IP, &fn);
++ 
++             if (hasfn || hasfile)
++                VG_(emit)( "%sin frame #%d, created by %ps (%ps:%s)%s\n",
++@@ -533,32 +539,35 @@ static void pp_addrinfo_WRK ( Addr a, co
++                xpost
++             );
++          if (ai->Addr.Block.block_kind==Block_Mallocd) {
++-            VG_(pp_ExeContext)(ai->Addr.Block.allocated_at);
++-            vg_assert (ai->Addr.Block.freed_at == VG_(null_ExeContext)());
+++            VG_(pp_ExeContextAndEpoch)(ai->Addr.Block.allocated_at);
+++            vg_assert(
+++               VG_(is_null_ExeContextAndEpoch)(ai->Addr.Block.freed_at));
++          }
++          else if (ai->Addr.Block.block_kind==Block_Freed) {
++-            VG_(pp_ExeContext)(ai->Addr.Block.freed_at);
++-            if (ai->Addr.Block.allocated_at != VG_(null_ExeContext)()) {
+++            VG_(pp_ExeContextAndEpoch)(ai->Addr.Block.freed_at);
+++            if (!VG_(is_null_ExeContextAndEpoch)(ai->Addr.Block.allocated_at)) {
++                VG_(emit)(
++                   "%sBlock was alloc'd at%s\n",
++                   xpre,
++                   xpost
++                );
++-               VG_(pp_ExeContext)(ai->Addr.Block.allocated_at);
+++               VG_(pp_ExeContextAndEpoch)(ai->Addr.Block.allocated_at);
++             }
++          }
++          else if (ai->Addr.Block.block_kind==Block_MempoolChunk
++                   || ai->Addr.Block.block_kind==Block_UserG) {
++             // client-defined
++-            VG_(pp_ExeContext)(ai->Addr.Block.allocated_at);
++-            vg_assert (ai->Addr.Block.freed_at == VG_(null_ExeContext)());
+++            VG_(pp_ExeContextAndEpoch)(ai->Addr.Block.allocated_at);
+++            vg_assert(VG_(is_null_ExeContextAndEpoch)(ai->Addr.Block.freed_at));
++             /* Nb: cannot have a freed_at, as a freed client-defined block
++                has a Block_Freed block_kind. */
++          } else {
++             // Client or Valgrind arena. At least currently, we never
++             // have stacktraces for these.
++-            vg_assert (ai->Addr.Block.allocated_at == VG_(null_ExeContext)());
++-            vg_assert (ai->Addr.Block.freed_at == VG_(null_ExeContext)());
+++            vg_assert(VG_(is_null_ExeContextAndEpoch)
+++                         (ai->Addr.Block.allocated_at));
+++            vg_assert(VG_(is_null_ExeContextAndEpoch)
+++                         (ai->Addr.Block.freed_at));
++          }
++          if (ai->Addr.Block.alloc_tinfo.tnr || ai->Addr.Block.alloc_tinfo.tid)
++             VG_(emit)(
++@@ -603,7 +612,7 @@ static void pp_addrinfo_WRK ( Addr a, co
++          if (ai->Addr.SectKind.kind == Vg_SectText) {
++             /* To better describe the address in a text segment,
++                pp a dummy stacktrace made of this single address. */
++-            VG_(pp_StackTrace)( &a, 1 );
+++            VG_(pp_StackTrace)( VG_(current_DiEpoch)(), &a, 1 );
++          }
++          break;
++ 
++Index: valgrind-3.13.0/coregrind/m_debuginfo/debuginfo.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_debuginfo/debuginfo.c
+++++ valgrind-3.13.0/coregrind/m_debuginfo/debuginfo.c
++@@ -70,6 +70,10 @@
++    should-we-load-debuginfo-now? finite state machine. */
++ #define DEBUG_FSM 0
++ 
+++/* Set this to 1 to enable somewhat minimal debug printing for the
+++   debuginfo-epoch machinery. */
+++#define DEBUG_EPOCHS 0
+++
++ 
++ /*------------------------------------------------------------*/
++ /*--- The _svma / _avma / _image / _bias naming scheme     ---*/
++@@ -109,6 +113,116 @@ static void caches__invalidate (void);
++ 
++ 
++ /*------------------------------------------------------------*/
+++/*--- Epochs                                               ---*/
+++/*------------------------------------------------------------*/
+++
+++/* The DebugInfo epoch is incremented every time we either load debuginfo in
+++   response to an object mapping, or an existing DebugInfo becomes
+++   non-current (or will be discarded) due to an object unmap.  By storing,
+++   in each DebugInfo, the first and last epoch for which it is valid, we can
+++   unambiguously identify the set of DebugInfos which should be used to
+++   provide metadata for a code or data address, provided we know the epoch
+++   to which that address pertains.
+++
+++   Note, this isn't the same as the "handle_counter" below.  That only
+++   advances when new DebugInfos are created.  "current_epoch" advances both
+++   at DebugInfo created and destruction-or-making-non-current.
+++*/
+++
+++// The value zero is reserved for indicating an invalid epoch number.
+++static UInt current_epoch = 1;
+++
+++inline DiEpoch VG_(current_DiEpoch) ( void ) {
+++   DiEpoch dep; dep.n = current_epoch; return dep;
+++}
+++
+++static void advance_current_DiEpoch ( const HChar* msg ) {
+++   current_epoch++;
+++   if (DEBUG_EPOCHS)
+++      VG_(printf)("Advancing current epoch to %u due to %s\n",
+++                  current_epoch, msg);
+++}
+++
+++static inline Bool eq_DiEpoch ( DiEpoch dep1, DiEpoch dep2 ) {
+++   return dep1.n == dep2.n && /*neither is invalid*/dep1.n != 0;
+++}
+++
+++// Is this DebugInfo currently "allocated" (pre-use state, only FSM active) ?
+++static inline Bool is_DebugInfo_allocated ( const DebugInfo* di )
+++{
+++   if (is_DiEpoch_INVALID(di->first_epoch)
+++       && is_DiEpoch_INVALID(di->last_epoch)) {
+++      return True;
+++   } else {
+++      return False;
+++   }
+++}
+++
+++// Is this DebugInfo currently "active" (valid for the current epoch) ?
+++static inline Bool is_DebugInfo_active ( const DebugInfo* di )
+++{
+++   if (!is_DiEpoch_INVALID(di->first_epoch)
+++       && is_DiEpoch_INVALID(di->last_epoch)) {
+++      // Yes it is active.  Sanity check ..
+++      tl_assert(di->first_epoch.n <= current_epoch);
+++      return True;
+++   } else {
+++      return False;
+++   }
+++}
+++
+++// Is this DebugInfo currently "archived" ?
+++static inline Bool is_DebugInfo_archived ( const DebugInfo* di )
+++{
+++   if (!is_DiEpoch_INVALID(di->first_epoch)
+++       && !is_DiEpoch_INVALID(di->last_epoch)) {
+++      // Yes it is archived.  Sanity checks ..
+++      tl_assert(di->first_epoch.n <= di->last_epoch.n);
+++      tl_assert(di->last_epoch.n <= current_epoch);
+++      return True;
+++   } else {
+++      return False;
+++   }
+++}
+++
+++// Is this DebugInfo valid for the specified epoch?
+++static inline Bool is_DI_valid_for_epoch ( const DebugInfo* di, DiEpoch ep )
+++{
+++   // Stay sane
+++   vg_assert(ep.n > 0 && ep.n <= current_epoch);
+++
+++   Bool first_valid = !is_DiEpoch_INVALID(di->first_epoch);
+++   Bool last_valid  = !is_DiEpoch_INVALID(di->last_epoch);
+++
+++   if (first_valid) {
+++      if (last_valid) {
+++         // Both valid.  di is in Archived state.
+++         return di->first_epoch.n <= ep.n && ep.n <= di->last_epoch.n;
+++      } else {
+++         // First is valid, last is invalid.  di is in Active state.
+++         return di->first_epoch.n <= ep.n;
+++      }
+++   } else {
+++      if (last_valid) {
+++         // First is invalid, last is valid.  This is an impossible state.
+++         vg_assert(0);
+++         /*NOTREACHED*/
+++         return False;
+++      } else {
+++         // Neither is valid.  di is in Allocated state.
+++         return False;
+++      }
+++   }
+++
+++}
+++
+++static inline UInt ROL32 ( UInt x, UInt n )
+++{
+++   return (x << n) | (x >> (32-n));
+++}
+++
+++
+++/*------------------------------------------------------------*/
++ /*--- Root structure                                       ---*/
++ /*------------------------------------------------------------*/
++ 
++@@ -162,6 +276,23 @@ static void move_DebugInfo_one_step_forw
++ }
++ 
++ 
+++// Debugging helper for epochs
+++static void show_epochs ( const HChar* msg )
+++{
+++   if (DEBUG_EPOCHS) {
+++      DebugInfo* di;
+++      VG_(printf)("\nDebugInfo epoch display, requested by \"%s\"\n", msg);
+++      VG_(printf)("  Current epoch (note: 0 means \"invalid epoch\") = %u\n",
+++                  current_epoch);
+++      for (di = debugInfo_list; di; di = di->next) {
+++         VG_(printf)("  [di=%p]  first %u  last %u  %s\n", 
+++                     di, di->first_epoch.n, di->last_epoch.n, di->fsm.filename);
+++      }
+++      VG_(printf)("\n");
+++   }
+++}
+++
+++
++ /*------------------------------------------------------------*/
++ /*--- Notification (acquire/discard) helpers               ---*/
++ /*------------------------------------------------------------*/
++@@ -182,6 +313,8 @@ DebugInfo* alloc_DebugInfo( const HChar*
++ 
++    di = ML_(dinfo_zalloc)("di.debuginfo.aDI.1", sizeof(DebugInfo));
++    di->handle       = handle_counter++;
+++   di->first_epoch  = DiEpoch_INVALID();
+++   di->last_epoch   = DiEpoch_INVALID();
++    di->fsm.filename = ML_(dinfo_strdup)("di.debuginfo.aDI.2", filename);
++    di->fsm.maps     = VG_(newXA)(
++                          ML_(dinfo_zalloc), "di.debuginfo.aDI.3",
++@@ -302,34 +435,52 @@ static void free_DebugInfo ( DebugInfo*
++ }
++ 
++ 
++-/* 'si' is a member of debugInfo_list.  Find it, remove it from the
++-   list, notify m_redir that this has happened, and free all storage
++-   reachable from it.
+++/* 'di' is a member of debugInfo_list.  Find it, and either (remove it from
+++   the list and free all storage reachable from it) or archive it, notify
+++   m_redir that this has happened, and free all storage reachable from it.
+++
+++   Note that 'di' can't be archived.  Is a DebugInfo is archived then we
+++   want to hold on to it forever.  This is asserted for.
+++
+++   Note also, we don't advance the current epoch here.  That's the
+++   responsibility of some (non-immediate) caller.
++ */
++-static void discard_DebugInfo ( DebugInfo* di )
+++static void discard_or_archive_DebugInfo ( DebugInfo* di )
++ {
++-   const HChar* reason = "munmap";
+++   const HChar* reason  = "munmap";
+++   const Bool   archive = VG_(clo_keep_debuginfo);
++ 
++    DebugInfo** prev_next_ptr = &debugInfo_list;
++    DebugInfo*  curr          =  debugInfo_list;
++ 
++    while (curr) {
++       if (curr == di) {
++-         /* Found it;  remove from list and free it. */
+++         /* It must be active! */
+++         vg_assert( is_DebugInfo_active(di));
+++         /* Found it; (remove from list and free it), or archive it. */
++          if (curr->have_dinfo
++              && (VG_(clo_verbosity) > 1 || VG_(clo_trace_redir)))
++             VG_(message)(Vg_DebugMsg, 
++-                         "Discarding syms at %#lx-%#lx in %s due to %s()\n",
+++                         "%s syms at %#lx-%#lx in %s due to %s()\n",
+++                         archive ? "Archiving" : "Discarding",
++                          di->text_avma, 
++                          di->text_avma + di->text_size,
++                          curr->fsm.filename ? curr->fsm.filename
++                                             : "???",
++                          reason);
++          vg_assert(*prev_next_ptr == curr);
++-         *prev_next_ptr = curr->next;
++-         if (curr->have_dinfo)
+++         if (!archive) {
+++            *prev_next_ptr = curr->next;
+++         }
+++         if (curr->have_dinfo) {
++             VG_(redir_notify_delete_DebugInfo)( curr );
++-         free_DebugInfo(curr);
+++         }
+++         if (archive) {
+++            /* Adjust the epoch markers appropriately. */
+++            di->last_epoch = VG_(current_DiEpoch)();
+++         } else {
+++            free_DebugInfo(curr);
+++         }
++          return;
++       }
++       prev_next_ptr = &curr->next;
++@@ -358,10 +509,11 @@ static Bool discard_syms_in_range ( Addr
++       while (True) {
++          if (curr == NULL)
++             break;
++-         if (curr->text_present
++-             && curr->text_size > 0
++-             && (start+length - 1 < curr->text_avma 
++-                 || curr->text_avma + curr->text_size - 1 < start)) {
+++         if (is_DebugInfo_archived(curr)
+++             || (curr->text_present
+++                 && curr->text_size > 0
+++                 && (start+length - 1 < curr->text_avma 
+++                     || curr->text_avma + curr->text_size - 1 < start))) {
++             /* no overlap */
++ 	 } else {
++ 	    found = True;
++@@ -372,7 +524,7 @@ static Bool discard_syms_in_range ( Addr
++ 
++       if (!found) break;
++       anyFound = True;
++-      discard_DebugInfo( curr );
+++      discard_or_archive_DebugInfo( curr );
++    }
++ 
++    return anyFound;
++@@ -418,9 +570,9 @@ static Bool do_DebugInfos_overlap ( cons
++ }
++ 
++ 
++-/* Discard all elements of debugInfo_list whose .mark bit is set.
+++/* Discard or archive all elements of debugInfo_list whose .mark bit is set.
++ */
++-static void discard_marked_DebugInfos ( void )
+++static void discard_or_archive_marked_DebugInfos ( void )
++ {
++    DebugInfo* curr;
++ 
++@@ -436,7 +588,7 @@ static void discard_marked_DebugInfos (
++       }
++ 
++       if (!curr) break;
++-      discard_DebugInfo( curr );
+++      discard_or_archive_DebugInfo( curr );
++ 
++    }
++ }
++@@ -446,19 +598,22 @@ static void discard_marked_DebugInfos (
++    Clearly diRef must have its mapping information set to something sane. */
++ static void discard_DebugInfos_which_overlap_with ( DebugInfo* diRef )
++ {
+++   vg_assert(is_DebugInfo_allocated(diRef));
++    DebugInfo* di;
++    /* Mark all the DebugInfos in debugInfo_list that need to be
++       deleted.  First, clear all the mark bits; then set them if they
++       overlap with siRef.  Since siRef itself is in this list we at
++       least expect its own mark bit to be set. */
++    for (di = debugInfo_list; di; di = di->next) {
+++      if (is_DebugInfo_archived(di))
+++         continue;
++       di->mark = do_DebugInfos_overlap( di, diRef );
++       if (di == diRef) {
++          vg_assert(di->mark);
++          di->mark = False;
++       }
++    }
++-   discard_marked_DebugInfos();
+++   discard_or_archive_marked_DebugInfos();
++ }
++ 
++ 
++@@ -470,6 +625,8 @@ static DebugInfo* find_or_create_DebugIn
++    DebugInfo* di;
++    vg_assert(filename);
++    for (di = debugInfo_list; di; di = di->next) {
+++      if (is_DebugInfo_archived(di))
+++         continue;
++       vg_assert(di->fsm.filename);
++       if (0==VG_(strcmp)(di->fsm.filename, filename))
++          break;
++@@ -480,6 +637,7 @@ static DebugInfo* find_or_create_DebugIn
++       di->next = debugInfo_list;
++       debugInfo_list = di;
++    }
+++   vg_assert(!is_DebugInfo_archived(di));
++    return di;
++ }
++ 
++@@ -723,6 +881,8 @@ static ULong di_notify_ACHIEVE_ACCEPT_ST
++    ULong di_handle;
++    Bool  ok;
++ 
+++   advance_current_DiEpoch("di_notify_ACHIEVE_ACCEPT_STATE");
+++
++    vg_assert(di->fsm.filename);
++    TRACE_SYMTAB("\n");
++    TRACE_SYMTAB("------ start ELF OBJECT "
++@@ -734,7 +894,8 @@ static ULong di_notify_ACHIEVE_ACCEPT_ST
++    /* We're going to read symbols and debug info for the avma
++       ranges specified in the _DebugInfoFsm mapping array. First
++       get rid of any other DebugInfos which overlap any of those
++-      ranges (to avoid total confusion). */
+++      ranges (to avoid total confusion).  But only those valid in
+++     the current epoch.  We don't want to discard archived DebugInfos. */
++    discard_DebugInfos_which_overlap_with( di );
++ 
++    /* The DebugInfoMappings that now exist in the FSM may involve
++@@ -765,6 +926,15 @@ static ULong di_notify_ACHIEVE_ACCEPT_ST
++          priv_storage.h. */
++       check_CFSI_related_invariants(di);
++       ML_(finish_CFSI_arrays)(di);
+++
+++      // Mark di's first epoch point as a valid epoch.  Because its
+++      // last_epoch value is still invalid, this changes di's state from
+++      // "allocated" to "active".
+++      vg_assert(is_DebugInfo_allocated(di));
+++      di->first_epoch = VG_(current_DiEpoch)();
+++      vg_assert(is_DebugInfo_active(di));
+++      show_epochs("di_notify_ACHIEVE_ACCEPT_STATE success");
+++
++       /* notify m_redir about it */
++       TRACE_SYMTAB("\n------ Notifying m_redir ------\n");
++       VG_(redir_notify_new_DebugInfo)( di );
++@@ -1077,8 +1247,11 @@ void VG_(di_notify_munmap)( Addr a, Size
++    Bool anyFound;
++    if (0) VG_(printf)("DISCARD %#lx %#lx\n", a, a+len);
++    anyFound = discard_syms_in_range(a, len);
++-   if (anyFound)
+++   if (anyFound) {
++       caches__invalidate();
+++      advance_current_DiEpoch("VG_(di_notify_munmap)");
+++      show_epochs("VG_(di_notify_munmap)");
+++   }
++ }
++ 
++ 
++@@ -1094,8 +1267,10 @@ void VG_(di_notify_mprotect)( Addr a, Si
++ #  endif
++    if (0 && !exe_ok) {
++       Bool anyFound = discard_syms_in_range(a, len);
++-      if (anyFound)
+++      if (anyFound) {
++          caches__invalidate();
+++         advance_current_DiEpoch("VG_(di_notify_mprotect)");
+++      }
++    }
++ }
++ 
++@@ -1395,6 +1570,7 @@ void VG_(di_notify_pdb_debuginfo)( Int f
++    caches__invalidate();
++    /* dump old info for this range, if any */
++    discard_syms_in_range( avma_obj, total_size );
+++   advance_current_DiEpoch("VG_(di_notify_pdb_debuginfo)");
++ 
++    { DebugInfo* di = find_or_create_DebugInfo_for(exename);
++ 
++@@ -1471,6 +1647,7 @@ DebugInfoMapping* ML_(find_rx_mapping) (
++ /*------------------------------------------------------------*/
++ /*--- Types and functions for inlined IP cursor            ---*/
++ /*------------------------------------------------------------*/
+++
++ struct _InlIPCursor {
++    Addr eip;             // Cursor used to describe calls at eip.
++    DebugInfo* di;        // DebugInfo describing inlined calls at eip
++@@ -1534,8 +1711,8 @@ Bool VG_(next_IIPC)(InlIPCursor *iipc)
++ }
++ 
++ /* Forward */
++-static void search_all_loctabs ( Addr ptr, /*OUT*/DebugInfo** pdi,
++-                                           /*OUT*/Word* locno );
+++static void search_all_loctabs ( DiEpoch ep, Addr ptr,
+++                                 /*OUT*/DebugInfo** pdi, /*OUT*/Word* locno );
++ 
++ /* Returns the position after which eip would be inserted in inltab.
++    (-1 if eip should be inserted before position 0).
++@@ -1565,7 +1742,7 @@ static Word inltab_insert_pos (DebugInfo
++    return lo - 1;
++ }
++ 
++-InlIPCursor* VG_(new_IIPC)(Addr eip)
+++InlIPCursor* VG_(new_IIPC)(DiEpoch ep, Addr eip)
++ {
++    DebugInfo*  di;
++    Word        locno;
++@@ -1576,8 +1753,8 @@ InlIPCursor* VG_(new_IIPC)(Addr eip)
++    if (!VG_(clo_read_inline_info))
++       return NULL; // No way we can find inlined calls.
++ 
++-   /* Search the DebugInfo for eip */
++-   search_all_loctabs ( eip, &di, &locno );
+++   /* Search the DebugInfo for (ep, eip) */
+++   search_all_loctabs ( ep, eip, &di, &locno );
++    if (di == NULL || di->inltab_used == 0)
++       return NULL; // No di (with inltab) containing eip.
++ 
++@@ -1641,8 +1818,8 @@ void VG_(delete_IIPC)(InlIPCursor *iipc)
++    If findText==True,  only text symbols are searched for.
++    If findText==False, only data symbols are searched for.
++ */
++-static void search_all_symtabs ( Addr ptr, /*OUT*/DebugInfo** pdi,
++-                                           /*OUT*/Word* symno,
+++static void search_all_symtabs ( DiEpoch ep, Addr ptr,
+++                                 /*OUT*/DebugInfo** pdi, /*OUT*/Word* symno,
++                                  Bool findText )
++ {
++    Word       sno;
++@@ -1651,6 +1828,9 @@ static void search_all_symtabs ( Addr pt
++ 
++    for (di = debugInfo_list; di != NULL; di = di->next) {
++ 
+++      if (!is_DI_valid_for_epoch(di, ep))
+++         continue;
+++
++       if (findText) {
++          /* Consider any symbol in the r-x mapped area to be text.
++             See Comment_Regarding_Text_Range_Checks in storage.c for
++@@ -1698,15 +1878,17 @@ static void search_all_symtabs ( Addr pt
++ }
++ 
++ 
++-/* Search all loctabs that we know about to locate ptr.  If found, set
++-   *pdi to the relevant DebugInfo, and *locno to the loctab entry
+++/* Search all loctabs that we know about to locate ptr at epoch ep.  If
+++   *found, set pdi to the relevant DebugInfo, and *locno to the loctab entry
++    *number within that.  If not found, *pdi is set to NULL. */
++-static void search_all_loctabs ( Addr ptr, /*OUT*/DebugInfo** pdi,
++-                                           /*OUT*/Word* locno )
+++static void search_all_loctabs ( DiEpoch ep, Addr ptr,
+++                                 /*OUT*/DebugInfo** pdi, /*OUT*/Word* locno )
++ {
++    Word       lno;
++    DebugInfo* di;
++    for (di = debugInfo_list; di != NULL; di = di->next) {
+++      if (!is_DI_valid_for_epoch(di, ep))
+++         continue;
++       if (di->text_present
++           && di->text_size > 0
++           && di->text_avma <= ptr 
++@@ -1729,19 +1911,22 @@ static void search_all_loctabs ( Addr pt
++ 
++ typedef
++    struct {
++-      Addr sym_avma;
+++      // (sym_epoch, sym_avma) are the hash table key.
+++      DiEpoch sym_epoch;
+++      Addr    sym_avma;
+++      // Fields below here are not part of the key.
++       const HChar* sym_name;
++       PtrdiffT offset : (sizeof(PtrdiffT)*8)-1; 
++       Bool isText : 1;
++    }
++    Sym_Name_CacheEnt;
++-/* Sym_Name_CacheEnt associates a queried address to the sym name found.
++-   By nature, if a sym name was found, it means the searched address
++-   stored in the cache is an avma (see e.g. search_all_symtabs).
++-   Note however that the caller is responsibe to work with 'avma'
++-   addresses e.g. when calling VG_(get_fnname) : m_debuginfo.c has
++-   no way to differentiate an 'svma a' from an 'avma a'. It is however
++-   unlikely that svma would percolate outside of this module. */
+++/* Sym_Name_CacheEnt associates a queried (epoch, address) pair to the sym
+++   name found.  By nature, if a sym name was found, it means the searched
+++   address stored in the cache is an avma (see e.g. search_all_symtabs).
+++   Note however that the caller is responsibe to work with 'avma' addresses
+++   e.g. when calling VG_(get_fnname) : m_debuginfo.c has no way to
+++   differentiate an 'svma a' from an 'avma a'. It is however unlikely that
+++   svma would percolate outside of this module. */
++ 
++ static Sym_Name_CacheEnt sym_name_cache[N_SYM_NAME_CACHE];
++ 
++@@ -1757,13 +1942,15 @@ static void sym_name_cache__invalidate (
++    sym_name_cache[0].sym_name = no_sym_name;
++ }
++ 
++-/* The whole point of this whole big deal: map a code address to a
++-   plausible symbol name.  Returns False if no idea; otherwise True.
+++/* The whole point of this whole big deal: map an (epoch, code address) pair
+++   to a plausible symbol name.  Returns False if no idea; otherwise True.
+++
++    Caller supplies buf.  If do_cxx_demangling is False, don't do
++    C++ demangling, regardless of VG_(clo_demangle) -- probably because the
++    call has come from VG_(get_fnname_raw)().  findText
++    indicates whether we're looking for a text symbol or a data symbol
++    -- caller must choose one kind or the other.
+++
++    NOTE: See IMPORTANT COMMENT above about persistence and ownership
++    in pub_tool_debuginfo.h 
++    get_sym_name and the fact it calls the demangler is the main reason
++@@ -1772,22 +1959,32 @@ static void sym_name_cache__invalidate (
++    (1) the DebugInfo it belongs to is not discarded
++    (2) the demangler is not invoked again
++    Also, the returned string is owned by "somebody else". Callers must
++-   not free it or modify it.*/
+++   not free it or modify it. */
++ static
++ Bool get_sym_name ( Bool do_cxx_demangling, Bool do_z_demangling,
++                     Bool do_below_main_renaming,
++-                    Addr a, const HChar** buf,
+++                    DiEpoch ep, Addr a, const HChar** buf,
++                     Bool match_anywhere_in_sym, Bool show_offset,
++                     Bool findText, /*OUT*/PtrdiffT* offsetP )
++ {
++-   UWord         hash = a % N_SYM_NAME_CACHE;
++-   Sym_Name_CacheEnt* se =  &sym_name_cache[hash];
+++   // Compute the hash from 'ep' and 'a'.  The latter contains lots of
+++   // significant bits, but 'ep' is expected to be a small number, typically
+++   // less than 500.  So rotate it around a bit in the hope of spreading the
+++   // bits out somewhat.
+++   vg_assert(!is_DiEpoch_INVALID(ep));
+++   UWord hash = a ^ (UWord)(ep.n ^ ROL32(ep.n, 5) 
+++                                 ^ ROL32(ep.n, 13) ^ ROL32(ep.n, 19));
+++   hash %= N_SYM_NAME_CACHE;
+++
+++   Sym_Name_CacheEnt* se = &sym_name_cache[hash];
++ 
++-   if (UNLIKELY(se->sym_avma != a || se->isText != findText)) {
+++   if (UNLIKELY(se->sym_epoch.n != ep.n || se->sym_avma != a
+++                || se->isText != findText)) {
++       DebugInfo* di;
++       Word       sno;
++ 
++-      search_all_symtabs ( a, &di, &sno, findText );
+++      search_all_symtabs ( ep, a, &di, &sno, findText );
+++      se->sym_epoch = ep;
++       se->sym_avma = a;
++       se->isText = findText;
++       if (di == NULL || a == 0)
++@@ -1846,12 +2043,12 @@ Bool get_sym_name ( Bool do_cxx_demangli
++ /* ppc64be-linux only: find the TOC pointer (R2 value) that should be in
++    force at the entry point address of the function containing
++    guest_code_addr.  Returns 0 if not known. */
++-Addr VG_(get_tocptr) ( Addr guest_code_addr )
+++Addr VG_(get_tocptr) ( DiEpoch ep, Addr guest_code_addr )
++ {
++ #if defined(VGA_ppc64be) || defined(VGA_ppc64le)
++    DebugInfo* si;
++    Word       sno;
++-   search_all_symtabs ( guest_code_addr, 
+++   search_all_symtabs ( ep, guest_code_addr, 
++                         &si, &sno,
++                         True/*consider text symbols only*/ );
++    if (si == NULL) 
++@@ -1867,11 +2064,11 @@ Addr VG_(get_tocptr) ( Addr guest_code_a
++    match anywhere in function, but don't show offsets.
++    NOTE: See IMPORTANT COMMENT above about persistence and ownership
++    in pub_tool_debuginfo.h */
++-Bool VG_(get_fnname) ( Addr a, const HChar** buf )
+++Bool VG_(get_fnname) ( DiEpoch ep, Addr a, const HChar** buf )
++ {
++    return get_sym_name ( /*C++-demangle*/True, /*Z-demangle*/True,
++                          /*below-main-renaming*/True,
++-                         a, buf,
+++                         ep, a, buf,
++                          /*match_anywhere_in_fun*/True, 
++                          /*show offset?*/False,
++                          /*text sym*/True,
++@@ -1882,11 +2079,11 @@ Bool VG_(get_fnname) ( Addr a, const HCh
++    match anywhere in function, and show offset if nonzero.
++    NOTE: See IMPORTANT COMMENT above about persistence and ownership
++    in pub_tool_debuginfo.h */
++-Bool VG_(get_fnname_w_offset) ( Addr a, const HChar** buf )
+++Bool VG_(get_fnname_w_offset) ( DiEpoch ep, Addr a, const HChar** buf )
++ {
++    return get_sym_name ( /*C++-demangle*/True, /*Z-demangle*/True,
++                          /*below-main-renaming*/True,
++-                         a, buf,
+++                         ep, a, buf,
++                          /*match_anywhere_in_fun*/True, 
++                          /*show offset?*/True,
++                          /*text sym*/True,
++@@ -1898,14 +2095,14 @@ Bool VG_(get_fnname_w_offset) ( Addr a,
++    and don't show offsets.
++    NOTE: See IMPORTANT COMMENT above about persistence and ownership
++    in pub_tool_debuginfo.h */
++-Bool VG_(get_fnname_if_entry) ( Addr a, const HChar** buf )
+++Bool VG_(get_fnname_if_entry) ( DiEpoch ep, Addr a, const HChar** buf )
++ {
++    const HChar *tmp;
++    Bool res;
++ 
++    res =  get_sym_name ( /*C++-demangle*/True, /*Z-demangle*/True,
++                          /*below-main-renaming*/True,
++-                         a, &tmp,
+++                         ep, a, &tmp,
++                          /*match_anywhere_in_fun*/False, 
++                          /*show offset?*/False,
++                          /*text sym*/True,
++@@ -1920,11 +2117,11 @@ Bool VG_(get_fnname_if_entry) ( Addr a,
++    offsets.
++    NOTE: See IMPORTANT COMMENT above about persistence and ownership
++    in pub_tool_debuginfo.h  */
++-Bool VG_(get_fnname_raw) ( Addr a, const HChar** buf )
+++Bool VG_(get_fnname_raw) ( DiEpoch ep, Addr a, const HChar** buf )
++ {
++    return get_sym_name ( /*C++-demangle*/False, /*Z-demangle*/False,
++                          /*below-main-renaming*/False,
++-                         a, buf,
+++                         ep, a, buf,
++                          /*match_anywhere_in_fun*/True, 
++                          /*show offset?*/False,
++                          /*text sym*/True,
++@@ -1936,14 +2133,22 @@ Bool VG_(get_fnname_raw) ( Addr a, const
++    don't show offsets.
++    NOTE: See IMPORTANT COMMENT above about persistence and ownership
++    in pub_tool_debuginfo.h */
++-Bool VG_(get_fnname_no_cxx_demangle) ( Addr a, const HChar** buf,
+++Bool VG_(get_fnname_no_cxx_demangle) ( DiEpoch ep, Addr a, const HChar** buf,
++                                        const InlIPCursor* iipc )
++ {
+++   // FIXME JRS 28 June 2017: should we use 'iipc->di->first_epoch'
+++   // instead of 'ep' in the call to get_sym_name?  At least let's
+++   // assert that the DebugInfo that 'iipc' mentions is valid for the
+++   // specified epoch.
+++   if (iipc) {
+++      vg_assert(is_DI_valid_for_epoch(iipc->di, ep));
+++   }
+++
++    if (is_bottom(iipc)) {
++       // At the bottom (towards main), we describe the fn at eip.
++       return get_sym_name ( /*C++-demangle*/False, /*Z-demangle*/True,
++                             /*below-main-renaming*/True,
++-                            a, buf,
+++                            ep, a, buf,
++                             /*match_anywhere_in_fun*/True, 
++                             /*show offset?*/False,
++                             /*text sym*/True,
++@@ -1962,13 +2167,13 @@ Bool VG_(get_fnname_no_cxx_demangle) ( A
++ /* mips-linux only: find the offset of current address. This is needed for 
++    stack unwinding for MIPS.
++ */
++-Bool VG_(get_inst_offset_in_function)( Addr a,
+++Bool VG_(get_inst_offset_in_function)( DiEpoch ep, Addr a,
++                                        /*OUT*/PtrdiffT* offset )
++ {
++    const HChar *fnname;
++    return get_sym_name ( /*C++-demangle*/False, /*Z-demangle*/False,
++                          /*below-main-renaming*/False,
++-                         a, &fnname,
+++                         ep, a, &fnname,
++                          /*match_anywhere_in_sym*/True, 
++                          /*show offset?*/False,
++                          /*text sym*/True,
++@@ -2000,13 +2205,13 @@ Vg_FnNameKind VG_(get_fnname_kind) ( con
++    }
++ }
++ 
++-Vg_FnNameKind VG_(get_fnname_kind_from_IP) ( Addr ip )
+++Vg_FnNameKind VG_(get_fnname_kind_from_IP) ( DiEpoch ep, Addr ip )
++ {
++    const HChar *buf;
++ 
++    // We don't demangle, because it's faster not to, and the special names
++    // we're looking for won't be mangled.
++-   if (VG_(get_fnname_raw) ( ip, &buf )) {
+++   if (VG_(get_fnname_raw) ( ep, ip, &buf )) {
++ 
++       return VG_(get_fnname_kind)(buf);
++    } else {
++@@ -2019,13 +2224,13 @@ Vg_FnNameKind VG_(get_fnname_kind_from_I
++    Also data_addr's offset from the symbol start is put into *offset.
++    NOTE: See IMPORTANT COMMENT above about persistence and ownership
++    in pub_tool_debuginfo.h  */
++-Bool VG_(get_datasym_and_offset)( Addr data_addr,
+++Bool VG_(get_datasym_and_offset)( DiEpoch ep, Addr data_addr,
++                                   /*OUT*/const HChar** dname,
++                                   /*OUT*/PtrdiffT* offset )
++ {
++    return get_sym_name ( /*C++-demangle*/False, /*Z-demangle*/False,
++                        /*below-main-renaming*/False,
++-                       data_addr, dname,
+++                       ep, data_addr, dname,
++                        /*match_anywhere_in_sym*/True, 
++                        /*show offset?*/False,
++                        /*text sym*/False,
++@@ -2038,7 +2243,7 @@ Bool VG_(get_datasym_and_offset)( Addr d
++    (1) the DebugInfo it belongs to is not discarded
++    (2) the segment containing the address is not merged with another segment
++ */
++-Bool VG_(get_objname) ( Addr a, const HChar** objname )
+++Bool VG_(get_objname) ( DiEpoch ep, Addr a, const HChar** objname )
++ {
++    DebugInfo* di;
++    const NSegment *seg;
++@@ -2047,6 +2252,8 @@ Bool VG_(get_objname) ( Addr a, const HC
++    /* Look in the debugInfo_list to find the name.  In most cases we
++       expect this to produce a result. */
++    for (di = debugInfo_list; di != NULL; di = di->next) {
+++      if (!is_DI_valid_for_epoch(di, ep))
+++         continue;
++       if (di->text_present
++           && di->text_size > 0
++           && di->text_avma <= a 
++@@ -2059,8 +2266,13 @@ Bool VG_(get_objname) ( Addr a, const HC
++       the debugInfo_list, ask the address space manager whether it
++       knows the name of the file associated with this mapping.  This
++       allows us to print the names of exe/dll files in the stack trace
++-      when running programs under wine. */
++-   if ( (seg = VG_(am_find_nsegment)(a)) != NULL 
+++      when running programs under wine.
+++
+++      Restrict this to the case where 'ep' is the current epoch, though, so
+++      that we don't return information about this epoch when the caller was
+++      enquiring about a different one. */
+++   if ( eq_DiEpoch(ep, VG_(current_DiEpoch)())
+++        && (seg = VG_(am_find_nsegment)(a)) != NULL 
++         && (filename = VG_(am_get_filename)(seg)) != NULL ) {
++       *objname = filename;
++       return True;
++@@ -2070,12 +2282,14 @@ Bool VG_(get_objname) ( Addr a, const HC
++ 
++ /* Map a code address to its DebugInfo.  Returns NULL if not found.  Doesn't
++    require debug info. */
++-DebugInfo* VG_(find_DebugInfo) ( Addr a )
+++DebugInfo* VG_(find_DebugInfo) ( DiEpoch ep, Addr a )
++ {
++    static UWord n_search = 0;
++    DebugInfo* di;
++    n_search++;
++    for (di = debugInfo_list; di != NULL; di = di->next) {
+++      if (!is_DI_valid_for_epoch(di, ep))
+++         continue;
++       if (di->text_present
++           && di->text_size > 0
++           && di->text_avma <= a 
++@@ -2091,13 +2305,13 @@ DebugInfo* VG_(find_DebugInfo) ( Addr a
++ /* Map a code address to a filename.  Returns True if successful. The
++    returned string is persistent as long as the DebugInfo to which it
++    belongs is not discarded. */
++-Bool VG_(get_filename)( Addr a, const HChar** filename )
+++Bool VG_(get_filename)( DiEpoch ep, Addr a, const HChar** filename )
++ {
++    DebugInfo* si;
++    Word       locno;
++    UInt       fndn_ix;
++ 
++-   search_all_loctabs ( a, &si, &locno );
+++   search_all_loctabs ( ep, a, &si, &locno );
++    if (si == NULL) 
++       return False;
++    fndn_ix = ML_(fndn_ix) (si, locno);
++@@ -2106,11 +2320,11 @@ Bool VG_(get_filename)( Addr a, const HC
++ }
++ 
++ /* Map a code address to a line number.  Returns True if successful. */
++-Bool VG_(get_linenum)( Addr a, UInt* lineno )
+++Bool VG_(get_linenum)( DiEpoch ep, Addr a, UInt* lineno )
++ {
++    DebugInfo* si;
++    Word       locno;
++-   search_all_loctabs ( a, &si, &locno );
+++   search_all_loctabs ( ep, a, &si, &locno );
++    if (si == NULL) 
++       return False;
++    *lineno = si->loctab[locno].lineno;
++@@ -2121,7 +2335,7 @@ Bool VG_(get_linenum)( Addr a, UInt* lin
++ /* Map a code address to a filename/line number/dir name info.
++    See prototype for detailed description of behaviour.
++ */
++-Bool VG_(get_filename_linenum) ( Addr a, 
+++Bool VG_(get_filename_linenum) ( DiEpoch ep, Addr a, 
++                                  /*OUT*/const HChar** filename,
++                                  /*OUT*/const HChar** dirname,
++                                  /*OUT*/UInt* lineno )
++@@ -2130,7 +2344,7 @@ Bool VG_(get_filename_linenum) ( Addr a,
++    Word       locno;
++    UInt       fndn_ix;
++ 
++-   search_all_loctabs ( a, &si, &locno );
+++   search_all_loctabs ( ep, a, &si, &locno );
++    if (si == NULL) {
++       if (dirname) {
++          *dirname = "";
++@@ -2159,7 +2373,8 @@ Bool VG_(get_filename_linenum) ( Addr a,
++    Therefore specify "*" to search all the objects.  On TOC-afflicted
++    platforms, a symbol is deemed to be found only if it has a nonzero
++    TOC pointer.  */
++-Bool VG_(lookup_symbol_SLOW)(const HChar* sopatt, const HChar* name,
+++Bool VG_(lookup_symbol_SLOW)(DiEpoch ep,
+++                             const HChar* sopatt, const HChar* name,
++                              SymAVMAs* avmas)
++ {
++    Bool     require_pToc = False;
++@@ -2172,6 +2387,8 @@ Bool VG_(lookup_symbol_SLOW)(const HChar
++    for (si = debugInfo_list; si; si = si->next) {
++       if (debug)
++          VG_(printf)("lookup_symbol_SLOW: considering %s\n", si->soname);
+++      if (!is_DI_valid_for_epoch(si, ep))
+++         continue;
++       if (!VG_(string_match)(sopatt, si->soname)) {
++          if (debug)
++             VG_(printf)(" ... skip\n");
++@@ -2254,7 +2471,7 @@ putStrEsc( SizeT n, HChar** buf, SizeT *
++    return n;
++ }
++ 
++-const HChar* VG_(describe_IP)(Addr eip, const InlIPCursor *iipc)
+++const HChar* VG_(describe_IP)(DiEpoch ep, Addr eip, const InlIPCursor *iipc)
++ {
++    static HChar *buf = NULL;
++    static SizeT bufsiz = 0;
++@@ -2267,7 +2484,10 @@ const HChar* VG_(describe_IP)(Addr eip,
++    HChar ibuf[50];   // large enough
++    SizeT n = 0;
++ 
++-   vg_assert (!iipc || iipc->eip == eip);
+++   // An InlIPCursor is associated with one specific DebugInfo.  So if
+++   // it exists, make sure that it is valid for the specified DiEpoch.
+++   vg_assert (!iipc
+++              || (is_DI_valid_for_epoch(iipc->di, ep) && iipc->eip == eip));
++ 
++    const HChar *buf_fn;
++    const HChar *buf_obj;
++@@ -2282,8 +2502,8 @@ const HChar* VG_(describe_IP)(Addr eip,
++    if (is_bottom(iipc)) {
++       // At the bottom (towards main), we describe the fn at eip.
++       know_fnname = VG_(clo_sym_offsets)
++-                    ? VG_(get_fnname_w_offset) (eip, &buf_fn)
++-                    : VG_(get_fnname) (eip, &buf_fn);
+++                    ? VG_(get_fnname_w_offset) (ep, eip, &buf_fn)
+++                    : VG_(get_fnname) (ep, eip, &buf_fn);
++    } else {
++       const DiInlLoc *next_inl = iipc && iipc->next_inltab >= 0
++          ? & iipc->di->inltab[iipc->next_inltab]
++@@ -2301,12 +2521,12 @@ const HChar* VG_(describe_IP)(Addr eip,
++       // ??? Currently never showing an offset.
++    }
++ 
++-   know_objname = VG_(get_objname)(eip, &buf_obj);
+++   know_objname = VG_(get_objname)(ep, eip, &buf_obj);
++ 
++    if (is_top(iipc)) {
++       // The source for the highest level is in the loctab entry.
++       know_srcloc  = VG_(get_filename_linenum)(
++-                        eip, 
+++                        ep, eip, 
++                         &buf_srcloc, 
++                         &buf_dirname,
++                         &lineno 
++@@ -2459,6 +2679,20 @@ const HChar* VG_(describe_IP)(Addr eip,
++ /*---                                                        ---*/
++ /*--------------------------------------------------------------*/
++ 
+++/* Note that the CFI machinery pertains to unwinding the stack "right now".
+++   There is no support for unwinding stack images obtained from some time in
+++   the past.  That means that:
+++
+++   (1) We only deal with CFI from DebugInfos that are valid for the current
+++       debuginfo epoch.  Unlike in the rest of the file, there is no
+++       epoch-awareness.
+++
+++   (2) We assume that the CFI cache will be invalidated every time the the
+++       epoch changes.  This is done by ensuring (in the file above) that
+++       every call to advance_current_DiEpoch has a call to
+++       caches__invalidate alongside it.
+++*/
+++
++ /* Gather up all the constant pieces of info needed to evaluate
++    a CfiExpr into one convenient struct. */
++ typedef
++@@ -2579,6 +2813,9 @@ UWord evalCfiExpr ( const XArray* exprs,
++    *cfsi_mP to the cfsi_m pointer in that DebugInfo's cfsi_m_pool.
++ 
++    If not found, set *diP to (DebugInfo*)1 and *cfsi_mP to zero.
+++
+++   Per comments at the top of this section, we only look for CFI in
+++   DebugInfos that are valid for the current epoch.
++ */
++ __attribute__((noinline))
++ static void find_DiCfSI ( /*OUT*/DebugInfo** diP, 
++@@ -2594,10 +2831,15 @@ static void find_DiCfSI ( /*OUT*/DebugIn
++ 
++    if (0) VG_(printf)("search for %#lx\n", ip);
++ 
+++   DiEpoch curr_epoch = VG_(current_DiEpoch)();
+++
++    for (di = debugInfo_list; di != NULL; di = di->next) {
++       Word j;
++       n_steps++;
++ 
+++      if (!is_DI_valid_for_epoch(di, curr_epoch))
+++         continue;
+++
++       /* Use the per-DebugInfo summary address ranges to skip
++          inapplicable DebugInfos quickly. */
++       if (di->cfsi_used == 0)
++@@ -2605,6 +2847,11 @@ static void find_DiCfSI ( /*OUT*/DebugIn
++       if (ip < di->cfsi_minavma || ip > di->cfsi_maxavma)
++          continue;
++ 
+++      // This di must be active (because we have explicitly chosen not to
+++      // allow unwinding stacks that pertain to some past epoch).  It can't
+++      // be archived or not-yet-active.
+++      vg_assert(is_DebugInfo_active(di));
+++
++       /* It might be in this DebugInfo.  Search it. */
++       j = ML_(search_one_cfitab)( di, ip );
++       vg_assert(j >= -1 && j < (Word)di->cfsi_used);
++@@ -3032,6 +3279,7 @@ Bool VG_(use_CF_info) ( /*MOD*/D3UnwindR
++ Bool VG_(use_FPO_info) ( /*MOD*/Addr* ipP,
++                          /*MOD*/Addr* spP,
++                          /*MOD*/Addr* fpP,
+++                         DiEpoch ep,
++                          Addr min_accessible,
++                          Addr max_accessible )
++ {
++@@ -3049,6 +3297,9 @@ Bool VG_(use_FPO_info) ( /*MOD*/Addr* ip
++    for (di = debugInfo_list; di != NULL; di = di->next) {
++       n_steps++;
++ 
+++      if (!is_DI_valid_for_epoch(di, ep))
+++         continue;
+++
++       /* Use the per-DebugInfo summary address ranges to skip
++          inapplicable DebugInfos quickly. */
++       if (di->fpo == NULL)
++@@ -3552,6 +3803,7 @@ static void format_message ( /*MOD*/XArr
++ static 
++ Bool consider_vars_in_frame ( /*MOD*/XArray* /* of HChar */ dname1,
++                               /*MOD*/XArray* /* of HChar */ dname2,
+++                              DiEpoch ep,
++                               Addr data_addr,
++                               Addr ip, Addr sp, Addr fp,
++                               /* shown to user: */
++@@ -3570,6 +3822,8 @@ Bool consider_vars_in_frame ( /*MOD*/XAr
++    /* first, find the DebugInfo that pertains to 'ip'. */
++    for (di = debugInfo_list; di; di = di->next) {
++       n_steps++;
+++      if (!is_DI_valid_for_epoch(di, ep))
+++         continue;
++       /* text segment missing? unlikely, but handle it .. */
++       if (!di->text_present || di->text_size == 0)
++          continue;
++@@ -3687,7 +3941,7 @@ Bool consider_vars_in_frame ( /*MOD*/XAr
++ Bool VG_(get_data_description)( 
++         /*MOD*/ XArray* /* of HChar */ dname1,
++         /*MOD*/ XArray* /* of HChar */ dname2,
++-        Addr data_addr
+++        DiEpoch ep, Addr data_addr
++      )
++ {
++ #  define N_FRAMES 8
++@@ -3807,7 +4061,7 @@ Bool VG_(get_data_description)(
++    vg_assert(n_frames >= 0 && n_frames <= N_FRAMES);
++    for (j = 0; j < n_frames; j++) {
++       if (consider_vars_in_frame( dname1, dname2,
++-                                  data_addr,
+++                                  ep, data_addr,
++                                   ips[j], 
++                                   sps[j], fps[j], tid, j )) {
++          zterm_XA( dname1 );
++@@ -3834,7 +4088,7 @@ Bool VG_(get_data_description)(
++          equivalent kludge. */
++       if (j > 0 /* this is a non-innermost frame */
++           && consider_vars_in_frame( dname1, dname2,
++-                                     data_addr,
+++                                     ep, data_addr,
++                                      ips[j] + 1, 
++                                      sps[j], fps[j], tid, j )) {
++          zterm_XA( dname1 );
++Index: valgrind-3.13.0/coregrind/m_debuginfo/priv_storage.h
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_debuginfo/priv_storage.h
+++++ valgrind-3.13.0/coregrind/m_debuginfo/priv_storage.h
++@@ -588,6 +588,36 @@ struct _DebugInfo {
++       structure is allocated. */
++    ULong handle;
++ 
+++   /* The range of epochs for which this DebugInfo is valid.  These also
+++      divide the DebugInfo's lifetime into three parts:
+++
+++      (1) Allocated: but with only .fsm holding useful info -- in
+++          particular, not yet holding any debug info.
+++          .first_epoch == DebugInfoEpoch_INVALID
+++          .last_epoch  == DebugInfoEpoch_INVALID
+++
+++      (2) Active: containing debug info, and current.
+++          .first_epoch != DebugInfoEpoch_INVALID
+++          .last_epoch  == DebugInfoEpoch_INVALID
+++
+++      (3) Archived: containing debug info, but no longer current.
+++          .first_epoch != DebugInfoEpoch_INVALID
+++          .last_epoch  != DebugInfoEpoch_INVALID
+++
+++      State (2) corresponds to an object which is currently mapped.  When
+++      the object is unmapped, what happens depends on the setting of
+++      --keep-debuginfo:
+++      
+++      * when =no, the DebugInfo is removed from debugInfo_list and
+++        deleted.
+++
+++      * when =yes, the DebugInfo is retained in debugInfo_list, but its
+++        .last_epoch field is filled in, and current_epoch is advanced.  This
+++        effectively moves the DebugInfo into state (3).
+++   */
+++   DiEpoch first_epoch;
+++   DiEpoch last_epoch;
+++
++    /* Used for debugging only - indicate what stuff to dump whilst
++       reading stuff into the seginfo.  Are computed as early in the
++       lifetime of the DebugInfo as possible -- at the point when it is
++Index: valgrind-3.13.0/coregrind/m_errormgr.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_errormgr.c
+++++ valgrind-3.13.0/coregrind/m_errormgr.c
++@@ -136,16 +136,16 @@ struct _Error {
++    Int count;
++ 
++    // The tool-specific part
++-   ThreadId tid;           // Initialised by core
++-   ExeContext* where;      // Initialised by core
++-   ErrorKind ekind;        // Used by ALL.  Must be in the range (0..)
++-   Addr addr;              // Used frequently
++-   const HChar* string;    // Used frequently
++-   void* extra;            // For any tool-specific extras
+++   ThreadId tid;              // Initialised by core
+++   ExeContextAndEpoch where;  // Initialised by core
+++   ErrorKind ekind;           // Used by ALL.  Must be in the range (0..)
+++   Addr addr;                 // Used frequently
+++   const HChar* string;       // Used frequently
+++   void* extra;               // For any tool-specific extras
++ };
++ 
++ 
++-ExeContext* VG_(get_error_where) ( const Error* err )
+++ExeContextAndEpoch VG_(get_error_where) ( const Error* err )
++ {
++    return err->where;
++ }
++@@ -293,7 +293,10 @@ static Bool eq_Error ( VgRes res, const
++ {
++    if (e1->ekind != e2->ekind) 
++       return False;
++-   if (!VG_(eq_ExeContext)(res, e1->where, e2->where))
+++   // This comparison ignores the debuginfo epoch.  Result is that we
+++   // could conclude this error is the same as one from some other epoch.
+++   // I don't think that's a big deal in practice.
+++   if (!VG_(eq_ExeContext)(res, e1->where.ec, e2->where.ec))
++       return False;
++ 
++    switch (e1->ekind) {
++@@ -321,15 +324,15 @@ static Bool eq_Error ( VgRes res, const
++ */
++ #define ERRTXT_LEN   4096
++ 
++-static void printSuppForIp_XML(UInt n, Addr ip, void* uu_opaque)
+++static void printSuppForIp_XML(UInt n, DiEpoch ep, Addr ip, void* uu_opaque)
++ {
++    const HChar *buf;
++-   InlIPCursor* iipc = VG_(new_IIPC)(ip);
+++   InlIPCursor* iipc = VG_(new_IIPC)(ep, ip);
++    do {
++-      if ( VG_(get_fnname_no_cxx_demangle) (ip, &buf, iipc) ) {
+++      if ( VG_(get_fnname_no_cxx_demangle) (ep, ip, &buf, iipc) ) {
++          VG_(printf_xml)("    <sframe> <fun>%pS</fun> </sframe>\n", buf);
++       } else
++-      if ( VG_(get_objname)(ip, &buf) ) {
+++      if ( VG_(get_objname)(ep, ip, &buf) ) {
++          VG_(printf_xml)("    <sframe> <obj>%pS</obj> </sframe>\n", buf);
++       } else {
++          VG_(printf_xml)("    <sframe> <obj>*</obj> </sframe>\n");
++@@ -338,16 +341,16 @@ static void printSuppForIp_XML(UInt n, A
++    VG_(delete_IIPC)(iipc);
++ }
++ 
++-static void printSuppForIp_nonXML(UInt n, Addr ip, void* textV)
+++static void printSuppForIp_nonXML(UInt n, DiEpoch ep, Addr ip, void* textV)
++ {
++    const HChar *buf;
++    XArray* /* of HChar */ text = (XArray*)textV;
++-   InlIPCursor* iipc = VG_(new_IIPC)(ip);
+++   InlIPCursor* iipc = VG_(new_IIPC)(ep, ip);
++    do {
++-      if ( VG_(get_fnname_no_cxx_demangle) (ip, &buf, iipc) ) {
+++      if ( VG_(get_fnname_no_cxx_demangle) (ep, ip, &buf, iipc) ) {
++          VG_(xaprintf)(text, "   fun:%s\n", buf);
++       } else
++-      if ( VG_(get_objname)(ip, &buf) ) {
+++      if ( VG_(get_objname)(ep, ip, &buf) ) {
++          VG_(xaprintf)(text, "   obj:%s\n", buf);
++       } else {
++          VG_(xaprintf)(text, "   obj:*\n");
++@@ -361,15 +364,15 @@ static void printSuppForIp_nonXML(UInt n
++ static void gen_suppression(const Error* err)
++ {
++    const HChar* name;
++-   ExeContext* ec;
+++   ExeContextAndEpoch ece;
++    XArray* /* HChar */ text;
++ 
++    const HChar* dummy_name = "insert_a_suppression_name_here";
++ 
++    vg_assert(err);
++ 
++-   ec = VG_(get_error_where)(err);
++-   vg_assert(ec);
+++   ece = VG_(get_error_where)(err);
+++   vg_assert(ece.ec);
++ 
++    name = VG_TDICT_CALL(tool_get_error_name, err);
++    if (NULL == name) {
++@@ -408,12 +411,12 @@ static void gen_suppression(const Error*
++       VG_(xaprintf)(text, "   %s\n", xtra);
++ 
++    // Print stack trace elements
++-   UInt n_ips = VG_(get_ExeContext_n_ips)(ec);
+++   UInt n_ips = VG_(get_ExeContext_n_ips)(ece.ec);
++    vg_assert(n_ips > 0);
++    vg_assert(n_ips <= VG_DEEPEST_BACKTRACE);
++    VG_(apply_StackTrace)(printSuppForIp_nonXML,
++-                         text,
++-                         VG_(get_ExeContext_StackTrace)(ec),
+++                         text, ece.epoch,
+++                         VG_(get_ExeContext_StackTrace)(ece.ec),
++                          n_ips);
++ 
++    VG_(xaprintf)(text, "}\n");
++@@ -441,9 +444,9 @@ static void gen_suppression(const Error*
++ 
++       // Print stack trace elements
++       VG_(apply_StackTrace)(printSuppForIp_XML,
++-                            NULL,
++-                            VG_(get_ExeContext_StackTrace)(ec),
++-                            VG_(get_ExeContext_n_ips)(ec));
+++                            NULL, ece.epoch,
+++                            VG_(get_ExeContext_StackTrace)(ece.ec),
+++                            VG_(get_ExeContext_n_ips)(ece.ec));
++ 
++       // And now the cdata bit
++       // XXX FIXME!  properly handle the case where the raw text
++@@ -637,7 +640,7 @@ static void pp_Error ( const Error* err,
++ /* Construct an error */
++ static
++ void construct_error ( Error* err, ThreadId tid, ErrorKind ekind, Addr a,
++-                       const HChar* s, void* extra, ExeContext* where )
+++                       const HChar* s, void* extra, ExeContextAndEpoch where )
++ {
++    /* DO NOT MAKE unique_counter NON-STATIC */
++    static UInt unique_counter = 0;
++@@ -650,10 +653,7 @@ void construct_error ( Error* err, Threa
++    err->supp     = NULL;
++    err->count    = 1;
++    err->tid      = tid;
++-   if (NULL == where)
++-     err->where = VG_(record_ExeContext)( tid, 0 );
++-   else
++-      err->where = where;
+++   err->where    = where;
++ 
++    /* Tool-relevant parts */
++    err->ekind  = ekind;
++@@ -744,7 +744,10 @@ void VG_(maybe_record_error) ( ThreadId
++    }
++ 
++    /* Build ourselves the error */
++-   construct_error ( &err, tid, ekind, a, s, extra, NULL );
+++   { ExeContextAndEpoch ece
+++        = VG_(tag_EC_with_current_epoch)( VG_(record_ExeContext)( tid, 0 ) );
+++      construct_error ( &err, tid, ekind, a, s, extra, ece );
+++   }
++ 
++    /* First, see if we've got an error record matching this one. */
++    em_errlist_searches++;
++@@ -853,7 +856,8 @@ void VG_(maybe_record_error) ( ThreadId
++    Bool 'count_error' dictates whether to count the error in n_errs_found.
++ */
++ Bool VG_(unique_error) ( ThreadId tid, ErrorKind ekind, Addr a, const HChar* s,
++-                         void* extra, ExeContext* where, Bool print_error,
+++                         void* extra, ExeContextAndEpoch where,
+++                         Bool print_error,
++                          Bool allow_db_attach, Bool count_error )
++ {
++    Error err;
++@@ -1016,7 +1020,7 @@ void VG_(show_all_errors) (  Int verbosi
++       vg_assert(! xml);
++ 
++       if ((i+1 == VG_(clo_dump_error))) {
++-         StackTrace ips = VG_(get_ExeContext_StackTrace)(p_min->where);
+++         StackTrace ips = VG_(get_ExeContext_StackTrace)(p_min->where.ec);
++          VG_(translate) ( 0 /* dummy ThreadId; irrelevant due to debugging*/,
++                           ips[0], /*debugging*/True, 0xFE/*verbosity*/,
++                           /*bbs_done*/0,
++@@ -1500,6 +1504,7 @@ static Bool supploc_IsQuery ( const void
++    allocations and the nr of debuginfo search. */
++ typedef
++    struct {
+++      DiEpoch epoch;  // used to interpret .ips
++       StackTrace ips; // stack trace we are lazily completing.
++       UWord n_ips; // nr of elements in ips.
++ 
++@@ -1595,9 +1600,11 @@ static void clearIPtoFunOrObjCompleter (
++                    su->sname,
++                    filename,
++                    su->sname_lineno);
++-      } else
+++      } else {
++          VG_(dmsg)("errormgr matching end no suppression matched:\n");
++-      VG_(pp_StackTrace) (ip2fo->ips, ip2fo->n_ips);
+++      }
+++      // JRS 27 July 2017: is it OK to use the current epoch here?
+++      VG_(pp_StackTrace) (ip2fo->epoch, ip2fo->ips, ip2fo->n_ips);
++       pp_ip2fo(ip2fo);
++    }
++    if (ip2fo->n_offsets_per_ip) VG_(free)(ip2fo->n_offsets_per_ip);
++@@ -1660,7 +1667,8 @@ static HChar* foComplete(IPtoFunOrObjCom
++          // up comparing "malloc" in the suppression against
++          // "_vgrZU_libcZdsoZa_malloc" in the backtrace, and the
++          // two of them need to be made to match.
++-         if (!VG_(get_fnname_no_cxx_demangle)(ip2fo->ips[ixInput],
+++         if (!VG_(get_fnname_no_cxx_demangle)(ip2fo->epoch,
+++                                              ip2fo->ips[ixInput],
++                                               &caller,
++                                               NULL))
++             caller = "???";
++@@ -1681,7 +1689,7 @@ static HChar* foComplete(IPtoFunOrObjCom
++             last_expand_pos_ips is the last offset in fun/obj where
++             ips[pos_ips] has been expanded. */
++ 
++-         if (!VG_(get_objname)(ip2fo->ips[pos_ips], &caller))
+++         if (!VG_(get_objname)(ip2fo->epoch, ip2fo->ips[pos_ips], &caller))
++             caller = "???";
++ 
++          // Have all inlined calls pointing at this object name
++@@ -1751,7 +1759,7 @@ static void expandInput (IPtoFunOrObjCom
++          const Addr IP = ip2fo->ips[ip2fo->n_ips_expanded];
++          InlIPCursor *iipc;
++ 
++-         iipc = VG_(new_IIPC)(IP);
+++         iipc = VG_(new_IIPC)(ip2fo->epoch, IP);
++          // The only thing we really need is the nr of inlined fn calls
++          // corresponding to the IP we will expand.
++          // However, computing this is mostly the same as finding
++@@ -1760,7 +1768,7 @@ static void expandInput (IPtoFunOrObjCom
++             const HChar *caller;
++             grow_offsets(ip2fo, ip2fo->n_expanded+1);
++             ip2fo->fun_offsets[ip2fo->n_expanded] = ip2fo->names_free;
++-            if (!VG_(get_fnname_no_cxx_demangle)(IP, 
+++            if (!VG_(get_fnname_no_cxx_demangle)(ip2fo->epoch, IP, 
++                                                  &caller,
++                                                  iipc))
++                caller = "???";
++@@ -1788,18 +1796,18 @@ static void expandInput (IPtoFunOrObjCom
++    }
++ }
++ 
++-static Bool haveInputInpC (void* inputCompleter, UWord ixInput )
+++static Bool haveInputInpC (void* inputCompleterV, UWord ixInput )
++ {
++-   IPtoFunOrObjCompleter* ip2fo = inputCompleter;
+++   IPtoFunOrObjCompleter* ip2fo = (IPtoFunOrObjCompleter*)inputCompleterV;
++    expandInput(ip2fo, ixInput);
++    return ixInput < ip2fo->n_expanded;
++ }
++ 
++ static Bool supp_pattEQinp ( const void* supplocV, const void* addrV,
++-                             void* inputCompleter, UWord ixInput )
+++                             void* inputCompleterV, UWord ixInput )
++ {
++-   const SuppLoc* supploc = supplocV; /* PATTERN */
++-   IPtoFunOrObjCompleter* ip2fo = inputCompleter;
+++   const SuppLoc* supploc = (const SuppLoc*)supplocV; /* PATTERN */
+++   IPtoFunOrObjCompleter* ip2fo = (IPtoFunOrObjCompleter*)inputCompleterV;
++    HChar* funobj_name; // Fun or Obj name.
++    Bool ret;
++ 
++@@ -1926,8 +1934,9 @@ static Supp* is_suppressible_error ( con
++    em_supplist_searches++;
++ 
++    /* Prepare the lazy input completer. */
++-   ip2fo.ips = VG_(get_ExeContext_StackTrace)(err->where);
++-   ip2fo.n_ips = VG_(get_ExeContext_n_ips)(err->where);
+++   ip2fo.epoch = err->where.epoch;
+++   ip2fo.ips = VG_(get_ExeContext_StackTrace)(err->where.ec);
+++   ip2fo.n_ips = VG_(get_ExeContext_n_ips)(err->where.ec);
++    ip2fo.n_ips_expanded = 0;
++    ip2fo.n_expanded = 0;
++    ip2fo.sz_offsets = 0;
++Index: valgrind-3.13.0/coregrind/m_execontext.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_execontext.c
+++++ valgrind-3.13.0/coregrind/m_execontext.c
++@@ -116,7 +116,7 @@ static ULong ec_cmpAlls;
++ 
++ 
++ /*------------------------------------------------------------*/
++-/*--- Exported functions.                                  ---*/
+++/*--- ExeContext functions.                                ---*/
++ /*------------------------------------------------------------*/
++ 
++ static ExeContext* record_ExeContext_wrk2 ( const Addr* ips, UInt n_ips );
++@@ -169,7 +169,9 @@ void VG_(print_ExeContext_stats) ( Bool
++          for (ec = ec_htab[i]; ec; ec = ec->chain) {
++             VG_(message)(Vg_DebugMsg, "   exectx: stacktrace ecu %u n_ips %u\n",
++                          ec->ecu, ec->n_ips);
++-            VG_(pp_StackTrace)( ec->ips, ec->n_ips );
+++            // FIXME JRS 27 July 2017: is a fake epoch here OK?
+++            DiEpoch ep = VG_(current_DiEpoch)();
+++            VG_(pp_StackTrace)( ep, ec->ips, ec->n_ips );
++          }
++       }
++       VG_(message)(Vg_DebugMsg, 
++@@ -202,13 +204,6 @@ void VG_(print_ExeContext_stats) ( Bool
++ }
++ 
++ 
++-/* Print an ExeContext. */
++-void VG_(pp_ExeContext) ( ExeContext* ec )
++-{
++-   VG_(pp_StackTrace)( ec->ips, ec->n_ips );
++-}
++-
++-
++ /* Compare two ExeContexts.  Number of callers considered depends on res. */
++ Bool VG_(eq_ExeContext) ( VgRes res, const ExeContext* e1,
++                           const ExeContext* e2 )
++@@ -544,12 +539,48 @@ ExeContext* VG_(make_ExeContext_from_Sta
++    return record_ExeContext_wrk2(ips, n_ips);
++ }
++ 
++-ExeContext* VG_(null_ExeContext) (void)
+++
+++/*------------------------------------------------------------*/
+++/*--- ExeContextAndEpoch functions.                        ---*/
+++/*------------------------------------------------------------*/
+++
+++ExeContextAndEpoch VG_(tag_EC_with_current_epoch)( ExeContext* ec )
+++{
+++   ExeContextAndEpoch ece;
+++   ece.ec    = ec;
+++   ece.epoch = VG_(current_DiEpoch)();
+++   return ece;
+++}
+++
+++ExeContextAndEpoch VG_(invalid_ExeContextAndEpoch) ( void )
+++{
+++   ExeContextAndEpoch ece;
+++   ece.ec      = NULL/*invalid ExeContext*/;
+++   ece.epoch.n = 0/*invalid epoch*/;
+++   return ece;
+++}
+++
+++
+++void VG_(pp_ExeContextAndEpoch) ( ExeContextAndEpoch ece )
+++{
+++   VG_(pp_StackTrace)( ece.epoch, ece.ec->ips, ece.ec->n_ips );
+++}
+++
+++ExeContextAndEpoch VG_(null_ExeContextAndEpoch) ( void )
++ {
++    init_ExeContext_storage();
++-   return null_ExeContext;
+++   ExeContextAndEpoch ece
+++      = mk_ExeContextAndEpoch(null_ExeContext, VG_(current_DiEpoch)());
+++   return ece;
++ }
++ 
+++Bool VG_(is_null_ExeContextAndEpoch)( ExeContextAndEpoch ece )
+++{
+++   init_ExeContext_storage();
+++   return ece.ec == null_ExeContext;
+++}
+++
+++
++ /*--------------------------------------------------------------------*/
++ /*--- end                                           m_execontext.c ---*/
++ /*--------------------------------------------------------------------*/
++Index: valgrind-3.13.0/coregrind/m_gdbserver/m_gdbserver.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_gdbserver/m_gdbserver.c
+++++ valgrind-3.13.0/coregrind/m_gdbserver/m_gdbserver.c
++@@ -142,14 +142,17 @@ static HChar* sym (Addr addr, Bool is_co
++    PtrdiffT offset;
++    if (w == 2) w = 0;
++ 
+++   // FIXME JRS 28 July 2017: HACK!  Is this correct?
+++   const DiEpoch ep = VG_(current_DiEpoch)();
+++
++    if (is_code) {
++       const HChar *name;
++-      name = VG_(describe_IP) (addr, NULL);
+++      name = VG_(describe_IP) (ep, addr, NULL);
++       if (buf[w]) VG_(free)(buf[w]);
++       buf[w] = VG_(strdup)("gdbserver sym", name);
++    } else {
++       const HChar *name;
++-      VG_(get_datasym_and_offset) (addr, &name, &offset);
+++      VG_(get_datasym_and_offset) (ep, addr, &name, &offset);
++       if (buf[w]) VG_(free)(buf[w]);
++       buf[w] = VG_(strdup)("gdbserver sym", name);
++    }
++Index: valgrind-3.13.0/coregrind/m_gdbserver/server.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_gdbserver/server.c
+++++ valgrind-3.13.0/coregrind/m_gdbserver/server.c
++@@ -195,6 +195,9 @@ int handle_gdb_valgrind_command (char *m
++    int   kwdid;
++    int int_value;
++ 
+++   // FIXME JRS 28 July 2017: HACK!  Is this correct?
+++   const DiEpoch ep = VG_(current_DiEpoch)();
+++
++    vg_assert (initial_valgrind_sink_saved);
++ 
++    strcpy (s, mon);
++@@ -334,7 +337,7 @@ int handle_gdb_valgrind_command (char *m
++          }
++          if (hostvisibility) {
++             const DebugInfo *tooldi 
++-               = VG_(find_DebugInfo) ((Addr)handle_gdb_valgrind_command);
+++               = VG_(find_DebugInfo) (ep, (Addr)handle_gdb_valgrind_command);
++             /* Normally, we should always find the tooldi. In case we
++                do not, suggest a 'likely somewhat working' address: */
++             const Addr tool_text_start
++@@ -442,14 +445,14 @@ int handle_gdb_valgrind_command (char *m
++                                                &dummy_sz, &ssaveptr)) {
++             // If tool provides location information, use that.
++             if (VG_(needs).info_location) {
++-               VG_TDICT_CALL(tool_info_location, address);
+++               VG_TDICT_CALL(tool_info_location, ep, address);
++             } 
++             // If tool does not provide location info, use the common one.
++             // Also use the common to compare with tool when debug log is set.
++             if (!VG_(needs).info_location || VG_(debugLog_getLevel)() > 0 ) {
++                AddrInfo ai;
++                ai.tag = Addr_Undescribed;
++-               VG_(describe_addr) (address, &ai);
+++               VG_(describe_addr) (ep, address, &ai);
++                VG_(pp_addrinfo) (address, &ai);
++                VG_(clear_addrinfo) (&ai);
++             }
++Index: valgrind-3.13.0/coregrind/m_gdbserver/target.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_gdbserver/target.c
+++++ valgrind-3.13.0/coregrind/m_gdbserver/target.c
++@@ -209,7 +209,10 @@ void gdbserver_process_exit_encountered
++ static
++ const HChar* sym (Addr addr)
++ {
++-   return VG_(describe_IP) (addr, NULL);
+++   // FIXME JRS 28 July 2017: HACK!  Is this correct?
+++   const DiEpoch ep = VG_(current_DiEpoch)();
+++
+++   return VG_(describe_IP) (ep, addr, NULL);
++ }
++ 
++ ThreadId vgdb_interrupted_tid = 0;
++Index: valgrind-3.13.0/coregrind/m_gdbserver/valgrind-low-arm.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_gdbserver/valgrind-low-arm.c
+++++ valgrind-3.13.0/coregrind/m_gdbserver/valgrind-low-arm.c
++@@ -149,8 +149,12 @@ Addr thumb_pc (Addr pc)
++       // the debug info with the bit0 set
++       // (why can't debug info do that for us ???)
++       // (why if this is a 4 bytes thumb instruction ???)
++-      if (VG_(get_fnname_raw) (pc | 1, &fnname)) {
++-         if (VG_(lookup_symbol_SLOW)( "*", fnname, &avmas )) {
+++
+++      // FIXME JRS 28 July 2017: HACK!  Is this correct?
+++      const DiEpoch ep = VG_(current_DiEpoch)();
+++
+++      if (VG_(get_fnname_raw) (ep, pc | 1, &fnname)) {
+++         if (VG_(lookup_symbol_SLOW)( ep, "*", fnname, &avmas )) {
++             dlog (1, "fnname %s lookupsym %p => %p %s.\n",
++                   fnname, C2v(avmas.main), C2v(pc),
++                   (avmas.main & 1 ? "thumb" : "arm"));
++Index: valgrind-3.13.0/coregrind/m_gdbserver/valgrind-low-mips32.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_gdbserver/valgrind-low-mips32.c
+++++ valgrind-3.13.0/coregrind/m_gdbserver/valgrind-low-mips32.c
++@@ -228,7 +228,11 @@ static Addr mips_adjust_breakpoint_addre
++    /* Make sure we don't scan back before the beginning of the current
++       function, since we may fetch constant data or insns that look like
++       a jump. */
++-   if (VG_(get_inst_offset_in_function) (bpaddr, &offset)) {
+++
+++   // FIXME JRS 28 July 2017: HACK!  Is this correct?
+++   const DiEpoch ep = VG_(current_DiEpoch)();
+++
+++   if (VG_(get_inst_offset_in_function) (ep, bpaddr, &offset)) {
++       func_addr = bpaddr - offset;
++       if (func_addr > boundary && func_addr <= bpaddr)
++          boundary = func_addr;
++Index: valgrind-3.13.0/coregrind/m_gdbserver/valgrind-low-mips64.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_gdbserver/valgrind-low-mips64.c
+++++ valgrind-3.13.0/coregrind/m_gdbserver/valgrind-low-mips64.c
++@@ -229,7 +229,11 @@ static Addr mips_adjust_breakpoint_addre
++    /* Make sure we don't scan back before the beginning of the current
++       function, since we may fetch constant data or insns that look like
++       a jump. */
++-   if (VG_(get_inst_offset_in_function) (bpaddr, &offset)) {
+++
+++   // FIXME JRS 28 July 2017: HACK!  Is this correct?
+++   const DiEpoch ep = VG_(current_DiEpoch)();
+++
+++   if (VG_(get_inst_offset_in_function) (ep, bpaddr, &offset)) {
++       func_addr = bpaddr - offset;
++       if (func_addr > boundary && func_addr <= bpaddr)
++          boundary = func_addr;
++Index: valgrind-3.13.0/coregrind/m_libcassert.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_libcassert.c
+++++ valgrind-3.13.0/coregrind/m_libcassert.c
++@@ -369,7 +369,7 @@ static void show_sched_status_wrk ( Bool
++          );
++       VG_(printf)("\nhost stacktrace:\n"); 
++       VG_(clo_xml) = False;
++-      VG_(pp_StackTrace) (ips, n_ips);
+++      VG_(pp_StackTrace) (VG_(current_DiEpoch)(), ips, n_ips);
++       VG_(clo_xml) = save_clo_xml;
++    }
++ 
++Index: valgrind-3.13.0/coregrind/m_main.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_main.c
+++++ valgrind-3.13.0/coregrind/m_main.c
++@@ -128,6 +128,10 @@ static void usage_NORETURN ( Bool debug_
++ "    --error-exitcode=<number> exit code to return if errors found [0=disable]\n"
++ "    --error-markers=<begin>,<end> add lines with begin/end markers before/after\n"
++ "                              each error output in plain text mode [none]\n"
+++"    --keep-debuginfo=no|yes   Keep symbols etc for unloaded code [no]\n"
+++"                              This allows stack traces for memory leaks to\n"
+++"                              include file/line info for code that has been\n"
+++"                              dlclose'd (or similar)\n"
++ "    --show-below-main=no|yes  continue stack traces below main() [no]\n"
++ "    --default-suppressions=yes|no\n"
++ "                              load default suppressions [yes]\n"
++@@ -626,6 +630,7 @@ void main_process_cmd_line_options( void
++       else if VG_BOOL_CLO(arg, "--run-libc-freeres", VG_(clo_run_libc_freeres)) {}
++       else if VG_BOOL_CLO(arg, "--run-cxx-freeres",  VG_(clo_run_cxx_freeres)) {}
++       else if VG_BOOL_CLO(arg, "--show-below-main",  VG_(clo_show_below_main)) {}
+++      else if VG_BOOL_CLO(arg, "--keep-debuginfo",   VG_(clo_keep_debuginfo)) {}
++       else if VG_BOOL_CLO(arg, "--time-stamp",       VG_(clo_time_stamp)) {}
++       else if VG_BOOL_CLO(arg, "--track-fds",        VG_(clo_track_fds)) {}
++       else if VG_BOOL_CLO(arg, "--trace-children",   VG_(clo_trace_children)) {}
++Index: valgrind-3.13.0/coregrind/m_options.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_options.c
+++++ valgrind-3.13.0/coregrind/m_options.c
++@@ -129,6 +129,7 @@ Bool   VG_(clo_run_libc_freeres) = True;
++ Bool   VG_(clo_run_cxx_freeres) = True;
++ Bool   VG_(clo_track_fds)      = False;
++ Bool   VG_(clo_show_below_main)= False;
+++Bool   VG_(clo_keep_debuginfo) = False;
++ Bool   VG_(clo_show_emwarns)   = False;
++ Word   VG_(clo_max_stackframe) = 2000000;
++ UInt   VG_(clo_max_threads)    = MAX_THREADS_DEFAULT;
++Index: valgrind-3.13.0/coregrind/m_redir.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_redir.c
+++++ valgrind-3.13.0/coregrind/m_redir.c
++@@ -1859,15 +1859,16 @@ static void show_active ( const HChar* l
++ {
++    Bool ok;
++    const HChar *buf;
++- 
++-   ok = VG_(get_fnname_w_offset)(act->from_addr, &buf);
+++
+++   DiEpoch ep = VG_(current_DiEpoch)(); 
+++   ok = VG_(get_fnname_w_offset)(ep, act->from_addr, &buf);
++    if (!ok) buf = "???";
++    // Stash away name1
++    HChar name1[VG_(strlen)(buf) + 1];
++    VG_(strcpy)(name1, buf);
++ 
++    const HChar *name2;
++-   ok = VG_(get_fnname_w_offset)(act->to_addr, &name2);
+++   ok = VG_(get_fnname_w_offset)(ep, act->to_addr, &name2);
++    if (!ok) name2 = "???";
++ 
++    VG_(message)(Vg_DebugMsg, "%s0x%08lx (%-20s) %s-> (%04d.%d) 0x%08lx %s\n", 
++Index: valgrind-3.13.0/coregrind/m_sbprofile.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_sbprofile.c
+++++ valgrind-3.13.0/coregrind/m_sbprofile.c
++@@ -74,6 +74,9 @@ void show_SB_profile ( const SBProfEntry
++ 
++    VG_(printf)("Total score = %'llu\n\n", score_total);
++ 
+++   // FIXME JRS 28 July 2017: this is probably not right in general
+++   DiEpoch ep = VG_(current_DiEpoch)();
+++
++    /* Print an initial per-block summary. */
++    VG_(printf)("rank  ---cumulative---      -----self-----\n");
++    score_cumul = 0;
++@@ -84,7 +87,7 @@ void show_SB_profile ( const SBProfEntry
++          continue;
++ 
++       const HChar *name;
++-      VG_(get_fnname_w_offset)(tops[r].addr, &name);
+++      VG_(get_fnname_w_offset)(ep, tops[r].addr, &name);
++ 
++       score_here = tops[r].score;
++       score_cumul += score_here;
++@@ -123,7 +126,7 @@ void show_SB_profile ( const SBProfEntry
++             continue;
++ 
++          const HChar *name;
++-         VG_(get_fnname_w_offset)(tops[r].addr, &name);
+++         VG_(get_fnname_w_offset)(ep, tops[r].addr, &name);
++ 
++          score_here = tops[r].score;
++          score_cumul += score_here;
++@@ -159,7 +162,7 @@ void show_SB_profile ( const SBProfEntry
++             continue;
++ 
++          const HChar *name;
++-         VG_(get_fnname_w_offset)(tops[r].addr, &name);
+++         VG_(get_fnname_w_offset)(ep, tops[r].addr, &name);
++ 
++          score_here = tops[r].score;
++ 
++Index: valgrind-3.13.0/coregrind/m_scheduler/scheduler.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_scheduler/scheduler.c
+++++ valgrind-3.13.0/coregrind/m_scheduler/scheduler.c
++@@ -2037,8 +2037,12 @@ void do_client_request ( ThreadId tid )
++ 
++          VG_(memset)(buf64, 0, 64);
++          UInt linenum = 0;
+++
+++         // FIXME JRS 28 July 2017: HACK!  Is this correct?
+++         const DiEpoch ep = VG_(current_DiEpoch)();
+++
++          Bool ok = VG_(get_filename_linenum)(
++-                      ip, &buf, NULL, &linenum
+++                      ep, ip, &buf, NULL, &linenum
++                    );
++          if (ok) {
++             /* For backward compatibility truncate the filename to
++Index: valgrind-3.13.0/coregrind/m_signals.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_signals.c
+++++ valgrind-3.13.0/coregrind/m_signals.c
++@@ -1878,7 +1878,7 @@ static void default_action(const vki_sig
++                       : VG_(record_depth_1_ExeContext)( tid,
++                                                         first_ip_delta );
++          vg_assert(ec);
++-         VG_(pp_ExeContext)( ec );
+++         VG_(pp_ExeContextAndEpoch)( VG_(tag_EC_with_current_epoch)(ec) );
++       }
++       if (sigNo == VKI_SIGSEGV 
++           && is_signal_from_kernel(tid, sigNo, info->si_code)
++Index: valgrind-3.13.0/coregrind/m_stacktrace.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_stacktrace.c
+++++ valgrind-3.13.0/coregrind/m_stacktrace.c
++@@ -446,6 +446,7 @@ UInt VG_(get_StackTrace_wrk) ( ThreadId
++       /* And, similarly, try for MSVC FPO unwind info. */
++       if (FPO_info_present
++           && VG_(use_FPO_info)( &uregs.xip, &uregs.xsp, &uregs.xbp,
+++                                VG_(current_DiEpoch)(),
++                                 fp_min, fp_max ) ) {
++          if (debug) unwind_case = "MS";
++          if (do_stats) stats.MS++;
++@@ -1539,12 +1540,12 @@ UInt VG_(get_StackTrace) ( ThreadId tid,
++                                        stack_highest_byte);
++ }
++ 
++-static void printIpDesc(UInt n, Addr ip, void* uu_opaque)
+++static void printIpDesc(UInt n, DiEpoch ep, Addr ip, void* uu_opaque)
++ {
++-   InlIPCursor *iipc = VG_(new_IIPC)(ip);
+++   InlIPCursor *iipc = VG_(new_IIPC)(ep, ip);
++ 
++    do {
++-      const HChar *buf = VG_(describe_IP)(ip, iipc);
+++      const HChar *buf = VG_(describe_IP)(ep, ip, iipc);
++       if (VG_(clo_xml)) {
++          VG_(printf_xml)("    %s\n", buf);
++       } else {
++@@ -1558,14 +1559,14 @@ static void printIpDesc(UInt n, Addr ip,
++ }
++ 
++ /* Print a StackTrace. */
++-void VG_(pp_StackTrace) ( StackTrace ips, UInt n_ips )
+++void VG_(pp_StackTrace) ( DiEpoch ep, StackTrace ips, UInt n_ips )
++ {
++    vg_assert( n_ips > 0 );
++ 
++    if (VG_(clo_xml))
++       VG_(printf_xml)("  <stack>\n");
++ 
++-   VG_(apply_StackTrace)( printIpDesc, NULL, ips, n_ips );
+++   VG_(apply_StackTrace)( printIpDesc, NULL, ep, ips, n_ips );
++ 
++    if (VG_(clo_xml))
++       VG_(printf_xml)("  </stack>\n");
++@@ -1580,13 +1581,13 @@ void VG_(get_and_pp_StackTrace) ( Thread
++                             NULL/*array to dump SP values in*/,
++                             NULL/*array to dump FP values in*/,
++                             0/*first_ip_delta*/);
++-   VG_(pp_StackTrace)(ips, n_ips);
+++   VG_(pp_StackTrace)(VG_(current_DiEpoch)(), ips, n_ips);
++ }
++ 
++ void VG_(apply_StackTrace)(
++-        void(*action)(UInt n, Addr ip, void* opaque),
+++        void(*action)(UInt n, DiEpoch ep, Addr ip, void* opaque),
++         void* opaque,
++-        StackTrace ips, UInt n_ips
+++        DiEpoch ep, StackTrace ips, UInt n_ips
++      )
++ {
++    Int i;
++@@ -1597,7 +1598,7 @@ void VG_(apply_StackTrace)(
++       // or the last appearance of a below main function.
++       // Then decrease n_ips so as to not call action for the below main
++       for (i = n_ips - 1; i >= 0; i--) {
++-         Vg_FnNameKind kind = VG_(get_fnname_kind_from_IP)(ips[i]);
+++         Vg_FnNameKind kind = VG_(get_fnname_kind_from_IP)(ep, ips[i]);
++          if (Vg_FnNameMain == kind || Vg_FnNameBelowMain == kind)
++             n_ips = i + 1;
++          if (Vg_FnNameMain == kind)
++@@ -1607,7 +1608,7 @@ void VG_(apply_StackTrace)(
++ 
++    for (i = 0; i < n_ips; i++)
++       // Act on the ip
++-      action(i, ips[i], opaque);
+++      action(i, ep, ips[i], opaque);
++ }
++ 
++ 
++Index: valgrind-3.13.0/coregrind/m_syswrap/syswrap-generic.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_syswrap/syswrap-generic.c
+++++ valgrind-3.13.0/coregrind/m_syswrap/syswrap-generic.c
++@@ -540,7 +540,8 @@ typedef struct OpenFd
++ {
++    Int fd;                        /* The file descriptor */
++    HChar *pathname;               /* NULL if not a regular file or unknown */
++-   ExeContext *where;             /* NULL if inherited from parent */
+++   ExeContextAndEpoch where;      /* VG_(null_ExeContextAndEpoch)
+++                                     if inherited from parent */
++    struct OpenFd *next, *prev;
++ } OpenFd;
++ 
++@@ -614,7 +615,10 @@ void ML_(record_fd_open_with_given_name)
++ 
++    i->fd = fd;
++    i->pathname = VG_(strdup)("syswrap.rfdowgn.2", pathname);
++-   i->where = (tid == -1) ? NULL : VG_(record_ExeContext)(tid, 0/*first_ip_delta*/);
+++   i->where = (tid == -1)
+++                 ? VG_(null_ExeContextAndEpoch)()
+++                 : VG_(tag_EC_with_current_epoch)(
+++                      VG_(record_ExeContext)(tid, 0/*first_ip_delta*/));
++ }
++ 
++ // Record opening of an fd, and find its name.
++@@ -846,8 +850,8 @@ void VG_(show_open_fds) (const HChar* wh
++          }
++       }
++ 
++-      if(i->where) {
++-         VG_(pp_ExeContext)(i->where);
+++      if (!VG_(is_null_ExeContextAndEpoch)(i->where)) {
+++         VG_(pp_ExeContextAndEpoch)(i->where);
++          VG_(message)(Vg_UserMsg, "\n");
++       } else {
++          VG_(message)(Vg_UserMsg, "   <inherited from parent>\n");
++Index: valgrind-3.13.0/coregrind/m_tooliface.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_tooliface.c
+++++ valgrind-3.13.0/coregrind/m_tooliface.c
++@@ -323,7 +323,7 @@ void VG_(needs_print_stats) (
++ }
++ 
++ void VG_(needs_info_location) (
++-   void (*info_location)(Addr)
+++   void (*info_location)(DiEpoch, Addr)
++ )
++ {
++    VG_(needs).info_location = True;
++Index: valgrind-3.13.0/coregrind/m_translate.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_translate.c
+++++ valgrind-3.13.0/coregrind/m_translate.c
++@@ -1527,24 +1527,25 @@ Bool VG_(translate) ( ThreadId tid,
++       Bool ok;
++       const HChar *buf;
++       const HChar *name2;
+++      const DiEpoch ep = VG_(current_DiEpoch)();
++ 
++       /* Try also to get the soname (not the filename) of the "from"
++          object.  This makes it much easier to debug redirection
++          problems. */
++       const HChar* nraddr_soname = "???";
++-      DebugInfo*   nraddr_di     = VG_(find_DebugInfo)(nraddr);
+++      DebugInfo*   nraddr_di     = VG_(find_DebugInfo)(ep, nraddr);
++       if (nraddr_di) {
++          const HChar* t = VG_(DebugInfo_get_soname)(nraddr_di);
++          if (t)
++             nraddr_soname = t;
++       }
++ 
++-      ok = VG_(get_fnname_w_offset)(nraddr, &buf);
+++      ok = VG_(get_fnname_w_offset)(ep, nraddr, &buf);
++       if (!ok) buf = "???";
++       // Stash away name1
++       HChar name1[VG_(strlen)(buf) + 1];
++       VG_(strcpy)(name1, buf);
++-      ok = VG_(get_fnname_w_offset)(addr, &name2);
+++      ok = VG_(get_fnname_w_offset)(ep, addr, &name2);
++       if (!ok) name2 = "???";
++ 
++       VG_(message)(Vg_DebugMsg, 
++@@ -1561,7 +1562,8 @@ Bool VG_(translate) ( ThreadId tid,
++    if (VG_(clo_trace_flags) || debugging_translation) {
++       const HChar* objname = "UNKNOWN_OBJECT";
++       OffT         objoff  = 0;
++-      DebugInfo*   di      = VG_(find_DebugInfo)( addr );
+++      const DiEpoch ep     = VG_(current_DiEpoch)();
+++      DebugInfo*   di      = VG_(find_DebugInfo)( ep, addr );
++       if (di) {
++          objname = VG_(DebugInfo_get_filename)(di);
++          objoff  = addr - VG_(DebugInfo_get_text_bias)(di);
++@@ -1569,7 +1571,7 @@ Bool VG_(translate) ( ThreadId tid,
++       vg_assert(objname);
++  
++       const HChar *fnname;
++-      Bool ok = VG_(get_fnname_w_offset)(addr, &fnname);
+++      Bool ok = VG_(get_fnname_w_offset)(ep, addr, &fnname);
++       if (!ok) fnname = "UNKNOWN_FUNCTION";
++       VG_(printf)(
++          "==== SB %u (evchecks %llu) [tid %u] 0x%lx %s %s%c0x%lx\n",
++Index: valgrind-3.13.0/coregrind/m_xtree.c
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/m_xtree.c
+++++ valgrind-3.13.0/coregrind/m_xtree.c
++@@ -438,6 +438,9 @@ void VG_(XT_callgrind_print)
++    const HChar* filename_dir;
++    const HChar* filename_name;
++ 
+++   // FIXME JRS 28 July 2017: HACK!  Is this correct?
+++   const DiEpoch ep = VG_(current_DiEpoch)();
+++
++    if (fp == NULL)
++       return;
++ 
++@@ -501,7 +504,7 @@ void VG_(XT_callgrind_print)
++       // the strings  called_filename/called_fnname.
++ #define CALLED_FLF(n)                                                   \
++       if ((n) < 0                                                       \
++-          || !VG_(get_filename_linenum)(ips[(n)],                       \
+++          || !VG_(get_filename_linenum)(ep, ips[(n)],                   \
++                                         &filename_name,                 \
++                                         &filename_dir,                  \
++                                         &called_linenum)) {             \
++@@ -509,7 +512,7 @@ void VG_(XT_callgrind_print)
++          called_linenum = 0;                                            \
++       }                                                                 \
++       if ((n) < 0                                                       \
++-          || !VG_(get_fnname)(ips[(n)], &called_fnname)) {              \
+++          || !VG_(get_fnname)(ep, ips[(n)], &called_fnname)) {          \
++          called_fnname = "UnknownFn???";                                \
++       }                                                                 \
++       {                                                                 \
++@@ -554,7 +557,9 @@ void VG_(XT_callgrind_print)
++ 
++          if (0) {
++             VG_(printf)("entry img %s\n", img);
++-            VG_(pp_ExeContext)(xe->ec);
+++            // JRS 27 July 2017: it may be a hack to use the current epoch
+++            // here.  I don't know.
+++            VG_(pp_ExeContextAndEpoch)(VG_(tag_EC_with_current_epoch)(xe->ec));
++             VG_(printf)("\n");
++          }
++          xt->add_data_fn(xt->tmp_data, VG_(indexXA)(xt->data, xecu));
++@@ -762,11 +767,14 @@ static void ms_output_group (VgFile* fp,
++    ms_make_groups(depth+1, group->ms_ec, group->n_ec, sig_sz,
++                   &n_groups, &groups);
++ 
+++   // FIXME JRS 28 July 2017: HACK!  Is this correct?
+++   const DiEpoch ep = VG_(current_DiEpoch)();
+++
++    FP("%*s" "n%u: %ld %s\n", 
++       depth + 1, "",
++       n_groups, 
++       group->total,
++-      VG_(describe_IP)(group->ms_ec->ips[depth] - 1, NULL));
+++      VG_(describe_IP)(ep, group->ms_ec->ips[depth] - 1, NULL));
++    /* XTREE??? Massif original code removes 1 to get the IP description. I am
++       wondering if this is not something that predates revision r8818,
++       which introduced a -1 in the stack unwind (see m_stacktrace.c)
++@@ -963,6 +971,10 @@ Int VG_(XT_offset_main_or_below_main)(Ad
++       from there.
++       If no main is found, we will then do a search for main or
++       below main function till the top. */
+++
+++   // FIXME JRS 28 July 2017: HACK!  Is this correct?
+++   const DiEpoch ep = VG_(current_DiEpoch)();
+++
++    static Int deepest_main = 0;
++    Vg_FnNameKind kind = Vg_FnNameNormal;
++    Int mbm = n_ips - 1; // Position of deepest main or below main.
++@@ -972,7 +984,7 @@ Int VG_(XT_offset_main_or_below_main)(Ad
++    for (i = n_ips - 1 - deepest_main;
++         i < n_ips;
++         i++) {
++-      mbmkind = VG_(get_fnname_kind_from_IP)(ips[i]);
+++      mbmkind = VG_(get_fnname_kind_from_IP)(ep, ips[i]);
++       if (mbmkind != Vg_FnNameNormal) {
++          mbm = i;
++          break;
++@@ -983,7 +995,7 @@ Int VG_(XT_offset_main_or_below_main)(Ad
++    for (i = mbm - 1;
++         i >= 0 && mbmkind != Vg_FnNameMain;
++         i--) {
++-      kind = VG_(get_fnname_kind_from_IP)(ips[i]);
+++      kind = VG_(get_fnname_kind_from_IP)(ep, ips[i]);
++       if (kind != Vg_FnNameNormal) {
++          mbm = i;
++          mbmkind = kind;
++Index: valgrind-3.13.0/coregrind/pub_core_debuginfo.h
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/pub_core_debuginfo.h
+++++ valgrind-3.13.0/coregrind/pub_core_debuginfo.h
++@@ -86,20 +86,21 @@ extern void VG_(di_discard_ALL_debuginfo
++  * It should only be used in cases where the names of interest will have
++  * particular (ie. non-mangled) forms, or the mangled form is acceptable. */
++ extern
++-Bool VG_(get_fnname_raw) ( Addr a, const HChar** buf );
+++Bool VG_(get_fnname_raw) ( DiEpoch ep, Addr a, const HChar** buf );
++ 
++ /* Like VG_(get_fnname), but without C++ demangling.  (But it does
++  Z-demangling and below-main renaming.)
++  iipc argument: same usage as in VG_(describe_IP) in pub_tool_debuginfo.h. */
++ extern
++-Bool VG_(get_fnname_no_cxx_demangle) ( Addr a, const HChar** buf,
+++Bool VG_(get_fnname_no_cxx_demangle) ( DiEpoch ep, Addr a, const HChar** buf,
++                                        const InlIPCursor* iipc );
++ 
++ /* mips-linux only: find the offset of current address. This is needed for 
++    stack unwinding for MIPS.
++ */
++ extern
++-Bool VG_(get_inst_offset_in_function)( Addr a, /*OUT*/PtrdiffT* offset );
+++Bool VG_(get_inst_offset_in_function)( DiEpoch ep, Addr a,
+++                                       /*OUT*/PtrdiffT* offset );
++ 
++ 
++ /* Use DWARF2/3 CFA information to do one step of stack unwinding.
++@@ -158,6 +159,7 @@ extern Bool VG_(FPO_info_present)(void);
++ extern Bool VG_(use_FPO_info) ( /*MOD*/Addr* ipP,
++                                 /*MOD*/Addr* spP,
++                                 /*MOD*/Addr* fpP,
+++                                DiEpoch ep,
++                                 Addr min_accessible,
++                                 Addr max_accessible );
++ 
++@@ -217,7 +219,7 @@ void VG_(DebugInfo_syms_getidx)  ( const
++ /* ppc64-linux only: find the TOC pointer (R2 value) that should be in
++    force at the entry point address of the function containing
++    guest_code_addr.  Returns 0 if not known. */
++-extern Addr VG_(get_tocptr) ( Addr guest_code_addr );
+++extern Addr VG_(get_tocptr) ( DiEpoch ep, Addr guest_code_addr );
++ 
++ /* Map a function name to its SymAVMAs.  Is done by
++    sequential search of all symbol tables, so is very slow.  To
++@@ -227,7 +229,8 @@ extern Addr VG_(get_tocptr) ( Addr guest
++    platforms, a symbol is deemed to be found only if it has a nonzero
++    TOC pointer.  */
++ extern
++-Bool VG_(lookup_symbol_SLOW)(const HChar* sopatt, const HChar* name,
+++Bool VG_(lookup_symbol_SLOW)(DiEpoch ep, 
+++                             const HChar* sopatt, const HChar* name,
++                              SymAVMAs* avmas);
++ 
++ #endif   // __PUB_CORE_DEBUGINFO_H
++Index: valgrind-3.13.0/coregrind/pub_core_tooliface.h
++===================================================================
++--- valgrind-3.13.0.orig/coregrind/pub_core_tooliface.h
+++++ valgrind-3.13.0/coregrind/pub_core_tooliface.h
++@@ -156,7 +156,7 @@ typedef struct {
++    void (*tool_print_stats)(void);
++ 
++    // VG_(needs).info_location
++-   void (*tool_info_location)(Addr a);
+++   void (*tool_info_location)(DiEpoch ep, Addr a);
++ 
++    // VG_(needs).malloc_replacement
++    void* (*tool_malloc)              (ThreadId, SizeT);
++Index: valgrind-3.13.0/docs/xml/manual-core.xml
++===================================================================
++--- valgrind-3.13.0.orig/docs/xml/manual-core.xml
+++++ valgrind-3.13.0/docs/xml/manual-core.xml
++@@ -1219,6 +1219,19 @@ that can report errors, e.g. Memcheck, b
++     </listitem>
++   </varlistentry>
++ 
+++  <varlistentry id="opt.keep-debuginfo" xreflabel="--keep-debuginfo">
+++    <term>
+++      <option><![CDATA[--keep-debuginfo=<yes|no> [default: no] ]]></option>
+++    </term>
+++    <listitem>
+++      <para>When enabled, keep symbols and all other debuginfo for unloaded
+++      code. This allows stack traces for memory leaks to include file/line
+++      info for code that has been dlclose'd (or similar).  Be careful with
+++      this, since it can lead to unbounded memory use for programs which
+++      repeatedly load and unload shard objects.</para>
+++    </listitem>
+++  </varlistentry>
+++  
++   <varlistentry id="opt.show-below-main" xreflabel="--show-below-main">
++     <term>
++       <option><![CDATA[--show-below-main=<yes|no> [default: no] ]]></option>
++Index: valgrind-3.13.0/drd/drd_error.c
++===================================================================
++--- valgrind-3.13.0.orig/drd/drd_error.c
+++++ valgrind-3.13.0/drd/drd_error.c
++@@ -139,12 +139,14 @@ static void first_observed(const Addr ob
++                           "    <what>%pS</what>\n"
++                           "    <address>0x%lx</address>\n",
++                           DRD_(clientobj_type_name)(cl->any.type), obj);
++-         VG_(pp_ExeContext)(cl->any.first_observed_at);
+++         VG_(pp_ExeContextAndEpoch)(
+++            VG_(tag_EC_with_current_epoch)(cl->any.first_observed_at));
++          print_err_detail("  </first_observed_at>\n");
++       } else {
++          print_err_detail("%s 0x%lx was first observed at:\n",
++                           DRD_(clientobj_type_name)(cl->any.type), obj);
++-         VG_(pp_ExeContext)(cl->any.first_observed_at);
+++         VG_(pp_ExeContextAndEpoch)(
+++            VG_(tag_EC_with_current_epoch)(cl->any.first_observed_at));
++       }
++    }
++ }
++@@ -161,6 +163,7 @@ void drd_report_data_race(const Error* c
++    const HChar* const indent = xml ? "  " : "";
++    AddrInfo ai;
++ 
+++   DiEpoch ep = VG_(current_DiEpoch)();
++    XArray* /* of HChar */ descr1
++       = VG_(newXA)( VG_(malloc), "drd.error.drdr2.1",
++                     VG_(free), sizeof(HChar) );
++@@ -172,7 +175,7 @@ void drd_report_data_race(const Error* c
++    tl_assert(dri->addr);
++    tl_assert(dri->size > 0);
++ 
++-   (void) VG_(get_data_description)(descr1, descr2, dri->addr);
+++   (void) VG_(get_data_description)(descr1, descr2, ep, dri->addr);
++    /* If there's nothing in descr1/2, free them.  Why is it safe to
++       VG_(indexXA) at zero here?  Because VG_(get_data_description)
++       guarantees to zero terminate descr1/2 regardless of the outcome
++@@ -202,7 +205,7 @@ void drd_report_data_race(const Error* c
++                     what_prefix, dri->access_type == eStore ? "store" : "load",
++                     dri->tid, dri->addr, dri->size, what_suffix);
++ 
++-   VG_(pp_ExeContext)(VG_(get_error_where)(err));
+++   VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(err));
++    if (descr1 != NULL) {
++       print_err_detail("%s%s\n", indent, (HChar*)VG_(indexXA)(descr1, 0));
++       if (descr2 != NULL)
++@@ -216,7 +219,7 @@ void drd_report_data_race(const Error* c
++          print_err_detail("  <allocation_context>\n");
++       else
++          print_err_detail(" Allocation context:\n");
++-      VG_(pp_ExeContext)(ai.lastchange);
+++      VG_(pp_ExeContextAndEpoch)(mk_ExeContextAndEpoch(ai.lastchange, ep));
++       if (xml)
++          print_err_detail("  </allocation_context>\n");
++    } else {
++@@ -322,7 +325,7 @@ static void drd_tool_error_pp(const Erro
++          print_err_detail("%sThe object at address 0x%lx is not a mutex.%s\n",
++                           what_prefix, p->mutex, what_suffix);
++       }
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       first_observed(p->mutex);
++       break;
++    }
++@@ -330,7 +333,7 @@ static void drd_tool_error_pp(const Erro
++       CondErrInfo* cdei =(CondErrInfo*)(VG_(get_error_extra)(e));
++       print_err_detail("%s%s: cond 0x%lx%s\n", what_prefix,
++                        VG_(get_error_string)(e), cdei->cond, what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       first_observed(cdei->cond);
++       break;
++    }
++@@ -339,7 +342,7 @@ static void drd_tool_error_pp(const Erro
++       print_err_detail("%s%s: cond 0x%lx, mutex 0x%lx locked by thread %u%s\n",
++                        what_prefix, VG_(get_error_string)(e), cdi->cond,
++                        cdi->mutex, cdi->owner, what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       first_observed(cdi->mutex);
++       break;
++    }
++@@ -349,7 +352,7 @@ static void drd_tool_error_pp(const Erro
++                        " has been signaled but the associated mutex 0x%lx is"
++                        " not locked by the signalling thread.%s\n",
++                        what_prefix, cei->cond, cei->mutex, what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       first_observed(cei->cond);
++       first_observed(cei->mutex);
++       break;
++@@ -359,7 +362,7 @@ static void drd_tool_error_pp(const Erro
++       print_err_detail("%s%s: condition variable 0x%lx, mutexes 0x%lx and"
++                        " 0x%lx%s\n", what_prefix, VG_(get_error_string)(e),
++                        cwei->cond, cwei->mutex1, cwei->mutex2, what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       first_observed(cwei->cond);
++       first_observed(cwei->mutex1);
++       first_observed(cwei->mutex2);
++@@ -370,7 +373,7 @@ static void drd_tool_error_pp(const Erro
++       tl_assert(sei);
++       print_err_detail("%s%s: semaphore 0x%lx%s\n", what_prefix,
++                        VG_(get_error_string)(e), sei->semaphore, what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       first_observed(sei->semaphore);
++       break;
++    }
++@@ -379,13 +382,14 @@ static void drd_tool_error_pp(const Erro
++       tl_assert(bei);
++       print_err_detail("%s%s: barrier 0x%lx%s\n", what_prefix,
++                        VG_(get_error_string)(e), bei->barrier, what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       if (bei->other_context) {
++          if (xml)
++             print_err_detail("  <confl_wait_call>\n");
++          print_err_detail("%sConflicting wait call by thread %u:%s\n",
++                           what_prefix, bei->other_tid, what_suffix);
++-         VG_(pp_ExeContext)(bei->other_context);
+++         VG_(pp_ExeContextAndEpoch)(
+++            VG_(tag_EC_with_current_epoch)(bei->other_context));
++          if (xml)
++             print_err_detail("  </confl_wait_call>\n");
++       }
++@@ -397,7 +401,7 @@ static void drd_tool_error_pp(const Erro
++       tl_assert(p);
++       print_err_detail("%s%s: rwlock 0x%lx.%s\n", what_prefix,
++                        VG_(get_error_string)(e), p->rwlock, what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       first_observed(p->rwlock);
++       break;
++    }
++@@ -409,14 +413,15 @@ static void drd_tool_error_pp(const Erro
++          print_err_detail("  <acquired_at>\n");
++       else
++          print_err_detail("Acquired at:\n");
++-      VG_(pp_ExeContext)(p->acquired_at);
+++      VG_(pp_ExeContextAndEpoch)(
+++         VG_(tag_EC_with_current_epoch)(p->acquired_at));
++       if (xml)
++          print_err_detail("  </acquired_at>\n");
++       print_err_detail("%sLock on %s 0x%lx was held during %u ms"
++                        " (threshold: %u ms).%s\n", what_prefix,
++                        VG_(get_error_string)(e), p->synchronization_object,
++                        p->hold_time_ms, p->threshold_ms, what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       first_observed(p->synchronization_object);
++       break;
++    }
++@@ -424,7 +429,7 @@ static void drd_tool_error_pp(const Erro
++       GenericErrInfo* gei = (GenericErrInfo*)(VG_(get_error_extra)(e));
++       print_err_detail("%s%s%s\n", what_prefix, VG_(get_error_string)(e),
++                        what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       if (gei->addr)
++ 	 first_observed(gei->addr);
++       break;
++@@ -433,7 +438,7 @@ static void drd_tool_error_pp(const Erro
++       InvalidThreadIdInfo* iti =(InvalidThreadIdInfo*)(VG_(get_error_extra)(e));
++       print_err_detail("%s%s 0x%llx%s\n", what_prefix, VG_(get_error_string)(e),
++                        iti->ptid, what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       break;
++    }
++    case UnimpHgClReq: {
++@@ -441,7 +446,7 @@ static void drd_tool_error_pp(const Erro
++       print_err_detail("%sThe annotation macro %s has not yet been implemented"
++                        " in %ps%s\n", what_prefix, uicr->descr,
++                        "<valgrind/helgrind.h>", what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       break;
++    }
++    case UnimpDrdClReq: {
++@@ -449,13 +454,13 @@ static void drd_tool_error_pp(const Erro
++       print_err_detail("%sThe annotation macro %s has not yet been implemented"
++                        " in %ps%s\n", what_prefix, uicr->descr,
++                        "<valgrind/drd.h>", what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       break;
++    }
++    default:
++       print_err_detail("%s%s%s\n", what_prefix, VG_(get_error_string)(e),
++                        what_suffix);
++-      VG_(pp_ExeContext)(VG_(get_error_where)(e));
+++      VG_(pp_ExeContextAndEpoch)(VG_(get_error_where)(e));
++       break;
++    }
++ }
++Index: valgrind-3.13.0/drd/drd_thread.c
++===================================================================
++--- valgrind-3.13.0.orig/drd/drd_thread.c
+++++ valgrind-3.13.0/drd/drd_thread.c
++@@ -1338,7 +1338,8 @@ static void show_call_stack(const DrdThr
++ 
++    if (vg_tid != VG_INVALID_THREADID) {
++       if (callstack)
++-         VG_(pp_ExeContext)(callstack);
+++         VG_(pp_ExeContextAndEpoch)(
+++            VG_(tag_EC_with_current_epoch)(callstack));
++       else
++          VG_(get_and_pp_StackTrace)(vg_tid, VG_(clo_backtrace_size));
++    } else {
++Index: valgrind-3.13.0/exp-bbv/bbv_main.c
++===================================================================
++--- valgrind-3.13.0.orig/exp-bbv/bbv_main.c
+++++ valgrind-3.13.0/exp-bbv/bbv_main.c
++@@ -346,6 +346,7 @@ static IRSB* bbv_instrument ( VgCallback
++    IRDirty  *di;
++    IRExpr   **argv, *arg1;
++    Int      regparms,opcode_type;
+++   DiEpoch  ep = VG_(current_DiEpoch)();
++ 
++       /* We don't handle a host/guest word size mismatch */
++    if (gWordTy != hWordTy) {
++@@ -392,8 +393,8 @@ static IRSB* bbv_instrument ( VgCallback
++       block_num++;
++          /* get function name and entry point information */
++       const HChar *fn_name;
++-      VG_(get_fnname)(origAddr, &fn_name);
++-      bbInfo->is_entry=VG_(get_fnname_if_entry)(origAddr, &fn_name);
+++      VG_(get_fnname)(ep, origAddr, &fn_name);
+++      bbInfo->is_entry=VG_(get_fnname_if_entry)(ep, origAddr, &fn_name);
++       bbInfo->fn_name =VG_(strdup)("bbv_strings", fn_name);
++          /* insert structure into table */
++       VG_(OSetGen_Insert)( instr_info_table, bbInfo );
++Index: valgrind-3.13.0/exp-dhat/dh_main.c
++===================================================================
++--- valgrind-3.13.0.orig/exp-dhat/dh_main.c
+++++ valgrind-3.13.0/exp-dhat/dh_main.c
++@@ -1146,7 +1146,7 @@ static void show_APInfo ( APInfo* api )
++              bufR, bufW,
++              api->n_reads, api->n_writes);
++ 
++-   VG_(pp_ExeContext)(api->ap);
+++   VG_(pp_ExeContextAndEpoch)(VG_(tag_EC_with_current_epoch)(api->ap));
++ 
++    if (api->histo && api->xsize_tag == Exactly) {
++       VG_(umsg)("\nAggregated access counts by offset:\n");
++Index: valgrind-3.13.0/exp-sgcheck/pc_common.c
++===================================================================
++--- valgrind-3.13.0.orig/exp-sgcheck/pc_common.c
+++++ valgrind-3.13.0/exp-sgcheck/pc_common.c
++@@ -322,7 +322,7 @@ void pc_pp_Error ( const Error* err )
++          emit( "  <what>Invalid %s of size %ld</what>\n",
++                xe->XE.SorG.sszB < 0 ? "write" : "read",
++                Word__abs(xe->XE.SorG.sszB) );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++    
++          emit( "  <auxwhat>Address %#lx expected vs actual:</auxwhat>\n",
++                xe->XE.SorG.addr );
++@@ -336,7 +336,7 @@ void pc_pp_Error ( const Error* err )
++          emit( "Invalid %s of size %ld\n", 
++                xe->XE.SorG.sszB < 0 ? "write" : "read",
++                Word__abs(xe->XE.SorG.sszB) );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++    
++          emit( " Address %#lx expected vs actual:\n", xe->XE.SorG.addr );
++          emit( " Expected: %s\n", &xe->XE.SorG.expect[0] );
++@@ -362,7 +362,7 @@ void pc_pp_Error ( const Error* err )
++             emit( "  <what>Invalid %s of size %ld</what>\n",
++                   readwrite(xe->XE.Heap.sszB),
++                   Word__abs(xe->XE.Heap.sszB) );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++    
++             emit( "  <auxwhat>Address %#lx is not derived from "
++                   "any known block</auxwhat>\n", a );
++@@ -372,7 +372,7 @@ void pc_pp_Error ( const Error* err )
++             emit( "Invalid %s of size %ld\n",
++                   readwrite(xe->XE.Heap.sszB),
++                   Word__abs(xe->XE.Heap.sszB) );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++    
++             emit( " Address %#lx is not derived from "
++                   "any known block\n", a );
++@@ -397,7 +397,7 @@ void pc_pp_Error ( const Error* err )
++                   how_invalid,
++                   readwrite(xe->XE.Heap.sszB),
++                   Word__abs(xe->XE.Heap.sszB) );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++    
++             emit( "  <auxwhat>Address %#lx is %lu bytes %s "
++                      "the accessing pointer's</auxwhat>\n",
++@@ -406,7 +406,8 @@ void pc_pp_Error ( const Error* err )
++                      "a block of size %lu %s</auxwhat>\n",
++                   legit, Seg__size(vseg),
++                   Seg__is_freed(vseg) ? "free'd" : "alloc'd" );
++-            VG_(pp_ExeContext)(Seg__where(vseg));
+++            VG_(pp_ExeContextAndEpoch)(
+++               VG_(tag_EC_with_current_epoch)(Seg__where(vseg)));
++ 
++          } else {
++ 
++@@ -414,14 +415,15 @@ void pc_pp_Error ( const Error* err )
++                   how_invalid,
++                   readwrite(xe->XE.Heap.sszB),
++                   Word__abs(xe->XE.Heap.sszB) );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++    
++             emit( " Address %#lx is %lu bytes %s the accessing pointer's\n",
++                   a, miss_size, place );
++             emit( " %slegitimate range, a block of size %lu %s\n",
++                   legit, Seg__size(vseg),
++                   Seg__is_freed(vseg) ? "free'd" : "alloc'd" );
++-            VG_(pp_ExeContext)(Seg__where(vseg));
+++            VG_(pp_ExeContextAndEpoch)(
+++               VG_(tag_EC_with_current_epoch)(Seg__where(vseg)));
++ 
++          }
++       }
++@@ -477,7 +479,7 @@ void pc_pp_Error ( const Error* err )
++ 
++          emit( "  <what>Invalid arguments to %s</what>\n",
++                xe->XE.Arith.opname );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++    
++          if (seg1 != seg2) {
++             if (NONPTR == seg1) {
++@@ -488,7 +490,8 @@ void pc_pp_Error ( const Error* err )
++                emit( "  <auxwhat>First arg derived from address %#lx of "
++                      "%lu-byte block alloc'd</auxwhat>\n",
++                      Seg__addr(seg1), Seg__size(seg1) );
++-               VG_(pp_ExeContext)(Seg__where(seg1));
+++               VG_(pp_ExeContextAndEpoch)(
+++                  VG_(tag_EC_with_current_epoch)(Seg__where(seg1)));
++             }
++             which = "Second arg";
++          } else {
++@@ -500,14 +503,15 @@ void pc_pp_Error ( const Error* err )
++             emit( "  <auxwhat>%s derived from address %#lx of "
++                   "%lu-byte block alloc'd</auxwhat>\n",
++                   which, Seg__addr(seg2), Seg__size(seg2) );
++-            VG_(pp_ExeContext)(Seg__where(seg2));
+++            VG_(pp_ExeContextAndEpoch)(
+++               VG_(tag_EC_with_current_epoch)(Seg__where(seg2)));
++          }
++ 
++       } else {
++ 
++          emit( "Invalid arguments to %s\n",
++                xe->XE.Arith.opname );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++    
++          if (seg1 != seg2) {
++             if (NONPTR == seg1) {
++@@ -518,7 +522,8 @@ void pc_pp_Error ( const Error* err )
++                emit( " First arg derived from address %#lx of "
++                      "%lu-byte block alloc'd\n",
++                      Seg__addr(seg1), Seg__size(seg1) );
++-               VG_(pp_ExeContext)(Seg__where(seg1));
+++               VG_(pp_ExeContextAndEpoch)(
+++                  VG_(tag_EC_with_current_epoch)(Seg__where(seg1)));
++             }
++             which = "Second arg";
++          } else {
++@@ -530,7 +535,8 @@ void pc_pp_Error ( const Error* err )
++             emit( " %s derived from address %#lx of "
++                   "%lu-byte block alloc'd\n",
++                   which, Seg__addr(seg2), Seg__size(seg2) );
++-            VG_(pp_ExeContext)(Seg__where(seg2));
+++            VG_(pp_ExeContextAndEpoch)(
+++               VG_(tag_EC_with_current_epoch)(Seg__where(seg2)));
++          }
++ 
++       }
++@@ -562,23 +568,25 @@ void pc_pp_Error ( const Error* err )
++ 
++             emit( "  <what>%s%s contains unaddressable byte(s)</what>\n",
++                   what, s );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++    
++             emit( "  <auxwhat>Address %#lx is %lu bytes inside a "
++                   "%lu-byte block free'd</auxwhat>\n",
++                   lo, lo-Seg__addr(seglo), Seg__size(seglo) );
++-            VG_(pp_ExeContext)(Seg__where(seglo));
+++            VG_(pp_ExeContextAndEpoch)(
+++               VG_(tag_EC_with_current_epoch)(Seg__where(seglo)));
++ 
++          } else {
++ 
++             emit( " %s%s contains unaddressable byte(s)\n",
++                   what, s );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++    
++             emit( " Address %#lx is %lu bytes inside a "
++                   "%lu-byte block free'd\n",
++                   lo, lo-Seg__addr(seglo), Seg__size(seglo) );
++-            VG_(pp_ExeContext)(Seg__where(seglo));
+++            VG_(pp_ExeContextAndEpoch)(
+++               VG_(tag_EC_with_current_epoch)(Seg__where(seglo)));
++ 
++          }
++ 
++@@ -589,7 +597,7 @@ void pc_pp_Error ( const Error* err )
++ 
++             emit( "  <what>%s%s is non-contiguous</what>\n",
++                   what, s );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++    
++             if (UNKNOWN == seglo) {
++                emit( "  <auxwhat>First byte is "
++@@ -598,7 +606,8 @@ void pc_pp_Error ( const Error* err )
++                emit( "  <auxwhat>First byte (%#lx) is %lu bytes inside a "
++                      "%lu-byte block alloc'd</auxwhat>\n",
++                      lo, lo-Seg__addr(seglo), Seg__size(seglo) );
++-               VG_(pp_ExeContext)(Seg__where(seglo));
+++               VG_(pp_ExeContextAndEpoch)(
+++                  VG_(tag_EC_with_current_epoch)(Seg__where(seglo)));
++             }
++    
++             if (UNKNOWN == seghi) {
++@@ -608,14 +617,15 @@ void pc_pp_Error ( const Error* err )
++                emit( "  <auxwhat>Last byte (%#lx) is %lu bytes inside a "
++                      "%lu-byte block alloc'd</auxwhat>\n",
++                      hi, hi-Seg__addr(seghi), Seg__size(seghi) );
++-               VG_(pp_ExeContext)(Seg__where(seghi));
+++               VG_(pp_ExeContextAndEpoch)(
+++                  VG_(tag_EC_with_current_epoch)(Seg__where(seghi)));
++             }
++ 
++          } else {
++ 
++             emit( "%s%s is non-contiguous\n",
++                   what, s );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++    
++             if (UNKNOWN == seglo) {
++                emit( " First byte is not inside a known block\n" );
++@@ -623,7 +633,8 @@ void pc_pp_Error ( const Error* err )
++                emit( " First byte (%#lx) is %lu bytes inside a "
++                      "%lu-byte block alloc'd\n",
++                      lo, lo-Seg__addr(seglo), Seg__size(seglo) );
++-               VG_(pp_ExeContext)(Seg__where(seglo));
+++               VG_(pp_ExeContextAndEpoch)(
+++                  VG_(tag_EC_with_current_epoch)(Seg__where(seglo)));
++             }
++    
++             if (UNKNOWN == seghi) {
++@@ -632,7 +643,8 @@ void pc_pp_Error ( const Error* err )
++                emit( " Last byte (%#lx) is %lu bytes inside a "
++                      "%lu-byte block alloc'd\n",
++                      hi, hi-Seg__addr(seghi), Seg__size(seghi) );
++-               VG_(pp_ExeContext)(Seg__where(seghi));
+++               VG_(pp_ExeContextAndEpoch)(
+++                  VG_(tag_EC_with_current_epoch)(Seg__where(seghi)));
++             }
++ 
++          }
++@@ -650,6 +662,8 @@ void pc_pp_Error ( const Error* err )
++ UInt pc_update_Error_extra ( const Error* err )
++ {
++    XError *xe = (XError*)VG_(get_error_extra)(err);
+++   DiEpoch ep = VG_(get_error_where)(err).epoch;
+++
++    tl_assert(xe);
++    switch (xe->tag) {
++       case XE_SorG:
++@@ -675,7 +689,7 @@ UInt pc_update_Error_extra ( const Error
++          have_descr
++             = VG_(get_data_description)( xe->XE.Heap.descr1,
++                                          xe->XE.Heap.descr2,
++-                                         xe->XE.Heap.addr );
+++                                         ep, xe->XE.Heap.addr );
++ 
++          /* If there's nothing in descr1/2, free it.  Why is it safe to
++             to VG_(indexXA) at zero here?  Because
++@@ -699,7 +713,7 @@ UInt pc_update_Error_extra ( const Error
++          if (!have_descr) {
++             const HChar *name;
++             if (VG_(get_datasym_and_offset)(
++-                   xe->XE.Heap.addr, &name,
+++                   ep, xe->XE.Heap.addr, &name,
++                    &xe->XE.Heap.datasymoff )
++                ) {
++               xe->XE.Heap.datasym =
++Index: valgrind-3.13.0/exp-sgcheck/sg_main.c
++===================================================================
++--- valgrind-3.13.0.orig/exp-sgcheck/sg_main.c
+++++ valgrind-3.13.0/exp-sgcheck/sg_main.c
++@@ -1936,7 +1936,8 @@ void shadowStack_new_frame ( ThreadId ti
++      const HChar *fnname;
++      Bool ok;
++      Addr ip = ip_post_call_insn;
++-     ok = VG_(get_fnname_w_offset)( ip, &fnname );
+++     DiEpoch ep = VG_(current_DiEpoch)();
+++     ok = VG_(get_fnname_w_offset)( ep, ip, &fnname );
++      while (d > 0) {
++         VG_(printf)(" ");
++         d--;
++Index: valgrind-3.13.0/helgrind/hg_addrdescr.c
++===================================================================
++--- valgrind-3.13.0.orig/helgrind/hg_addrdescr.c
+++++ valgrind-3.13.0/helgrind/hg_addrdescr.c
++@@ -45,7 +45,7 @@
++ #include "hg_lock_n_thread.h"
++ #include "hg_addrdescr.h"            /* self */
++ 
++-void HG_(describe_addr) ( Addr a, /*OUT*/AddrInfo* ai )
+++void HG_(describe_addr) ( DiEpoch ep, Addr a, /*OUT*/AddrInfo* ai )
++ {
++    tl_assert(ai->tag == Addr_Undescribed);
++ 
++@@ -75,13 +75,14 @@ void HG_(describe_addr) ( Addr a, /*OUT*
++       ai->Addr.Block.block_desc = "block";
++       ai->Addr.Block.block_szB  = hszB;
++       ai->Addr.Block.rwoffset   = (Word)(a) - (Word)(haddr);
++-      ai->Addr.Block.allocated_at = hctxt;
+++      ai->Addr.Block.allocated_at.ec = hctxt;
+++      ai->Addr.Block.allocated_at.epoch = ep;
++       VG_(initThreadInfo) (&ai->Addr.Block.alloc_tinfo);
++       ai->Addr.Block.alloc_tinfo.tnr = tnr;
++-      ai->Addr.Block.freed_at = VG_(null_ExeContext)();;
+++      ai->Addr.Block.freed_at = VG_(null_ExeContextAndEpoch)();
++    } else {
++       /* No block found. Search a non-heap block description. */
++-      VG_(describe_addr) (a, ai);
+++      VG_(describe_addr) (ep, a, ai);
++ 
++       /* In case ai contains a tid, set tnr to the corresponding helgrind
++          thread number. */
++@@ -100,14 +101,14 @@ void HG_(describe_addr) ( Addr a, /*OUT*
++    }
++ }
++ 
++-Bool HG_(get_and_pp_addrdescr) (Addr addr)
+++Bool HG_(get_and_pp_addrdescr) (DiEpoch ep, Addr addr)
++ {
++ 
++    Bool ret;
++    AddrInfo glai;
++ 
++    glai.tag = Addr_Undescribed;
++-   HG_(describe_addr) (addr, &glai);
+++   HG_(describe_addr) (ep, addr, &glai);
++    VG_(pp_addrinfo) (addr, &glai);
++    ret = glai.tag != Addr_Unknown;
++ 
++Index: valgrind-3.13.0/helgrind/hg_addrdescr.h
++===================================================================
++--- valgrind-3.13.0.orig/helgrind/hg_addrdescr.h
+++++ valgrind-3.13.0/helgrind/hg_addrdescr.h
++@@ -37,12 +37,12 @@
++    lock description, putting the result in ai.
++    This might allocate some memory in ai, to be cleared with
++    VG_(clear_addrinfo). */
++-extern void HG_(describe_addr) ( Addr a, /*OUT*/AddrInfo* ai );
+++extern void HG_(describe_addr) ( DiEpoch ep, Addr a, /*OUT*/AddrInfo* ai );
++ 
++ /* Get a readable description of addr, then print it using HG_(pp_addrdescr)
++    using xml False and VG_(printf) to emit the characters.
++    Returns True if a description was found/printed, False otherwise. */
++-extern Bool HG_(get_and_pp_addrdescr) (Addr a);
+++extern Bool HG_(get_and_pp_addrdescr) (DiEpoch ep, Addr a);
++ 
++ /* For error creation/address description:
++    map 'data_addr' to a malloc'd chunk, if any.
++Index: valgrind-3.13.0/helgrind/hg_errors.c
++===================================================================
++--- valgrind-3.13.0.orig/helgrind/hg_errors.c
+++++ valgrind-3.13.0/helgrind/hg_errors.c
++@@ -421,7 +421,8 @@ UInt HG_(update_extra) ( const Error* er
++          VG_(printf)("HG_(update_extra): "
++                      "%d conflicting-event queries\n", xxx);
++ 
++-      HG_(describe_addr) (xe->XE.Race.data_addr, &xe->XE.Race.data_addrinfo);
+++      HG_(describe_addr) (VG_(get_error_where)(err).epoch,
+++                          xe->XE.Race.data_addr, &xe->XE.Race.data_addrinfo);
++ 
++       /* And poke around in the conflicting-event map, to see if we
++          can rustle up a plausible-looking conflicting memory access
++@@ -748,7 +749,8 @@ static Bool announce_one_thread ( Thread
++          VG_(printf_xml)("  <isrootthread></isrootthread>\n");
++       } else {
++          tl_assert(thr->created_at != NULL);
++-         VG_(pp_ExeContext)( thr->created_at );
+++         VG_(pp_ExeContextAndEpoch)(
+++            VG_(tag_EC_with_current_epoch)( thr->created_at ) );
++       }
++       VG_(printf_xml)("</announcethread>\n\n");
++ 
++@@ -767,7 +769,8 @@ static Bool announce_one_thread ( Thread
++          tl_assert(thr->created_at != NULL);
++          VG_(message)(Vg_UserMsg, "Thread #%d was created\n",
++                                   thr->errmsg_index);
++-         VG_(pp_ExeContext)( thr->created_at );
+++         VG_(pp_ExeContextAndEpoch)(
+++            VG_(tag_EC_with_current_epoch)( thr->created_at ) );
++       }
++       VG_(message)(Vg_UserMsg, "\n");
++ 
++@@ -789,19 +792,21 @@ static void announce_LockP ( Lock* lk )
++       if (lk->appeared_at) {
++          emit( "  <auxwhat>Lock at %p was first observed</auxwhat>\n",
++                (void*)lk );
++-         VG_(pp_ExeContext)( lk->appeared_at );
+++         VG_(pp_ExeContextAndEpoch)(
+++            VG_(tag_EC_with_current_epoch)( lk->appeared_at ) );
++       }
++ 
++    } else {
++       if (lk->appeared_at) {
++          VG_(umsg)( " Lock at %p was first observed\n",
++                     (void*)lk->guestaddr );
++-         VG_(pp_ExeContext)( lk->appeared_at );
+++         VG_(pp_ExeContextAndEpoch)(
+++            VG_(tag_EC_with_current_epoch)( lk->appeared_at ) );
++       } else {
++          VG_(umsg)( " Lock at %p : no stacktrace for first observation\n",
++                     (void*)lk->guestaddr );
++       }
++-      HG_(get_and_pp_addrdescr) (lk->guestaddr);
+++      HG_(get_and_pp_addrdescr) (VG_(current_DiEpoch)(), lk->guestaddr);
++       VG_(umsg)("\n");
++    }
++ }
++@@ -941,11 +946,12 @@ void HG_(pp_Error) ( const Error* err )
++          emit( "    <hthreadid>%d</hthreadid>\n",
++                (Int)xe->XE.Misc.thr->errmsg_index );
++          emit( "  </xwhat>\n" );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          if (xe->XE.Misc.auxstr) {
++             emit("  <auxwhat>%s</auxwhat>\n", xe->XE.Misc.auxstr);
++             if (xe->XE.Misc.auxctx)
++-               VG_(pp_ExeContext)( xe->XE.Misc.auxctx );
+++               VG_(pp_ExeContextAndEpoch)(
+++                  VG_(tag_EC_with_current_epoch)( xe->XE.Misc.auxctx ));
++          }
++ 
++       } else {
++@@ -953,11 +959,12 @@ void HG_(pp_Error) ( const Error* err )
++          emit( "Thread #%d: %s\n",
++                (Int)xe->XE.Misc.thr->errmsg_index,
++                xe->XE.Misc.errstr );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          if (xe->XE.Misc.auxstr) {
++             emit(" %s\n", xe->XE.Misc.auxstr);
++             if (xe->XE.Misc.auxctx)
++-               VG_(pp_ExeContext)( xe->XE.Misc.auxctx );
+++               VG_(pp_ExeContextAndEpoch)(
+++                  VG_(tag_EC_with_current_epoch)( xe->XE.Misc.auxctx ));
++          }
++ 
++       }
++@@ -978,17 +985,21 @@ void HG_(pp_Error) ( const Error* err )
++          emit( "    <hthreadid>%d</hthreadid>\n",
++                (Int)xe->XE.LockOrder.thr->errmsg_index );
++          emit( "  </xwhat>\n" );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          if (xe->XE.LockOrder.shouldbe_earlier_ec
++              && xe->XE.LockOrder.shouldbe_later_ec) {
++             emit( "  <auxwhat>Required order was established by "
++                   "acquisition of lock at %p</auxwhat>\n",
++                   (void*)xe->XE.LockOrder.shouldbe_earlier_lk->guestaddr );
++-            VG_(pp_ExeContext)( xe->XE.LockOrder.shouldbe_earlier_ec );
+++            VG_(pp_ExeContextAndEpoch)(
+++               VG_(tag_EC_with_current_epoch)(
+++                  xe->XE.LockOrder.shouldbe_earlier_ec ));
++             emit( "  <auxwhat>followed by a later acquisition "
++                   "of lock at %p</auxwhat>\n",
++                   (void*)xe->XE.LockOrder.shouldbe_later_lk->guestaddr );
++-            VG_(pp_ExeContext)( xe->XE.LockOrder.shouldbe_later_ec );
+++            VG_(pp_ExeContextAndEpoch)(
+++               VG_(tag_EC_with_current_epoch)(
+++                  xe->XE.LockOrder.shouldbe_later_ec ));
++          }
++          announce_LockP ( xe->XE.LockOrder.shouldbe_earlier_lk );
++          announce_LockP ( xe->XE.LockOrder.shouldbe_later_lk );
++@@ -1004,25 +1015,31 @@ void HG_(pp_Error) ( const Error* err )
++                "acquisition of lock at %p\n",
++                (void*)xe->XE.LockOrder.shouldbe_later_lk->guestaddr);
++          if (xe->XE.LockOrder.actual_earlier_ec) {
++-             VG_(pp_ExeContext)(xe->XE.LockOrder.actual_earlier_ec);
+++             VG_(pp_ExeContextAndEpoch)(
+++                VG_(tag_EC_with_current_epoch)(
+++                   xe->XE.LockOrder.actual_earlier_ec));
++          } else {
++             emit("   (stack unavailable)\n");
++          }
++          emit( "\n" );
++          emit(" followed by a later acquisition of lock at %p\n",
++               (void*)xe->XE.LockOrder.shouldbe_earlier_lk->guestaddr);
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          if (xe->XE.LockOrder.shouldbe_earlier_ec
++              && xe->XE.LockOrder.shouldbe_later_ec) {
++             emit("\n");
++             emit( "Required order was established by "
++                   "acquisition of lock at %p\n",
++                   (void*)xe->XE.LockOrder.shouldbe_earlier_lk->guestaddr );
++-            VG_(pp_ExeContext)( xe->XE.LockOrder.shouldbe_earlier_ec );
+++            VG_(pp_ExeContextAndEpoch)(
+++               VG_(tag_EC_with_current_epoch)(
+++                   xe->XE.LockOrder.shouldbe_earlier_ec ));
++             emit( "\n" );
++             emit( " followed by a later acquisition of lock at %p\n",
++                   (void*)xe->XE.LockOrder.shouldbe_later_lk->guestaddr );
++-            VG_(pp_ExeContext)( xe->XE.LockOrder.shouldbe_later_ec );
+++            VG_(pp_ExeContextAndEpoch)(
+++               VG_(tag_EC_with_current_epoch)(
+++                  xe->XE.LockOrder.shouldbe_later_ec ));
++          }
++          emit("\n");
++          announce_LockP ( xe->XE.LockOrder.shouldbe_earlier_lk );
++@@ -1048,7 +1065,7 @@ void HG_(pp_Error) ( const Error* err )
++          emit( "  </xwhat>\n" );
++          emit( "  <what>with error code %ld (%s)</what>\n",
++                xe->XE.PthAPIerror.err, xe->XE.PthAPIerror.errstr );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++ 
++       } else {
++ 
++@@ -1057,7 +1074,7 @@ void HG_(pp_Error) ( const Error* err )
++                       xe->XE.PthAPIerror.fnname );
++          emit( "   with error code %ld (%s)\n",
++                xe->XE.PthAPIerror.err, xe->XE.PthAPIerror.errstr );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++ 
++       }
++ 
++@@ -1077,14 +1094,14 @@ void HG_(pp_Error) ( const Error* err )
++          emit( "    <hthreadid>%d</hthreadid>\n",
++                (Int)xe->XE.UnlockBogus.thr->errmsg_index );
++          emit( "  </xwhat>\n" );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++ 
++       } else {
++ 
++          emit( "Thread #%d unlocked an invalid lock at %p\n",
++                (Int)xe->XE.UnlockBogus.thr->errmsg_index,
++                (void*)xe->XE.UnlockBogus.lock_ga );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++ 
++       }
++ 
++@@ -1109,7 +1126,7 @@ void HG_(pp_Error) ( const Error* err )
++          emit( "    <hthreadid>%d</hthreadid>\n",
++                (Int)xe->XE.UnlockForeign.owner->errmsg_index );
++          emit( "  </xwhat>\n" );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          announce_LockP ( xe->XE.UnlockForeign.lock );
++ 
++       } else {
++@@ -1119,7 +1136,7 @@ void HG_(pp_Error) ( const Error* err )
++                (Int)xe->XE.UnlockForeign.thr->errmsg_index,
++                (void*)xe->XE.UnlockForeign.lock->guestaddr,
++                (Int)xe->XE.UnlockForeign.owner->errmsg_index );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          announce_LockP ( xe->XE.UnlockForeign.lock );
++ 
++       }
++@@ -1141,7 +1158,7 @@ void HG_(pp_Error) ( const Error* err )
++          emit( "    <hthreadid>%d</hthreadid>\n",
++                (Int)xe->XE.UnlockUnlocked.thr->errmsg_index );
++          emit( "  </xwhat>\n" );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          announce_LockP ( xe->XE.UnlockUnlocked.lock);
++ 
++       } else {
++@@ -1149,7 +1166,7 @@ void HG_(pp_Error) ( const Error* err )
++          emit( "Thread #%d unlocked a not-locked lock at %p\n",
++                (Int)xe->XE.UnlockUnlocked.thr->errmsg_index,
++                (void*)xe->XE.UnlockUnlocked.lock->guestaddr );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          announce_LockP ( xe->XE.UnlockUnlocked.lock);
++ 
++       }
++@@ -1179,7 +1196,7 @@ void HG_(pp_Error) ( const Error* err )
++          emit( "    <hthreadid>%d</hthreadid>\n",
++                (Int)xe->XE.Race.thr->errmsg_index );
++          emit( "  </xwhat>\n" );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++ 
++          if (xe->XE.Race.h2_ct) {
++             tl_assert(xe->XE.Race.h2_ct_accEC); // assured by update_extra
++@@ -1192,7 +1209,8 @@ void HG_(pp_Error) ( const Error* err )
++             emit( "    <hthreadid>%d</hthreadid>\n", 
++                   xe->XE.Race.h2_ct->errmsg_index);
++             emit("  </xauxwhat>\n");
++-            VG_(pp_ExeContext)( xe->XE.Race.h2_ct_accEC );
+++            VG_(pp_ExeContextAndEpoch)(
+++               VG_(tag_EC_with_current_epoch)( xe->XE.Race.h2_ct_accEC ));
++          }
++ 
++          if (xe->XE.Race.h1_ct) {
++@@ -1204,13 +1222,17 @@ void HG_(pp_Error) ( const Error* err )
++                   xe->XE.Race.h1_ct->errmsg_index );
++             emit("  </xauxwhat>\n");
++             if (xe->XE.Race.h1_ct_mbsegstartEC) {
++-               VG_(pp_ExeContext)( xe->XE.Race.h1_ct_mbsegstartEC );
+++               VG_(pp_ExeContextAndEpoch)(
+++                  VG_(tag_EC_with_current_epoch)(
+++                     xe->XE.Race.h1_ct_mbsegstartEC ));
++             } else {
++                emit( "  <auxwhat>(the start of the thread)</auxwhat>\n" );
++             }
++             emit( "  <auxwhat>but before</auxwhat>\n" );
++             if (xe->XE.Race.h1_ct_mbsegendEC) {
++-               VG_(pp_ExeContext)( xe->XE.Race.h1_ct_mbsegendEC );
+++               VG_(pp_ExeContextAndEpoch)(
+++                  VG_(tag_EC_with_current_epoch)(
+++                     xe->XE.Race.h1_ct_mbsegendEC ));
++             } else {
++                emit( "  <auxwhat>(the end of the thread)</auxwhat>\n" );
++             }
++@@ -1228,7 +1250,7 @@ void HG_(pp_Error) ( const Error* err )
++ 
++          tl_assert(xe->XE.Race.locksHeldW);
++          show_LockP_summary_textmode( xe->XE.Race.locksHeldW, "" );
++-         VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++         VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++ 
++          if (xe->XE.Race.h2_ct) {
++             tl_assert(xe->XE.Race.h2_ct_accEC); // assured by update_extra
++@@ -1240,7 +1262,8 @@ void HG_(pp_Error) ( const Error* err )
++                   xe->XE.Race.h2_ct_accSzB,
++                   xe->XE.Race.h2_ct->errmsg_index );
++             show_LockP_summary_textmode( xe->XE.Race.h2_ct_locksHeldW, "" );
++-            VG_(pp_ExeContext)( xe->XE.Race.h2_ct_accEC );
+++            VG_(pp_ExeContextAndEpoch)(
+++               VG_(tag_EC_with_current_epoch)( xe->XE.Race.h2_ct_accEC ));
++          }
++ 
++          if (xe->XE.Race.h1_ct) {
++@@ -1248,13 +1271,17 @@ void HG_(pp_Error) ( const Error* err )
++                   "after\n",
++                   xe->XE.Race.h1_ct->errmsg_index );
++             if (xe->XE.Race.h1_ct_mbsegstartEC) {
++-               VG_(pp_ExeContext)( xe->XE.Race.h1_ct_mbsegstartEC );
+++               VG_(pp_ExeContextAndEpoch)(
+++                  VG_(tag_EC_with_current_epoch)(
+++                     xe->XE.Race.h1_ct_mbsegstartEC ));
++             } else {
++                emit( "   (the start of the thread)\n" );
++             }
++             emit( " but before\n" );
++             if (xe->XE.Race.h1_ct_mbsegendEC) {
++-               VG_(pp_ExeContext)( xe->XE.Race.h1_ct_mbsegendEC );
+++               VG_(pp_ExeContextAndEpoch)(
+++                  VG_(tag_EC_with_current_epoch)(
+++                     xe->XE.Race.h1_ct_mbsegendEC ));
++             } else {
++                emit( "   (the end of the thread)\n" );
++             }
++@@ -1307,7 +1334,7 @@ void HG_(print_access) (StackTrace ips,
++       show_LockP_summary_textmode( locksHeldW_P, "" );
++       HG_(free) (locksHeldW_P);
++    }
++-   VG_(pp_StackTrace) (ips, n_ips);
+++   VG_(pp_StackTrace)( VG_(current_DiEpoch)(), ips, n_ips );
++    VG_(printf) ("\n");
++ }
++ 
++Index: valgrind-3.13.0/helgrind/hg_main.c
++===================================================================
++--- valgrind-3.13.0.orig/helgrind/hg_main.c
+++++ valgrind-3.13.0/helgrind/hg_main.c
++@@ -483,13 +483,14 @@ static void pp_Lock ( Int d, Lock* lk,
++                       Bool show_lock_addrdescr,
++                       Bool show_internal_data)
++ {
+++   DiEpoch ep = VG_(current_DiEpoch)();
++    space(d+0); 
++    if (show_internal_data)
++       VG_(printf)("Lock %p (ga %#lx) {\n", lk, lk->guestaddr);
++    else
++       VG_(printf)("Lock ga %#lx {\n", lk->guestaddr);
++    if (!show_lock_addrdescr 
++-       || !HG_(get_and_pp_addrdescr) ((Addr) lk->guestaddr))
+++       || !HG_(get_and_pp_addrdescr) (ep, (Addr) lk->guestaddr))
++       VG_(printf)("\n");
++       
++    if (sHOW_ADMIN) {
++@@ -4598,7 +4599,7 @@ static Bool is_in_dynamic_linker_shared_
++    DebugInfo* dinfo;
++    const HChar* soname;
++ 
++-   dinfo = VG_(find_DebugInfo)( ga );
+++   dinfo = VG_(find_DebugInfo)( VG_(current_DiEpoch)(), ga );
++    if (!dinfo) return False;
++ 
++    soname = VG_(DebugInfo_get_soname)(dinfo);
++@@ -5817,9 +5818,9 @@ static void hg_post_clo_init ( void )
++       VG_(XTMemory_Full_init)(VG_(XT_filter_1top_and_maybe_below_main));
++ }
++ 
++-static void hg_info_location (Addr a)
+++static void hg_info_location (DiEpoch ep, Addr a)
++ {
++-   (void) HG_(get_and_pp_addrdescr) (a);
+++   (void) HG_(get_and_pp_addrdescr) (ep, a);
++ }
++ 
++ static void hg_pre_clo_init ( void )
++Index: valgrind-3.13.0/helgrind/libhb_core.c
++===================================================================
++--- valgrind-3.13.0.orig/helgrind/libhb_core.c
+++++ valgrind-3.13.0/helgrind/libhb_core.c
++@@ -4095,7 +4095,7 @@ static void note_local_Kw_n_stack_for (
++       VG_(printf)("LOCAL Kw: thr %p,  Kw %llu,  ec %p\n",
++                   thr, pair.ull, pair.ec );
++    if (0)
++-      VG_(pp_ExeContext)(pair.ec);
+++      VG_(pp_ExeContextAndEpoch)(VG_(tag_EC_with_current_epoch)(pair.ec));
++ }
++ 
++ static Int cmp__ULong_n_EC__by_ULong ( const ULong_n_EC* pair1,
++Index: valgrind-3.13.0/include/pub_tool_addrinfo.h
++===================================================================
++--- valgrind-3.13.0.orig/include/pub_tool_addrinfo.h
+++++ valgrind-3.13.0/include/pub_tool_addrinfo.h
++@@ -135,6 +135,7 @@ struct _AddrInfo {
++       // (spoffset will be negative, as stacks are assumed growing down).
++       struct {
++          ThreadInfo tinfo;
+++         DiEpoch  epoch;
++          Addr     IP;
++          Int      frameNo;
++          StackPos stackPos;
++@@ -151,9 +152,9 @@ struct _AddrInfo {
++          const HChar* block_desc;   // "block","mempool","user-defined",arena
++          SizeT       block_szB;
++          PtrdiffT    rwoffset;
++-         ExeContext* allocated_at;  // might be null_ExeContext.
++-         ThreadInfo  alloc_tinfo;   // which thread did alloc this block.
++-         ExeContext* freed_at;      // might be null_ExeContext.
+++         ExeContextAndEpoch allocated_at; // might contain null_ExeContext.
+++         ThreadInfo         alloc_tinfo;  // which thread alloc'd this block.
+++         ExeContextAndEpoch freed_at;     // might contain null_ExeContext.
++       } Block;
++ 
++       // In a global .data symbol.  This holds
++@@ -204,7 +205,7 @@ struct _AddrInfo {
++    On entry, ai->tag must be equal to Addr_Undescribed.
++    This might allocate some memory, that can be cleared with
++    VG_(clear_addrinfo). */
++-extern void VG_(describe_addr) ( Addr a, /*OUT*/AddrInfo* ai );
+++extern void VG_(describe_addr) ( DiEpoch ep, Addr a, /*OUT*/AddrInfo* ai );
++ 
++ extern void VG_(clear_addrinfo) ( AddrInfo* ai);
++ 
++Index: valgrind-3.13.0/include/pub_tool_basics.h
++===================================================================
++--- valgrind-3.13.0.orig/include/pub_tool_basics.h
+++++ valgrind-3.13.0/include/pub_tool_basics.h
++@@ -129,6 +129,24 @@ typedef  struct { UWord uw1; UWord uw2;
++ /* ThreadIds are simply indices into the VG_(threads)[] array. */
++ typedef UInt ThreadId;
++ 
+++
+++/* You need a debuginfo epoch in order to convert an address into any source
+++   level entity, since that conversion depends on what objects were mapped
+++   in at the time.  An epoch is simply a monotonically increasing counter,
+++   which we wrap up in a struct so as to enable the C type system to
+++   distinguish it from other kinds of numbers.  m_debuginfo holds and
+++   maintains the current epoch number. */
+++typedef  struct { UInt n; }  DiEpoch;
+++
+++static inline DiEpoch DiEpoch_INVALID ( void ) {
+++   DiEpoch dep; dep.n = 0; return dep;
+++}
+++
+++static inline Bool is_DiEpoch_INVALID ( DiEpoch dep ) {
+++   return dep.n == 0;
+++}
+++
+++
++ /* Many data structures need to allocate and release memory.
++    The allocation/release functions must be provided by the caller.
++    The Alloc_Fn_t function must allocate a chunk of memory of size szB.
++Index: valgrind-3.13.0/include/pub_tool_debuginfo.h
++===================================================================
++--- valgrind-3.13.0.orig/include/pub_tool_debuginfo.h
+++++ valgrind-3.13.0/include/pub_tool_debuginfo.h
++@@ -31,11 +31,20 @@
++ #ifndef __PUB_TOOL_DEBUGINFO_H
++ #define __PUB_TOOL_DEBUGINFO_H
++ 
++-#include "pub_tool_basics.h"   // VG_ macro
+++#include "pub_tool_basics.h"   // VG_ macro, DiEpoch
++ #include "pub_tool_xarray.h"   // XArray
++ 
+++
++ /*====================================================================*/
++-/*=== Obtaining debug information                                  ===*/
+++/*=== Debuginfo epochs.                                            ===*/
+++/*====================================================================*/
+++
+++// This returns the current epoch.
+++DiEpoch VG_(current_DiEpoch)(void);
+++
+++
+++/*====================================================================*/
+++/*=== Obtaining information pertaining to source artefacts.        ===*/
++ /*====================================================================*/
++ 
++ /* IMPORTANT COMMENT about memory persistence and ownership.
++@@ -76,11 +85,11 @@
++    demangles C++ function names.  VG_(get_fnname_w_offset) is the
++    same, except it appends "+N" to symbol names to indicate offsets.
++    NOTE: See IMPORTANT COMMENT above about persistence and ownership. */
++-extern Bool VG_(get_filename) ( Addr a, const HChar** filename );
++-extern Bool VG_(get_fnname)   ( Addr a, const HChar** fnname );
++-extern Bool VG_(get_linenum)  ( Addr a, UInt* linenum );
+++extern Bool VG_(get_filename) ( DiEpoch ep, Addr a, const HChar** filename );
+++extern Bool VG_(get_fnname)   ( DiEpoch ep, Addr a, const HChar** fnname );
+++extern Bool VG_(get_linenum)  ( DiEpoch ep, Addr a, UInt* linenum );
++ extern Bool VG_(get_fnname_w_offset)
++-                              ( Addr a, const HChar** fnname );
+++                              ( DiEpoch ep, Addr a, const HChar** fnname );
++ 
++ /* This one is the most general.  It gives filename, line number and
++    optionally directory name.  filename and linenum may not be NULL.
++@@ -95,7 +104,7 @@ extern Bool VG_(get_fnname_w_offset)
++    Returned value indicates whether any filename/line info could be
++    found. */
++ extern Bool VG_(get_filename_linenum)
++-                              ( Addr a, 
+++                              ( DiEpoch ep, Addr a, 
++                                 /*OUT*/const HChar** filename,
++                                 /*OUT*/const HChar** dirname,
++                                 /*OUT*/UInt* linenum );
++@@ -108,7 +117,8 @@ extern Bool VG_(get_filename_linenum)
++    of its symbols, this function will not be able to recognise function
++    entry points within it.
++    NOTE: See IMPORTANT COMMENT above about persistence and ownership. */
++-extern Bool VG_(get_fnname_if_entry) ( Addr a, const HChar** fnname );
+++extern Bool VG_(get_fnname_if_entry) ( DiEpoch ep, Addr a,
+++                                       const HChar** fnname );
++ 
++ typedef
++    enum {
++@@ -121,13 +131,13 @@ typedef
++ extern Vg_FnNameKind VG_(get_fnname_kind) ( const HChar* name );
++ 
++ /* Like VG_(get_fnname_kind), but takes a code address. */
++-extern Vg_FnNameKind VG_(get_fnname_kind_from_IP) ( Addr ip );
+++extern Vg_FnNameKind VG_(get_fnname_kind_from_IP) ( DiEpoch ep, Addr ip );
++ 
++ /* Looks up data_addr in the collection of data symbols, and if found
++    puts its name (or as much as will fit) into dname[0 .. n_dname-1],
++    which is guaranteed to be zero terminated.  Also data_addr's offset
++    from the symbol start is put into *offset. */
++-extern Bool VG_(get_datasym_and_offset)( Addr data_addr,
+++extern Bool VG_(get_datasym_and_offset)( DiEpoch ep, Addr data_addr,
++                                          /*OUT*/const HChar** dname,
++                                          /*OUT*/PtrdiffT* offset );
++ 
++@@ -147,14 +157,14 @@ extern Bool VG_(get_datasym_and_offset)(
++ Bool VG_(get_data_description)( 
++         /*MOD*/ XArray* /* of HChar */ dname1v,
++         /*MOD*/ XArray* /* of HChar */ dname2v,
++-        Addr data_addr
+++        DiEpoch ep, Addr data_addr
++      );
++ 
++ /* Succeeds if the address is within a shared object or the main executable.
++    It first searches if Addr a belongs to the text segment of debug info.
++    If not found, it asks the address space manager whether it
++    knows the name of the file associated with this mapping. */
++-extern Bool VG_(get_objname)  ( Addr a, const HChar** objname );
+++extern Bool VG_(get_objname) ( DiEpoch ep, Addr a, const HChar** objname );
++ 
++ 
++ /* Cursor allowing to describe inlined function calls at an IP,
++@@ -169,7 +179,7 @@ typedef  struct _InlIPCursor InlIPCursor
++    eip can possibly corresponds to inlined function call(s).
++    To describe eip and the inlined function calls, the following must
++    be done:
++-       InlIPCursor *iipc = VG_(new_IIPC)(eip);
+++       InlIPCursor *iipc = VG_(new_IIPC)(ep, eip);
++        do {
++           buf = VG_(describe_IP)(eip, iipc);
++           ... use buf ...
++@@ -182,12 +192,16 @@ typedef  struct _InlIPCursor InlIPCursor
++    Note, that the returned string is allocated in a static buffer local to
++    VG_(describe_IP). That buffer will be overwritten with every invocation.
++    Therefore, callers need to possibly stash away the string.
+++
+++   Since this maps a code location to a source artefact (function names),
+++   new_IIPC requires a DiEpoch argument (ep) too.
++ */
++-extern const HChar* VG_(describe_IP)(Addr eip, const InlIPCursor* iipc);
+++extern const HChar* VG_(describe_IP)(DiEpoch ep, Addr eip,
+++                                     const InlIPCursor* iipc);
++ 
++ /* Builds a IIPC (Inlined IP Cursor) to describe eip and all the inlined calls
++    at eip. Such a cursor must be deleted after use using VG_(delete_IIPC). */
++-extern InlIPCursor* VG_(new_IIPC)(Addr eip);
+++extern InlIPCursor* VG_(new_IIPC)(DiEpoch ep, Addr eip);
++ /* Move the cursor to the next call to describe.
++    Returns True if there are still calls to describe.
++    False if nothing to describe anymore. */
++@@ -239,7 +253,7 @@ VG_(di_get_global_blocks_from_dihandle)
++ 
++ 
++ /*====================================================================*/
++-/*=== Obtaining debug information                                  ===*/
+++/*=== Obtaining information pertaining to shared objects.          ===*/
++ /*====================================================================*/
++ 
++ /* A way to make limited debuginfo queries on a per-mapped-object
++@@ -248,7 +262,7 @@ typedef  struct _DebugInfo  DebugInfo;
++ 
++ /* Returns NULL if the DebugInfo isn't found.  It doesn't matter if
++    debug info is present or not. */
++-DebugInfo* VG_(find_DebugInfo) ( Addr a );
+++DebugInfo* VG_(find_DebugInfo) ( DiEpoch ep, Addr a );
++ 
++ /* Fish bits out of DebugInfos. */
++ Addr          VG_(DebugInfo_get_text_avma)   ( const DebugInfo *di );
++Index: valgrind-3.13.0/include/pub_tool_errormgr.h
++===================================================================
++--- valgrind-3.13.0.orig/include/pub_tool_errormgr.h
+++++ valgrind-3.13.0/include/pub_tool_errormgr.h
++@@ -56,11 +56,11 @@ typedef
++ 
++ /* Useful in VG_(tdict).tool_error_matches_suppression(),
++  * VG_(tdict).tool_pp_Error(), etc */
++-ExeContext*  VG_(get_error_where)   ( const Error* err );
++-ErrorKind    VG_(get_error_kind)    ( const Error* err );
++-Addr         VG_(get_error_address) ( const Error* err );
++-const HChar* VG_(get_error_string)  ( const Error* err );
++-void*        VG_(get_error_extra)   ( const Error* err );
+++ExeContextAndEpoch  VG_(get_error_where)   ( const Error* err );
+++ErrorKind           VG_(get_error_kind)    ( const Error* err );
+++Addr                VG_(get_error_address) ( const Error* err );
+++const HChar*        VG_(get_error_string)  ( const Error* err );
+++void*               VG_(get_error_extra)   ( const Error* err );
++ 
++ /* Call this when an error occurs.  It will be recorded if it hasn't been
++    seen before.  If it has, the existing error record will have its count
++@@ -90,7 +90,7 @@ extern void VG_(maybe_record_error) ( Th
++    whether to add the error in the error total count (another mild hack). */
++ extern Bool VG_(unique_error) ( ThreadId tid, ErrorKind ekind,
++                                 Addr a, const HChar* s, void* extra,
++-                                ExeContext* where, Bool print_error,
+++                                ExeContextAndEpoch where, Bool print_error,
++                                 Bool allow_GDB_attach, Bool count_error );
++ 
++ /* Gets from fd (an opened suppression file) a non-blank, non-comment
++Index: valgrind-3.13.0/include/pub_tool_execontext.h
++===================================================================
++--- valgrind-3.13.0.orig/include/pub_tool_execontext.h
+++++ valgrind-3.13.0/include/pub_tool_execontext.h
++@@ -30,7 +30,13 @@
++ #ifndef __PUB_TOOL_EXECONTEXT_H
++ #define __PUB_TOOL_EXECONTEXT_H
++ 
++-#include "pub_tool_basics.h"   // ThreadID
+++#include "pub_tool_basics.h"     // ThreadID
+++#include "pub_tool_debuginfo.h"  // DiEpoch
+++
+++
+++/*====================================================================*/
+++/*=== ExeContext                                                   ===*/
+++/*====================================================================*/
++ 
++ // It's an abstract type.
++ typedef
++@@ -84,9 +90,6 @@ extern void VG_(apply_ExeContext)( void(
++ extern Bool VG_(eq_ExeContext) ( VgRes res, const ExeContext* e1,
++                                  const ExeContext* e2 );
++ 
++-// Print an ExeContext.
++-extern void VG_(pp_ExeContext) ( ExeContext* ec );
++-
++ // Get the 32-bit unique reference number for this ExeContext
++ // (the "ExeContext Unique").  Guaranteed to be nonzero and to be a
++ // multiple of four (iow, the lowest two bits are guaranteed to
++@@ -113,10 +116,52 @@ static inline Bool VG_(is_plausible_ECU)
++ // Make an ExeContext containing exactly the specified stack frames.
++ ExeContext* VG_(make_ExeContext_from_StackTrace)( const Addr* ips, UInt n_ips );
++ 
++-// Returns the "null" exe context. The null execontext is an artificial
++-// exe context, with a stack trace made of one Addr (the NULL address).
++-extern 
++-ExeContext* VG_(null_ExeContext) (void);
+++
+++/*====================================================================*/
+++/*=== ExeContextAndEpoch                                           ===*/
+++/*====================================================================*/
+++
+++/* A plain ExeContext is not generally symbolisable, since we also need to
+++   know which DebugInfo epoch it pertains to.  ExeContextAndEpoch pairs them
+++   up.  Note this is just two words, so passing it around by value is
+++   fine. */
+++typedef
+++   struct {
+++      ExeContext* ec;
+++      DiEpoch     epoch;
+++   }
+++   ExeContextAndEpoch;
+++
+++// A trivial constructor.
+++static inline ExeContextAndEpoch mk_ExeContextAndEpoch ( ExeContext* ec,
+++                                                         DiEpoch ep ) {
+++   ExeContextAndEpoch ece;
+++   ece.ec    = ec;
+++   ece.epoch = ep;
+++   return ece;
+++}
+++
+++// Generates a completely invalid ExeContextAndEpoch, with NULL for .ec and
+++// zero for .epoch.  Both values are invalid.
+++ExeContextAndEpoch VG_(invalid_ExeContextAndEpoch) ( void );
+++
+++// Takes an ExeContext and tags it with the current epoch, which is
+++// generally what we want to do.
+++ExeContextAndEpoch VG_(tag_EC_with_current_epoch)( ExeContext* ec );
+++
+++// Print an ExeContextAndEpoch.  We can't print a plain ExeContext
+++// because we can't symbolising it without knowing which debuginfo
+++// epoch it pertains to.
+++void VG_(pp_ExeContextAndEpoch) ( ExeContextAndEpoch ece );
+++
+++// Returns the "null" exe context tagged with the current debuginfo
+++// epoch. The null execontext is an artificial exe context, with a stack
+++// trace made of one Addr (the NULL address), and the current epoch.
+++ExeContextAndEpoch VG_(null_ExeContextAndEpoch) ( void );
+++
+++// Is this a value obtained from VG_(null_ExeContextAndEpoch) ?
+++Bool VG_(is_null_ExeContextAndEpoch)( ExeContextAndEpoch ece );
+++
++ 
++ #endif   // __PUB_TOOL_EXECONTEXT_H
++ 
++Index: valgrind-3.13.0/include/pub_tool_options.h
++===================================================================
++--- valgrind-3.13.0.orig/include/pub_tool_options.h
+++++ valgrind-3.13.0/include/pub_tool_options.h
++@@ -249,6 +249,12 @@ extern Int   VG_(clo_backtrace_size);
++ /* Continue stack traces below main()?  Default: NO */
++ extern Bool VG_(clo_show_below_main);
++ 
+++/* Keep symbols (and all other debuginfo) for code that is unloaded (dlclose
+++   or similar) so that stack traces can still give line/file info for
+++   previously captured stack traces.  e.g. ... showing where a block was
+++   allocated e.g. leaks of or accesses just outside a block. */
+++extern Bool VG_(clo_keep_debuginfo);
+++
++ 
++ /* Used to expand file names.  "option_name" is the option name, eg.
++    "--log-file".  'format' is what follows, eg. "cachegrind.out.%p".  In
++Index: valgrind-3.13.0/include/pub_tool_stacktrace.h
++===================================================================
++--- valgrind-3.13.0.orig/include/pub_tool_stacktrace.h
+++++ valgrind-3.13.0/include/pub_tool_stacktrace.h
++@@ -31,7 +31,7 @@
++ #ifndef __PUB_TOOL_STACKTRACE_H
++ #define __PUB_TOOL_STACKTRACE_H
++ 
++-#include "pub_tool_basics.h"   // Addr
+++#include "pub_tool_basics.h"   // Addr, DiEpoch
++ 
++ // The basic stack trace type:  just an array of code addresses.
++ typedef Addr* StackTrace;
++@@ -64,19 +64,19 @@ extern UInt VG_(get_StackTrace) ( Thread
++                                   /*OUT*/StackTrace fps,
++                                   Word first_ip_delta );
++ 
++-// Apply a function to every element in the StackTrace.  The parameter
++-// 'n' gives the index of the passed ip.  'opaque' is an arbitrary
++-// pointer provided to each invocation of 'action' (a poor man's
++-// closure).  Doesn't go below main() unless --show-below-main=yes is
++-// set.
+++// Apply a function to every element in the StackTrace.  The parameter 'n'
+++// gives the index of the passed ip.  'opaque' is an arbitrary pointer
+++// provided to each invocation of 'action' (a poor man's closure).  'ep' is
+++// the debuginfo epoch assumed to apply to all code addresses in the stack
+++// trace.  Doesn't go below main() unless --show-below-main=yes is set.
++ extern void VG_(apply_StackTrace)(
++-               void(*action)(UInt n, Addr ip, void* opaque),
+++               void(*action)(UInt n, DiEpoch ep, Addr ip, void* opaque),
++                void* opaque,
++-               StackTrace ips, UInt n_ips
+++               DiEpoch ep, StackTrace ips, UInt n_ips
++             );
++ 
++ // Print a StackTrace.
++-extern void VG_(pp_StackTrace) ( StackTrace ips, UInt n_ips );
+++extern void VG_(pp_StackTrace) ( DiEpoch ep, StackTrace ips, UInt n_ips );
++ 
++ // Gets and immediately prints a StackTrace.  Just a bit simpler than
++ // calling VG_(get_StackTrace)() then VG_(pp_StackTrace)().
++Index: valgrind-3.13.0/include/pub_tool_tooliface.h
++===================================================================
++--- valgrind-3.13.0.orig/include/pub_tool_tooliface.h
+++++ valgrind-3.13.0/include/pub_tool_tooliface.h
++@@ -463,7 +463,7 @@ extern void VG_(needs_print_stats) (
++    of an address ? */
++ extern void VG_(needs_info_location) (
++    // Get and pp information about Addr
++-   void (*info_location)(Addr)
+++   void (*info_location)(DiEpoch, Addr)
++ );
++ 
++ /* Do we need to see variable type and location information? */
++Index: valgrind-3.13.0/lackey/lk_main.c
++===================================================================
++--- valgrind-3.13.0.orig/lackey/lk_main.c
+++++ valgrind-3.13.0/lackey/lk_main.c
++@@ -664,6 +664,7 @@ IRSB* lk_instrument ( VgCallbackClosure*
++    Addr       iaddr = 0, dst;
++    UInt       ilen = 0;
++    Bool       condition_inverted = False;
+++   DiEpoch    ep = VG_(current_DiEpoch)();
++ 
++    if (gWordTy != hWordTy) {
++       /* We don't currently support this case. */
++@@ -750,7 +751,7 @@ IRSB* lk_instrument ( VgCallbackClosure*
++                tl_assert(clo_fnname);
++                tl_assert(clo_fnname[0]);
++                const HChar *fnname;
++-               if (VG_(get_fnname_if_entry)(st->Ist.IMark.addr, 
+++               if (VG_(get_fnname_if_entry)(ep, st->Ist.IMark.addr, 
++                                             &fnname)
++                    && 0 == VG_(strcmp)(fnname, clo_fnname)) {
++                   di = unsafeIRDirty_0_N( 
++Index: valgrind-3.13.0/massif/ms_main.c
++===================================================================
++--- valgrind-3.13.0.orig/massif/ms_main.c
+++++ valgrind-3.13.0/massif/ms_main.c
++@@ -520,8 +520,9 @@ void filter_IPs (Addr* ips, Int n_ips,
++    //  alloc function 'inside' a stacktrace e.g.
++    //    0x1 0x2 0x3 alloc func1 main
++    //  becomes   0x1 0x2 0x3 func1 main
+++   DiEpoch ep = VG_(current_DiEpoch)();
++    for (i = *top; i < n_ips; i++) {
++-      top_has_fnname = VG_(get_fnname)(ips[*top], &fnname);
+++      top_has_fnname = VG_(get_fnname)(ep, ips[*top], &fnname);
++       if (top_has_fnname &&  VG_(strIsMemberXA)(alloc_fns, fnname)) {
++          VERB(4, "filtering alloc fn %s\n", fnname);
++          (*top)++;
++@@ -576,7 +577,8 @@ static ExeContext* make_ec(ThreadId tid,
++    if (exclude_first_entry && n_ips > 0) {
++       const HChar *fnname;
++       VERB(4, "removing top fn %s from stacktrace\n", 
++-           VG_(get_fnname)(ips[0], &fnname) ? fnname : "???");
+++              VG_(get_fnname)(VG_(current_DiEpoch)(), ips[0], &fnname)
+++                 ? fnname : "???");
++       return VG_(make_ExeContext_from_StackTrace)(ips+1, n_ips-1);
++    } else
++       return VG_(make_ExeContext_from_StackTrace)(ips, n_ips);
++Index: valgrind-3.13.0/memcheck/mc_errors.c
++===================================================================
++--- valgrind-3.13.0.orig/memcheck/mc_errors.c
+++++ valgrind-3.13.0/memcheck/mc_errors.c
++@@ -94,15 +94,15 @@ struct _MC_Error {
++       struct {
++          SizeT szB;   // size of value in bytes
++          // Origin info
++-         UInt        otag;      // origin tag
++-         ExeContext* origin_ec; // filled in later
+++         UInt               otag;       // origin tag
+++         ExeContextAndEpoch origin_ece; // filled in later
++       } Value;
++ 
++       // Use of an undefined value in a conditional branch or move.
++       struct {
++          // Origin info
++-         UInt        otag;      // origin tag
++-         ExeContext* origin_ec; // filled in later
+++         UInt               otag;       // origin tag
+++         ExeContextAndEpoch origin_ece; // filled in later
++       } Cond;
++ 
++       // Addressability error in core (signal-handling) operation.
++@@ -127,8 +127,8 @@ struct _MC_Error {
++       // System call register input contains undefined bytes.
++       struct {
++          // Origin info
++-         UInt        otag;      // origin tag
++-         ExeContext* origin_ec; // filled in later
+++         UInt               otag;       // origin tag
+++         ExeContextAndEpoch origin_ece; // filled in later
++       } RegParam;
++ 
++       // System call memory input contains undefined/unaddressable bytes
++@@ -136,8 +136,8 @@ struct _MC_Error {
++          Bool     isAddrErr;  // Addressability or definedness error?
++          AddrInfo ai;
++          // Origin info
++-         UInt        otag;      // origin tag
++-         ExeContext* origin_ec; // filled in later
+++         UInt               otag;       // origin tag
+++         ExeContextAndEpoch origin_ece; // filled in later
++       } MemParam;
++ 
++       // Problem found from a client request like CHECK_MEM_IS_ADDRESSABLE.
++@@ -145,8 +145,8 @@ struct _MC_Error {
++          Bool     isAddrErr;  // Addressability or definedness error?
++          AddrInfo ai;
++          // Origin info
++-         UInt        otag;      // origin tag
++-         ExeContext* origin_ec; // filled in later
+++         UInt               otag;       // origin tag
+++         ExeContextAndEpoch origin_ece; // filled in later
++       } User;
++ 
++       // Program tried to free() something that's not a heap block (this
++@@ -279,10 +279,10 @@ static const HChar* pp_Reachedness_for_l
++    }
++ }
++ 
++-static void mc_pp_origin ( ExeContext* ec, UInt okind )
+++static void mc_pp_origin ( ExeContextAndEpoch ece, UInt okind )
++ {
++    const HChar* src = NULL;
++-   tl_assert(ec);
+++   tl_assert(ece.ec);
++ 
++    switch (okind) {
++       case MC_OKIND_STACK:   src = " by a stack allocation"; break;
++@@ -295,10 +295,10 @@ static void mc_pp_origin ( ExeContext* e
++    if (VG_(clo_xml)) {
++       emit( "  <auxwhat>Uninitialised value was created%s</auxwhat>\n",
++             src);
++-      VG_(pp_ExeContext)( ec );
+++      VG_(pp_ExeContextAndEpoch)( ece );
++    } else {
++       emit( " Uninitialised value was created%s\n", src);
++-      VG_(pp_ExeContext)( ec );
+++      VG_(pp_ExeContextAndEpoch)( ece );
++    }
++ }
++ 
++@@ -379,7 +379,7 @@ static void pp_LossRecord(UInt n_this_re
++          emit( "    <leakedblocks>%u</leakedblocks>\n", lr->num_blocks);
++          emit( "  </xwhat>\n" );
++       }
++-      VG_(pp_ExeContext)(lr->key.allocated_at);
+++      VG_(pp_ExeContextAndEpoch)(lr->key.allocated_at);
++    } else { /* ! if (xml) */
++       if (lr->indirect_szB > 0) {
++          emit(
++@@ -401,7 +401,7 @@ static void pp_LossRecord(UInt n_this_re
++             n_this_record, n_total_records
++          );
++       }
++-      VG_(pp_ExeContext)(lr->key.allocated_at);
+++      VG_(pp_ExeContextAndEpoch)(lr->key.allocated_at);
++    } /* if (xml) */
++ }
++ 
++@@ -427,11 +427,11 @@ void MC_(pp_Error) ( const Error* err )
++             emit( "  <kind>CoreMemError</kind>\n" );
++             emit( "  <what>%pS contains unaddressable byte(s)</what>\n",
++                   VG_(get_error_string)(err));
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          } else {
++             emit( "%s contains unaddressable byte(s)\n",
++                   VG_(get_error_string)(err));
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          }
++          break;
++       
++@@ -441,19 +441,19 @@ void MC_(pp_Error) ( const Error* err )
++             emit( "  <kind>UninitValue</kind>\n" );
++             emit( "  <what>Use of uninitialised value of size %lu</what>\n",
++                   extra->Err.Value.szB );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
++-            if (extra->Err.Value.origin_ec)
++-               mc_pp_origin( extra->Err.Value.origin_ec,
++-                            extra->Err.Value.otag & 3 );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
+++            if (extra->Err.Value.origin_ece.ec)
+++               mc_pp_origin( extra->Err.Value.origin_ece,
+++                             extra->Err.Value.otag & 3 );
++          } else {
++             /* Could also show extra->Err.Cond.otag if debugging origin
++                tracking */
++             emit( "Use of uninitialised value of size %lu\n",
++                   extra->Err.Value.szB );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
++-            if (extra->Err.Value.origin_ec)
++-               mc_pp_origin( extra->Err.Value.origin_ec,
++-                            extra->Err.Value.otag & 3 );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
+++            if (extra->Err.Value.origin_ece.ec)
+++               mc_pp_origin( extra->Err.Value.origin_ece,
+++                             extra->Err.Value.otag & 3 );
++          }
++          break;
++ 
++@@ -463,18 +463,18 @@ void MC_(pp_Error) ( const Error* err )
++             emit( "  <kind>UninitCondition</kind>\n" );
++             emit( "  <what>Conditional jump or move depends"
++                   " on uninitialised value(s)</what>\n" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
++-            if (extra->Err.Cond.origin_ec)
++-               mc_pp_origin( extra->Err.Cond.origin_ec,
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
+++            if (extra->Err.Cond.origin_ece.ec)
+++               mc_pp_origin( extra->Err.Cond.origin_ece,
++                              extra->Err.Cond.otag & 3 );
++          } else {
++             /* Could also show extra->Err.Cond.otag if debugging origin
++                tracking */
++             emit( "Conditional jump or move depends"
++                   " on uninitialised value(s)\n" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
++-            if (extra->Err.Cond.origin_ec)
++-               mc_pp_origin( extra->Err.Cond.origin_ec,
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
+++            if (extra->Err.Cond.origin_ece.ec)
+++               mc_pp_origin( extra->Err.Cond.origin_ece,
++                              extra->Err.Cond.otag & 3 );
++          }
++          break;
++@@ -486,16 +486,16 @@ void MC_(pp_Error) ( const Error* err )
++             emit( "  <what>Syscall param %pS contains "
++                   "uninitialised byte(s)</what>\n",
++                   VG_(get_error_string)(err) );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
++-            if (extra->Err.RegParam.origin_ec)
++-               mc_pp_origin( extra->Err.RegParam.origin_ec,
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
+++            if (extra->Err.RegParam.origin_ece.ec)
+++               mc_pp_origin( extra->Err.RegParam.origin_ece,
++                              extra->Err.RegParam.otag & 3 );
++          } else {
++             emit( "Syscall param %s contains uninitialised byte(s)\n",
++                   VG_(get_error_string)(err) );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
++-            if (extra->Err.RegParam.origin_ec)
++-               mc_pp_origin( extra->Err.RegParam.origin_ec,
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
+++            if (extra->Err.RegParam.origin_ece.ec)
+++               mc_pp_origin( extra->Err.RegParam.origin_ece,
++                              extra->Err.RegParam.otag & 3 );
++          }
++          break;
++@@ -509,24 +509,24 @@ void MC_(pp_Error) ( const Error* err )
++                   VG_(get_error_string)(err),
++                   extra->Err.MemParam.isAddrErr 
++                      ? "unaddressable" : "uninitialised" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)(VG_(get_error_address)(err),
++                                 &extra->Err.MemParam.ai, False);
++-            if (extra->Err.MemParam.origin_ec 
+++            if (extra->Err.MemParam.origin_ece.ec 
++                 && !extra->Err.MemParam.isAddrErr)
++-               mc_pp_origin( extra->Err.MemParam.origin_ec,
+++               mc_pp_origin( extra->Err.MemParam.origin_ece,
++                              extra->Err.MemParam.otag & 3 );
++          } else {
++             emit( "Syscall param %s points to %s byte(s)\n",
++                   VG_(get_error_string)(err),
++                   extra->Err.MemParam.isAddrErr 
++                      ? "unaddressable" : "uninitialised" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)(VG_(get_error_address)(err),
++                                 &extra->Err.MemParam.ai, False);
++-            if (extra->Err.MemParam.origin_ec 
+++            if (extra->Err.MemParam.origin_ece.ec 
++                 && !extra->Err.MemParam.isAddrErr)
++-               mc_pp_origin( extra->Err.MemParam.origin_ec,
+++               mc_pp_origin( extra->Err.MemParam.origin_ece,
++                              extra->Err.MemParam.otag & 3 );
++          }
++          break;
++@@ -540,21 +540,21 @@ void MC_(pp_Error) ( const Error* err )
++                   "during client check request</what>\n", 
++                    extra->Err.User.isAddrErr
++                       ? "Unaddressable" : "Uninitialised" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)(VG_(get_error_address)(err), &extra->Err.User.ai,
++                                 False);
++-            if (extra->Err.User.origin_ec && !extra->Err.User.isAddrErr)
++-               mc_pp_origin( extra->Err.User.origin_ec,
+++            if (extra->Err.User.origin_ece.ec && !extra->Err.User.isAddrErr)
+++               mc_pp_origin( extra->Err.User.origin_ece,
++                              extra->Err.User.otag & 3 );
++          } else {
++             emit( "%s byte(s) found during client check request\n", 
++                    extra->Err.User.isAddrErr
++                       ? "Unaddressable" : "Uninitialised" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)(VG_(get_error_address)(err), &extra->Err.User.ai,
++                                 False);
++-            if (extra->Err.User.origin_ec && !extra->Err.User.isAddrErr)
++-               mc_pp_origin( extra->Err.User.origin_ec,
+++            if (extra->Err.User.origin_ece.ec && !extra->Err.User.isAddrErr)
+++               mc_pp_origin( extra->Err.User.origin_ece,
++                              extra->Err.User.otag & 3 );
++          }
++          break;
++@@ -564,12 +564,12 @@ void MC_(pp_Error) ( const Error* err )
++             emit( "  <kind>InvalidFree</kind>\n" );
++             emit( "  <what>Invalid free() / delete / delete[]"
++                   " / realloc()</what>\n" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)( VG_(get_error_address)(err),
++                                  &extra->Err.Free.ai, False );
++          } else {
++             emit( "Invalid free() / delete / delete[] / realloc()\n" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)( VG_(get_error_address)(err),
++                                  &extra->Err.Free.ai, False );
++          }
++@@ -579,12 +579,12 @@ void MC_(pp_Error) ( const Error* err )
++          if (xml) {
++             emit( "  <kind>MismatchedFree</kind>\n" );
++             emit( "  <what>Mismatched free() / delete / delete []</what>\n" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)(VG_(get_error_address)(err),
++                                 &extra->Err.FreeMismatch.ai, False);
++          } else {
++             emit( "Mismatched free() / delete / delete []\n" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)(VG_(get_error_address)(err),
++                                 &extra->Err.FreeMismatch.ai, False);
++          }
++@@ -597,7 +597,7 @@ void MC_(pp_Error) ( const Error* err )
++             emit( "  <what>Invalid %s of size %lu</what>\n",
++                   extra->Err.Addr.isWrite ? "write" : "read",
++                   extra->Err.Addr.szB );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)( VG_(get_error_address)(err),
++                                  &extra->Err.Addr.ai,
++                                  extra->Err.Addr.maybe_gcc );
++@@ -605,7 +605,7 @@ void MC_(pp_Error) ( const Error* err )
++             emit( "Invalid %s of size %lu\n",
++                   extra->Err.Addr.isWrite ? "write" : "read",
++                   extra->Err.Addr.szB );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++ 
++             VG_(pp_addrinfo_mc)( VG_(get_error_address)(err),
++                                  &extra->Err.Addr.ai,
++@@ -618,12 +618,12 @@ void MC_(pp_Error) ( const Error* err )
++             emit( "  <kind>InvalidJump</kind>\n" );
++             emit( "  <what>Jump to the invalid address stated "
++                   "on the next line</what>\n" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)( VG_(get_error_address)(err), &extra->Err.Jump.ai,
++                                  False );
++          } else {
++             emit( "Jump to the invalid address stated on the next line\n" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)( VG_(get_error_address)(err), &extra->Err.Jump.ai,
++                                  False );
++          }
++@@ -644,7 +644,7 @@ void MC_(pp_Error) ( const Error* err )
++                      extra->Err.Overlap.dst, extra->Err.Overlap.src,
++                      extra->Err.Overlap.szB );
++             }
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          } else {
++             if (extra->Err.Overlap.szB == 0) {
++                emit( "Source and destination overlap in %s(%#lx, %#lx)\n",
++@@ -656,7 +656,7 @@ void MC_(pp_Error) ( const Error* err )
++                      extra->Err.Overlap.dst, extra->Err.Overlap.src,
++                      extra->Err.Overlap.szB );
++             }
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          }
++          break;
++ 
++@@ -666,12 +666,12 @@ void MC_(pp_Error) ( const Error* err )
++          if (xml) {
++             emit( "  <kind>InvalidMemPool</kind>\n" );
++             emit( "  <what>Illegal memory pool address</what>\n" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)( VG_(get_error_address)(err),
++                                  &extra->Err.IllegalMempool.ai, False );
++          } else {
++             emit( "Illegal memory pool address\n" );
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++             VG_(pp_addrinfo_mc)( VG_(get_error_address)(err),
++                                  &extra->Err.IllegalMempool.ai, False );
++          }
++@@ -695,14 +695,14 @@ void MC_(pp_Error) ( const Error* err )
++                   extra->Err.FishyValue.function_name,
++                   (SSizeT)extra->Err.FishyValue.value);
++             emit( "</what>");
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          } else {
++             emit( "Argument '%s' of function %s has a fishy "
++                   "(possibly negative) value: %ld\n",
++                   extra->Err.FishyValue.argument_name,
++                   extra->Err.FishyValue.function_name,
++                   (SSizeT)extra->Err.FishyValue.value);
++-            VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+++            VG_(pp_ExeContextAndEpoch)( VG_(get_error_where)(err) );
++          }
++          break;
++ 
++@@ -773,9 +773,10 @@ void MC_(record_value_error) ( ThreadId
++    tl_assert( MC_(clo_mc_level) >= 2 );
++    if (otag > 0)
++       tl_assert( MC_(clo_mc_level) == 3 );
++-   extra.Err.Value.szB       = szB;
++-   extra.Err.Value.otag      = otag;
++-   extra.Err.Value.origin_ec = NULL;  /* Filled in later */
+++   extra.Err.Value.szB        = szB;
+++   extra.Err.Value.otag       = otag;
+++   extra.Err.Value.origin_ece = VG_(invalid_ExeContextAndEpoch)();
+++                                /* Filled in later */
++    VG_(maybe_record_error)( tid, Err_Value, /*addr*/0, /*s*/NULL, &extra );
++ }
++ 
++@@ -785,8 +786,9 @@ void MC_(record_cond_error) ( ThreadId t
++    tl_assert( MC_(clo_mc_level) >= 2 );
++    if (otag > 0)
++       tl_assert( MC_(clo_mc_level) == 3 );
++-   extra.Err.Cond.otag      = otag;
++-   extra.Err.Cond.origin_ec = NULL;  /* Filled in later */
+++   extra.Err.Cond.otag       = otag;
+++   extra.Err.Cond.origin_ece = VG_(invalid_ExeContextAndEpoch)();
+++                               /* Filled in later */
++    VG_(maybe_record_error)( tid, Err_Cond, /*addr*/0, /*s*/NULL, &extra );
++ }
++ 
++@@ -804,8 +806,9 @@ void MC_(record_regparam_error) ( Thread
++    tl_assert(VG_INVALID_THREADID != tid);
++    if (otag > 0)
++       tl_assert( MC_(clo_mc_level) == 3 );
++-   extra.Err.RegParam.otag      = otag;
++-   extra.Err.RegParam.origin_ec = NULL;  /* Filled in later */
+++   extra.Err.RegParam.otag       = otag;
+++   extra.Err.RegParam.origin_ece = VG_(invalid_ExeContextAndEpoch)();
+++                                 /* Filled in later */
++    VG_(maybe_record_error)( tid, Err_RegParam, /*addr*/0, msg, &extra );
++ }
++ 
++@@ -820,10 +823,11 @@ void MC_(record_memparam_error) ( Thread
++       tl_assert( MC_(clo_mc_level) == 3 );
++       tl_assert( !isAddrErr );
++    }
++-   extra.Err.MemParam.isAddrErr = isAddrErr;
++-   extra.Err.MemParam.ai.tag    = Addr_Undescribed;
++-   extra.Err.MemParam.otag      = otag;
++-   extra.Err.MemParam.origin_ec = NULL;  /* Filled in later */
+++   extra.Err.MemParam.isAddrErr  = isAddrErr;
+++   extra.Err.MemParam.ai.tag     = Addr_Undescribed;
+++   extra.Err.MemParam.otag       = otag;
+++   extra.Err.MemParam.origin_ece = VG_(invalid_ExeContextAndEpoch)();
+++                                 /* Filled in later */
++    VG_(maybe_record_error)( tid, Err_MemParam, a, msg, &extra );
++ }
++ 
++@@ -925,10 +929,11 @@ void MC_(record_user_error) ( ThreadId t
++       tl_assert( MC_(clo_mc_level) >= 2 );
++    }
++    tl_assert(VG_INVALID_THREADID != tid);
++-   extra.Err.User.isAddrErr = isAddrErr;
++-   extra.Err.User.ai.tag    = Addr_Undescribed;
++-   extra.Err.User.otag      = otag;
++-   extra.Err.User.origin_ec = NULL;  /* Filled in later */
+++   extra.Err.User.isAddrErr  = isAddrErr;
+++   extra.Err.User.ai.tag     = Addr_Undescribed;
+++   extra.Err.User.otag       = otag;
+++   extra.Err.User.origin_ece = VG_(invalid_ExeContextAndEpoch)();
+++                             /* Filled in later */
++    VG_(maybe_record_error)( tid, Err_User, a, /*s*/NULL, &extra );
++ }
++ 
++@@ -1053,7 +1058,7 @@ static Bool mempool_block_maybe_describe
++ 
++ /* Describe an address as best you can, for error messages,
++    putting the result in ai. */
++-static void describe_addr ( Addr a, /*OUT*/AddrInfo* ai )
+++static void describe_addr ( DiEpoch ep, Addr a, /*OUT*/AddrInfo* ai )
++ {
++    MC_Chunk*  mc;
++ 
++@@ -1121,28 +1126,30 @@ static void describe_addr ( Addr a, /*OU
++    }
++ 
++    /* No block found. Search a non-heap block description. */
++-   VG_(describe_addr) (a, ai);
+++   VG_(describe_addr) (ep, a, ai);
++ }
++ 
++-void MC_(pp_describe_addr) ( Addr a )
+++void MC_(pp_describe_addr) ( DiEpoch ep, Addr a )
++ {
++    AddrInfo ai;
++ 
++    ai.tag = Addr_Undescribed;
++-   describe_addr (a, &ai);
+++   describe_addr (ep, a, &ai);
++    VG_(pp_addrinfo_mc) (a, &ai, /* maybe_gcc */ False);
++    VG_(clear_addrinfo) (&ai);
++ }
++ 
++-/* Fill in *origin_ec as specified by otag, or NULL it out if otag
+++/* Fill in *origin_ece as specified by otag, or NULL it out if otag
++    does not refer to a known origin. */
++-static void update_origin ( /*OUT*/ExeContext** origin_ec,
+++static void update_origin ( /*OUT*/ExeContextAndEpoch* origin_ece,
++                             UInt otag )
++ {
++    UInt ecu = otag & ~3;
++-   *origin_ec = NULL;
++    if (VG_(is_plausible_ECU)(ecu)) {
++-      *origin_ec = VG_(get_ExeContext_from_ECU)( ecu );
+++      *origin_ece
+++         = VG_(tag_EC_with_current_epoch)(VG_(get_ExeContext_from_ECU)( ecu ));
+++   } else {
+++      *origin_ece = VG_(invalid_ExeContextAndEpoch)();
++    }
++ }
++ 
++@@ -1150,6 +1157,7 @@ static void update_origin ( /*OUT*/ExeCo
++ UInt MC_(update_Error_extra)( const Error* err )
++ {
++    MC_Error* extra = VG_(get_error_extra)(err);
+++   DiEpoch   ep    = VG_(get_error_where)(err).epoch;
++ 
++    switch (VG_(get_error_kind)(err)) {
++    // These ones don't have addresses associated with them, and so don't
++@@ -1169,45 +1177,45 @@ UInt MC_(update_Error_extra)( const Erro
++    // origin tag.  Note that it is a kludge to assume that 
++    // a length-1 trace indicates a stack origin.  FIXME.
++    case Err_Value:
++-      update_origin( &extra->Err.Value.origin_ec,
+++      update_origin( &extra->Err.Value.origin_ece,
++                      extra->Err.Value.otag );
++       return sizeof(MC_Error);
++    case Err_Cond:
++-      update_origin( &extra->Err.Cond.origin_ec,
+++      update_origin( &extra->Err.Cond.origin_ece,
++                      extra->Err.Cond.otag );
++       return sizeof(MC_Error);
++    case Err_RegParam:
++-      update_origin( &extra->Err.RegParam.origin_ec,
+++      update_origin( &extra->Err.RegParam.origin_ece,
++                      extra->Err.RegParam.otag );
++       return sizeof(MC_Error);
++ 
++    // These ones always involve a memory address.
++    case Err_Addr:
++-      describe_addr ( VG_(get_error_address)(err),
+++      describe_addr ( ep, VG_(get_error_address)(err),
++                       &extra->Err.Addr.ai );
++       return sizeof(MC_Error);
++    case Err_MemParam:
++-      describe_addr ( VG_(get_error_address)(err),
+++      describe_addr ( ep, VG_(get_error_address)(err),
++                       &extra->Err.MemParam.ai );
++-      update_origin( &extra->Err.MemParam.origin_ec,
+++      update_origin( &extra->Err.MemParam.origin_ece,
++                      extra->Err.MemParam.otag );
++       return sizeof(MC_Error);
++    case Err_Jump:
++-      describe_addr ( VG_(get_error_address)(err),
+++      describe_addr ( ep, VG_(get_error_address)(err),
++                       &extra->Err.Jump.ai );
++       return sizeof(MC_Error);
++    case Err_User:
++-      describe_addr ( VG_(get_error_address)(err),
+++      describe_addr ( ep, VG_(get_error_address)(err),
++                       &extra->Err.User.ai );
++-      update_origin( &extra->Err.User.origin_ec,
+++      update_origin( &extra->Err.User.origin_ece,
++                      extra->Err.User.otag );
++       return sizeof(MC_Error);
++    case Err_Free:
++-      describe_addr ( VG_(get_error_address)(err),
+++      describe_addr ( ep, VG_(get_error_address)(err),
++                       &extra->Err.Free.ai );
++       return sizeof(MC_Error);
++    case Err_IllegalMempool:
++-      describe_addr ( VG_(get_error_address)(err),
+++      describe_addr ( ep, VG_(get_error_address)(err),
++                       &extra->Err.IllegalMempool.ai );
++       return sizeof(MC_Error);
++ 
++@@ -1252,7 +1260,7 @@ static Bool client_block_maybe_describe(
++          ai->Addr.Block.rwoffset   = (Word)(a) - (Word)(cgbs[i].start);
++          ai->Addr.Block.allocated_at = cgbs[i].where;
++          VG_(initThreadInfo) (&ai->Addr.Block.alloc_tinfo);
++-         ai->Addr.Block.freed_at = VG_(null_ExeContext)();;
+++         ai->Addr.Block.freed_at = VG_(null_ExeContextAndEpoch)();
++          return True;
++       }
++    }
++Index: valgrind-3.13.0/memcheck/mc_include.h
++===================================================================
++--- valgrind-3.13.0.orig/memcheck/mc_include.h
+++++ valgrind-3.13.0/memcheck/mc_include.h
++@@ -67,17 +67,17 @@ typedef
++       Addr         data;            // Address of the actual block.
++       SizeT        szB : (sizeof(SizeT)*8)-2; // Size requested; 30 or 62 bits.
++       MC_AllocKind allockind : 2;   // Which operation did the allocation.
++-      ExeContext*  where[0];
+++      ExeContextAndEpoch where[0];
++       /* Variable-length array. The size depends on MC_(clo_keep_stacktraces).
++          This array optionally stores the alloc and/or free stack trace. */
++    }
++    MC_Chunk;
++ 
++-/* Returns the execontext where the MC_Chunk was allocated/freed.
+++/* Returns the execontext and epoch where the MC_Chunk was allocated/freed.
++    Returns VG_(null_ExeContext)() if the execontext has not been recorded (due
++    to MC_(clo_keep_stacktraces) and/or because block not yet freed). */
++-ExeContext* MC_(allocated_at) (MC_Chunk*);
++-ExeContext* MC_(freed_at) (MC_Chunk*);
+++ExeContextAndEpoch MC_(allocated_at) (MC_Chunk*);
+++ExeContextAndEpoch MC_(freed_at) (MC_Chunk*);
++ 
++ /* Records and sets execontext according to MC_(clo_keep_stacktraces) */
++ void  MC_(set_allocated_at) (ThreadId, MC_Chunk*);
++@@ -432,8 +432,8 @@ typedef
++ /* When a LossRecord is put into an OSet, these elements represent the key. */
++ typedef
++    struct _LossRecordKey {
++-      Reachedness  state;        // LC_Extra.state value shared by all blocks.
++-      ExeContext*  allocated_at; // Where they were allocated.
+++      Reachedness         state;  // LC_Extra.state value shared by all blocks.
+++      ExeContextAndEpoch  allocated_at; // Where they were allocated.
++    } 
++    LossRecordKey;
++ 
++@@ -569,8 +569,8 @@ Bool MC_(record_fishy_value_error)  ( Th
++ /* Leak kinds tokens to call VG_(parse_enum_set). */
++ extern const HChar* MC_(parse_leak_kinds_tokens);
++ 
++-/* prints a description of address a */
++-void MC_(pp_describe_addr) (Addr a);
+++/* prints a description of address a in the specified debuginfo epoch */
+++void MC_(pp_describe_addr) ( DiEpoch ep, Addr a );
++ 
++ /* Is this address in a user-specified "ignored range" ? */
++ Bool MC_(in_ignored_range) ( Addr a );
++@@ -588,10 +588,10 @@ Bool MC_(in_ignored_range_below_sp) ( Ad
++    start == size == 0.  */
++ typedef
++    struct {
++-      Addr        start;
++-      SizeT       size;
++-      ExeContext* where;
++-      HChar*      desc;
+++      Addr               start;
+++      SizeT              size;
+++      ExeContextAndEpoch where;
+++      HChar*             desc;
++    } 
++    CGenBlock;
++ 
++Index: valgrind-3.13.0/memcheck/mc_leakcheck.c
++===================================================================
++--- valgrind-3.13.0.orig/memcheck/mc_leakcheck.c
+++++ valgrind-3.13.0/memcheck/mc_leakcheck.c
++@@ -1060,6 +1060,8 @@ lc_scan_memory(Addr start, SizeT len, Bo
++    const Addr end = VG_ROUNDDN(start+len, sizeof(Addr));
++    fault_catcher_t prev_catcher;
++ 
+++   const DiEpoch ep = VG_(current_DiEpoch)();
+++
++    if (VG_DEBUG_LEAKCHECK)
++       VG_(printf)("scan %#lx-%#lx (%lu)\n", start, end, len);
++ 
++@@ -1139,14 +1141,14 @@ lc_scan_memory(Addr start, SizeT len, Bo
++             if (addr >= searched && addr < searched + szB) {
++                if (addr == searched) {
++                   VG_(umsg)("*%#lx points at %#lx\n", ptr, searched);
++-                  MC_(pp_describe_addr) (ptr);
+++                  MC_(pp_describe_addr) (ep, ptr); // FIXME JRS: ep correct?
++                } else {
++                   Int ch_no;
++                   MC_Chunk *ch;
++                   LC_Extra *ex;
++                   VG_(umsg)("*%#lx interior points at %lu bytes inside %#lx\n",
++                             ptr, (long unsigned) addr - searched, searched);
++-                  MC_(pp_describe_addr) (ptr);
+++                  MC_(pp_describe_addr) (ep, ptr); // FIXME JRS: ep correct?
++                   if (lc_is_a_chunk_ptr(addr, &ch_no, &ch, &ex) ) {
++                      Int h;
++                      for (h = LchStdString; h < N_LEAK_CHECK_HEURISTICS; h++) {
++@@ -1203,13 +1205,17 @@ static Word cmp_LossRecordKey_LossRecord
++    // Compare on states first because that's fast.
++    if (a->state < b->state) return -1;
++    if (a->state > b->state) return  1;
++-   // Ok, the states are equal.  Now compare the locations, which is slower.
+++   // Also on epochs, for the same reason.
+++   if (a->allocated_at.epoch.n < b->allocated_at.epoch.n) return -1;
+++   if (a->allocated_at.epoch.n > b->allocated_at.epoch.n) return 1;
+++   // Ok, the states and epochs are equal.  Now compare the locations, which
+++   // is slower.
++    if (VG_(eq_ExeContext)(
++-            MC_(clo_leak_resolution), a->allocated_at, b->allocated_at))
+++            MC_(clo_leak_resolution), a->allocated_at.ec, b->allocated_at.ec))
++       return 0;
++    // Different locations.  Ordering is arbitrary, just use the ec pointer.
++-   if (a->allocated_at < b->allocated_at) return -1;
++-   if (a->allocated_at > b->allocated_at) return  1;
+++   if (a->allocated_at.ec < b->allocated_at.ec) return -1;
+++   if (a->allocated_at.ec > b->allocated_at.ec) return  1;
++    VG_(tool_panic)("bad LossRecord comparison");
++ }
++ 
++@@ -1231,10 +1237,15 @@ static Int cmp_LossRecords(const void* v
++    // possible.  So:  compare num_blocks.
++    if (lr_a->num_blocks < lr_b->num_blocks) return -1;
++    if (lr_a->num_blocks > lr_b->num_blocks) return  1;
+++   // Then epochs.
+++   if (lr_a->key.allocated_at.epoch.n < lr_b->key.allocated_at.epoch.n)
+++      return -1;
+++   if (lr_a->key.allocated_at.epoch.n > lr_b->key.allocated_at.epoch.n)
+++      return 1;
++    // Finally, compare ExeContext addresses... older ones are likely to have
++    // lower addresses.
++-   if (lr_a->key.allocated_at < lr_b->key.allocated_at) return -1;
++-   if (lr_a->key.allocated_at > lr_b->key.allocated_at) return  1;
+++   if (lr_a->key.allocated_at.ec < lr_b->key.allocated_at.ec) return -1;
+++   if (lr_a->key.allocated_at.ec > lr_b->key.allocated_at.ec) return  1;
++    return 0;
++ }
++ 
++@@ -1381,7 +1392,7 @@ static void XT_insert_lr (LossRecord* lr
++       xtl.xt_lr[i].vid[XT_Decrease].num_blocks 
++          = lr->old_num_blocks - lr->num_blocks;
++ 
++-   VG_(XT_add_to_ec)(leak_xt, lr->key.allocated_at, &xtl);
+++   VG_(XT_add_to_ec)(leak_xt, lr->key.allocated_at.ec, &xtl);
++ }
++ 
++ static void MC_(XT_Leak_sub) (void* from, const void* xtleak)
++@@ -2133,9 +2144,9 @@ void MC_(detect_memory_leaks) ( ThreadId
++             VG_(umsg)("Block 0x%lx..0x%lx overlaps with block 0x%lx..0x%lx\n",
++                       start1, end1, start2, end2);
++             VG_(umsg)("Blocks allocation contexts:\n"),
++-            VG_(pp_ExeContext)( MC_(allocated_at)(ch1));
+++            VG_(pp_ExeContextAndEpoch)( MC_(allocated_at)(ch1));
++             VG_(umsg)("\n"),
++-            VG_(pp_ExeContext)(  MC_(allocated_at)(ch2));
+++            VG_(pp_ExeContextAndEpoch)(  MC_(allocated_at)(ch2));
++             VG_(umsg)("This is usually caused by using ");
++             VG_(umsg)("VALGRIND_MALLOCLIKE_BLOCK in an inappropriate way.\n");
++             tl_assert (0);
++Index: valgrind-3.13.0/memcheck/mc_main.c
++===================================================================
++--- valgrind-3.13.0.orig/memcheck/mc_main.c
+++++ valgrind-3.13.0/memcheck/mc_main.c
++@@ -6719,9 +6719,11 @@ static Bool handle_gdb_monitor_command (
++       const HChar* src;
++       UInt otag;
++       UInt ecu;
++-      ExeContext* origin_ec;
+++      ExeContextAndEpoch origin_ece;
++       MC_ReadResult res;
++ 
+++      const DiEpoch ep = VG_(current_DiEpoch)();
+++
++       Int kwdid = VG_(keyword_id) 
++          ("addressable defined",
++           VG_(strtok_r) (NULL, " ", &ssaveptr), kwd_report_all);
++@@ -6738,7 +6740,8 @@ static Bool handle_gdb_monitor_command (
++             VG_(printf)
++                ("Address %p len %lu not addressable:\nbad address %p\n",
++                 (void *)address, szB, (void *) bad_addr);
++-         MC_(pp_describe_addr) (address);
+++         // FIXME JRS epoch ok?
+++         MC_(pp_describe_addr) (ep, address);
++          break;
++       case  1: /* defined */
++          res = is_mem_defined ( address, szB, &bad_addr, &otag );
++@@ -6765,14 +6768,16 @@ static Bool handle_gdb_monitor_command (
++                 (void *)address, szB, (void *) bad_addr, src);
++             ecu = otag & ~3;
++             if (VG_(is_plausible_ECU)(ecu)) {
++-               origin_ec = VG_(get_ExeContext_from_ECU)( ecu );
++-               VG_(pp_ExeContext)( origin_ec );
+++               origin_ece = VG_(tag_EC_with_current_epoch)(
+++                               VG_(get_ExeContext_from_ECU)( ecu ));
+++               VG_(pp_ExeContextAndEpoch)( origin_ece );
++             }
++          }
++          else
++             VG_(printf) ("Address %p len %lu defined\n",
++                          (void *)address, szB);
++-         MC_(pp_describe_addr) (address);
+++         // FIXME JRS epoch ok?
+++         MC_(pp_describe_addr) (ep, address);
++          break;
++       default: tl_assert(0);
++       }
++@@ -7049,7 +7054,9 @@ static Bool mc_handle_client_request ( T
++             cgbs[i].start = arg[1];
++             cgbs[i].size  = arg[2];
++             cgbs[i].desc  = VG_(strdup)("mc.mhcr.1", (HChar *)arg[3]);
++-            cgbs[i].where = VG_(record_ExeContext) ( tid, 0/*first_ip_delta*/ );
+++            cgbs[i].where = VG_(tag_EC_with_current_epoch)(
+++                               VG_(record_ExeContext) ( tid,
+++                                                        0/*first_ip_delta*/ ));
++             *ret = i;
++          } else
++             *ret = -1;
++@@ -7917,7 +7924,7 @@ static void mc_post_clo_init ( void )
++    }
++ 
++    MC_(chunk_poolalloc) = VG_(newPA)
++-      (sizeof(MC_Chunk) + MC_(n_where_pointers)() * sizeof(ExeContext*),
+++      (sizeof(MC_Chunk) + MC_(n_where_pointers)() * sizeof(ExeContextAndEpoch),
++        1000,
++        VG_(malloc),
++        "mc.cMC.1 (MC_Chunk pools)",
++Index: valgrind-3.13.0/memcheck/mc_malloc_wrappers.c
++===================================================================
++--- valgrind-3.13.0.orig/memcheck/mc_malloc_wrappers.c
+++++ valgrind-3.13.0/memcheck/mc_malloc_wrappers.c
++@@ -199,8 +199,8 @@ MC_Chunk* create_MC_Chunk ( ThreadId tid
++    mc->szB       = szB;
++    mc->allockind = kind;
++    switch ( MC_(n_where_pointers)() ) {
++-      case 2: mc->where[1] = 0; // fallback to 1
++-      case 1: mc->where[0] = 0; // fallback to 0
+++      case 2: mc->where[1] = VG_(invalid_ExeContextAndEpoch)(); // fall thru
+++      case 1: mc->where[0] = VG_(invalid_ExeContextAndEpoch)(); // fall thru
++       case 0: break;
++       default: tl_assert(0);
++    }
++@@ -268,30 +268,34 @@ static Bool live_block (MC_Chunk* mc)
++    return in_block_list ( MC_(malloc_list), mc );
++ }
++ 
++-ExeContext* MC_(allocated_at) (MC_Chunk* mc)
+++ExeContextAndEpoch MC_(allocated_at) (MC_Chunk* mc)
++ {
++    switch (MC_(clo_keep_stacktraces)) {
++-      case KS_none:            return VG_(null_ExeContext) ();
+++      case KS_none:            return VG_(null_ExeContextAndEpoch) ();
++       case KS_alloc:           return mc->where[0];
++-      case KS_free:            return VG_(null_ExeContext) ();
++-      case KS_alloc_then_free: return (live_block(mc) ?
++-                                       mc->where[0] : VG_(null_ExeContext) ());
+++      case KS_free:            return VG_(null_ExeContextAndEpoch) ();
+++      case KS_alloc_then_free: return live_block(mc) 
+++                                         ? mc->where[0]
+++                                         : VG_(null_ExeContextAndEpoch) ();
++       case KS_alloc_and_free:  return mc->where[0];
++       default: tl_assert (0);
++    }
++ }
++ 
++-ExeContext* MC_(freed_at) (MC_Chunk* mc)
+++ExeContextAndEpoch MC_(freed_at) (MC_Chunk* mc)
++ {
++    switch (MC_(clo_keep_stacktraces)) {
++-      case KS_none:            return VG_(null_ExeContext) ();
++-      case KS_alloc:           return VG_(null_ExeContext) ();
++-      case KS_free:            return (mc->where[0] ?
++-                                       mc->where[0] : VG_(null_ExeContext) ());
++-      case KS_alloc_then_free: return (live_block(mc) ?
++-                                       VG_(null_ExeContext) () : mc->where[0]);
++-      case KS_alloc_and_free:  return (mc->where[1] ?
++-                                       mc->where[1] : VG_(null_ExeContext) ());
+++      case KS_none:            return VG_(null_ExeContextAndEpoch) ();
+++      case KS_alloc:           return VG_(null_ExeContextAndEpoch) ();
+++      case KS_free:            return mc->where[0].ec
+++                                         ? mc->where[0]
+++                                         : VG_(null_ExeContextAndEpoch) ();
+++      case KS_alloc_then_free: return live_block(mc)
+++                                         ? VG_(null_ExeContextAndEpoch) ()
+++                                         : mc->where[0];
+++      case KS_alloc_and_free:  return mc->where[1].ec
+++                                         ? mc->where[1]
+++                                         : VG_(null_ExeContextAndEpoch) ();
++       default: tl_assert (0);
++    }
++ }
++@@ -306,15 +310,16 @@ void  MC_(set_allocated_at) (ThreadId ti
++       case KS_alloc_and_free:  break;
++       default: tl_assert (0);
++    }
++-   mc->where[0] = VG_(record_ExeContext) ( tid, 0/*first_ip_delta*/ );
+++   mc->where[0] = VG_(tag_EC_with_current_epoch)(
+++                     VG_(record_ExeContext) ( tid, 0/*first_ip_delta*/ ));
++    if (UNLIKELY(VG_(clo_xtree_memory) == Vg_XTMemory_Full))
++-       VG_(XTMemory_Full_alloc)(mc->szB, mc->where[0]);
+++       VG_(XTMemory_Full_alloc)(mc->szB, mc->where[0].ec);
++ }
++ 
++ void  MC_(set_freed_at) (ThreadId tid, MC_Chunk* mc)
++ {
++    Int pos;
++-   ExeContext* ec_free;
+++   ExeContextAndEpoch ec_free;
++ 
++    switch (MC_(clo_keep_stacktraces)) {
++       case KS_none:            return;
++@@ -333,9 +338,10 @@ void  MC_(set_freed_at) (ThreadId tid, M
++       Note: we are guaranteed to find the ec_alloc in mc->where[0], as
++       mc_post_clo_init verifies the consistency of --xtree-memory and
++       --keep-stacktraces. */
++-   ec_free = VG_(record_ExeContext) ( tid, 0/*first_ip_delta*/ );
+++   ec_free = VG_(tag_EC_with_current_epoch)(
+++                VG_(record_ExeContext) ( tid, 0/*first_ip_delta*/ ));
++    if (UNLIKELY(VG_(clo_xtree_memory) == Vg_XTMemory_Full))
++-       VG_(XTMemory_Full_free)(mc->szB, mc->where[0], ec_free);
+++       VG_(XTMemory_Full_free)(mc->szB, mc->where[0].ec, ec_free.ec);
++    if (LIKELY(pos >= 0))
++       mc->where[pos] = ec_free;
++ }
++@@ -391,7 +397,7 @@ void* MC_(new_block) ( ThreadId tid,
++    if (is_zeroed)
++       MC_(make_mem_defined)( p, szB );
++    else {
++-      UInt ecu = VG_(get_ECU_from_ExeContext)(MC_(allocated_at)(mc));
+++      UInt ecu = VG_(get_ECU_from_ExeContext)(MC_(allocated_at)(mc).ec);
++       tl_assert(VG_(is_plausible_ECU)(ecu));
++       MC_(make_mem_undefined_w_otag)( p, szB, ecu | MC_OKIND_HEAP );
++    }
++@@ -605,7 +611,7 @@ void* MC_(realloc) ( ThreadId tid, void*
++          // If the block has grown, we mark the grown area as undefined.
++          // We have to do that after VG_(HT_add_node) to ensure the ecu
++          // execontext is for a fully allocated block.
++-         ecu = VG_(get_ECU_from_ExeContext)(MC_(allocated_at)(new_mc));
+++         ecu = VG_(get_ECU_from_ExeContext)(MC_(allocated_at)(new_mc).ec);
++          tl_assert(VG_(is_plausible_ECU)(ecu));
++          MC_(make_mem_undefined_w_otag)( a_new+old_szB,
++                                          new_szB-old_szB,
++@@ -673,7 +679,7 @@ void MC_(handle_resizeInPlace)(ThreadId
++       return;
++ 
++    if (UNLIKELY(VG_(clo_xtree_memory) == Vg_XTMemory_Full))
++-       VG_(XTMemory_Full_resize_in_place)(oldSizeB,  newSizeB, mc->where[0]);
+++       VG_(XTMemory_Full_resize_in_place)(oldSizeB, newSizeB, mc->where[0].ec);
++ 
++    mc->szB = newSizeB;
++    if (newSizeB < oldSizeB) {
++@@ -887,7 +893,7 @@ check_mempool_sane(MC_Mempool* mp)
++                          chunks[i]->data, 
++                          chunks[i]->data + chunks[i]->szB);
++ 
++-            VG_(pp_ExeContext)(MC_(allocated_at)(chunks[i]));
+++            VG_(pp_ExeContextAndEpoch)(MC_(allocated_at)(chunks[i]));
++          }
++    }
++    VG_(free)(chunks);
++@@ -1147,7 +1153,7 @@ static void xtmemory_report_next_block(X
++    if (mc) {
++       xta->nbytes = mc->szB;
++       xta->nblocks = 1;
++-      *ec_alloc = MC_(allocated_at)(mc);
+++      *ec_alloc = MC_(allocated_at)(mc).ec;
++    } else
++       xta->nblocks = 0;
++ }
++Index: valgrind-3.13.0/memcheck/tests/linux/Makefile.am
++===================================================================
++--- valgrind-3.13.0.orig/memcheck/tests/linux/Makefile.am
+++++ valgrind-3.13.0/memcheck/tests/linux/Makefile.am
++@@ -6,6 +6,10 @@ dist_noinst_SCRIPTS = filter_stderr
++ EXTRA_DIST = \
++ 	brk.stderr.exp brk.vgtest \
++ 	capget.vgtest capget.stderr.exp capget.stderr.exp2 \
+++	dlclose_leak-no-keep.stderr.exp dlclose_leak-no-keep.stdout.exp \
+++	    dlclose_leak-no-keep.vgtest \
+++	dlclose_leak.stderr.exp dlclose_leak.stdout.exp \
+++	    dlclose_leak.vgtest \
++ 	ioctl-tiocsig.vgtest ioctl-tiocsig.stderr.exp \
++ 	lsframe1.vgtest lsframe1.stdout.exp lsframe1.stderr.exp \
++ 	lsframe2.vgtest lsframe2.stdout.exp lsframe2.stderr.exp \
++@@ -25,6 +29,7 @@ EXTRA_DIST = \
++ check_PROGRAMS = \
++ 	brk \
++ 	capget \
+++	dlclose_leak dlclose_leak_so.so \
++ 	ioctl-tiocsig \
++ 	getregset \
++ 	lsframe1 \
++@@ -48,3 +53,15 @@ AM_CXXFLAGS += $(AM_FLAG_M3264_PRI)
++ stack_switch_LDADD    = -lpthread
++ timerfd_syscall_LDADD = -lrt
++ 
+++# Build shared object for dlclose_leak
+++dlclose_leak_so_so_SOURCES = dlclose_leak_so.c
+++dlclose_leak_so_so_CFLAGS  = $(AM_CFLAGS) -fpic -g -O0
+++dlclose_leak_so_so_LDFLAGS  = -fpic $(AM_FLAG_M3264_PRI) -shared -Wl,-soname \
+++                              -Wl,dlclose_leak_so.so
+++
+++dlclose_leak_SOURCES          = dlclose_leak.c
+++dlclose_leak_DEPENDENCIES     = dlclose_leak_so.so
+++dlclose_leak_LDADD            = dlclose_leak_so.so
+++dlclose_leak_LDFLAGS          = $(AM_FLAG_M3264_PRI) \
+++                                -ldl \
+++                                -Wl,-rpath,$(top_builddir)/memcheck/tests/linux
++Index: valgrind-3.13.0/memcheck/tests/linux/dlclose_leak-no-keep.stderr.exp
++===================================================================
++--- /dev/null
+++++ valgrind-3.13.0/memcheck/tests/linux/dlclose_leak-no-keep.stderr.exp
++@@ -0,0 +1,30 @@
+++
+++Conditional jump or move depends on uninitialised value(s)
+++   ...
+++
+++Invalid read of size 1
+++   ...
+++ Address 0x........ is 1 bytes before a block of size 1 alloc'd
+++   at 0x........: malloc (vg_replace_malloc.c:...)
+++   ...
+++
+++done!
+++
+++HEAP SUMMARY:
+++    in use at exit: 1 bytes in 1 blocks
+++  total heap usage: 4 allocs, 3 frees, 123 bytes allocated
+++
+++1 bytes in 1 blocks are definitely lost in loss record ... of ...
+++   at 0x........: malloc (vg_replace_malloc.c:...)
+++   ...
+++
+++LEAK SUMMARY:
+++   definitely lost: 1 bytes in 1 blocks
+++   indirectly lost: 0 bytes in 0 blocks
+++     possibly lost: 0 bytes in 0 blocks
+++   still reachable: 0 bytes in 0 blocks
+++        suppressed: 0 bytes in 0 blocks
+++
+++For counts of detected and suppressed errors, rerun with: -v
+++Use --track-origins=yes to see where uninitialised values come from
+++ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)
++Index: valgrind-3.13.0/memcheck/tests/linux/dlclose_leak-no-keep.vgtest
++===================================================================
++--- /dev/null
+++++ valgrind-3.13.0/memcheck/tests/linux/dlclose_leak-no-keep.vgtest
++@@ -0,0 +1,3 @@
+++prog: dlclose_leak
+++stderr_filter: ../filter_stderr
+++vgopts: --leak-check=yes --keep-debuginfo=no
++Index: valgrind-3.13.0/memcheck/tests/linux/dlclose_leak.c
++===================================================================
++--- /dev/null
+++++ valgrind-3.13.0/memcheck/tests/linux/dlclose_leak.c
++@@ -0,0 +1,32 @@
+++/*  Test reporting of memory leaks in objects that have been dlopen'ed.
+++ *   File:   dlclose_leak.c */
+++
+++#include <stdio.h>
+++#include <stdlib.h>
+++#include <dlfcn.h>
+++#include <assert.h>
+++
+++int (*jmp_on_uninit)(void);
+++char* (*alloc_1_byte)(void);
+++
+++int main(int argc, char** argv) {
+++    char* memToLeak;
+++    char x;
+++    void* handle = dlopen("./dlclose_leak_so.so", RTLD_NOW);
+++    if(!handle) {
+++        printf("FAILURE to dlopen dlclose_leak_so.so\n");
+++        return EXIT_FAILURE;
+++    }
+++    jmp_on_uninit = dlsym(handle,"jmp_on_uninit");
+++    //fprintf(stderr, "jmp_on_uninit: %p\n", jmp_on_uninit);
+++    assert(jmp_on_uninit);
+++    alloc_1_byte = dlsym(handle,"alloc_1_byte");
+++    //fprintf(stderr, "alloc_1_byte: %p\n", alloc_1_byte);
+++    assert(alloc_1_byte);
+++    (void)jmp_on_uninit();
+++    memToLeak = alloc_1_byte();
+++    dlclose(handle);
+++    x = memToLeak[-1];
+++    fprintf(stderr, "done!\n");
+++    return (EXIT_SUCCESS);
+++}
++Index: valgrind-3.13.0/memcheck/tests/linux/dlclose_leak.stderr.exp
++===================================================================
++--- /dev/null
+++++ valgrind-3.13.0/memcheck/tests/linux/dlclose_leak.stderr.exp
++@@ -0,0 +1,33 @@
+++
+++Conditional jump or move depends on uninitialised value(s)
+++   at 0x........: jmp_on_uninit (dlclose_leak_so.c:10)
+++   by 0x........: main (dlclose_leak.c:26)
+++
+++Invalid read of size 1
+++   at 0x........: main (dlclose_leak.c:29)
+++ Address 0x........ is 1 bytes before a block of size 1 alloc'd
+++   at 0x........: malloc (vg_replace_malloc.c:...)
+++   by 0x........: alloc_1_byte (dlclose_leak_so.c:20)
+++   by 0x........: main (dlclose_leak.c:27)
+++
+++done!
+++
+++HEAP SUMMARY:
+++    in use at exit: 1 bytes in 1 blocks
+++  total heap usage: 4 allocs, 3 frees, 123 bytes allocated
+++
+++1 bytes in 1 blocks are definitely lost in loss record ... of ...
+++   at 0x........: malloc (vg_replace_malloc.c:...)
+++   by 0x........: alloc_1_byte (dlclose_leak_so.c:20)
+++   by 0x........: main (dlclose_leak.c:27)
+++
+++LEAK SUMMARY:
+++   definitely lost: 1 bytes in 1 blocks
+++   indirectly lost: 0 bytes in 0 blocks
+++     possibly lost: 0 bytes in 0 blocks
+++   still reachable: 0 bytes in 0 blocks
+++        suppressed: 0 bytes in 0 blocks
+++
+++For counts of detected and suppressed errors, rerun with: -v
+++Use --track-origins=yes to see where uninitialised values come from
+++ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)
++Index: valgrind-3.13.0/memcheck/tests/linux/dlclose_leak.vgtest
++===================================================================
++--- /dev/null
+++++ valgrind-3.13.0/memcheck/tests/linux/dlclose_leak.vgtest
++@@ -0,0 +1,3 @@
+++prog: dlclose_leak
+++stderr_filter: ../filter_stderr
+++vgopts: --leak-check=yes --keep-debuginfo=yes
++Index: valgrind-3.13.0/memcheck/tests/linux/dlclose_leak_so.c
++===================================================================
++--- /dev/null
+++++ valgrind-3.13.0/memcheck/tests/linux/dlclose_leak_so.c
++@@ -0,0 +1,21 @@
+++/* dlclose_leak_so.c */
+++
+++#include <stdlib.h>
+++
+++/** Makes a jump based on an uninitialized variable in order to make sure
+++ * errors reported while the dlopen'ed object is loaded work. */
+++int jmp_on_uninit(void) {
+++    int uninit[27];
+++    __asm__ __volatile("":::"cc","memory");
+++    if(uninit[13]) {
+++        return 1;
+++    } else {
+++        return 0;
+++    }
+++}
+++
+++/** Leak 1 byte of memory. This is to test the stack check reported after the
+++ *  object has been dlclose'd. */
+++char* alloc_1_byte(void) {
+++    return (char*)malloc(1);
+++}
++Index: valgrind-3.13.0/none/tests/cmdline1.stdout.exp
++===================================================================
++--- valgrind-3.13.0.orig/none/tests/cmdline1.stdout.exp
+++++ valgrind-3.13.0/none/tests/cmdline1.stdout.exp
++@@ -42,6 +42,10 @@ usage: valgrind [options] prog-and-args
++     --error-exitcode=<number> exit code to return if errors found [0=disable]
++     --error-markers=<begin>,<end> add lines with begin/end markers before/after
++                               each error output in plain text mode [none]
+++    --keep-debuginfo=no|yes   Keep symbols etc for unloaded code [no]
+++                              This allows stack traces for memory leaks to
+++                              include file/line info for code that has been
+++                              dlclose'd (or similar)
++     --show-below-main=no|yes  continue stack traces below main() [no]
++     --default-suppressions=yes|no
++                               load default suppressions [yes]
++Index: valgrind-3.13.0/none/tests/cmdline2.stdout.exp
++===================================================================
++--- valgrind-3.13.0.orig/none/tests/cmdline2.stdout.exp
+++++ valgrind-3.13.0/none/tests/cmdline2.stdout.exp
++@@ -42,6 +42,10 @@ usage: valgrind [options] prog-and-args
++     --error-exitcode=<number> exit code to return if errors found [0=disable]
++     --error-markers=<begin>,<end> add lines with begin/end markers before/after
++                               each error output in plain text mode [none]
+++    --keep-debuginfo=no|yes   Keep symbols etc for unloaded code [no]
+++                              This allows stack traces for memory leaks to
+++                              include file/line info for code that has been
+++                              dlclose'd (or similar)
++     --show-below-main=no|yes  continue stack traces below main() [no]
++     --default-suppressions=yes|no
++                               load default suppressions [yes]
--- a/build/unix/build-gcc/build-gcc.sh
+++ b/build/unix/build-gcc/build-gcc.sh
@@ -44,17 +44,17 @@ prepare() {
     mpfr-*.tar.*)
       # If download_prerequisites wants 2.4.2, use 3.1.5 instead.
       file=${file/2.4.2/3.1.5}
       download_and_check http://www.mpfr.org/${file%.tar.*} $file.asc
       ;;
     mpc-*.tar.*)
       # If download_prerequisites wants 0.8.1, use 0.8.2 instead.
       file=${file/0.8.1/0.8.2}
-      download_and_check http://www.multiprecision.org/mpc/download $file.asc
+      download_and_check http://www.multiprecision.org/downloads $file.asc
       ;;
     *)
       download $(dirname $url) $file
       ;;
     esac
     tar xaf $TMPDIR/$file
     ln -sf ${file%.tar.*} ${file%-*}
   done
--- a/build/valgrind/x86_64-redhat-linux-gnu.sup
+++ b/build/valgrind/x86_64-redhat-linux-gnu.sup
@@ -257,16 +257,38 @@
   Memcheck:Cond
   fun:_ZN9selectors8matching33matches_complex_selector_internal*
   fun:_ZN9selectors8matching24matches_complex_selector*
   ...
   fun:_ZN5style9traversal13compute_style*
   fun:recalc_style_at<style::gecko::wrapper::GeckoElement,style::gecko::traversal::RecalcStyleOnly,closure>
 }
 
+# Similar issue triggered by rust 1.23.0 on builds of stylo.
+#
+# at 0x11819B3E: std::sync::once::Once::call_once::{{closure}} (raw_vec.rs:225)
+# by 0x118FDCCC: std::sync::once::Once::call_inner (once.rs:341)
+# by 0x1139C761: UnknownInlinedFun (once.rs:228)
+{
+  Bug 1418083 Servo::TraverseSubtree, January 2018
+  Memcheck:Cond
+  fun:*ZN3std4sync4once4Once9call_once*
+  fun:*ZN3std4sync4once4Once10call_inner*
+  ...
+  fun:Servo_TraverseSubtree
+}
+
+# Issue triggered by rust 1.23.0 on builds of stylo.
+{
+  Bug 1418083 SelectorList::parse, January 2018
+  Memcheck:Cond
+  fun:_ZN36_$LT$smallvec..SmallVec*
+  fun:_ZN52_$LT$selectors..parser..SelectorList*
+}
+
 ###################################################
 #  For valgrind-mochitest ("tc-M-V [tier 2]") runs on taskcluster.
 #  See bug 1248365.
 #  These are specific to Ubuntu 12.04.5, 64-bit.
 ###################################################
 
 
 # Not sure what this is.  Is it the well-known
--- a/devtools/client/webconsole/package.json
+++ b/devtools/client/webconsole/package.json
@@ -1,15 +1,16 @@
 {
   "name": "webconsole",
   "version": "0.0.1",
   "engines": {
     "node": ">=6.9.0"
   },
   "scripts": {
+    "preinstall": "cd ../netmonitor && npm install && cd ../webconsole",
     "start": "cross-env NODE_ENV=production node bin/dev-server",
     "dev": "node bin/dev-server",
     "test": "cross-env NODE_ENV=test NODE_PATH=../../../ mocha new-console-output/test/**/*.test.js --compilers js:babel-register -r jsdom-global/register -r ./new-console-output/test/require-helper.js"
   },
   "dependencies": {
     "amd-loader": "0.0.5",
     "babel-preset-es2015": "^6.6.0",
     "babel-preset-es2017": "^6.24.1",
--- a/dom/animation/KeyframeEffectReadOnly.cpp
+++ b/dom/animation/KeyframeEffectReadOnly.cpp
@@ -1283,17 +1283,17 @@ KeyframeEffectReadOnly::GetKeyframes(JSC
                "Invalid computed offset");
     keyframeDict.mComputedOffset.Construct(keyframe.mComputedOffset);
     if (keyframe.mTimingFunction) {
       keyframeDict.mEasing.Truncate();
       keyframe.mTimingFunction.ref().AppendToString(keyframeDict.mEasing);
     } // else if null, leave easing as its default "linear".
 
     if (keyframe.mComposite) {
-      keyframeDict.mComposite.Construct(keyframe.mComposite.value());
+      keyframeDict.mComposite.SetValue(keyframe.mComposite.value());
     }
 
     JS::Rooted<JS::Value> keyframeJSValue(aCx);
     if (!ToJSValue(aCx, keyframeDict, &keyframeJSValue)) {
       aRv.Throw(NS_ERROR_FAILURE);
       return;
     }
 
--- a/dom/animation/KeyframeUtils.cpp
+++ b/dom/animation/KeyframeUtils.cpp
@@ -653,17 +653,17 @@ ConvertKeyframeSequence(JSContext* aCx,
     Keyframe* keyframe = aResult.AppendElement(fallible);
     if (!keyframe) {
       return false;
     }
     if (!keyframeDict.mOffset.IsNull()) {
       keyframe->mOffset.emplace(keyframeDict.mOffset.Value());
     }
 
-    if (keyframeDict.mComposite.WasPassed()) {
+    if (!keyframeDict.mComposite.IsNull()) {
       keyframe->mComposite.emplace(keyframeDict.mComposite.Value());
     }
 
     // Look for additional property-values pairs on the object.
     nsTArray<PropertyValuesPair> propertyValuePairs;
     if (value.isObject()) {
       JS::Rooted<JSObject*> object(aCx, &value.toObject());
       if (!GetPropertyValuesPairs(aCx, object,
@@ -1542,33 +1542,37 @@ GetKeyframeListFromPropertyIndexedKeyfra
       aResult[i].mTimingFunction = easings[i % easings.Length()];
     }
   }
 
   // Fill in any composite operations.
   //
   // This corresponds to step 5, "Otherwise," branch, substep 12 of
   // https://drafts.csswg.org/web-animations/#processing-a-keyframes-argument
-  const FallibleTArray<dom::CompositeOperation>* compositeOps;
-  AutoTArray<dom::CompositeOperation, 1> singleCompositeOp;
+  const FallibleTArray<Nullable<dom::CompositeOperation>>* compositeOps =
+    nullptr;
+  AutoTArray<Nullable<dom::CompositeOperation>, 1> singleCompositeOp;
   auto& composite = keyframeDict.mComposite;
   if (composite.IsCompositeOperation()) {
     singleCompositeOp.AppendElement(composite.GetAsCompositeOperation());
-    const FallibleTArray<dom::CompositeOperation>& asFallibleArray =
+    const FallibleTArray<Nullable<dom::CompositeOperation>>& asFallibleArray =
       singleCompositeOp;
     compositeOps = &asFallibleArray;
-  } else {
-    compositeOps = &composite.GetAsCompositeOperationSequence();
+  } else if (composite.IsCompositeOperationOrNullSequence()) {
+    compositeOps = &composite.GetAsCompositeOperationOrNullSequence();
   }
 
   // Fill in and repeat as needed.
-  if (!compositeOps->IsEmpty()) {
+  if (compositeOps && !compositeOps->IsEmpty()) {
+    size_t length = compositeOps->Length();
     for (size_t i = 0; i < aResult.Length(); i++) {
-      aResult[i].mComposite.emplace(
-        compositeOps->ElementAt(i % compositeOps->Length()));
+      if (!compositeOps->ElementAt(i % length).IsNull()) {
+        aResult[i].mComposite.emplace(
+          compositeOps->ElementAt(i % length).Value());
+      }
     }
   }
 }
 
 /**
  * Returns true if the supplied set of keyframes has keyframe values for
  * any property for which it does not also supply a value for the 0% and 100%
  * offsets. In this case we are supposed to synthesize an additive zero value
--- a/dom/animation/test/css-animations/file_keyframeeffect-getkeyframes.html
+++ b/dom/animation/test/css-animations/file_keyframeeffect-getkeyframes.html
@@ -220,26 +220,26 @@ test(function(t) {
 
   div.style.animation = 'anim-simple 100s';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
     { offset: 0, computedOffset: 0, easing: "ease",
-      color: "rgb(0, 0, 0)" },
+      color: "rgb(0, 0, 0)", composite: null },
     { offset: 1, computedOffset: 1, easing: "ease",
-      color: "rgb(255, 255, 255)" },
+      color: "rgb(255, 255, 255)", composite: null },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for a simple'
-   + 'animation');
+   + ' animation');
 
 test(function(t) {
   kTimingFunctionValues.forEach(function(easing) {
     var div = addDiv(t);
 
     div.style.animation = 'anim-simple-three 100s ' + easing;
     var frames = getKeyframes(div);
 
@@ -290,20 +290,20 @@ test(function(t) {
   var div = addDiv(t);
 
   div.style.animation = 'anim-simple-shorthand 100s';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       marginBottom: "8px", marginLeft: "8px",
       marginRight: "8px", marginTop: "8px" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       marginBottom: "16px", marginLeft: "16px",
       marginRight: "16px", marginTop: "16px" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for a simple'
@@ -314,19 +314,19 @@ test(function(t) {
 
   div.style.animation = 'anim-omit-to 100s';
   div.style.color = 'rgb(255, 255, 255)';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       color: "rgb(0, 0, 255)" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       color: "rgb(255, 255, 255)" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for an ' +
    'animation with a 0% keyframe and no 100% keyframe');
@@ -336,19 +336,19 @@ test(function(t) {
 
   div.style.animation = 'anim-omit-from 100s';
   div.style.color = 'rgb(255, 255, 255)';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       color: "rgb(255, 255, 255)" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       color: "rgb(0, 0, 255)" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for an ' +
    'animation with a 100% keyframe and no 0% keyframe');
@@ -358,21 +358,21 @@ test(function(t) {
 
   div.style.animation = 'anim-omit-from-to 100s';
   div.style.color = 'rgb(255, 255, 255)';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 3, "number of frames");
 
   var expected = [
-    { offset: 0,   computedOffset: 0,   easing: "ease",
+    { offset: 0,   computedOffset: 0,   easing: "ease", composite: null,
       color: "rgb(255, 255, 255)" },
-    { offset: 0.5, computedOffset: 0.5, easing: "ease",
+    { offset: 0.5, computedOffset: 0.5, easing: "ease", composite: null,
       color: "rgb(0, 0, 255)" },
-    { offset: 1,   computedOffset: 1,   easing: "ease",
+    { offset: 1,   computedOffset: 1,   easing: "ease", composite: null,
       color: "rgb(255, 255, 255)" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for an ' +
    'animation with no 0% or 100% keyframe but with a 50% keyframe');
@@ -382,19 +382,19 @@ test(function(t) {
 
   div.style.animation = 'anim-partially-omit-to 100s';
   div.style.marginTop = '250px';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       marginTop: '50px', marginBottom: '100px' },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       marginTop: '250px', marginBottom: '200px' },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for an ' +
    'animation with a partially complete 100% keyframe (because the ' +
@@ -404,23 +404,23 @@ test(function(t) {
   var div = addDiv(t);
 
   div.style.animation = 'anim-different-props 100s';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 4, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       color: "rgb(0, 0, 0)", marginTop: "8px" },
-    { offset: 0.25, computedOffset: 0.25, easing: "ease",
+    { offset: 0.25, computedOffset: 0.25, easing: "ease", composite: null,
       color: "rgb(0, 0, 255)" },
-    { offset: 0.75, computedOffset: 0.75, easing: "ease",
+    { offset: 0.75, computedOffset: 0.75, easing: "ease", composite: null,
       marginTop: "12px" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       color: "rgb(255, 255, 255)", marginTop: "16px" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for an ' +
    'animation with different properties on different keyframes, all ' +
@@ -430,23 +430,23 @@ test(function(t) {
   var div = addDiv(t);
 
   div.style.animation = 'anim-different-props-and-easing 100s';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 4, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "linear",
+    { offset: 0, computedOffset: 0, easing: "linear", composite: null,
       color: "rgb(0, 0, 0)", marginTop: "8px" },
-    { offset: 0.25, computedOffset: 0.25, easing: "steps(1)",
+    { offset: 0.25, computedOffset: 0.25, easing: "steps(1)", composite: null,
       color: "rgb(0, 0, 255)" },
-    { offset: 0.75, computedOffset: 0.75, easing: "ease-in",
+    { offset: 0.75, computedOffset: 0.75, easing: "ease-in", composite: null,
       marginTop: "12px" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       color: "rgb(255, 255, 255)", marginTop: "16px" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for an ' +
    'animation with different properties on different keyframes, with ' +
@@ -456,19 +456,19 @@ test(function(t) {
   var div = addDiv(t);
 
   div.style.animation = 'anim-merge-offset 100s';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       color: "rgb(0, 0, 0)", marginTop: "8px" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       color: "rgb(255, 255, 255)", marginTop: "16px" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for an ' +
    'animation with multiple keyframes for the same time, and all with ' +
@@ -478,21 +478,21 @@ test(function(t) {
   var div = addDiv(t);
 
   div.style.animation = 'anim-merge-offset-and-easing 100s';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 3, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "steps(1)",
+    { offset: 0, computedOffset: 0, easing: "steps(1)", composite: null,
       color: "rgb(0, 0, 0)", fontSize: "16px" },
-    { offset: 0, computedOffset: 0, easing: "linear",
+    { offset: 0, computedOffset: 0, easing: "linear", composite: null,
       marginTop: "8px", paddingLeft: "2px" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       color: "rgb(255, 255, 255)", fontSize: "32px", marginTop: "16px",
       paddingLeft: "4px" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for an ' +
@@ -503,21 +503,21 @@ test(function(t) {
   var div = addDiv(t);
 
   div.style.animation = 'anim-no-merge-equiv-easing 100s';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 3, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "steps(1)",
+    { offset: 0, computedOffset: 0, easing: "steps(1)", composite: null,
       marginTop: "0px", marginRight: "0px", marginBottom: "0px" },
-    { offset: 0.5, computedOffset: 0.5, easing: "steps(1)",
+    { offset: 0.5, computedOffset: 0.5, easing: "steps(1)", composite: null,
       marginTop: "10px", marginRight: "10px", marginBottom: "10px" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       marginTop: "20px", marginRight: "20px", marginBottom: "20px" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for an ' +
    'animation with multiple keyframes for the same time and with ' +
@@ -527,27 +527,27 @@ test(function(t) {
   var div = addDiv(t);
 
   div.style.animation = 'anim-overriding 100s';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 6, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       paddingTop: "30px" },
-    { offset: 0.5, computedOffset: 0.5, easing: "ease",
+    { offset: 0.5, computedOffset: 0.5, easing: "ease", composite: null,
       paddingTop: "20px" },
-    { offset: 0.75, computedOffset: 0.75, easing: "ease",
+    { offset: 0.75, computedOffset: 0.75, easing: "ease", composite: null,
       paddingTop: "20px" },
-    { offset: 0.85, computedOffset: 0.85, easing: "ease",
+    { offset: 0.85, computedOffset: 0.85, easing: "ease", composite: null,
       paddingTop: "30px" },
-    { offset: 0.851, computedOffset: 0.851, easing: "ease",
+    { offset: 0.851, computedOffset: 0.851, easing: "ease", composite: null,
       paddingTop: "60px" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       paddingTop: "70px" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for ' +
    'overlapping keyframes');
@@ -559,19 +559,19 @@ test(function(t) {
   var div = addDiv(t);
 
   div.style.animation = 'anim-filter 100s';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       filter: "none" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       filter: "blur(5px) sepia(60%) saturate(30%)" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected values for ' +
    'animations with filter properties and missing keyframes');
@@ -580,19 +580,19 @@ test(function(t) {
   var div = addDiv(t);
 
   div.style.animation = 'anim-filter-drop-shadow 100s';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       filter: "drop-shadow(rgb(0, 255, 0) 10px 10px 10px)" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       filter: "drop-shadow(rgb(255, 0, 0) 50px 30px 10px)" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected values for ' +
    'animation with drop-shadow of filter property');
@@ -608,21 +608,22 @@ test(function(t) {
                          '0 0 16px rgb(0, 0, 255), ' +
                          '0 0 3.2px rgb(0, 0, 255)';
   div.style.animation = 'anim-text-shadow 100s';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       textShadow: "rgb(0, 0, 0) 1px 1px 2px,"
                   + " rgb(0, 0, 255) 0px 0px 16px,"
                   + " rgb(0, 0, 255) 0px 0px 3.2px" },
-    { offset: 1, computedOffset: 1, easing: "ease", textShadow: "none" },
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
+      textShadow: "none" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected values for ' +
    'animations with text-shadow properties and missing keyframes');
 
@@ -634,19 +635,19 @@ test(function(t) {
   var div = addDiv(t);
 
   div.style.animation = 'anim-background-size 100s';
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       backgroundSize: "auto auto" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       backgroundSize: "50% auto, 6px auto, contain" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 
   // Test inheriting a background-size value
@@ -666,19 +667,19 @@ test(function(t) {
   var div = addDiv(t);
   div.style.animation = 'anim-variables 100s';
 
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       transform: "none" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       transform: "translate(100px, 0px)" },
   ];
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected values for ' +
    'animations with CSS variables as keyframe values');
 
@@ -686,22 +687,22 @@ test(function(t) {
   var div = addDiv(t);
   div.style.animation = 'anim-variables-shorthand 100s';
 
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       marginBottom: "0px",
       marginLeft: "0px",
       marginRight: "0px",
       marginTop: "0px" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       marginBottom: "100px",
       marginLeft: "100px",
       marginRight: "100px",
       marginTop: "100px" },
   ];
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
@@ -712,19 +713,19 @@ test(function(t) {
   var div = addDiv(t);
   div.style.animation = 'anim-custom-property-in-keyframe 100s';
 
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       color: "rgb(0, 0, 0)" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       color: "rgb(0, 255, 0)" },
   ];
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected values for ' +
    'animations with a CSS variable which is overriden by the value in keyframe');
 
@@ -732,19 +733,19 @@ test(function(t) {
   var div = addDiv(t);
   div.style.animation = 'anim-only-custom-property-in-keyframe 100s';
 
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease",
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
       transform: "translate(100px, 0px)" },
-    { offset: 1, computedOffset: 1, easing: "ease",
+    { offset: 1, computedOffset: 1, easing: "ease", composite: null,
       transform: "none" },
   ];
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected values for ' +
    'animations with only custom property in a keyframe');
 
--- a/dom/animation/test/css-transitions/file_keyframeeffect-getkeyframes.html
+++ b/dom/animation/test/css-transitions/file_keyframeeffect-getkeyframes.html
@@ -31,18 +31,20 @@ test(function(t) {
   div.style.transition = 'left 100s';
   div.style.left = '100px';
 
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "ease", left: "0px" },
-    { offset: 1, computedOffset: 1, easing: "linear", left: "100px" },
+    { offset: 0, computedOffset: 0, easing: "ease", composite: null,
+      left: "0px" },
+    { offset: 1, computedOffset: 1, easing: "linear", composite: null,
+      left: "100px" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for a simple'
    + ' transition');
 
@@ -54,18 +56,20 @@ test(function(t) {
   div.style.transition = 'left 100s steps(2,end)';
   div.style.left = '100px';
 
   var frames = getKeyframes(div);
 
   assert_equals(frames.length, 2, "number of frames");
 
   var expected = [
-    { offset: 0, computedOffset: 0, easing: "steps(2)", left: "0px" },
-    { offset: 1, computedOffset: 1, easing: "linear", left: "100px" },
+    { offset: 0, computedOffset: 0, easing: "steps(2)", composite: null,
+      left: "0px" },
+    { offset: 1, computedOffset: 1, easing: "linear", composite: null,
+      left: "100px" },
   ];
 
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for a simple'
    + ' transition with a non-default easing function');
 
@@ -76,18 +80,20 @@ test(function(t) {
   div.style.transition = 'left 100s';
   div.style.left = 'var(--var-100px)';
 
   var frames = getKeyframes(div);
 
   // CSS transition endpoints are based on the computed value so we
   // shouldn't see the variable reference
   var expected = [
-    { offset: 0, computedOffset: 0, easing: 'ease', left: '0px' },
-    { offset: 1, computedOffset: 1, easing: 'linear', left: '100px' },
+    { offset: 0, computedOffset: 0, easing: 'ease', composite: null,
+      left: '0px' },
+    { offset: 1, computedOffset: 1, easing: 'linear', composite: null,
+      left: '100px' },
   ];
   for (var i = 0; i < frames.length; i++) {
     assert_frames_equal(frames[i], expected[i], "ComputedKeyframe #" + i);
   }
 }, 'KeyframeEffectReadOnly.getKeyframes() returns expected frames for a'
    + ' transition with a CSS variable endpoint');
 
 done();
--- a/dom/base/nsFrameLoader.cpp
+++ b/dom/base/nsFrameLoader.cpp
@@ -1125,25 +1125,18 @@ nsFrameLoader::AddTreeItemToTreeOwner(ns
                                       nsIDocShellTreeOwner* aOwner,
                                       int32_t aParentType,
                                       nsIDocShell* aParentNode)
 {
   NS_PRECONDITION(aItem, "Must have docshell treeitem");
   NS_PRECONDITION(mOwnerContent, "Must have owning content");
 
   nsAutoString value;
-  bool isContent = false;
-  mOwnerContent->GetAttr(kNameSpaceID_None, TypeAttrName(), value);
-
-  // we accept "content" and "content-xxx" values.
-  // We ignore anything that comes after 'content-'.
-  isContent = value.LowerCaseEqualsLiteral("content") ||
-    StringBeginsWith(value, NS_LITERAL_STRING("content-"),
-                     nsCaseInsensitiveStringComparator());
-
+  bool isContent = mOwnerContent->AttrValueIs(
+    kNameSpaceID_None, TypeAttrName(), nsGkAtoms::content, eIgnoreCase);
 
   // Force mozbrowser frames to always be typeContent, even if the
   // mozbrowser interfaces are disabled.
   nsCOMPtr<nsIDOMMozBrowserFrame> mozbrowser =
     do_QueryInterface(mOwnerContent);
   if (mozbrowser) {
     bool isMozbrowser = false;
     mozbrowser->GetMozbrowser(&isMozbrowser);
@@ -3177,22 +3170,18 @@ nsFrameLoader::TryRemoteBrowser()
         return false;
       }
     }
 
     if (!mOwnerContent->IsXULElement()) {
       return false;
     }
 
-    nsAutoString value;
-    mOwnerContent->GetAttr(kNameSpaceID_None, nsGkAtoms::type, value);
-
-    if (!value.LowerCaseEqualsLiteral("content") &&
-        !StringBeginsWith(value, NS_LITERAL_STRING("content-"),
-                          nsCaseInsensitiveStringComparator())) {
+    if (!mOwnerContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                    nsGkAtoms::content, eIgnoreCase)) {
       return false;
     }
 
     // Try to get the related content parent from our browser element.
     Tie(openerContentParent, sameTabGroupAs) = GetContentParent(mOwnerContent);
   }
 
   uint32_t chromeFlags = 0;
@@ -3743,23 +3732,17 @@ nsFrameLoader::AttributeChanged(nsIDocum
   if (!is_primary) {
     nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
     if (pm)
       pm->HidePopupsInDocShell(mDocShell);
   }
 #endif
 
   parentTreeOwner->ContentShellRemoved(mDocShell);
-
-  nsAutoString value;
-  aElement->GetAttr(kNameSpaceID_None, TypeAttrName(), value);
-
-  if (value.LowerCaseEqualsLiteral("content") ||
-      StringBeginsWith(value, NS_LITERAL_STRING("content-"),
-                       nsCaseInsensitiveStringComparator())) {
+  if (aElement->AttrValueIs(kNameSpaceID_None, TypeAttrName(), nsGkAtoms::content, eIgnoreCase)) {
     parentTreeOwner->ContentShellAdded(mDocShell, is_primary);
   }
 }
 
 /**
  * Send the RequestNotifyAfterRemotePaint message to the current Tab.
  */
 void
--- a/dom/security/test/general/test_bug1277803.xul
+++ b/dom/security/test/general/test_bug1277803.xul
@@ -90,10 +90,10 @@
     SimpleTest.waitForExplicitFinish();
     SimpleTest.registerCleanupFunction(function() {
       if (testWindow) {
         testWindow.close();
       }
     });
   ]]></script>
 
-  <browser type="content-primary" flex="1" id="content" src="about:blank"/>
+  <browser type="content" primary="true" flex="1" id="content" src="about:blank"/>
 </window>
--- a/dom/webidl/BaseKeyframeTypes.webidl
+++ b/dom/webidl/BaseKeyframeTypes.webidl
@@ -17,23 +17,23 @@ enum CompositeOperation { "replace", "ad
 
 // The following dictionary types are not referred to by other .webidl files,
 // but we use it for manual JS->IDL and IDL->JS conversions in
 // KeyframeEffectReadOnly's implementation.
 
 dictionary BasePropertyIndexedKeyframe {
   (double? or sequence<double?>) offset = [];
   (DOMString or sequence<DOMString>) easing = [];
-  (CompositeOperation or sequence<CompositeOperation>) composite = [];
+  (CompositeOperation? or sequence<CompositeOperation?>) composite = [];
 };
 
 dictionary BaseKeyframe {
   double? offset = null;
   DOMString easing = "linear";
-  CompositeOperation composite;
+  CompositeOperation? composite = null;
 
   // Non-standard extensions
 
   // Member to allow testing when StyleAnimationValue::ComputeValues fails.
   //
   // Note that we currently only apply this to shorthand properties since
   // it's easier to annotate shorthand property values and because we have
   // only ever observed ComputeValues failing on shorthand values.
--- a/dom/xul/test/file_bug1271240.xul
+++ b/dom/xul/test/file_bug1271240.xul
@@ -72,11 +72,11 @@ https://bugzilla.mozilla.org/show_bug.cg
 
   function makePrerenderedBrowserActive(browser) {
     browser.frameLoader.makePrerenderedLoaderActive();
     return browser;
   }
 
   ]]>
   </script>
-  <!-- <browser type="content-primary" flex="1" id="content" />
-  <browser type="content-primary" flex="1" id="content-remote" remote="true" /> -->
+  <!-- <browser type="content" flex="1" id="content" />
+  <browser type="content" flex="1" id="content-remote" remote="true" /> -->
 </window>
--- a/ipc/app/moz.build
+++ b/ipc/app/moz.build
@@ -1,23 +1,19 @@
 # -*- Mode: python; 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/.
 
-# Any changes that affect Android need to be made in pie/moz.build as well.
-
 if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'android':
     Program(CONFIG['MOZ_CHILD_PROCESS_NAME'])
     SOURCES += [
         'MozillaRuntimeMainAndroid.cpp',
     ]
-
-    DIRS += ['pie']
 else:
     GeckoProgram(CONFIG['MOZ_CHILD_PROCESS_NAME'], linkage='dependent')
 
     SOURCES += [
         'MozillaRuntimeMain.cpp',
     ]
 
 include('/ipc/chromium/chromium-config.mozbuild')
deleted file mode 100644
--- a/ipc/app/pie/moz.build
+++ /dev/null
@@ -1,19 +0,0 @@
-# -*- Mode: python; 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/.
-
-Program(CONFIG['MOZ_CHILD_PROCESS_NAME_PIE'])
-SOURCES += [
-    '../MozillaRuntimeMainAndroid.cpp',
-]
-
-include('/ipc/chromium/chromium-config.mozbuild')
-
-LOCAL_INCLUDES += [
-    '/toolkit/xre',
-    '/xpcom/base',
-]
-
-LDFLAGS += ['-pie']
--- a/ipc/glue/moz.build
+++ b/ipc/glue/moz.build
@@ -214,18 +214,18 @@ LOCAL_INCLUDES += [
     '/toolkit/xre',
     '/xpcom/threads',
 ]
 
 include('/ipc/chromium/chromium-config.mozbuild')
 
 FINAL_LIBRARY = 'xul'
 
-for var in ('MOZ_CHILD_PROCESS_NAME', 'MOZ_CHILD_PROCESS_NAME_PIE',
-            'MOZ_CHILD_PROCESS_BUNDLE', 'DLL_PREFIX', 'DLL_SUFFIX'):
+for var in ('MOZ_CHILD_PROCESS_NAME', 'MOZ_CHILD_PROCESS_BUNDLE',
+            'DLL_PREFIX', 'DLL_SUFFIX'):
     DEFINES[var] = '"%s"' % CONFIG[var]
 
 if CONFIG['MOZ_SANDBOX'] and CONFIG['OS_ARCH'] == 'WINNT':
     LOCAL_INCLUDES += [
         '/security/sandbox/chromium',
         '/security/sandbox/chromium-shim',
         '/security/sandbox/win/src/sandboxbroker',
     ]
--- a/js/src/builtin/TestingFunctions.cpp
+++ b/js/src/builtin/TestingFunctions.cpp
@@ -609,19 +609,21 @@ WasmTextToBinary(JSContext* cx, unsigned
 
     if (args.hasDefined(1)) {
         if (!args[1].isString()) {
             ReportUsageErrorASCII(cx, callee, "Second argument, if present, must be a String");
             return false;
         }
     }
 
+    uintptr_t stackLimit = GetNativeStackLimit(cx);
+
     wasm::Bytes bytes;
     UniqueChars error;
-    if (!wasm::TextToBinary(twoByteChars.twoByteChars(), &bytes, &error)) {
+    if (!wasm::TextToBinary(twoByteChars.twoByteChars(), stackLimit, &bytes, &error)) {
         JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_WASM_TEXT_FAIL,
                                   error.get() ? error.get() : "out of memory");
         return false;
     }
 
     RootedObject obj(cx, JS_NewUint8Array(cx, bytes.length()));
     if (!obj)
         return false;
--- a/js/src/jit-test/tests/wasm/compiler-frame-depth.js
+++ b/js/src/jit-test/tests/wasm/compiler-frame-depth.js
@@ -10,9 +10,17 @@ var code = `(module
  (func
   (result f32)
   (param f32)
   ${expr}
  )
  (export "run" 0)
 )`;
 
-wasmFullPass(code, Math.fround(13.37), {}, 13.37);
+try {
+    wasmFullPass(code, Math.fround(13.37), {}, 13.37);
+} catch (e) {
+    // ASAN will fail these tests because its stack frames are much bigger than
+    // usual ones and the parser will bail out during its recursive descent.
+    // Ignore those errors specifically.
+    assertEq(e.message.includes('out of memory'), true);
+    assertEq(getBuildConfiguration().asan, true);
+}
--- a/js/src/jsfriendapi.h
+++ b/js/src/jsfriendapi.h
@@ -1052,17 +1052,17 @@ CheckRecursionLimit(JSContext* cx, uintp
     if (!JS_CHECK_STACK_SIZE(limit, &stackDummy)) {
         ReportOverRecursed(cx);
         return false;
     }
     return true;
 }
 
 MOZ_ALWAYS_INLINE bool
-CheckRecursionLimitDontReport(JSContext* cx, uintptr_t limit)
+CheckRecursionLimitDontReport(uintptr_t limit)
 {
     int stackDummy;
 
     JS_STACK_OOM_POSSIBLY_FAIL();
 
     return JS_CHECK_STACK_SIZE(limit, &stackDummy);
 }
 
@@ -1071,25 +1071,25 @@ CheckRecursionLimit(JSContext* cx)
 {
     JS_STACK_OOM_POSSIBLY_FAIL_REPORT();
 
     // GetNativeStackLimit(cx) is pretty slow because it has to do an uninlined
     // call to RunningWithTrustedPrincipals to determine which stack limit to
     // use. To work around this, check the untrusted limit first to avoid the
     // overhead in most cases.
     uintptr_t untrustedLimit = GetNativeStackLimit(cx, JS::StackForUntrustedScript);
-    if (MOZ_LIKELY(CheckRecursionLimitDontReport(cx, untrustedLimit)))
+    if (MOZ_LIKELY(CheckRecursionLimitDontReport(untrustedLimit)))
         return true;
     return CheckRecursionLimit(cx, GetNativeStackLimit(cx));
 }
 
 MOZ_ALWAYS_INLINE bool
 CheckRecursionLimitDontReport(JSContext* cx)
 {
-    return CheckRecursionLimitDontReport(cx, GetNativeStackLimit(cx));
+    return CheckRecursionLimitDontReport(GetNativeStackLimit(cx));
 }
 
 MOZ_ALWAYS_INLINE bool
 CheckRecursionLimitWithStackPointerDontReport(JSContext* cx, void* sp)
 {
     JS_STACK_OOM_POSSIBLY_FAIL();
 
     return JS_CHECK_STACK_SIZE(GetNativeStackLimit(cx), sp);
@@ -1118,18 +1118,18 @@ CheckRecursionLimitConservative(JSContex
 {
     return CheckRecursionLimit(cx, GetNativeStackLimit(cx, JS::StackForUntrustedScript,
                                                        -1024 * int(sizeof(size_t))));
 }
 
 MOZ_ALWAYS_INLINE bool
 CheckRecursionLimitConservativeDontReport(JSContext* cx)
 {
-    return CheckRecursionLimitDontReport(cx, GetNativeStackLimit(cx, JS::StackForUntrustedScript,
-                                                                 -1024 * int(sizeof(size_t))));
+    return CheckRecursionLimitDontReport(GetNativeStackLimit(cx, JS::StackForUntrustedScript,
+                                                             -1024 * int(sizeof(size_t))));
 }
 
 JS_FRIEND_API(void)
 StartPCCountProfiling(JSContext* cx);
 
 JS_FRIEND_API(void)
 StopPCCountProfiling(JSContext* cx);
 
--- a/js/src/wasm/WasmTextToBinary.cpp
+++ b/js/src/wasm/WasmTextToBinary.cpp
@@ -1660,22 +1660,25 @@ WasmTokenStream::next()
 namespace {
 
 struct WasmParseContext
 {
     WasmTokenStream ts;
     LifoAlloc& lifo;
     UniqueChars* error;
     DtoaState* dtoaState;
-
-    WasmParseContext(const char16_t* text, LifoAlloc& lifo, UniqueChars* error)
+    uintptr_t stackLimit;
+
+    WasmParseContext(const char16_t* text, uintptr_t stackLimit, LifoAlloc& lifo,
+                     UniqueChars* error)
       : ts(text, error),
         lifo(lifo),
         error(error),
-        dtoaState(NewDtoaState())
+        dtoaState(NewDtoaState()),
+        stackLimit(stackLimit)
     {}
 
     ~WasmParseContext() {
         DestroyDtoaState(dtoaState);
     }
 };
 
 } // end anonymous namespace
@@ -2864,16 +2867,18 @@ ParseGrowMemory(WasmParseContext& c, boo
         return nullptr;
 
     return new(c.lifo) AstGrowMemory(operand);
 }
 
 static AstExpr*
 ParseExprBody(WasmParseContext& c, WasmToken token, bool inParens)
 {
+    if (!CheckRecursionLimitDontReport(c.stackLimit))
+        return nullptr;
     switch (token.kind()) {
       case WasmToken::Unreachable:
         return new(c.lifo) AstUnreachable;
       case WasmToken::AtomicCmpXchg:
         return ParseAtomicCmpXchg(c, token.threadOp(), inParens);
       case WasmToken::AtomicLoad:
         return ParseAtomicLoad(c, token.threadOp(), inParens);
       case WasmToken::AtomicRMW:
@@ -3723,19 +3728,20 @@ ParseBinaryModule(WasmParseContext& c, A
     auto* data = new(c.lifo) AstDataSegment(nullptr, Move(fragments));
     if (!data || !module->append(data))
         return nullptr;
 
     return module;
 }
 
 static AstModule*
-ParseModule(const char16_t* text, LifoAlloc& lifo, UniqueChars* error, bool* binary)
+ParseModule(const char16_t* text, uintptr_t stackLimit, LifoAlloc& lifo, UniqueChars* error,
+            bool* binary)
 {
-    WasmParseContext c(text, lifo, error);
+    WasmParseContext c(text, stackLimit, lifo, error);
 
     *binary = false;
 
     if (!c.ts.match(WasmToken::OpenParen, c.error))
         return nullptr;
     if (!c.ts.match(WasmToken::Module, c.error))
         return nullptr;
 
@@ -5431,22 +5437,22 @@ EncodeBinaryModule(const AstModule& modu
     }
 
     return true;
 }
 
 /*****************************************************************************/
 
 bool
-wasm::TextToBinary(const char16_t* text, Bytes* bytes, UniqueChars* error)
+wasm::TextToBinary(const char16_t* text, uintptr_t stackLimit, Bytes* bytes, UniqueChars* error)
 {
     LifoAlloc lifo(AST_LIFO_DEFAULT_CHUNK_SIZE);
 
     bool binary = false;
-    AstModule* module = ParseModule(text, lifo, error, &binary);
+    AstModule* module = ParseModule(text, stackLimit, lifo, error, &binary);
     if (!module)
         return false;
 
     if (binary)
         return EncodeBinaryModule(*module, bytes);
 
     if (!ResolveModule(lifo, module, error))
         return false;
--- a/js/src/wasm/WasmTextToBinary.h
+++ b/js/src/wasm/WasmTextToBinary.h
@@ -24,14 +24,14 @@
 namespace js {
 namespace wasm {
 
 // Translate the textual representation of a wasm module (given by a
 // null-terminated char16_t array) into serialized bytes. If there is an error
 // other than out-of-memory an error message string will be stored in 'error'.
 
 extern MOZ_MUST_USE bool
-TextToBinary(const char16_t* text, Bytes* bytes, UniqueChars* error);
+TextToBinary(const char16_t* text, uintptr_t stackLimit, Bytes* bytes, UniqueChars* error);
 
 } // namespace wasm
 } // namespace js
 
 #endif // wasm_text_to_binary_h
--- a/js/xpconnect/shell/moz.build
+++ b/js/xpconnect/shell/moz.build
@@ -45,14 +45,11 @@ if CONFIG['OS_ARCH'] == 'WINNT':
             'winmm.dll',
             'user32.dll',
         ]
 
     DELAYLOAD_DLLS += [
         'xul.dll',
     ]
 
-if CONFIG['OS_TARGET'] == 'Android':
-    LDFLAGS += ['-pie']
-
 CFLAGS += CONFIG['TK_CFLAGS']
 CXXFLAGS += CONFIG['TK_CFLAGS']
 OS_LIBS += CONFIG['TK_LIBS']
--- a/layout/reftests/ogg-video/reftest.list
+++ b/layout/reftests/ogg-video/reftest.list
@@ -1,10 +1,10 @@
 # NOTE: bug 1084564 covers "fails"/"skip" annotations for android below:
-fuzzy(255,5000) random-if(webrender) == 444-1.html 444-1-ref.html
+fuzzy(255,5000) == 444-1.html 444-1-ref.html
 fails-if(Android) == aspect-ratio-1a.xhtml aspect-ratio-1-ref.html
 fails-if(Android) == aspect-ratio-1b.xhtml aspect-ratio-1-ref.html
 fails-if(Android) skip-if(gtkWidget) == aspect-ratio-2a.xhtml aspect-ratio-2-ref.html
 fails-if(Android) skip-if(gtkWidget) == aspect-ratio-2b.xhtml aspect-ratio-2-ref.html
 == aspect-ratio-3a.xhtml aspect-ratio-3-ref.xhtml
 == aspect-ratio-3b.xhtml aspect-ratio-3-ref.xhtml
 fails-if(Android) random-if(layersGPUAccelerated) == encoded-aspect-ratio-1.html encoded-aspect-ratio-1-ref.html
 fails-if(Android) == basic-1.xhtml basic-1-ref.html
deleted file mode 100644
--- a/layout/style/CachedAnonBoxStyles.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 tw=80: */
-/* 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 "nsIMemoryReporter.h"
-#include "mozilla/CachedAnonBoxStyles.h"
-#include "mozilla/ServoStyleContext.h"
-
-namespace mozilla {
-
-void
-CachedAnonBoxStyles::Insert(ServoStyleContext* aStyle)
-{
-  MOZ_ASSERT(aStyle);
-  MOZ_ASSERT(aStyle->IsInheritingAnonBox());
-
-  if (IsEmpty()) {
-    RefPtr<ServoStyleContext> s = aStyle;
-    mBits = reinterpret_cast<uintptr_t>(s.forget().take());
-    MOZ_ASSERT(!IsEmpty() && !IsIndirect());
-  } else if (IsIndirect()) {
-    AsIndirect()->AppendElement(aStyle);
-  } else {
-    IndirectCache* cache = new IndirectCache();
-    cache->AppendElement(dont_AddRef(AsDirect()));
-    cache->AppendElement(aStyle);
-    mBits = reinterpret_cast<uintptr_t>(cache) | 1;
-    MOZ_ASSERT(IsIndirect());
-  }
-}
-
-ServoStyleContext*
-CachedAnonBoxStyles::Lookup(nsAtom* aAnonBox) const
-{
-  MOZ_ASSERT(nsCSSAnonBoxes::IsInheritingAnonBox(aAnonBox));
-  if (IsIndirect()) {
-    for (auto& style : *AsIndirect()) {
-      if (style->GetPseudo() == aAnonBox) {
-        return style;
-      }
-    }
-
-    return nullptr;
-  }
-
-  ServoStyleContext* direct = AsDirect();
-  return direct && direct->GetPseudo() == aAnonBox ? direct : nullptr;
-}
-
-void
-CachedAnonBoxStyles::AddSizeOfIncludingThis(nsWindowSizes& aSizes, size_t* aCVsSize) const
-{
-  if (IsIndirect()) {
-    for (auto& style : *AsIndirect()) {
-      if (!aSizes.mState.HaveSeenPtr(style)) {
-        style->AddSizeOfIncludingThis(aSizes, aCVsSize);
-      }
-    }
-
-    return;
-  }
-
-  ServoStyleContext* direct = AsDirect();
-  if (direct && !aSizes.mState.HaveSeenPtr(direct)) {
-    direct->AddSizeOfIncludingThis(aSizes, aCVsSize);
-  }
-}
-
-} // namespace mozilla
deleted file mode 100644
--- a/layout/style/CachedAnonBoxStyles.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 tw=80: */
-/* 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 mozilla_CachedAnonBoxStyles_h
-#define mozilla_CachedAnonBoxStyles_h
-
-#include "nsAtom.h"
-#include "nsTArray.h"
-
-class nsWindowSizes;
-
-namespace mozilla {
-
-class ServoStyleContext;
-
-// Cache of anonymous box styles that inherit from a given style.
-//
-// To minimize memory footprint, the cache is word-sized with a tagged pointer
-// If there is only one entry, it's stored inline. If there are more, they're
-// stored in an out-of-line buffer. See bug 1429126 comment 0 and comment 1 for
-// the measurements and rationale that influenced the design.
-class CachedAnonBoxStyles
-{
-public:
-  void Insert(ServoStyleContext* aStyle);
-  ServoStyleContext* Lookup(nsAtom* aAnonBox) const;
-
-  CachedAnonBoxStyles() : mBits(0) {}
-  ~CachedAnonBoxStyles()
-  {
-    if (IsIndirect()) {
-      delete AsIndirect();
-    } else if (!IsEmpty()) {
-      RefPtr<ServoStyleContext> ref = dont_AddRef(AsDirect());
-    }
-  }
-
-  void AddSizeOfIncludingThis(nsWindowSizes& aSizes, size_t* aCVsSize) const;
-
-private:
-  // See bug 1429126 comment 1 for the choice of four here.
-  typedef AutoTArray<RefPtr<ServoStyleContext>, 4> IndirectCache;
-
-  bool IsEmpty() const { return !mBits; }
-  bool IsIndirect() const { return (mBits & 1); }
-
-  ServoStyleContext* AsDirect() const
-  {
-    MOZ_ASSERT(!IsIndirect());
-    return reinterpret_cast<ServoStyleContext*>(mBits);
-  }
-
-  IndirectCache* AsIndirect() const
-  {
-    MOZ_ASSERT(IsIndirect());
-    return reinterpret_cast<IndirectCache*>(mBits & ~1);
-  }
-
-  uintptr_t mBits;
-};
-
-} // namespace mozilla
-
-#endif // mozilla_CachedAnonBoxStyles_h
new file mode 100644
--- /dev/null
+++ b/layout/style/CachedInheritingStyles.cpp
@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "nsIMemoryReporter.h"
+#include "mozilla/CachedInheritingStyles.h"
+#include "mozilla/ServoStyleContext.h"
+
+namespace mozilla {
+
+void
+CachedInheritingStyles::Insert(ServoStyleContext* aStyle)
+{
+  MOZ_ASSERT(aStyle);
+  MOZ_ASSERT(aStyle->IsInheritingAnonBox() || aStyle->IsLazilyCascadedPseudoElement());
+
+  if (IsEmpty()) {
+    RefPtr<ServoStyleContext> s = aStyle;
+    mBits = reinterpret_cast<uintptr_t>(s.forget().take());
+    MOZ_ASSERT(!IsEmpty() && !IsIndirect());
+  } else if (IsIndirect()) {
+    AsIndirect()->AppendElement(aStyle);
+  } else {
+    IndirectCache* cache = new IndirectCache();
+    cache->AppendElement(dont_AddRef(AsDirect()));
+    cache->AppendElement(aStyle);
+    mBits = reinterpret_cast<uintptr_t>(cache) | 1;
+    MOZ_ASSERT(IsIndirect());
+  }
+}
+
+ServoStyleContext*
+CachedInheritingStyles::Lookup(nsAtom* aPseudoTag) const
+{
+  MOZ_ASSERT(nsCSSAnonBoxes::IsInheritingAnonBox(aPseudoTag) ||
+             nsCSSPseudoElements::IsPseudoElement(aPseudoTag));
+  if (IsIndirect()) {
+    for (auto& style : *AsIndirect()) {
+      if (style->GetPseudo() == aPseudoTag) {
+        return style;
+      }
+    }
+
+    return nullptr;
+  }
+
+  ServoStyleContext* direct = AsDirect();
+  return direct && direct->GetPseudo() == aPseudoTag ? direct : nullptr;
+}
+
+void
+CachedInheritingStyles::AddSizeOfIncludingThis(nsWindowSizes& aSizes, size_t* aCVsSize) const
+{
+  if (IsIndirect()) {
+    for (auto& style : *AsIndirect()) {
+      if (!aSizes.mState.HaveSeenPtr(style)) {
+        style->AddSizeOfIncludingThis(aSizes, aCVsSize);
+      }
+    }
+
+    return;
+  }
+
+  ServoStyleContext* direct = AsDirect();
+  if (direct && !aSizes.mState.HaveSeenPtr(direct)) {
+    direct->AddSizeOfIncludingThis(aSizes, aCVsSize);
+  }
+}
+
+} // namespace mozilla
new file mode 100644
--- /dev/null
+++ b/layout/style/CachedInheritingStyles.h
@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 mozilla_CachedInheritingStyles_h
+#define mozilla_CachedInheritingStyles_h
+
+#include "nsAtom.h"
+#include "nsTArray.h"
+
+class nsWindowSizes;
+
+namespace mozilla {
+
+class ServoStyleContext;
+
+// Cache of anonymous box and lazy pseudo styles that inherit from a given style.
+//
+// To minimize memory footprint, the cache is word-sized with a tagged pointer
+// If there is only one entry, it's stored inline. If there are more, they're
+// stored in an out-of-line buffer. See bug 1429126 comment 0 and comment 1 for
+// the measurements and rationale that influenced the design.
+class CachedInheritingStyles
+{
+public:
+  void Insert(ServoStyleContext* aStyle);
+  ServoStyleContext* Lookup(nsAtom* aPseudoTag) const;
+
+  CachedInheritingStyles() : mBits(0) {}
+  ~CachedInheritingStyles()
+  {
+    if (IsIndirect()) {
+      delete AsIndirect();
+    } else if (!IsEmpty()) {
+      RefPtr<ServoStyleContext> ref = dont_AddRef(AsDirect());
+    }
+  }
+
+  void AddSizeOfIncludingThis(nsWindowSizes& aSizes, size_t* aCVsSize) const;
+
+private:
+  // See bug 1429126 comment 1 for the choice of four here.
+  typedef AutoTArray<RefPtr<ServoStyleContext>, 4> IndirectCache;
+
+  bool IsEmpty() const { return !mBits; }
+  bool IsIndirect() const { return (mBits & 1); }
+
+  ServoStyleContext* AsDirect() const
+  {
+    MOZ_ASSERT(!IsIndirect());
+    return reinterpret_cast<ServoStyleContext*>(mBits);
+  }
+
+  IndirectCache* AsIndirect() const
+  {
+    MOZ_ASSERT(IsIndirect());
+    return reinterpret_cast<IndirectCache*>(mBits & ~1);
+  }
+
+  uintptr_t mBits;
+};
+
+} // namespace mozilla
+
+#endif // mozilla_CachedInheritingStyles_h
--- a/layout/style/ServoStyleContext.cpp
+++ b/layout/style/ServoStyleContext.cpp
@@ -40,18 +40,12 @@ ServoStyleContext::GetCachedLazyPseudoSt
              aPseudo != CSSPseudoElementType::InheritingAnonBox &&
              aPseudo != CSSPseudoElementType::NonInheritingAnonBox);
   MOZ_ASSERT(!IsLazilyCascadedPseudoElement(), "Lazy pseudos can't inherit lazy pseudos");
 
   if (nsCSSPseudoElements::PseudoElementSupportsUserActionState(aPseudo)) {
     return nullptr;
   }
 
-  auto* current = mNextLazyPseudoStyle.get();
-
-  while (current && current->GetPseudoType() != aPseudo) {
-    current = current->mNextLazyPseudoStyle.get();
-  }
-
-  return current;
+  return mCachedInheritingStyles.Lookup(nsCSSPseudoElements::GetPseudoAtom(aPseudo));
 }
 
 } // namespace mozilla
--- a/layout/style/ServoStyleContext.h
+++ b/layout/style/ServoStyleContext.h
@@ -7,17 +7,17 @@
 #ifndef mozilla_ServoStyleContext_h
 #define mozilla_ServoStyleContext_h
 
 #include "nsIMemoryReporter.h"
 #include "nsStyleContext.h"
 #include "nsWindowSizes.h"
 #include <algorithm>
 
-#include "mozilla/CachedAnonBoxStyles.h"
+#include "mozilla/CachedInheritingStyles.h"
 
 namespace mozilla {
 
 namespace dom {
 class Element;
 } // namespace dom
 
 MOZ_DEFINE_MALLOC_ENCLOSING_SIZE_OF(ServoComputedValuesMallocEnclosingSizeOf)
@@ -45,50 +45,48 @@ public:
   {
     return IsPseudoElement() &&
            !nsCSSPseudoElements::IsEagerlyCascadedInServo(GetPseudoType());
   }
 
   ServoStyleContext* GetCachedInheritingAnonBoxStyle(nsAtom* aAnonBox) const
   {
     MOZ_ASSERT(nsCSSAnonBoxes::IsInheritingAnonBox(aAnonBox));
-    return mInheritingAnonBoxStyles.Lookup(aAnonBox);
+    return mCachedInheritingStyles.Lookup(aAnonBox);
   }
 
   void SetCachedInheritedAnonBoxStyle(nsAtom* aAnonBox, ServoStyleContext* aStyle)
   {
     MOZ_ASSERT(!GetCachedInheritingAnonBoxStyle(aAnonBox));
-    mInheritingAnonBoxStyles.Insert(aStyle);
+    mCachedInheritingStyles.Insert(aStyle);
   }
 
   ServoStyleContext* GetCachedLazyPseudoStyle(CSSPseudoElementType aPseudo) const;
 
   void SetCachedLazyPseudoStyle(ServoStyleContext* aStyle)
   {
     MOZ_ASSERT(aStyle->GetPseudo() && !aStyle->IsAnonBox());
     MOZ_ASSERT(!GetCachedLazyPseudoStyle(aStyle->GetPseudoType()));
-    MOZ_ASSERT(!aStyle->mNextLazyPseudoStyle);
     MOZ_ASSERT(!IsLazilyCascadedPseudoElement(), "lazy pseudos can't inherit lazy pseudos");
     MOZ_ASSERT(aStyle->IsLazilyCascadedPseudoElement());
 
     // Since we're caching lazy pseudo styles on the ComputedValues of the
     // originating element, we can assume that we either have the same
     // originating element, or that they were at least similar enough to share
     // the same ComputedValues, which means that they would match the same
     // pseudo rules. This allows us to avoid matching selectors and checking
     // the rule node before deciding to share.
     //
     // The one place this optimization breaks is with pseudo-elements that
     // support state (like :hover). So we just avoid sharing in those cases.
     if (nsCSSPseudoElements::PseudoElementSupportsUserActionState(aStyle->GetPseudoType())) {
       return;
     }
 
-    mNextLazyPseudoStyle.swap(aStyle->mNextLazyPseudoStyle);
-    mNextLazyPseudoStyle = aStyle;
+    mCachedInheritingStyles.Insert(aStyle);
   }
 
   /**
    * Makes this context match |aOther| in terms of which style structs have
    * been resolved.
    */
   inline void ResolveSameStructsAs(const ServoStyleContext* aOther);
 
@@ -98,39 +96,22 @@ public:
   void AddSizeOfIncludingThis(nsWindowSizes& aSizes, size_t* aCVsSize) const
   {
     // Note: |this| sits within a servo_arc::Arc, i.e. it is preceded by a
     // refcount. So we need to measure it with a function that can handle an
     // interior pointer. We use ServoComputedValuesMallocEnclosingSizeOf to
     // clearly identify in DMD's output the memory measured here.
     *aCVsSize += ServoComputedValuesMallocEnclosingSizeOf(this);
     mSource.AddSizeOfExcludingThis(aSizes);
-    mInheritingAnonBoxStyles.AddSizeOfIncludingThis(aSizes, aCVsSize);
-
-    if (mNextLazyPseudoStyle &&
-        !aSizes.mState.HaveSeenPtr(mNextLazyPseudoStyle)) {
-      mNextLazyPseudoStyle->AddSizeOfIncludingThis(aSizes, aCVsSize);
-    }
+    mCachedInheritingStyles.AddSizeOfIncludingThis(aSizes, aCVsSize);
   }
 
 private:
   nsPresContext* mPresContext;
   ServoComputedData mSource;
 
-  // A cache of inheriting anon boxes inheriting from this style _if the style
-  // isn't an inheriting anon-box_.
-  CachedAnonBoxStyles mInheritingAnonBoxStyles;
-
-  // A linked-list cache of lazy pseudo styles inheriting from this style _if
-  // the style isn't a lazy pseudo style itself_.
-  //
-  // Otherwise it represents the next entry in the cache of the parent style
-  // context.
-  //
-  // Note that we store these separately from inheriting anonymous boxes so that
-  // text nodes inheriting from lazy pseudo styles can share styles, which is
-  // very important on some pages.
-  RefPtr<ServoStyleContext> mNextLazyPseudoStyle;
+  // A cache of anonymous box and lazy pseudo styles inheriting from this style.
+  CachedInheritingStyles mCachedInheritingStyles;
 };
 
 } // namespace mozilla
 
 #endif // mozilla_ServoStyleContext_h
--- a/layout/style/moz.build
+++ b/layout/style/moz.build
@@ -75,17 +75,17 @@ EXPORTS += [
     'nsStyleStructInlines.h',
     'nsStyleTransformMatrix.h',
     'nsStyleUtil.h',
 ]
 
 EXPORTS.mozilla += [
     'AnimationCollection.h',
     'BindingStyleRule.h',
-    'CachedAnonBoxStyles.h',
+    'CachedInheritingStyles.h',
     'CSSEnabledState.h',
     'CSSStyleSheet.h',
     'CSSVariableDeclarations.h',
     'CSSVariableResolver.h',
     'CSSVariableValues.h',
     'DeclarationBlock.h',
     'DeclarationBlockInlines.h',
     'DocumentStyleRootIterator.h',
@@ -174,17 +174,17 @@ EXPORTS.mozilla.css += [
     'StreamLoader.h',
     'StyleRule.h',
     'URLMatchingFunction.h',
 ]
 
 UNIFIED_SOURCES += [
     'AnimationCollection.cpp',
     'BindingStyleRule.cpp',
-    'CachedAnonBoxStyles.cpp',
+    'CachedInheritingStyles.cpp',
     'CounterStyleManager.cpp',
     'CSS.cpp',
     'CSSFontFeatureValuesRule.cpp',
     'CSSImportRule.cpp',
     'CSSKeyframeRule.cpp',
     'CSSKeyframesRule.cpp',
     'CSSLexer.cpp',
     'CSSMediaRule.cpp',
--- a/layout/tools/reftest/README.txt
+++ b/layout/tools/reftest/README.txt
@@ -44,26 +44,24 @@ Manifest Format
 
 The test manifest format is a plain text file.  A line starting with a
 "#" is a comment.  Lines may be commented using whitespace followed by
 a "#" and the comment.  Each non-blank line (after removal of comments)
 must be one of the following:
 
 1. Inclusion of another manifest
 
-   <failure-type>* include <relative_path>
+   <skip-type>* include <relative_path>
 
-   <failure-type> is the same as listed below for a test item.  As for
-   test items, multiple failure types listed on the same line are
-   combined by using the last matching failure type listed on the line.
-   However, the failure type on a manifest is combined with the failure
-   type on the test (or on a nested manifest) with the rule that the
-   last in the following list wins:  fails, random, skip.  (In other
-   words, when combining <failure-type> from the manifest include and
-   the test line, skip always wins, and random beats fails.)
+   <skip-type> is one of the skip or skip-if items (see their definitions
+   in <failure-type> below). If any of the skip types evaluate to true (i.e.
+   they are a plain "skip" or they are a "skip-if" with a condition that
+   evaluates to true), then the include statement is skipped. Otherwise,
+   reftests in the specified manifest are included in the set of reftests
+   that are run.
 
 2. A test item
 
    [ <failure-type> | <preference> ]* [<http>] <type> <url> <url_ref>
 
    where
 
    a. <failure-type> (optional) is one of the following:
--- a/layout/tools/reftest/manifest.jsm
+++ b/layout/tools/reftest/manifest.jsm
@@ -26,26 +26,26 @@ const RE_PREF_ITEM = /^(|test-|ref-)pref
 
 function ReadTopManifest(aFileURL, aFilter)
 {
     var url = g.ioService.newURI(aFileURL);
     if (!url)
         throw "Expected a file or http URL for the manifest.";
 
     g.manifestsLoaded = {};
-    ReadManifest(url, EXPECTED_PASS, aFilter);
+    ReadManifest(url, aFilter);
 }
 
 // Note: If you materially change the reftest manifest parsing,
 // please keep the parser in print-manifest-dirs.py in sync.
-function ReadManifest(aURL, inherited_status, aFilter)
+function ReadManifest(aURL, aFilter)
 {
-    // Ensure each manifest is only read once. This assumes that manifests that are
-    // included with an unusual inherited_status or filters will be read via their
-    // include before they are read directly in the case of a duplicate
+    // Ensure each manifest is only read once. This assumes that manifests that
+    // are included with filters will be read via their include before they are
+    // read directly in the case of a duplicate
     if (g.manifestsLoaded.hasOwnProperty(aURL.spec)) {
         if (g.manifestsLoaded[aURL.spec] === null)
             return;
         else
             aFilter = [aFilter[0], aFilter[1], true];
     }
     g.manifestsLoaded[aURL.spec] = aFilter[1];
 
@@ -127,16 +127,17 @@ function ReadManifest(aURL, inherited_st
         var maxAsserts = 0;
         var needs_focus = false;
         var slow = false;
         var testPrefSettings = defaultTestPrefSettings.concat();
         var refPrefSettings = defaultRefPrefSettings.concat();
         var fuzzy_delta = { min: 0, max: 2 };
         var fuzzy_pixels = { min: 0, max: 1 };
         var chaosMode = false;
+        var nonSkipUsed = false;
 
         while (items[0].match(/^(fails|needs-focus|random|skip|asserts|slow|require-or|silentfail|pref|test-pref|ref-pref|fuzzy|chaos-mode)/)) {
             var item = items.shift();
             var stat;
             var cond;
             var m = item.match(/^(fails|random|skip|silentfail)-if(\(.*\))$/);
             if (m) {
                 stat = m[1];
@@ -214,31 +215,33 @@ function ReadManifest(aURL, inherited_st
               }
             } else if (item == "chaos-mode") {
                 cond = false;
                 chaosMode = true;
             } else {
                 throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": unexpected item " + item;
             }
 
+            if (stat != "skip") {
+                nonSkipUsed = true;
+            }
+
             if (cond) {
                 if (stat == "fails") {
                     expected_status = EXPECTED_FAIL;
                 } else if (stat == "random") {
                     expected_status = EXPECTED_RANDOM;
                 } else if (stat == "skip") {
                     expected_status = EXPECTED_DEATH;
                 } else if (stat == "silentfail") {
                     allow_silent_fail = true;
                 }
             }
         }
 
-        expected_status = Math.max(expected_status, inherited_status);
-
         if (minAsserts > maxAsserts) {
             throw "Bad range in manifest file " + aURL.spec + " line " + lineNo;
         }
 
         var runHttp = false;
         var httpDepth;
         if (items[0] == "HTTP") {
             runHttp = (aURL.scheme == "file"); // We can't yet run the local HTTP server
@@ -266,20 +269,38 @@ function ReadManifest(aURL, inherited_st
 
         var principal = secMan.createCodebasePrincipal(aURL, {});
 
         if (items[0] == "include") {
             if (items.length != 2)
                 throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": incorrect number of arguments to include";
             if (runHttp)
                 throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": use of include with http";
-            var incURI = g.ioService.newURI(items[1], null, listURL);
-            secMan.checkLoadURIWithPrincipal(principal, incURI,
-                                             CI.nsIScriptSecurityManager.DISALLOW_SCRIPT);
-            ReadManifest(incURI, expected_status, aFilter);
+
+            // If the expected_status is EXPECTED_PASS (the default) then allow
+            // the include. If it is EXPECTED_DEATH, that means there was a skip
+            // or skip-if annotation (with a true condition) on this include
+            // statement, so we should skip the include. Any other expected_status
+            // is disallowed since it's nonintuitive as to what the intended
+            // effect is.
+            if (nonSkipUsed) {
+                throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": include statement with annotation other than 'skip' or 'skip-if'";
+            } else if (expected_status == EXPECTED_DEATH) {
+                g.logger.info("Skipping included manifest at " + aURL.spec + " line " + lineNo + " due to matching skip condition");
+            } else {
+                // poor man's assertion
+                if (expected_status != EXPECTED_PASS) {
+                    throw "Error in manifest file parsing code: we should never get expected_status=" + expected_status + " when nonSkipUsed=false (from " + aURL.spec + " line " + lineNo + ")";
+                }
+
+                var incURI = g.ioService.newURI(items[1], null, listURL);
+                secMan.checkLoadURIWithPrincipal(principal, incURI,
+                                                 CI.nsIScriptSecurityManager.DISALLOW_SCRIPT);
+                ReadManifest(incURI, aFilter);
+            }
         } else if (items[0] == TYPE_LOAD) {
             if (items.length != 2)
                 throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": incorrect number of arguments to load";
             if (expected_status != EXPECTED_PASS &&
                 expected_status != EXPECTED_DEATH)
                 throw "Error in manifest file " + aURL.spec + " line " + lineNo + ": incorrect known failure type for load test";
             var [testURI] = runHttp
                             ? ServeFiles(principal, httpDepth,
--- a/media/libcubeb/README_MOZILLA
+++ b/media/libcubeb/README_MOZILLA
@@ -1,8 +1,12 @@
 The source from this directory was copied from the cubeb 
 git repository using the update.sh script.  The only changes
-made were those applied by update.sh and the addition of
-Makefile.in build files for the Mozilla build system.
+made were those applied by update.sh, the addition of
+Makefile.in build files for the Mozilla build system,
+and the following patches, which may be overwritten when
+included upstream.
+https://github.com/kinetiknz/cubeb/pull/398/commits/c8e66dee61a35e6a6d54e3630e1668bdbd6984b4
+https://github.com/kinetiknz/cubeb/pull/398/commits/2ed979bc891cf1a7822799947a357d4d3b625964
 
 The cubeb git repository is: git://github.com/kinetiknz/cubeb.git
 
 The git commit ID used was bda37c26b0ed46c568e35b10728fc498262778f3 (2017-12-28 09:34:08 +1000)
--- a/media/libcubeb/gtest/test_resampler.cpp
+++ b/media/libcubeb/gtest/test_resampler.cpp
@@ -492,52 +492,55 @@ TEST(cubeb, resampler_output_only_noop)
   got = cubeb_resampler_fill(resampler, nullptr, nullptr,
                              out_buffer, out_frames);
 
   ASSERT_EQ(got, out_frames);
 
   cubeb_resampler_destroy(resampler);
 }
 
-long test_drain_data_cb(cubeb_stream * /*stm*/, void * /*user_ptr*/,
+long test_drain_data_cb(cubeb_stream * /*stm*/, void * user_ptr,
                         const void * input_buffer,
                         void * output_buffer, long frame_count)
 {
   EXPECT_TRUE(output_buffer);
   EXPECT_TRUE(!input_buffer);
-  return frame_count - 10;
+  auto cb_count = static_cast<int *>(user_ptr);
+  (*cb_count)++;
+  return frame_count - 1;
 }
 
 TEST(cubeb, resampler_drain)
 {
   cubeb_stream_params output_params;
   int target_rate;
 
   output_params.rate = 44100;
   output_params.channels = 1;
   output_params.format = CUBEB_SAMPLE_FLOAT32NE;
   target_rate = 48000;
+  int cb_count = 0;
 
   cubeb_resampler * resampler =
     cubeb_resampler_create((cubeb_stream*)nullptr, nullptr, &output_params, target_rate,
-                           test_drain_data_cb, nullptr,
+                           test_drain_data_cb, &cb_count,
                            CUBEB_RESAMPLER_QUALITY_VOIP);
 
   const long out_frames = 128;
   float out_buffer[out_frames];
   long got;
 
   do {
     got = cubeb_resampler_fill(resampler, nullptr, nullptr,
                                out_buffer, out_frames);
   } while (got == out_frames);
 
-  /* If the above is not an infinite loop, the drain was a success, just mark
-   * this test as such. */
-  ASSERT_TRUE(true);
+  /* The callback should be called once but not again after returning <
+   * frame_count. */
+  ASSERT_EQ(cb_count, 1);
 
   cubeb_resampler_destroy(resampler);
 }
 
 // gtest does not support using ASSERT_EQ and friend in a function that returns
 // a value.
 void check_output(const void * input_buffer, void * output_buffer, long frame_count)
 {
--- a/media/libcubeb/src/cubeb_resampler.cpp
+++ b/media/libcubeb/src/cubeb_resampler.cpp
@@ -140,37 +140,43 @@ template<typename T, typename InputProce
 long
 cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
 ::fill_internal_output(T * input_buffer, long * input_frames_count,
                        T * output_buffer, long output_frames_needed)
 {
   assert(!input_buffer && (!input_frames_count || *input_frames_count == 0) &&
          output_buffer && output_frames_needed);
 
-  long got = 0;
-  T * out_unprocessed = nullptr;
-  long output_frames_before_processing = 0;
+  if (!draining) {
+    long got = 0;
+    T * out_unprocessed = nullptr;
+    long output_frames_before_processing = 0;
 
-  /* fill directly the input buffer of the output processor to save a copy */
-  output_frames_before_processing =
-    output_processor->input_needed_for_output(output_frames_needed);
+    /* fill directly the input buffer of the output processor to save a copy */
+    output_frames_before_processing =
+      output_processor->input_needed_for_output(output_frames_needed);
+
+    out_unprocessed =
+      output_processor->input_buffer(output_frames_before_processing);
 
-  out_unprocessed =
-    output_processor->input_buffer(output_frames_before_processing);
+    got = data_callback(stream, user_ptr,
+                        nullptr, out_unprocessed,
+                        output_frames_before_processing);
+
+    if (got < output_frames_before_processing) {
+      draining = true;
 
-  got = data_callback(stream, user_ptr,
-                      nullptr, out_unprocessed,
-                      output_frames_before_processing);
+      if (got < 0) {
+        return got;
+      }
+    }
 
-  if (got < 0) {
-    return got;
+    output_processor->written(got);
   }
 
-  output_processor->written(got);
-
   /* Process the output. If not enough frames have been returned from the
   * callback, drain the processors. */
   return output_processor->output(output_buffer, output_frames_needed);
 }
 
 template<typename T, typename InputProcessor, typename OutputProcessor>
 long
 cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
@@ -199,21 +205,26 @@ cubeb_resampler_speex<T, InputProcessor,
 }
 
 template<typename T, typename InputProcessor, typename OutputProcessor>
 long
 cubeb_resampler_speex<T, InputProcessor, OutputProcessor>
 ::fill_internal_duplex(T * in_buffer, long * input_frames_count,
                        T * out_buffer, long output_frames_needed)
 {
+  if (draining) {
+    // discard input and drain any signal remaining in the resampler.
+    return output_processor->output(out_buffer, output_frames_needed);
+  }
+
   /* The input data, after eventual resampling. This is passed to the callback. */
   T * resampled_input = nullptr;
   /* The output buffer passed down in the callback, that might be resampled. */
   T * out_unprocessed = nullptr;
-  size_t output_frames_before_processing = 0;
+  long output_frames_before_processing = 0;
   /* The number of frames returned from the callback. */
   long got = 0;
 
   /* We need to determine how much frames to present to the consumer.
    * - If we have a two way stream, but we're only resampling input, we resample
    * the input to the number of output frames.
    * - If we have a two way stream, but we're only resampling the output, we
    * resize the input buffer of the output resampler to the number of input
@@ -238,18 +249,22 @@ cubeb_resampler_speex<T, InputProcessor,
   } else {
     resampled_input = nullptr;
   }
 
   got = data_callback(stream, user_ptr,
                       resampled_input, out_unprocessed,
                       output_frames_before_processing);
 
-  if (got < 0) {
-    return got;
+  if (got < output_frames_before_processing) {
+    draining = true;
+
+    if (got < 0) {
+      return got;
+    }
   }
 
   output_processor->written(got);
 
   input_processor->drop_audio_if_needed();
 
   /* Process the output. If not enough frames have been returned from the
    * callback, drain the processors. */
--- a/media/libcubeb/src/cubeb_resampler_internal.h
+++ b/media/libcubeb/src/cubeb_resampler_internal.h
@@ -57,21 +57,21 @@ struct cubeb_resampler {
 
 /** Base class for processors. This is just used to share methods for now. */
 class processor {
 public:
   explicit processor(uint32_t channels)
     : channels(channels)
   {}
 protected:
-  size_t frames_to_samples(size_t frames)
+  size_t frames_to_samples(size_t frames) const
   {
     return frames * channels;
   }
-  size_t samples_to_frames(size_t samples)
+  size_t samples_to_frames(size_t samples) const
   {
     assert(!(samples % channels));
     return samples / channels;
   }
   /** The number of channel of the audio buffers to be resampled. */
   const uint32_t channels;
 };
 
@@ -152,16 +152,17 @@ private:
                             T * output_buffer, long output_frames_needed);
 
   std::unique_ptr<InputProcessing> input_processor;
   std::unique_ptr<OutputProcessing> output_processor;
   processing_callback fill_internal;
   cubeb_stream * const stream;
   const cubeb_data_callback data_callback;
   void * const user_ptr;
+  bool draining = false;
 };
 
 /** Handles one way of a (possibly) duplex resampler, working on interleaved
  * audio buffers of type T. This class is designed so that the number of frames
  * coming out of the resampler can be precisely controled. It manages its own
  * input buffer, and can use the caller's output buffer, or allocate its own. */
 template<typename T>
 class cubeb_resampler_speex_one_way : public processor {
@@ -277,17 +278,17 @@ public:
 
     return latency;
   }
 
   /** Returns the number of frames to pass in the input of the resampler to have
    * exactly `output_frame_count` resampled frames. This can return a number
    * slightly bigger than what is strictly necessary, but it guaranteed that the
    * number of output frames will be exactly equal. */
-  uint32_t input_needed_for_output(uint32_t output_frame_count)
+  uint32_t input_needed_for_output(uint32_t output_frame_count) const
   {
     int32_t unresampled_frames_left = samples_to_frames(resampling_in_buffer.length());
     int32_t resampled_frames_left = samples_to_frames(resampling_out_buffer.length());
     float input_frames_needed =
       (output_frame_count - unresampled_frames_left) * resampling_ratio
         - resampled_frames_left;
     if (input_frames_needed < 0) {
       return 0;
@@ -456,17 +457,17 @@ public:
 
     return to_pop;
   }
   /** Returns the number of frames one needs to input into the delay line to get
    * #frames_needed frames back.
    * @parameter frames_needed the number of frames one want to write into the
    * delay_line
    * @returns the number of frames one will get. */
-  size_t input_needed_for_output(uint32_t frames_needed)
+  size_t input_needed_for_output(uint32_t frames_needed) const
   {
     return frames_needed;
   }
   /** Returns the number of frames produces for `input_frames` frames in input */
   size_t output_for_input(uint32_t input_frames)
   {
     return input_frames;
   }
--- a/media/webrtc/trunk/build/mac/find_sdk.py
+++ b/media/webrtc/trunk/build/mac/find_sdk.py
@@ -79,16 +79,17 @@ def main():
   if options.print_sdk_path:
     print subprocess.check_output(
         ['xcrun', '-sdk', 'macosx' + best_sdk, '--show-sdk-path']).strip()
 
   return best_sdk
 
 
 if __name__ == '__main__':
-  if sys.platform == 'darwin':
+  if sys.platform == 'darwin' or os.environ.get('MOZ_AUTOMATION') != '1':
     print main()
   else:
-    # Mozilla builds cross-compile on Linux, so return some fake data to keep
-    # the build system happy. These values aren't used anywhere.
+    # Mozilla builds cross-compile on Linux or install an SDK from tooltool, so
+    # return some fake data to keep the build system happy. These values aren't
+    # used anywhere.
     print "."
     print "."
   sys.exit(0)
--- a/mobile/android/geckoview/src/main/java/org/mozilla/gecko/GeckoSession.java
+++ b/mobile/android/geckoview/src/main/java/org/mozilla/gecko/GeckoSession.java
@@ -291,32 +291,46 @@ public class GeckoSession extends LayerS
         private NativeQueue mNativeQueue;
         private Binder mBinder;
 
         public Window(final NativeQueue nativeQueue) {
             mNativeQueue = nativeQueue;
         }
 
         @Override // IInterface
-        public IBinder asBinder() {
+        public Binder asBinder() {
             if (mBinder == null) {
                 mBinder = new Binder();
                 mBinder.attachInterface(this, Window.class.getName());
             }
             return mBinder;
         }
 
         @WrapForJNI(dispatchTo = "proxy")
         public static native void open(Window instance, Compositor compositor,
                                        EventDispatcher dispatcher,
                                        GeckoBundle settings, String chromeUri,
                                        int screenId, boolean privateMode);
 
-        @WrapForJNI(dispatchTo = "proxy")
-        @Override protected native void disposeNative();
+        @Override // JNIObject
+        protected void disposeNative() {
+            // Detach ourselves from the binder as well, to prevent this window from being
+            // read from any parcels.
+            asBinder().attachInterface(null, Window.class.getName());
+
+            if (GeckoThread.isStateAtLeast(GeckoThread.State.PROFILE_READY)) {
+                nativeDisposeNative();
+            } else {
+                GeckoThread.queueNativeCallUntil(GeckoThread.State.PROFILE_READY,
+                        this, "nativeDisposeNative");
+            }
+        }
+
+        @WrapForJNI(dispatchTo = "proxy", stubName = "DisposeNative")
+        private native void nativeDisposeNative();
 
         @WrapForJNI(dispatchTo = "proxy")
         public native void close();
 
         @WrapForJNI(dispatchTo = "proxy")
         public native void transfer(Compositor compositor, EventDispatcher dispatcher,
                                     GeckoBundle settings);
 
@@ -523,24 +537,22 @@ public class GeckoSession extends LayerS
         ThreadUtils.assertOnUiThread();
 
         if (!isOpen()) {
             throw new IllegalStateException("Session is not open");
         }
 
         if (GeckoThread.isStateAtLeast(GeckoThread.State.PROFILE_READY)) {
             mWindow.close();
-            mWindow.disposeNative();
         } else {
             GeckoThread.queueNativeCallUntil(GeckoThread.State.PROFILE_READY,
                     mWindow, "close");
-            GeckoThread.queueNativeCallUntil(GeckoThread.State.PROFILE_READY,
-                    mWindow, "disposeNative");
         }
 
+        mWindow.disposeNative();
         mWindow = null;
         onWindowChanged();
     }
 
     private void onWindowChanged() {
         if (mWindow != null) {
             mTextInput.onWindowChanged(mWindow);
         }
--- a/mobile/android/installer/Makefile.in
+++ b/mobile/android/installer/Makefile.in
@@ -22,17 +22,16 @@ MOZ_PKG_DUPEFLAGS = -f $(srcdir)/allowed
 DEFINES += -DPKG_LOCALE_MANIFEST=$(topobjdir)/mobile/android/installer/locale-manifest.in
 MOZ_CHROME_LOCALE_ENTRIES=@BINPATH@/chrome/
 
 DEFINES += \
   -DMOZ_APP_NAME=$(MOZ_APP_NAME) \
   -DPREF_DIR=$(PREF_DIR) \
   -DJAREXT= \
   -DMOZ_CHILD_PROCESS_NAME=$(MOZ_CHILD_PROCESS_NAME) \
-  -DMOZ_CHILD_PROCESS_NAME_PIE=$(MOZ_CHILD_PROCESS_NAME_PIE) \
   -DANDROID_CPU_ARCH=$(ANDROID_CPU_ARCH) \
   $(NULL)
 
 ifdef MOZ_DEBUG
 DEFINES += -DMOZ_DEBUG=1
 endif
 
 ifdef MOZ_ANDROID_EXCLUDE_FONTS
--- a/mobile/android/installer/package-manifest.in
+++ b/mobile/android/installer/package-manifest.in
@@ -69,17 +69,16 @@
 #ifndef MOZ_FOLD_LIBS
 @BINPATH@/@DLL_PREFIX@mozsqlite3@DLL_SUFFIX@
 #endif
 
 [lib destdir="lib/@ANDROID_CPU_ARCH@"]
 @BINPATH@/@DLL_PREFIX@mozglue@DLL_SUFFIX@
 # This should be MOZ_CHILD_PROCESS_NAME, but that has a "lib/" prefix.
 @BINPATH@/@MOZ_CHILD_PROCESS_NAME@
-@BINPATH@/@MOZ_CHILD_PROCESS_NAME_PIE@
 
 #ifdef MOZ_ANDROID_GOOGLE_VR
 @BINPATH@/@DLL_PREFIX@gvr@DLL_SUFFIX@
 #endif
 
 [xpcom]
 @BINPATH@/package-name.txt
 @BINPATH@/classes.dex
--- a/netwerk/protocol/http/Http2Session.cpp
+++ b/netwerk/protocol/http/Http2Session.cpp
@@ -440,17 +440,17 @@ Http2Session::AddStream(nsAHttpTransacti
               "transaction (%08x).\n", this, aHttpTransaction, trans,
               static_cast<uint32_t>(rv)));
       }
       return true;
     }
   }
 
   aHttpTransaction->SetConnection(this);
-  aHttpTransaction->OnActivated(true);
+  aHttpTransaction->OnActivated();
 
   if (aUseTunnel) {
     LOG3(("Http2Session::AddStream session=%p trans=%p OnTunnel",
           this, aHttpTransaction));
     DispatchOnTunnel(aHttpTransaction, aCallbacks);
     return true;
   }
 
--- a/netwerk/protocol/http/nsAHttpTransaction.h
+++ b/netwerk/protocol/http/nsAHttpTransaction.h
@@ -42,17 +42,17 @@ class nsAHttpTransaction : public nsSupp
 public:
     NS_DECLARE_STATIC_IID_ACCESSOR(NS_AHTTPTRANSACTION_IID)
 
     // called by the connection when it takes ownership of the transaction.
     virtual void SetConnection(nsAHttpConnection *) = 0;
 
     // called by the connection after a successfull activation of this transaction
     // in other words, tells the transaction it transitioned to the "active" state.
-    virtual void OnActivated(bool h2) {}
+    virtual void OnActivated() {}
 
     // used to obtain the connection associated with this transaction
     virtual nsAHttpConnection *Connection() = 0;
 
     // called by the connection to get security callbacks to set on the
     // socket transport.
     virtual void GetSecurityCallbacks(nsIInterfaceRequestor **) = 0;
 
--- a/netwerk/protocol/http/nsHttpConnection.cpp
+++ b/netwerk/protocol/http/nsHttpConnection.cpp
@@ -725,17 +725,17 @@ nsHttpConnection::Activate(nsAHttpTransa
     }
 
     if (mTLSFilter) {
         rv = mTLSFilter->SetProxiedTransaction(trans);
         NS_ENSURE_SUCCESS(rv, rv);
         mTransaction = mTLSFilter;
     }
 
-    trans->OnActivated(false);
+    trans->OnActivated();
 
     rv = OnOutputStreamReady(mSocketOut);
 
 failed_activation:
     if (NS_FAILED(rv)) {
         mTransaction = nullptr;
     }
 
--- a/netwerk/protocol/http/nsHttpTransaction.cpp
+++ b/netwerk/protocol/http/nsHttpTransaction.cpp
@@ -106,17 +106,16 @@ nsHttpTransaction::nsHttpTransaction()
     , mCurrentHttpResponseHeaderSize(0)
     , mThrottlingReadAllowance(THROTTLE_NO_LIMIT)
     , mCapsToClear(0)
     , mResponseIsComplete(false)
     , mReadingStopped(false)
     , mClosed(false)
     , mConnected(false)
     , mActivated(false)
-    , mActivatedAsH2(false)
     , mHaveStatusLine(false)
     , mHaveAllHeaders(false)
     , mTransactionDone(false)
     , mDidContentStart(false)
     , mNoContent(false)
     , mSentData(false)
     , mReceivedData(false)
     , mStatusEventPending(false)
@@ -170,16 +169,17 @@ void nsHttpTransaction::ResumeReading()
 
     mReadingStopped = false;
 
     // This with either reengage the limit when still throttled in WriteSegments or
     // simply reset to allow unlimeted reading again.
     mThrottlingReadAllowance = THROTTLE_NO_LIMIT;
 
     if (mConnection) {
+        mConnection->TransactionHasDataToRecv(this);
         nsresult rv = mConnection->ResumeRecv();
         if (NS_FAILED(rv)) {
             LOG(("  resume failed with rv=%" PRIx32, static_cast<uint32_t>(rv)));
         }
     }
 }
 
 bool nsHttpTransaction::EligibleForThrottling() const
@@ -534,21 +534,20 @@ nsHttpTransaction::SetConnection(nsAHttp
 {
     {
         MutexAutoLock lock(mLock);
         mConnection = conn;
     }
 }
 
 void
-nsHttpTransaction::OnActivated(bool h2)
+nsHttpTransaction::OnActivated()
 {
     MOZ_ASSERT(OnSocketThread());
 
-    mActivatedAsH2 = h2;
     if (mActivated) {
         return;
     }
 
     mActivated = true;
     gHttpHandler->ConnMgr()->AddActiveTransaction(this);
 }
 
@@ -870,27 +869,16 @@ nsHttpTransaction::WritePipeSegment(nsIO
     if (NS_FAILED(rv))
         trans->Close(rv);
 
     return rv; // failure code only stops WriteSegments; it is not propagated.
 }
 
 bool nsHttpTransaction::ShouldThrottle()
 {
-    if (mActivatedAsH2) {
-        // Throttling feature is now disabled for http/2 transactions
-        // because of bug 1367861.  The logic around mActivatedAsH2
-        // will be removed when that is fixed.
-        // 
-        // Calling ShouldThrottle on the manager just to make sure
-        // the throttling time window is correctly updated by this transaction.
-        Unused << gHttpHandler->ConnMgr()->ShouldThrottle(this);
-        return false;
-    }
-
     if (mClassOfService & nsIClassOfService::DontThrottle) {
         // We deliberately don't touch the throttling window here since
         // DontThrottle requests are expected to be long-standing media
         // streams and would just unnecessarily block running downloads.
         // If we want to ballance bandwidth for media responses against
         // running downloads, we need to find something smarter like 
         // changing the suspend/resume throttling intervals at-runtime.
         return false;
--- a/netwerk/protocol/http/nsHttpTransaction.h
+++ b/netwerk/protocol/http/nsHttpTransaction.h
@@ -85,17 +85,17 @@ public:
                                uint64_t               reqContentLength,
                                bool                   reqBodyIncludesHeaders,
                                nsIEventTarget        *consumerTarget,
                                nsIInterfaceRequestor *callbacks,
                                nsITransportEventSink *eventsink,
                                uint64_t               topLevelOuterContentWindowId,
                                nsIAsyncInputStream  **responseBody);
 
-    void OnActivated(bool h2) override;
+    void OnActivated() override;
 
     // attributes
     nsHttpResponseHead    *ResponseHead()   { return mHaveAllHeaders ? mResponseHead : nullptr; }
     nsISupports           *SecurityInfo()   { return mSecurityInfo; }
 
     nsIEventTarget        *ConsumerTarget() { return mConsumerTarget; }
     nsISupports           *HttpChannel()    { return mChannel; }
 
@@ -344,17 +344,16 @@ private:
     // to resume reading.
     bool                            mReadingStopped;
 
     // state flags, all logically boolean, but not packed together into a
     // bitfield so as to avoid bitfield-induced races.  See bug 560579.
     bool                            mClosed;
     bool                            mConnected;
     bool                            mActivated;
-    bool                            mActivatedAsH2;
     bool                            mHaveStatusLine;
     bool                            mHaveAllHeaders;
     bool                            mTransactionDone;
     bool                            mDidContentStart;
     bool                            mNoContent; // expecting an empty entity body
     bool                            mSentData;
     bool                            mReceivedData;
     bool                            mStatusEventPending;
--- a/old-configure.in
+++ b/old-configure.in
@@ -4426,18 +4426,16 @@ dnl ====================================
 if test "$MOZ_WIDGET_TOOLKIT" != "android"; then
   MOZ_CHILD_PROCESS_NAME="plugin-container${BIN_SUFFIX}"
 else
   # We want to let Android unpack the file at install time, but it only does
   # so if the file is named libsomething.so. The lib/ path is also required
   # because the unpacked file will be under the lib/ subdirectory and will
   # need to be executed from that path.
   MOZ_CHILD_PROCESS_NAME="libplugin-container.so"
-  MOZ_CHILD_PROCESS_NAME_PIE="libplugin-container-pie.so"
-  AC_SUBST(MOZ_CHILD_PROCESS_NAME_PIE)
 fi
 MOZ_CHILD_PROCESS_BUNDLE="plugin-container.app/Contents/MacOS/"
 MOZ_CHILD_PROCESS_BUNDLENAME="${MOZ_APP_DISPLAYNAME}CP"
 
 AC_SUBST(MOZ_CHILD_PROCESS_NAME)
 AC_SUBST(MOZ_CHILD_PROCESS_BUNDLE)
 AC_SUBST(MOZ_CHILD_PROCESS_BUNDLENAME)
 
--- a/servo/components/style/gecko/generated/structs.rs
+++ b/servo/components/style/gecko/generated/structs.rs
@@ -470,17 +470,17 @@ pub type ServoStyleContextStrong = ::gec
         /// A PostTraversalTask is only safe to run immediately after the Servo
         /// traversal, since it can hold raw pointers to DOM objects. 
  # [ repr ( C ) ] # [ derive ( Debug , Copy ) ] pub struct PostTraversalTask { pub mType : root :: mozilla :: PostTraversalTask_Type , pub mTarget : * mut :: std :: os :: raw :: c_void , pub mResult : root :: nsresult , } pub const PostTraversalTask_Type_ResolveFontFaceLoadedPromise : root :: mozilla :: PostTraversalTask_Type = 0 ; pub const PostTraversalTask_Type_RejectFontFaceLoadedPromise : root :: mozilla :: PostTraversalTask_Type = 1 ; pub const PostTraversalTask_Type_DispatchLoadingEventAndReplaceReadyPromise : root :: mozilla :: PostTraversalTask_Type = 2 ; pub const PostTraversalTask_Type_DispatchFontFaceSetCheckLoadingFinishedAfterDelay : root :: mozilla :: PostTraversalTask_Type = 3 ; pub const PostTraversalTask_Type_LoadFontEntry : root :: mozilla :: PostTraversalTask_Type = 4 ; pub type PostTraversalTask_Type = :: std :: os :: raw :: c_int ; # [ test ] fn bindgen_test_layout_PostTraversalTask ( ) { assert_eq ! ( :: std :: mem :: size_of :: < PostTraversalTask > ( ) , 24usize , concat ! ( "Size of: " , stringify ! ( PostTraversalTask ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < PostTraversalTask > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( PostTraversalTask ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const PostTraversalTask ) ) . mType as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( PostTraversalTask ) , "::" , stringify ! ( mType ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const PostTraversalTask ) ) . mTarget as * const _ as usize } , 8usize , concat ! ( "Alignment of field: " , stringify ! ( PostTraversalTask ) , "::" , stringify ! ( mTarget ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const PostTraversalTask ) ) . mResult as * const _ as usize } , 16usize , concat ! ( "Alignment of field: " , stringify ! ( PostTraversalTask ) , "::" , stringify ! ( mResult ) ) ) ; } impl Clone for PostTraversalTask { fn clone ( & self ) -> Self { * self } } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct ServoStyleRuleMap { _unused : [ u8 ; 0 ] } pub const StylistState_NotDirty : root :: mozilla :: StylistState = 0 ; pub const StylistState_StyleSheetsDirty : root :: mozilla :: StylistState = 1 ; pub const StylistState_XBLStyleSheetsDirty : root :: mozilla :: StylistState = 2 ; pub type StylistState = u8 ; pub const OriginFlags_UserAgent : root :: mozilla :: OriginFlags = root :: mozilla :: OriginFlags ( 1 ) ; pub const OriginFlags_User : root :: mozilla :: OriginFlags = root :: mozilla :: OriginFlags ( 2 ) ; pub const OriginFlags_Author : root :: mozilla :: OriginFlags = root :: mozilla :: OriginFlags ( 4 ) ; pub const OriginFlags_All : root :: mozilla :: OriginFlags = root :: mozilla :: OriginFlags ( 7 ) ; impl :: std :: ops :: BitOr < root :: mozilla :: OriginFlags > for root :: mozilla :: OriginFlags { type Output = Self ; # [ inline ] fn bitor ( self , other : Self ) -> Self { OriginFlags ( self . 0 | other . 0 ) } } impl :: std :: ops :: BitOrAssign for root :: mozilla :: OriginFlags { # [ inline ] fn bitor_assign ( & mut self , rhs : root :: mozilla :: OriginFlags ) { self . 0 |= rhs . 0 ; } } impl :: std :: ops :: BitAnd < root :: mozilla :: OriginFlags > for root :: mozilla :: OriginFlags { type Output = Self ; # [ inline ] fn bitand ( self , other : Self ) -> Self { OriginFlags ( self . 0 & other . 0 ) } } impl :: std :: ops :: BitAndAssign for root :: mozilla :: OriginFlags { # [ inline ] fn bitand_assign ( & mut self , rhs : root :: mozilla :: OriginFlags ) { self . 0 &= rhs . 0 ; } } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone , PartialEq , Eq , Hash ) ] pub struct OriginFlags ( pub u8 ) ; 
  /// The set of style sheets that apply to a document, backed by a Servo
         /// Stylist.  A ServoStyleSet contains ServoStyleSheets. 
  # [ repr ( C ) ] pub struct ServoStyleSet { pub mKind : root :: mozilla :: ServoStyleSet_Kind , pub mPresContext : * mut root :: nsPresContext , pub mLastPresContextUsesXBLStyleSet : * mut :: std :: os :: raw :: c_void , pub mRawSet : root :: mozilla :: UniquePtr < root :: RawServoStyleSet > , pub mSheets : [ u64 ; 9usize ] , pub mAuthorStyleDisabled : bool , pub mStylistState : root :: mozilla :: StylistState , pub mUserFontSetUpdateGeneration : u64 , pub mUserFontCacheUpdateGeneration : u32 , pub mNeedsRestyleAfterEnsureUniqueInner : bool , pub mNonInheritingStyleContexts : [ u64 ; 7usize ] , pub mPostTraversalTasks : root :: nsTArray < root :: mozilla :: PostTraversalTask > , pub mStyleRuleMap : root :: mozilla :: UniquePtr < root :: mozilla :: ServoStyleRuleMap > , pub mBindingManager : root :: RefPtr < root :: nsBindingManager > , } pub type ServoStyleSet_SnapshotTable = root :: mozilla :: ServoElementSnapshotTable ; pub const ServoStyleSet_Kind_Master : root :: mozilla :: ServoStyleSet_Kind = 0 ; pub const ServoStyleSet_Kind_ForXBL : root :: mozilla :: ServoStyleSet_Kind = 1 ; pub type ServoStyleSet_Kind = u8 ; extern "C" {
  # [ link_name = "\u{1}_ZN7mozilla13ServoStyleSet17sInServoTraversalE" ] 
  pub static mut  ServoStyleSet_sInServoTraversal  :  * mut root :: mozilla :: ServoStyleSet ;
-} # [ test ] fn bindgen_test_layout_ServoStyleSet ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ServoStyleSet > ( ) , 208usize , concat ! ( "Size of: " , stringify ! ( ServoStyleSet ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ServoStyleSet > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ServoStyleSet ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mKind as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mKind ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mPresContext as * const _ as usize } , 8usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mPresContext ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mLastPresContextUsesXBLStyleSet as * const _ as usize } , 16usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mLastPresContextUsesXBLStyleSet ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mRawSet as * const _ as usize } , 24usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mRawSet ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mSheets as * const _ as usize } , 32usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mSheets ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mAuthorStyleDisabled as * const _ as usize } , 104usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mAuthorStyleDisabled ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mStylistState as * const _ as usize } , 105usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mStylistState ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mUserFontSetUpdateGeneration as * const _ as usize } , 112usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mUserFontSetUpdateGeneration ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mUserFontCacheUpdateGeneration as * const _ as usize } , 120usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mUserFontCacheUpdateGeneration ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mNeedsRestyleAfterEnsureUniqueInner as * const _ as usize } , 124usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mNeedsRestyleAfterEnsureUniqueInner ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mNonInheritingStyleContexts as * const _ as usize } , 128usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mNonInheritingStyleContexts ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mPostTraversalTasks as * const _ as usize } , 184usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mPostTraversalTasks ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mStyleRuleMap as * const _ as usize } , 192usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mStyleRuleMap ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mBindingManager as * const _ as usize } , 200usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mBindingManager ) ) ) ; } # [ repr ( C ) ] pub struct ServoStyleContext { pub _base : root :: nsStyleContext , pub mPresContext : * mut root :: nsPresContext , pub mSource : root :: ServoComputedData , pub mNextInheritingAnonBoxStyle : root :: RefPtr < root :: mozilla :: ServoStyleContext > , pub mNextLazyPseudoStyle : root :: RefPtr < root :: mozilla :: ServoStyleContext > , } # [ test ] fn bindgen_test_layout_ServoStyleContext ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ServoStyleContext > ( ) , 256usize , concat ! ( "Size of: " , stringify ! ( ServoStyleContext ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ServoStyleContext > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ServoStyleContext ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleContext ) ) . mPresContext as * const _ as usize } , 16usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleContext ) , "::" , stringify ! ( mPresContext ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleContext ) ) . mSource as * const _ as usize } , 24usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleContext ) , "::" , stringify ! ( mSource ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleContext ) ) . mNextInheritingAnonBoxStyle as * const _ as usize } , 240usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleContext ) , "::" , stringify ! ( mNextInheritingAnonBoxStyle ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleContext ) ) . mNextLazyPseudoStyle as * const _ as usize } , 248usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleContext ) , "::" , stringify ! ( mNextLazyPseudoStyle ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy ) ] pub struct DeclarationBlock { pub mContainer : root :: mozilla :: DeclarationBlock__bindgen_ty_1 , pub mImmutable : bool , pub mType : root :: mozilla :: StyleBackendType , pub mIsDirty : u32 , } # [ repr ( C ) ] # [ derive ( Debug , Copy ) ] pub struct DeclarationBlock__bindgen_ty_1 { pub mRaw : root :: __BindgenUnionField < usize > , pub mOwningRule : root :: __BindgenUnionField < * mut root :: mozilla :: css :: Rule > , pub mHTMLCSSStyleSheet : root :: __BindgenUnionField < * mut root :: nsHTMLCSSStyleSheet > , pub bindgen_union_field : u64 , } # [ test ] fn bindgen_test_layout_DeclarationBlock__bindgen_ty_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < DeclarationBlock__bindgen_ty_1 > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( DeclarationBlock__bindgen_ty_1 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < DeclarationBlock__bindgen_ty_1 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( DeclarationBlock__bindgen_ty_1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock__bindgen_ty_1 ) ) . mRaw as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock__bindgen_ty_1 ) , "::" , stringify ! ( mRaw ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock__bindgen_ty_1 ) ) . mOwningRule as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock__bindgen_ty_1 ) , "::" , stringify ! ( mOwningRule ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock__bindgen_ty_1 ) ) . mHTMLCSSStyleSheet as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock__bindgen_ty_1 ) , "::" , stringify ! ( mHTMLCSSStyleSheet ) ) ) ; } impl Clone for DeclarationBlock__bindgen_ty_1 { fn clone ( & self ) -> Self { * self } } # [ test ] fn bindgen_test_layout_DeclarationBlock ( ) { assert_eq ! ( :: std :: mem :: size_of :: < DeclarationBlock > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( DeclarationBlock ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < DeclarationBlock > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( DeclarationBlock ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock ) ) . mContainer as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock ) , "::" , stringify ! ( mContainer ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock ) ) . mImmutable as * const _ as usize } , 8usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock ) , "::" , stringify ! ( mImmutable ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock ) ) . mType as * const _ as usize } , 9usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock ) , "::" , stringify ! ( mType ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock ) ) . mIsDirty as * const _ as usize } , 12usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock ) , "::" , stringify ! ( mIsDirty ) ) ) ; } impl Clone for DeclarationBlock { fn clone ( & self ) -> Self { * self } } # [ repr ( C ) ] # [ derive ( Debug ) ] pub struct ServoDeclarationBlock { pub _base : root :: mozilla :: DeclarationBlock , pub mRefCnt : root :: mozilla :: ThreadSafeAutoRefCnt , pub mRaw : root :: RefPtr < root :: RawServoDeclarationBlock > , } pub type ServoDeclarationBlock_HasThreadSafeRefCnt = root :: mozilla :: TrueType ; # [ test ] fn bindgen_test_layout_ServoDeclarationBlock ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ServoDeclarationBlock > ( ) , 32usize , concat ! ( "Size of: " , stringify ! ( ServoDeclarationBlock ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ServoDeclarationBlock > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ServoDeclarationBlock ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoDeclarationBlock ) ) . mRefCnt as * const _ as usize } , 16usize , concat ! ( "Alignment of field: " , stringify ! ( ServoDeclarationBlock ) , "::" , stringify ! ( mRefCnt ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoDeclarationBlock ) ) . mRaw as * const _ as usize } , 24usize , concat ! ( "Alignment of field: " , stringify ! ( ServoDeclarationBlock ) , "::" , stringify ! ( mRaw ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug ) ] pub struct CSSFontFaceDescriptors { pub mFamily : root :: nsCSSValue , pub mStyle : root :: nsCSSValue , pub mWeight : root :: nsCSSValue , pub mStretch : root :: nsCSSValue , pub mSrc : root :: nsCSSValue , pub mUnicodeRange : root :: nsCSSValue , pub mFontFeatureSettings : root :: nsCSSValue , pub mFontLanguageOverride : root :: nsCSSValue , pub mDisplay : root :: nsCSSValue , } extern "C" {
+} # [ test ] fn bindgen_test_layout_ServoStyleSet ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ServoStyleSet > ( ) , 208usize , concat ! ( "Size of: " , stringify ! ( ServoStyleSet ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ServoStyleSet > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ServoStyleSet ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mKind as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mKind ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mPresContext as * const _ as usize } , 8usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mPresContext ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mLastPresContextUsesXBLStyleSet as * const _ as usize } , 16usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mLastPresContextUsesXBLStyleSet ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mRawSet as * const _ as usize } , 24usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mRawSet ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mSheets as * const _ as usize } , 32usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mSheets ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mAuthorStyleDisabled as * const _ as usize } , 104usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mAuthorStyleDisabled ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mStylistState as * const _ as usize } , 105usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mStylistState ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mUserFontSetUpdateGeneration as * const _ as usize } , 112usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mUserFontSetUpdateGeneration ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mUserFontCacheUpdateGeneration as * const _ as usize } , 120usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mUserFontCacheUpdateGeneration ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mNeedsRestyleAfterEnsureUniqueInner as * const _ as usize } , 124usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mNeedsRestyleAfterEnsureUniqueInner ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mNonInheritingStyleContexts as * const _ as usize } , 128usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mNonInheritingStyleContexts ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mPostTraversalTasks as * const _ as usize } , 184usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mPostTraversalTasks ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mStyleRuleMap as * const _ as usize } , 192usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mStyleRuleMap ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleSet ) ) . mBindingManager as * const _ as usize } , 200usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleSet ) , "::" , stringify ! ( mBindingManager ) ) ) ; } # [ repr ( C ) ] pub struct ServoStyleContext { pub _base : root :: nsStyleContext , pub mPresContext : * mut root :: nsPresContext , pub mSource : root :: ServoComputedData , pub mNextInheritingAnonBoxStyle : root :: RefPtr < root :: mozilla :: ServoStyleContext > , } # [ test ] fn bindgen_test_layout_ServoStyleContext ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ServoStyleContext > ( ) , 248usize , concat ! ( "Size of: " , stringify ! ( ServoStyleContext ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ServoStyleContext > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ServoStyleContext ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleContext ) ) . mPresContext as * const _ as usize } , 16usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleContext ) , "::" , stringify ! ( mPresContext ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleContext ) ) . mSource as * const _ as usize } , 24usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleContext ) , "::" , stringify ! ( mSource ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoStyleContext ) ) . mNextInheritingAnonBoxStyle as * const _ as usize } , 240usize , concat ! ( "Alignment of field: " , stringify ! ( ServoStyleContext ) , "::" , stringify ! ( mNextInheritingAnonBoxStyle ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy ) ] pub struct DeclarationBlock { pub mContainer : root :: mozilla :: DeclarationBlock__bindgen_ty_1 , pub mImmutable : bool , pub mType : root :: mozilla :: StyleBackendType , pub mIsDirty : u32 , } # [ repr ( C ) ] # [ derive ( Debug , Copy ) ] pub struct DeclarationBlock__bindgen_ty_1 { pub mRaw : root :: __BindgenUnionField < usize > , pub mOwningRule : root :: __BindgenUnionField < * mut root :: mozilla :: css :: Rule > , pub mHTMLCSSStyleSheet : root :: __BindgenUnionField < * mut root :: nsHTMLCSSStyleSheet > , pub bindgen_union_field : u64 , } # [ test ] fn bindgen_test_layout_DeclarationBlock__bindgen_ty_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < DeclarationBlock__bindgen_ty_1 > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( DeclarationBlock__bindgen_ty_1 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < DeclarationBlock__bindgen_ty_1 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( DeclarationBlock__bindgen_ty_1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock__bindgen_ty_1 ) ) . mRaw as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock__bindgen_ty_1 ) , "::" , stringify ! ( mRaw ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock__bindgen_ty_1 ) ) . mOwningRule as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock__bindgen_ty_1 ) , "::" , stringify ! ( mOwningRule ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock__bindgen_ty_1 ) ) . mHTMLCSSStyleSheet as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock__bindgen_ty_1 ) , "::" , stringify ! ( mHTMLCSSStyleSheet ) ) ) ; } impl Clone for DeclarationBlock__bindgen_ty_1 { fn clone ( & self ) -> Self { * self } } # [ test ] fn bindgen_test_layout_DeclarationBlock ( ) { assert_eq ! ( :: std :: mem :: size_of :: < DeclarationBlock > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( DeclarationBlock ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < DeclarationBlock > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( DeclarationBlock ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock ) ) . mContainer as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock ) , "::" , stringify ! ( mContainer ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock ) ) . mImmutable as * const _ as usize } , 8usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock ) , "::" , stringify ! ( mImmutable ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock ) ) . mType as * const _ as usize } , 9usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock ) , "::" , stringify ! ( mType ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const DeclarationBlock ) ) . mIsDirty as * const _ as usize } , 12usize , concat ! ( "Alignment of field: " , stringify ! ( DeclarationBlock ) , "::" , stringify ! ( mIsDirty ) ) ) ; } impl Clone for DeclarationBlock { fn clone ( & self ) -> Self { * self } } # [ repr ( C ) ] # [ derive ( Debug ) ] pub struct ServoDeclarationBlock { pub _base : root :: mozilla :: DeclarationBlock , pub mRefCnt : root :: mozilla :: ThreadSafeAutoRefCnt , pub mRaw : root :: RefPtr < root :: RawServoDeclarationBlock > , } pub type ServoDeclarationBlock_HasThreadSafeRefCnt = root :: mozilla :: TrueType ; # [ test ] fn bindgen_test_layout_ServoDeclarationBlock ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ServoDeclarationBlock > ( ) , 32usize , concat ! ( "Size of: " , stringify ! ( ServoDeclarationBlock ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ServoDeclarationBlock > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( ServoDeclarationBlock ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoDeclarationBlock ) ) . mRefCnt as * const _ as usize } , 16usize , concat ! ( "Alignment of field: " , stringify ! ( ServoDeclarationBlock ) , "::" , stringify ! ( mRefCnt ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const ServoDeclarationBlock ) ) . mRaw as * const _ as usize } , 24usize , concat ! ( "Alignment of field: " , stringify ! ( ServoDeclarationBlock ) , "::" , stringify ! ( mRaw ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug ) ] pub struct CSSFontFaceDescriptors { pub mFamily : root :: nsCSSValue , pub mStyle : root :: nsCSSValue , pub mWeight : root :: nsCSSValue , pub mStretch : root :: nsCSSValue , pub mSrc : root :: nsCSSValue , pub mUnicodeRange : root :: nsCSSValue , pub mFontFeatureSettings : root :: nsCSSValue , pub mFontLanguageOverride : root :: nsCSSValue , pub mDisplay : root :: nsCSSValue , } extern "C" {
  # [ link_name = "\u{1}_ZN7mozilla22CSSFontFaceDescriptors6FieldsE" ] 
  pub static mut  CSSFontFaceDescriptors_Fields  :  [ * const root :: nsCSSValue ; 0usize ] ;
 } # [ test ] fn bindgen_test_layout_CSSFontFaceDescriptors ( ) { assert_eq ! ( :: std :: mem :: size_of :: < CSSFontFaceDescriptors > ( ) , 144usize , concat ! ( "Size of: " , stringify ! ( CSSFontFaceDescriptors ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < CSSFontFaceDescriptors > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( CSSFontFaceDescriptors ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const CSSFontFaceDescriptors ) ) . mFamily as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( CSSFontFaceDescriptors ) , "::" , stringify ! ( mFamily ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const CSSFontFaceDescriptors ) ) . mStyle as * const _ as usize } , 16usize , concat ! ( "Alignment of field: " , stringify ! ( CSSFontFaceDescriptors ) , "::" , stringify ! ( mStyle ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const CSSFontFaceDescriptors ) ) . mWeight as * const _ as usize } , 32usize , concat ! ( "Alignment of field: " , stringify ! ( CSSFontFaceDescriptors ) , "::" , stringify ! ( mWeight ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const CSSFontFaceDescriptors ) ) . mStretch as * const _ as usize } , 48usize , concat ! ( "Alignment of field: " , stringify ! ( CSSFontFaceDescriptors ) , "::" , stringify ! ( mStretch ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const CSSFontFaceDescriptors ) ) . mSrc as * const _ as usize } , 64usize , concat ! ( "Alignment of field: " , stringify ! ( CSSFontFaceDescriptors ) , "::" , stringify ! ( mSrc ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const CSSFontFaceDescriptors ) ) . mUnicodeRange as * const _ as usize } , 80usize , concat ! ( "Alignment of field: " , stringify ! ( CSSFontFaceDescriptors ) , "::" , stringify ! ( mUnicodeRange ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const CSSFontFaceDescriptors ) ) . mFontFeatureSettings as * const _ as usize } , 96usize , concat ! ( "Alignment of field: " , stringify ! ( CSSFontFaceDescriptors ) , "::" , stringify ! ( mFontFeatureSettings ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const CSSFontFaceDescriptors ) ) . mFontLanguageOverride as * const _ as usize } , 112usize , concat ! ( "Alignment of field: " , stringify ! ( CSSFontFaceDescriptors ) , "::" , stringify ! ( mFontLanguageOverride ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const CSSFontFaceDescriptors ) ) . mDisplay as * const _ as usize } , 128usize , concat ! ( "Alignment of field: " , stringify ! ( CSSFontFaceDescriptors ) , "::" , stringify ! ( mDisplay ) ) ) ; } pub mod intl { # [ allow ( unused_imports ) ] use self :: super :: super :: super :: root ; # [ repr ( C ) ] # [ derive ( Debug ) ] pub struct LineBreaker { pub mRefCnt : root :: nsAutoRefCnt , } pub type LineBreaker_HasThreadSafeRefCnt = root :: mozilla :: FalseType ; pub const LineBreaker_kWordBreak_Normal : root :: mozilla :: intl :: LineBreaker__bindgen_ty_1 = 0 ; pub const LineBreaker_kWordBreak_BreakAll : root :: mozilla :: intl :: LineBreaker__bindgen_ty_1 = 1 ; pub const LineBreaker_kWordBreak_KeepAll : root :: mozilla :: intl :: LineBreaker__bindgen_ty_1 = 2 ; pub type LineBreaker__bindgen_ty_1 = :: std :: os :: raw :: c_uint ; # [ test ] fn bindgen_test_layout_LineBreaker ( ) { assert_eq ! ( :: std :: mem :: size_of :: < LineBreaker > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( LineBreaker ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < LineBreaker > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( LineBreaker ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const LineBreaker ) ) . mRefCnt as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( LineBreaker ) , "::" , stringify ! ( mRefCnt ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug ) ] pub struct WordBreaker { pub mRefCnt : root :: nsAutoRefCnt , } pub type WordBreaker_HasThreadSafeRefCnt = root :: mozilla :: FalseType ; # [ test ] fn bindgen_test_layout_WordBreaker ( ) { assert_eq ! ( :: std :: mem :: size_of :: < WordBreaker > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( WordBreaker ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < WordBreaker > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( WordBreaker ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const WordBreaker ) ) . mRefCnt as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( WordBreaker ) , "::" , stringify ! ( mRefCnt ) ) ) ; } } } # [ repr ( C ) ] # [ derive ( Debug , Copy ) ] pub struct InfallibleAllocPolicy { pub _address : u8 , } # [ test ] fn bindgen_test_layout_InfallibleAllocPolicy ( ) { assert_eq ! ( :: std :: mem :: size_of :: < InfallibleAllocPolicy > ( ) , 1usize , concat ! ( "Size of: " , stringify ! ( InfallibleAllocPolicy ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < InfallibleAllocPolicy > ( ) , 1usize , concat ! ( "Alignment of " , stringify ! ( InfallibleAllocPolicy ) ) ) ; } impl Clone for InfallibleAllocPolicy { fn clone ( & self ) -> Self { * self } } 
  /// MozRefCountType is Mozilla's reference count type.
     ///
     /// We use the same type to represent the refcount of RefCounted objects
     /// as well, in order to be able to use the leak detection facilities
     /// that are implemented by XPCOM.
@@ -2029,9 +2029,9 @@ pub type ServoStyleContextStrong = ::gec
  # [ link_name = "\u{1}_ZN14nsContentUtils24sInnerOrOuterWindowCountE" ] 
  pub static mut  nsContentUtils_sInnerOrOuterWindowCount  :  i32 ;
 } extern "C" {
  # [ link_name = "\u{1}_ZN14nsContentUtils32sInnerOrOuterWindowSerialCounterE" ] 
  pub static mut  nsContentUtils_sInnerOrOuterWindowSerialCounter  :  u32 ;
 } pub type nsMediaFeatureValueGetter = :: std :: option :: Option < unsafe extern "C" fn ( aPresContext : * mut root :: nsPresContext , aFeature : * const root :: nsMediaFeature , aResult : * mut root :: nsCSSValue ) > ; # [ repr ( C ) ] # [ derive ( Debug , Copy ) ] pub struct nsMediaFeature { pub mName : * mut * mut root :: nsStaticAtom , pub mRangeType : root :: nsMediaFeature_RangeType , pub mValueType : root :: nsMediaFeature_ValueType , pub mReqFlags : u8 , pub mData : root :: nsMediaFeature__bindgen_ty_1 , pub mGetter : root :: nsMediaFeatureValueGetter , } # [ repr ( u32 ) ] # [ derive ( Debug , Copy , Clone , PartialEq , Eq , Hash ) ] pub enum nsMediaFeature_RangeType { eMinMaxAllowed = 0 , eMinMaxNotAllowed = 1 , } # [ repr ( u32 ) ] # [ derive ( Debug , Copy , Clone , PartialEq , Eq , Hash ) ] pub enum nsMediaFeature_ValueType { eLength = 0 , eInteger = 1 , eFloat = 2 , eBoolInteger = 3 , eIntRatio = 4 , eResolution = 5 , eEnumerated = 6 , eIdent = 7 , } pub const nsMediaFeature_RequirementFlags_eNoRequirements : root :: nsMediaFeature_RequirementFlags = 0 ; pub const nsMediaFeature_RequirementFlags_eHasWebkitPrefix : root :: nsMediaFeature_RequirementFlags = 1 ; pub const nsMediaFeature_RequirementFlags_eWebkitDevicePixelRatioPrefEnabled : root :: nsMediaFeature_RequirementFlags = 2 ; pub const nsMediaFeature_RequirementFlags_eUserAgentAndChromeOnly : root :: nsMediaFeature_RequirementFlags = 4 ; pub type nsMediaFeature_RequirementFlags = u8 ; # [ repr ( C ) ] # [ derive ( Debug , Copy ) ] pub struct nsMediaFeature__bindgen_ty_1 { pub mInitializer_ : root :: __BindgenUnionField < * const :: std :: os :: raw :: c_void > , pub mKeywordTable : root :: __BindgenUnionField < * const root :: nsCSSProps_KTableEntry > , pub mMetric : root :: __BindgenUnionField < * const * const root :: nsAtom > , pub bindgen_union_field : u64 , } # [ test ] fn bindgen_test_layout_nsMediaFeature__bindgen_ty_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < nsMediaFeature__bindgen_ty_1 > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( nsMediaFeature__bindgen_ty_1 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < nsMediaFeature__bindgen_ty_1 > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( nsMediaFeature__bindgen_ty_1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const nsMediaFeature__bindgen_ty_1 ) ) . mInitializer_ as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( nsMediaFeature__bindgen_ty_1 ) , "::" , stringify ! ( mInitializer_ ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const nsMediaFeature__bindgen_ty_1 ) ) . mKeywordTable as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( nsMediaFeature__bindgen_ty_1 ) , "::" , stringify ! ( mKeywordTable ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const nsMediaFeature__bindgen_ty_1 ) ) . mMetric as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( nsMediaFeature__bindgen_ty_1 ) , "::" , stringify ! ( mMetric ) ) ) ; } impl Clone for nsMediaFeature__bindgen_ty_1 { fn clone ( & self ) -> Self { * self } } # [ test ] fn bindgen_test_layout_nsMediaFeature ( ) { assert_eq ! ( :: std :: mem :: size_of :: < nsMediaFeature > ( ) , 40usize , concat ! ( "Size of: " , stringify ! ( nsMediaFeature ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < nsMediaFeature > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( nsMediaFeature ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const nsMediaFeature ) ) . mName as * const _ as usize } , 0usize , concat ! ( "Alignment of field: " , stringify ! ( nsMediaFeature ) , "::" , stringify ! ( mName ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const nsMediaFeature ) ) . mRangeType as * const _ as usize } , 8usize , concat ! ( "Alignment of field: " , stringify ! ( nsMediaFeature ) , "::" , stringify ! ( mRangeType ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const nsMediaFeature ) ) . mValueType as * const _ as usize } , 12usize , concat ! ( "Alignment of field: " , stringify ! ( nsMediaFeature ) , "::" , stringify ! ( mValueType ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const nsMediaFeature ) ) . mReqFlags as * const _ as usize } , 16usize , concat ! ( "Alignment of field: " , stringify ! ( nsMediaFeature ) , "::" , stringify ! ( mReqFlags ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const nsMediaFeature ) ) . mData as * const _ as usize } , 24usize , concat ! ( "Alignment of field: " , stringify ! ( nsMediaFeature ) , "::" , stringify ! ( mData ) ) ) ; assert_eq ! ( unsafe { & ( * ( 0 as * const nsMediaFeature ) ) . mGetter as * const _ as usize } , 32usize , concat ! ( "Alignment of field: " , stringify ! ( nsMediaFeature ) , "::" , stringify ! ( mGetter ) ) ) ; } impl Clone for nsMediaFeature { fn clone ( & self ) -> Self { * self } } # [ repr ( C ) ] # [ derive ( Debug , Copy ) ] pub struct nsMediaFeatures { pub _address : u8 , } extern "C" {
  # [ link_name = "\u{1}_ZN15nsMediaFeatures8featuresE" ] 
  pub static mut  nsMediaFeatures_features  :  [ root :: nsMediaFeature ; 0usize ] ;
-} # [ test ] fn bindgen_test_layout_nsMediaFeatures ( ) { assert_eq ! ( :: std :: mem :: size_of :: < nsMediaFeatures > ( ) , 1usize , concat ! ( "Size of: " , stringify ! ( nsMediaFeatures ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < nsMediaFeatures > ( ) , 1usize , concat ! ( "Alignment of " , stringify ! ( nsMediaFeatures ) ) ) ; } impl Clone for nsMediaFeatures { fn clone ( & self ) -> Self { * self } } # [ test ] fn __bindgen_test_layout_nsTSubstring_open0_char16_t_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTSubstring < u16 > > ( ) , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTSubstring < u16 > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTSubstring < u16 > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTSubstring < u16 > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTString_open0_char16_t_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < ::nsstring::nsStringRepr > ( ) , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( ::nsstring::nsStringRepr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < ::nsstring::nsStringRepr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( ::nsstring::nsStringRepr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTSubstring_open0_char_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTSubstring < :: std :: os :: raw :: c_char > > ( ) , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTSubstring < :: std :: os :: raw :: c_char > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTSubstring < :: std :: os :: raw :: c_char > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTSubstring < :: std :: os :: raw :: c_char > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTString_open0_char_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTString < :: std :: os :: raw :: c_char > > ( ) , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTString < :: std :: os :: raw :: c_char > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTString < :: std :: os :: raw :: c_char > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTString < :: std :: os :: raw :: c_char > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsISupports_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_CSSVariableValues_Variable_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: mozilla :: CSSVariableValues_Variable > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: CSSVariableValues_Variable > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: mozilla :: CSSVariableValues_Variable > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: CSSVariableValues_Variable > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_FontFamilyName_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: mozilla :: FontFamilyName > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: FontFamilyName > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: mozilla :: FontFamilyName > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: FontFamilyName > ) ) ) ; } # [ test ] fn __bindgen_test_layout_NotNull_open0_RefPtr_open1_SharedFontList_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: NotNull < root :: RefPtr < root :: mozilla :: SharedFontList > > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: NotNull < root :: RefPtr < root :: mozilla :: SharedFontList > > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: NotNull < root :: RefPtr < root :: mozilla :: SharedFontList > > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: NotNull < root :: RefPtr < root :: mozilla :: SharedFontList > > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_SharedFontList_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: SharedFontList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: SharedFontList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: SharedFontList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: SharedFontList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_uint32_t_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < u32 > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < u32 > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < u32 > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < u32 > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_gfxFontFeatureValueSet_ValueList_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: gfxFontFeatureValueSet_ValueList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: gfxFontFeatureValueSet_ValueList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: gfxFontFeatureValueSet_ValueList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: gfxFontFeatureValueSet_ValueList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_uint32_t_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < u32 > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < u32 > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < u32 > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < u32 > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_gfxAlternateValue_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: gfxAlternateValue > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: gfxAlternateValue > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: gfxAlternateValue > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: gfxAlternateValue > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_gfxFontFeatureValueSet_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: gfxFontFeatureValueSet > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: gfxFontFeatureValueSet > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: gfxFontFeatureValueSet > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: gfxFontFeatureValueSet > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_gfxFontFeature_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: gfxFontFeature > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: gfxFontFeature > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: gfxFontFeature > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: gfxFontFeature > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_gfxFontVariation_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: gfxFontVariation > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: gfxFontVariation > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: gfxFontVariation > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: gfxFontVariation > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_nsAtom_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: RefPtr < root :: nsAtom > > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: RefPtr < root :: nsAtom > > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: RefPtr < root :: nsAtom > > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: RefPtr < root :: nsAtom > > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_BaseTimeDuration_open0_TimeDurationValueCalculator_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: BaseTimeDuration > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: BaseTimeDuration ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: BaseTimeDuration > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: BaseTimeDuration ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_JSErrorNotes_Note_DeletePolicy_open1_JSErrorNotes_Note_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DeletePolicy_open0_JSErrorNotes_Note_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_JSErrorNotes_DeletePolicy_open1_JSErrorNotes_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DeletePolicy_open0_JSErrorNotes_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; } # [ test ] fn __bindgen_test_layout_iterator_open0_input_iterator_tag_UniquePtr_open1_JSErrorNotes_Note_DeletePolicy_open2_JSErrorNotes_Note_close2_close1_long_ptr_UniquePtr_ref_UniquePtr_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: std :: iterator > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: std :: iterator ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: std :: iterator > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: std :: iterator ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_JSErrorNotes_Note_DeletePolicy_open1_JSErrorNotes_Note_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DeletePolicy_open0_JSErrorNotes_Note_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_JSErrorNotes_Note_DeletePolicy_open1_JSErrorNotes_Note_close1_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DeletePolicy_open0_JSErrorNotes_Note_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_JSErrorNotes_Note_DeletePolicy_open1_JSErrorNotes_Note_close1_close0_instantiation_3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DeletePolicy_open0_JSErrorNotes_Note_close0_instantiation_3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_JSErrorNotes_Note_DeletePolicy_open1_JSErrorNotes_Note_close1_close0_instantiation_4 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DeletePolicy_open0_JSErrorNotes_Note_close0_instantiation_4 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_JSErrorNotes_Note_DeletePolicy_open1_JSErrorNotes_Note_close1_close0_instantiation_5 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes_Note > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DeletePolicy_open0_JSErrorNotes_Note_close0_instantiation_5 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_JSErrorNotes_DeletePolicy_open1_JSErrorNotes_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: JSErrorNotes > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: JSErrorNotes > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DeletePolicy_open0_JSErrorNotes_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: JS :: DeletePolicy > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: JS :: DeletePolicy ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_StyleSheet_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: StyleSheet > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: StyleSheet > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: StyleSheet > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: StyleSheet > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_MediaList_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: MediaList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: MediaList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: MediaList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: MediaList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_StyleSheet_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: StyleSheet > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: StyleSheet > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: StyleSheet > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: StyleSheet > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_StyleSetHandle_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: mozilla :: StyleSetHandle > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: StyleSetHandle > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: mozilla :: StyleSetHandle > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: StyleSetHandle > ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_ProfilerBacktrace_ProfilerBacktraceDestructor_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: ProfilerBacktrace > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: ProfilerBacktrace > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: ProfilerBacktrace > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: ProfilerBacktrace > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsNodeInfoManager_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsNodeInfoManager > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsNodeInfoManager > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsNodeInfoManager > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsNodeInfoManager > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIPrincipal_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIPrincipal_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsBindingManager_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsBindingManager > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsBindingManager > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsBindingManager > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsBindingManager > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAttrChildContentList_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAttrChildContentList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAttrChildContentList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAttrChildContentList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAttrChildContentList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_LinkedList_open1_nsRange_close1_DefaultDelete_open1_LinkedList_open2_nsRange_close2_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: LinkedList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: LinkedList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: LinkedList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: LinkedList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_LinkedList_open1_nsRange_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_LinkedList_open1_nsRange_close1_DefaultDelete_open1_LinkedList_open2_nsRange_close2_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: LinkedList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: LinkedList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: LinkedList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: LinkedList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_LinkedList_open1_nsRange_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_NodeInfo_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: NodeInfo > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: NodeInfo > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: NodeInfo > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: NodeInfo > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIContent_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_ShadowRoot_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: ShadowRoot > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: ShadowRoot > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: ShadowRoot > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: ShadowRoot > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_HTMLSlotElement_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: HTMLSlotElement > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: HTMLSlotElement > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: HTMLSlotElement > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: HTMLSlotElement > ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsIContent_nsExtendedContentSlots_DefaultDelete_open1_nsIContent_nsExtendedContentSlots_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsIContent_nsExtendedContentSlots > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsIContent_nsExtendedContentSlots > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsIContent_nsExtendedContentSlots > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsIContent_nsExtendedContentSlots > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsIContent_nsExtendedContentSlots_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIWeakReference_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_ptr_void_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < * mut :: std :: os :: raw :: c_void > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < * mut :: std :: os :: raw :: c_void > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < * mut :: std :: os :: raw :: c_void > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < * mut :: std :: os :: raw :: c_void > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsPtrHashKey_open0_void_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsPtrHashKey < :: std :: os :: raw :: c_void > > ( ) , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsPtrHashKey < :: std :: os :: raw :: c_void > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsPtrHashKey < :: std :: os :: raw :: c_void > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsPtrHashKey < :: std :: os :: raw :: c_void > ) ) ) ; } # [ test ] fn __bindgen_test_layout_StaticRefPtr_open0_nsIContent_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: StaticRefPtr < root :: nsIContent > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: StaticRefPtr < root :: nsIContent > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: StaticRefPtr < root :: nsIContent > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: StaticRefPtr < root :: nsIContent > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIDocument_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsPresContext_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsPresContext > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsPresContext > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsPresContext > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsPresContext > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsFrameSelection_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsFrameSelection > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsFrameSelection > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsFrameSelection > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsFrameSelection > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsITimer_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsPtrHashKey_open0_WeakFrame_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsPtrHashKey < root :: WeakFrame > > ( ) , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsPtrHashKey < root :: WeakFrame > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsPtrHashKey < root :: WeakFrame > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsPtrHashKey < root :: WeakFrame > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsRefPtrHashKey_open0_nsAtom_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsRefPtrHashKey < root :: nsAtom > > ( ) , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsRefPtrHashKey < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsRefPtrHashKey < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsRefPtrHashKey < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsCString_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsCString > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsCString > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsCString > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsCString > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_EventTarget_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIDocument_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_EventTarget_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_Performance_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: Performance > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: Performance > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: Performance > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: Performance > ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_TimeoutManager_DefaultDelete_open1_TimeoutManager_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: dom :: TimeoutManager > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: dom :: TimeoutManager > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: dom :: TimeoutManager > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: dom :: TimeoutManager > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_TimeoutManager_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsPIDOMWindowOuter_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIContent_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_ptr_AudioContext_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < * mut root :: mozilla :: dom :: AudioContext > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < * mut root :: mozilla :: dom :: AudioContext > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < * mut root :: mozilla :: dom :: AudioContext > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < * mut root :: mozilla :: dom :: AudioContext > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_TabGroup_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: TabGroup > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: TabGroup > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: TabGroup > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: TabGroup > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsPIDOMWindowInner_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_EventTarget_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIDocument_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_EventTarget_close0_instantiation_3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_Element_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIDocShell_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_TabGroup_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: TabGroup > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: TabGroup > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: TabGroup > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: TabGroup > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsPIDOMWindowOuter_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_4 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsBaseContentList_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsBaseContentList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsBaseContentList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsBaseContentList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsBaseContentList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsAutoPtr_open0_nsTHashtable_open1_nsIdentifierMapEntry_ChangeCallbackEntry_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < u64 > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( u64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < u64 > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( u64 ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsIdentifierMapEntry_Element_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsIdentifierMapEntry_Element > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsIdentifierMapEntry_Element > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsIdentifierMapEntry_Element > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsIdentifierMapEntry_Element > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_StyleSheet_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: RefPtr < root :: mozilla :: StyleSheet > > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: RefPtr < root :: mozilla :: StyleSheet > > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: RefPtr < root :: mozilla :: StyleSheet > > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: RefPtr < root :: mozilla :: StyleSheet > > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_StyleSheet_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: StyleSheet > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: StyleSheet > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: StyleSheet > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: StyleSheet > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_StyleSheetList_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: StyleSheetList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: StyleSheetList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: StyleSheetList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: StyleSheetList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_RawServoAnimationValue_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: RawServoAnimationValue > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: RawServoAnimationValue > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: RawServoAnimationValue > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: RawServoAnimationValue > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_PropertyValuePair_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: mozilla :: PropertyValuePair > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: PropertyValuePair > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: mozilla :: PropertyValuePair > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: PropertyValuePair > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsStyleAutoArray_open0_StyleAnimation_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsStyleAutoArray < root :: mozilla :: StyleAnimation > > ( ) , 56usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsStyleAutoArray < root :: mozilla :: StyleAnimation > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsStyleAutoArray < root :: mozilla :: StyleAnimation > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsStyleAutoArray < root :: mozilla :: StyleAnimation > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIDocument_close0_instantiation_3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_RawServoSelectorList_DefaultDelete_open1_RawServoSelectorList_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: RawServoSelectorList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: RawServoSelectorList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: RawServoSelectorList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: RawServoSelectorList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_RawServoSelectorList_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsCSSSelectorList_DefaultDelete_open1_nsCSSSelectorList_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsCSSSelectorList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsCSSSelectorList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsCSSSelectorList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsCSSSelectorList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsCSSSelectorList_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsCSSSelectorList_DefaultDelete_open1_nsCSSSelectorList_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsCSSSelectorList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsCSSSelectorList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsCSSSelectorList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsCSSSelectorList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsCSSSelectorList_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_RawServoSelectorList_DefaultDelete_open1_RawServoSelectorList_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: RawServoSelectorList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: RawServoSelectorList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: RawServoSelectorList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: RawServoSelectorList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_RawServoSelectorList_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIObserver_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsIDocument_SelectorCache_DefaultDelete_open1_nsIDocument_SelectorCache_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsIDocument_SelectorCache > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsIDocument_SelectorCache > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsIDocument_SelectorCache > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsIDocument_SelectorCache > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsIDocument_SelectorCache_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsIDocument_SelectorCache_DefaultDelete_open1_nsIDocument_SelectorCache_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsIDocument_SelectorCache > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsIDocument_SelectorCache > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsIDocument_SelectorCache > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsIDocument_SelectorCache > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsIDocument_SelectorCache_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_5 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_6 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_7 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_8 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_9 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_URLExtraData_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: URLExtraData > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: URLExtraData > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: URLExtraData > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: URLExtraData > ) ) ) ; } # [ test ] fn __bindgen_test_layout_NotNull_open0_ptr_const_nsIDocument__Encoding_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: NotNull < * const root :: nsIDocument_Encoding > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: NotNull < * const root :: nsIDocument_Encoding > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: NotNull < * const root :: nsIDocument_Encoding > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: NotNull < * const root :: nsIDocument_Encoding > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_Loader_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: css :: Loader > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: Loader > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: css :: Loader > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: Loader > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_ImageLoader_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: css :: ImageLoader > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: ImageLoader > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: css :: ImageLoader > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: ImageLoader > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsHTMLStyleSheet_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsHTMLStyleSheet > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsHTMLStyleSheet > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsHTMLStyleSheet > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsHTMLStyleSheet > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsHTMLCSSStyleSheet_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsHTMLCSSStyleSheet > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsHTMLCSSStyleSheet > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsHTMLCSSStyleSheet > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsHTMLCSSStyleSheet > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_ImageTracker_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: ImageTracker > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: ImageTracker > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: ImageTracker > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: ImageTracker > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsAutoPtr_open0_nsTHashtable_open1_nsPtrHashKey_open2_nsISupports_close2_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < u64 > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( u64 ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < u64 > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( u64 ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_Link_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsSMILAnimationController_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsSMILAnimationController > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsSMILAnimationController > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsSMILAnimationController > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsSMILAnimationController > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsAutoPtr_open1_nsPropertyTable_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsAutoPtr < root :: nsPropertyTable > > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsAutoPtr < root :: nsPropertyTable > > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsAutoPtr < root :: nsPropertyTable > > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsAutoPtr < root :: nsPropertyTable > > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIHTMLCollection_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_FontFaceSet_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: FontFaceSet > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: FontFaceSet > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: FontFaceSet > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: FontFaceSet > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIScriptGlobalObject_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIDocument_close0_instantiation_4 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIChannel_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsISupports_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIChannel_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMArray_open0_nsINode_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMArray > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMArray ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMArray > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMArray ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIDocument_close0_instantiation_5 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsWeakPtr_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsWeakPtr > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsWeakPtr > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsWeakPtr > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsWeakPtr > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIDocumentEncoder_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsIDocument_FrameRequest_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsIDocument_FrameRequest > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsIDocument_FrameRequest > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsIDocument_FrameRequest > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsIDocument_FrameRequest > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIStructuredCloneContainer_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIVariant_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_XPathEvaluator_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: XPathEvaluator > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: XPathEvaluator > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: XPathEvaluator > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: XPathEvaluator > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_AnonymousContent_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: RefPtr < root :: mozilla :: dom :: AnonymousContent > > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: RefPtr < root :: mozilla :: dom :: AnonymousContent > > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: RefPtr < root :: mozilla :: dom :: AnonymousContent > > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: RefPtr < root :: mozilla :: dom :: AnonymousContent > > ) ) ) ; } # [ test ] fn __bindgen_test_layout_LinkedList_open0_MediaQueryList_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: LinkedList > ( ) , 24usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: LinkedList ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: LinkedList > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: LinkedList ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_DocGroup_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: DocGroup > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: DocGroup > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: DocGroup > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: DocGroup > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsCOMPtr > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsCOMPtr > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsCOMPtr > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsCOMPtr > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIPrincipal_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsCOMPtr > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsCOMPtr > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsCOMPtr > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsCOMPtr > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIPrincipal_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_uint64_t_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < u64 > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < u64 > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < u64 > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < u64 > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsINode_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsAutoPtr_open0_LangGroupFontPrefs_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsAutoPtr < root :: mozilla :: LangGroupFontPrefs > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsAutoPtr < root :: mozilla :: LangGroupFontPrefs > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsAutoPtr < root :: mozilla :: LangGroupFontPrefs > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsAutoPtr < root :: mozilla :: LangGroupFontPrefs > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIDocument_close0_instantiation_6 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsDeviceContext_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsDeviceContext > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsDeviceContext > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsDeviceContext > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsDeviceContext > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_EventStateManager_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: EventStateManager > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: EventStateManager > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: EventStateManager > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: EventStateManager > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsRefreshDriver_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsRefreshDriver > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsRefreshDriver > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsRefreshDriver > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsRefreshDriver > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_EffectCompositor_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: EffectCompositor > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: EffectCompositor > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: EffectCompositor > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: EffectCompositor > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsTransitionManager_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsTransitionManager > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsTransitionManager > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsTransitionManager > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsTransitionManager > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAnimationManager_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAnimationManager > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAnimationManager > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAnimationManager > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAnimationManager > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_RestyleManager_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: RestyleManager > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: RestyleManager > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: RestyleManager > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: RestyleManager > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_CounterStyleManager_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: CounterStyleManager > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: CounterStyleManager > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: CounterStyleManager > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: CounterStyleManager > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_4 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_gfxFontFeatureValueSet_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: gfxFontFeatureValueSet > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: gfxFontFeatureValueSet > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: gfxFontFeatureValueSet > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: gfxFontFeatureValueSet > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_5 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsITheme_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIPrintSettings_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsITimer_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsBidi_DefaultDelete_open1_nsBidi_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsBidi > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsBidi > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsBidi > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsBidi > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsBidi_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsRect_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsRect > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsRect > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsRect > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsRect > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsAutoPtr_open0_gfxTextPerfMetrics_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsAutoPtr < root :: gfxTextPerfMetrics > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsAutoPtr < root :: gfxTextPerfMetrics > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsAutoPtr < root :: gfxTextPerfMetrics > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsAutoPtr < root :: gfxTextPerfMetrics > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsAutoPtr_open0_gfxMissingFontRecorder_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsAutoPtr < root :: gfxMissingFontRecorder > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsAutoPtr < root :: gfxMissingFontRecorder > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsAutoPtr < root :: gfxMissingFontRecorder > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsAutoPtr < root :: gfxMissingFontRecorder > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsRefPtrHashKey_open0_nsAtom_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsRefPtrHashKey < root :: nsAtom > > ( ) , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsRefPtrHashKey < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsRefPtrHashKey < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsRefPtrHashKey < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_URLParams_Param_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: mozilla :: dom :: URLParams_Param > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: dom :: URLParams_Param > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: mozilla :: dom :: URLParams_Param > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: dom :: URLParams_Param > ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_URLParams_DefaultDelete_open1_URLParams_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: dom :: URLParams > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: dom :: URLParams > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: dom :: URLParams > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: dom :: URLParams > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_URLParams_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_10 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_11 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIPrincipal_close0_instantiation_3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_const_char_FreePolicy_open1_const_char_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < :: std :: os :: raw :: c_char > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < :: std :: os :: raw :: c_char > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < :: std :: os :: raw :: c_char > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < :: std :: os :: raw :: c_char > ) ) ) ; } # [ test ] fn __bindgen_test_layout_FreePolicy_open0_const_char_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: detail :: FreePolicy > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: detail :: FreePolicy ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: detail :: FreePolicy > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: detail :: FreePolicy ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIEventTarget_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsMainThreadPtrHandle_open0_nsIURI_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsMainThreadPtrHandle < root :: nsIURI > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsMainThreadPtrHandle < root :: nsIURI > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsMainThreadPtrHandle < root :: nsIURI > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsMainThreadPtrHandle < root :: nsIURI > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_URLExtraData_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: URLExtraData > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: URLExtraData > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: URLExtraData > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: URLExtraData > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsPtrHashKey_open0_nsIDocument_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsPtrHashKey < root :: nsIDocument > > ( ) , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsPtrHashKey < root :: nsIDocument > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsPtrHashKey < root :: nsIDocument > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsPtrHashKey < root :: nsIDocument > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_GridNamedArea_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: mozilla :: css :: GridNamedArea > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: css :: GridNamedArea > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: mozilla :: css :: GridNamedArea > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: css :: GridNamedArea > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsString_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < ::nsstring::nsStringRepr > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < ::nsstring::nsStringRepr > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < ::nsstring::nsStringRepr > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < ::nsstring::nsStringRepr > ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsCSSValueList_DefaultDelete_open1_nsCSSValueList_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsCSSValueList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsCSSValueList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsCSSValueList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsCSSValueList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsCSSValueList_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsCSSValuePairList_DefaultDelete_open1_nsCSSValuePairList_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsCSSValuePairList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsCSSValuePairList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsCSSValuePairList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsCSSValuePairList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsCSSValuePairList_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsCSSValueGradientStop_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsCSSValueGradientStop > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsCSSValueGradientStop > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsCSSValueGradientStop > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsCSSValueGradientStop > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_12 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_13 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIPrincipal_close0_instantiation_4 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_imgRequestProxy_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: imgRequestProxy > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: imgRequestProxy > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: imgRequestProxy > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: imgRequestProxy > ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_ProxyBehaviour_DefaultDelete_open1_ProxyBehaviour_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: ProxyBehaviour > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: ProxyBehaviour > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: ProxyBehaviour > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: ProxyBehaviour > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_ProxyBehaviour_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_imgRequestProxy_ImageURL_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: imgRequestProxy_ImageURL > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: imgRequestProxy_ImageURL > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: imgRequestProxy_ImageURL > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: imgRequestProxy_ImageURL > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsILoadGroup_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_TabGroup_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: TabGroup > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: TabGroup > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: TabGroup > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: TabGroup > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIEventTarget_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsString_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < ::nsstring::nsStringRepr > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < ::nsstring::nsStringRepr > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < ::nsstring::nsStringRepr > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < ::nsstring::nsStringRepr > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsRefPtrHashKey_open0_nsAtom_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsRefPtrHashKey < root :: nsAtom > > ( ) , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsRefPtrHashKey < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsRefPtrHashKey < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsRefPtrHashKey < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_ptr_CounterStyle_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < * mut root :: mozilla :: CounterStyle > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < * mut root :: mozilla :: CounterStyle > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < * mut root :: mozilla :: CounterStyle > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < * mut root :: mozilla :: CounterStyle > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_6 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsStyleGradientStop_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsStyleGradientStop > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleGradientStop > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsStyleGradientStop > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleGradientStop > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_imgRequestProxy_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: imgRequestProxy > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: imgRequestProxy > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: imgRequestProxy > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: imgRequestProxy > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_ImageValue_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: css :: ImageValue > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: ImageValue > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: css :: ImageValue > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: ImageValue > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_ImageTracker_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: ImageTracker > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: ImageTracker > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: ImageTracker > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: ImageTracker > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_DocGroup_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: dom :: DocGroup > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: DocGroup > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: dom :: DocGroup > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: dom :: DocGroup > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMArray_open0_imgIContainer_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMArray > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMArray ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMArray > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMArray ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsStyleSides_DefaultDelete_open1_nsStyleSides_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsStyleSides > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleSides > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsStyleSides > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleSides > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsStyleSides_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsStyleSides_DefaultDelete_open1_nsStyleSides_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsStyleSides > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleSides > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsStyleSides > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleSides > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsStyleSides_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_CachedBorderImageData_DefaultDelete_open1_CachedBorderImageData_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: CachedBorderImageData > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: CachedBorderImageData > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: CachedBorderImageData > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: CachedBorderImageData > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_CachedBorderImageData_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsStyleSides_DefaultDelete_open1_nsStyleSides_close1_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsStyleSides > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleSides > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsStyleSides > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleSides > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsStyleSides_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsStyleAutoArray_open0_nsStyleImageLayers_Layer_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsStyleAutoArray < root :: nsStyleImageLayers_Layer > > ( ) , 104usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsStyleAutoArray < root :: nsStyleImageLayers_Layer > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsStyleAutoArray < root :: nsStyleImageLayers_Layer > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsStyleAutoArray < root :: nsStyleImageLayers_Layer > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nscolor_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nscolor > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nscolor > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nscolor > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nscolor > ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsBorderColors_DefaultDelete_open1_nsBorderColors_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsBorderColors > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsBorderColors > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsBorderColors > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsBorderColors > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsBorderColors_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_pair_open1_nsString_nsString_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: std :: pair < ::nsstring::nsStringRepr , ::nsstring::nsStringRepr > > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: std :: pair < ::nsstring::nsStringRepr , ::nsstring::nsStringRepr > > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: std :: pair < ::nsstring::nsStringRepr , ::nsstring::nsStringRepr > > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: std :: pair < ::nsstring::nsStringRepr , ::nsstring::nsStringRepr > > ) ) ) ; } # [ test ] fn __bindgen_test_layout_pair_open0_nsString_nsString_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: std :: pair < ::nsstring::nsStringRepr , ::nsstring::nsStringRepr > > ( ) , 32usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: std :: pair < ::nsstring::nsStringRepr , ::nsstring::nsStringRepr > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: std :: pair < ::nsstring::nsStringRepr , ::nsstring::nsStringRepr > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: std :: pair < ::nsstring::nsStringRepr , ::nsstring::nsStringRepr > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsStyleImageRequest_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsStyleImageRequest > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsStyleImageRequest > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsStyleImageRequest > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsStyleImageRequest > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsStyleQuoteValues_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsStyleQuoteValues > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsStyleQuoteValues > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsStyleQuoteValues > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsStyleQuoteValues > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsTArray_open1_nsString_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsTArray < ::nsstring::nsStringRepr > > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsTArray < ::nsstring::nsStringRepr > > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsTArray < ::nsstring::nsStringRepr > > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsTArray < ::nsstring::nsStringRepr > > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsString_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < ::nsstring::nsStringRepr > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < ::nsstring::nsStringRepr > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < ::nsstring::nsStringRepr > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < ::nsstring::nsStringRepr > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsStyleCoord_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsStyleCoord > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleCoord > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsStyleCoord > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleCoord > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsStyleCoord_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsStyleCoord > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleCoord > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsStyleCoord > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleCoord > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsString_close0_instantiation_3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < ::nsstring::nsStringRepr > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < ::nsstring::nsStringRepr > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < ::nsstring::nsStringRepr > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < ::nsstring::nsStringRepr > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsString_close0_instantiation_4 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < ::nsstring::nsStringRepr > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < ::nsstring::nsStringRepr > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < ::nsstring::nsStringRepr > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < ::nsstring::nsStringRepr > ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsStyleGridTemplate_DefaultDelete_open1_nsStyleGridTemplate_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsStyleGridTemplate > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleGridTemplate > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsStyleGridTemplate > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleGridTemplate > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsStyleGridTemplate_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsStyleGridTemplate_DefaultDelete_open1_nsStyleGridTemplate_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsStyleGridTemplate > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleGridTemplate > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsStyleGridTemplate > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleGridTemplate > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsStyleGridTemplate_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_GridTemplateAreasValue_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: css :: GridTemplateAreasValue > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: GridTemplateAreasValue > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: css :: GridTemplateAreasValue > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: GridTemplateAreasValue > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsCSSShadowArray_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsCSSShadowArray > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsCSSShadowArray > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsCSSShadowArray > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsCSSShadowArray > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_7 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_8 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsStyleCoord_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsStyleCoord > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleCoord > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsStyleCoord > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleCoord > ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsStyleImage_DefaultDelete_open1_nsStyleImage_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsStyleImage > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleImage > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsStyleImage > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleImage > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsStyleImage_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsStyleImage_DefaultDelete_open1_nsStyleImage_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsStyleImage > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleImage > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsStyleImage > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleImage > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsStyleImage_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_StyleBasicShape_DefaultDelete_open1_StyleBasicShape_close1_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: StyleBasicShape > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: StyleBasicShape > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: StyleBasicShape > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: StyleBasicShape > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_StyleBasicShape_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_StyleBasicShape_DefaultDelete_open1_StyleBasicShape_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: StyleBasicShape > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: StyleBasicShape > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: StyleBasicShape > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: StyleBasicShape > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_StyleBasicShape_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_StyleBasicShape_DefaultDelete_open1_StyleBasicShape_close1_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: StyleBasicShape > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: StyleBasicShape > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: mozilla :: StyleBasicShape > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: mozilla :: StyleBasicShape > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_StyleBasicShape_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsStyleImage_DefaultDelete_open1_nsStyleImage_close1_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsStyleImage > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleImage > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsStyleImage > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsStyleImage > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsStyleImage_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_URLValue_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: css :: URLValue > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: URLValue > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: css :: URLValue > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: URLValue > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_nsAtom_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: RefPtr < root :: nsAtom > > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: RefPtr < root :: nsAtom > > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: RefPtr < root :: nsAtom > > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: RefPtr < root :: nsAtom > > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_9 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_Position_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: mozilla :: Position > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: Position > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: mozilla :: Position > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: mozilla :: Position > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsCSSValueSharedList_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsCSSValueSharedList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsCSSValueSharedList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsCSSValueSharedList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsCSSValueSharedList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsStyleAutoArray_open0_StyleTransition_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsStyleAutoArray < root :: mozilla :: StyleTransition > > ( ) , 48usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsStyleAutoArray < root :: mozilla :: StyleTransition > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsStyleAutoArray < root :: mozilla :: StyleTransition > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsStyleAutoArray < root :: mozilla :: StyleTransition > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsStyleAutoArray_open0_StyleAnimation_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsStyleAutoArray < root :: mozilla :: StyleAnimation > > ( ) , 56usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsStyleAutoArray < root :: mozilla :: StyleAnimation > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsStyleAutoArray < root :: mozilla :: StyleAnimation > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsStyleAutoArray < root :: mozilla :: StyleAnimation > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsStyleContentData_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsStyleContentData > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleContentData > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsStyleContentData > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleContentData > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsStyleCounterData_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsStyleCounterData > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleCounterData > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsStyleCounterData > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleCounterData > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsStyleCounterData_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsStyleCounterData > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleCounterData > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsStyleCounterData > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleCounterData > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsCSSValueSharedList_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsCSSValueSharedList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsCSSValueSharedList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsCSSValueSharedList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsCSSValueSharedList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsStyleImageRequest_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsStyleImageRequest > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsStyleImageRequest > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsStyleImageRequest > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsStyleImageRequest > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsCursorImage_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsCursorImage > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsCursorImage > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsCursorImage > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsCursorImage > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_URLValue_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: css :: URLValue > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: URLValue > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: css :: URLValue > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: URLValue > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_URLValue_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: css :: URLValue > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: URLValue > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: css :: URLValue > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: URLValue > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_URLValue_close0_instantiation_3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: mozilla :: css :: URLValue > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: URLValue > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: mozilla :: css :: URLValue > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: mozilla :: css :: URLValue > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsStyleCoord_close0_instantiation_3 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsStyleCoord > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleCoord > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsStyleCoord > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleCoord > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_nsAtom_close1_close0_instantiation_2 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: RefPtr < root :: nsAtom > > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: RefPtr < root :: nsAtom > > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: RefPtr < root :: nsAtom > > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: RefPtr < root :: nsAtom > > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_10 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsAtom > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsAtom > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsStyleFilter_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsStyleFilter > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleFilter > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsStyleFilter > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsStyleFilter > ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_nsCSSShadowArray_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: nsCSSShadowArray > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: nsCSSShadowArray > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: nsCSSShadowArray > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: nsCSSShadowArray > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_ptr_nsISupports_close0_instantiation ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < * mut root :: nsISupports > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < * mut root :: nsISupports > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < * mut root :: nsISupports > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < * mut root :: nsISupports > ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsCSSValueList_DefaultDelete_open1_nsCSSValueList_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsCSSValueList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsCSSValueList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsCSSValueList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsCSSValueList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsCSSValueList_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_UniquePtr_open0_nsCSSValuePairList_DefaultDelete_open1_nsCSSValuePairList_close1_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: UniquePtr < root :: nsCSSValuePairList > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsCSSValuePairList > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: UniquePtr < root :: nsCSSValuePairList > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: UniquePtr < root :: nsCSSValuePairList > ) ) ) ; } # [ test ] fn __bindgen_test_layout_DefaultDelete_open0_nsCSSValuePairList_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: mozilla :: DefaultDelete > ( ) , 1usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: mozilla :: DefaultDelete ) ) ) ; } # [ test ] fn __bindgen_test_layout_RefPtr_open0_RawServoAnimationValue_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: RefPtr < root :: RawServoAnimationValue > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: RefPtr < root :: RawServoAnimationValue > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: RefPtr < root :: RawServoAnimationValue > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: RefPtr < root :: RawServoAnimationValue > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsTArray_open0_nsCString_close0_instantiation_1 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsTArray < root :: nsCString > > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsTArray < root :: nsCString > ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsTArray < root :: nsCString > > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsTArray < root :: nsCString > ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_14 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_15 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIURI_close0_instantiation_16 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; } # [ test ] fn __bindgen_test_layout_nsCOMPtr_open0_nsIPrincipal_close0_instantiation_5 ( ) { assert_eq ! ( :: std :: mem :: size_of :: < root :: nsCOMPtr > ( ) , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( root :: nsCOMPtr ) ) ) ; assert_eq ! ( :: std :: m