diff --git a/pkgs/compiler-lib/compiler/zo-parse.rkt b/pkgs/compiler-lib/compiler/zo-parse.rkt
index 5d3f8dce98..ffc49b3291 100644
--- a/pkgs/compiler-lib/compiler/zo-parse.rkt
+++ b/pkgs/compiler-lib/compiler/zo-parse.rkt
@@ -608,24 +608,27 @@
                 [(pair? v)
                  (if (eq? #t (car v))
                      ;; Share decoded wraps with all nested parts.
-                     (let loop ([v (cdr v)])
+                     (let iloop ([v (cdr v)])
                        (cond
                          [(pair? v) 
                           (let ploop ([v v])
                             (cond
                               [(null? v) null]
-                              [(pair? v) (add-wrap (cons (loop (car v)) (ploop (cdr v))))]
-                              [else (loop v)]))]
-                         [(box? v) (add-wrap (box (loop (unbox v))))]
+                              [(pair? v) (add-wrap (cons (iloop (car v)) (ploop (cdr v))))]
+                              [else (iloop v)]))]
+                         [(box? v) (add-wrap (box (iloop (unbox v))))]
                          [(vector? v)
-                          (add-wrap (list->vector (map loop (vector->list v))))]
+                          (add-wrap (list->vector (map iloop (vector->list v))))]
+                         [(hash? v)
+                          (add-wrap (for/hash ([(k v) (in-hash v)])
+                                      (values k (iloop v))))]
                          [(prefab-struct-key v)
                           => (lambda (k)
                                (add-wrap
                                 (apply
                                  make-prefab-struct 
                                  k
-                                 (map loop (struct->list v)))))]
+                                 (map iloop (struct->list v)))))]
                          [else (add-wrap v)]))
                      ;; Decode sub-elements that have their own wraps:
                      (let-values ([(v counter) (if (exact-integer? (car v))
@@ -641,6 +644,9 @@
                 [(box? v) (add-wrap (box (loop (unbox v))))]
                 [(vector? v)
                  (add-wrap (list->vector (map loop (vector->list v))))]
+                [(hash? v)
+                 (add-wrap (for/hash ([(k v) (in-hash v)])
+                             (values k (loop v))))]
                 [(prefab-struct-key v)
                  => (lambda (k)
                       (add-wrap
diff --git a/pkgs/racket-pkgs/racket-test/tests/racket/syntax.rktl b/pkgs/racket-pkgs/racket-test/tests/racket/syntax.rktl
index 5a449592a9..db19b24479 100644
--- a/pkgs/racket-pkgs/racket-test/tests/racket/syntax.rktl
+++ b/pkgs/racket-pkgs/racket-test/tests/racket/syntax.rktl
@@ -1799,6 +1799,19 @@
 (compile '(#%variable-reference))
 (expand '(#%variable-reference))
 
+;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Check marshal & unmarshal of a syntax object
+;; containing a list with a hash table
+
+(let ([v #'(quote-syntax (#hash((1 . 2))))])
+  (define-values (i o) (make-pipe))
+  (write (compile v) o)
+  (close-output-port o)
+  (define e
+    (parameterize ([read-accept-compiled #t])
+      (read i)))
+  (test (syntax->datum (eval v)) syntax->datum (eval e)))
+
 ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (report-errs)
diff --git a/racket/src/racket/src/syntax.c b/racket/src/racket/src/syntax.c
index ef63a15108..aa1a3ee456 100644
--- a/racket/src/racket/src/syntax.c
+++ b/racket/src/racket/src/syntax.c
@@ -6594,7 +6594,7 @@ static Scheme_Object *extract_for_common_wrap(Scheme_Object *a, int get_mark, in
         else
           return SCHEME_CDR(v);
       }
-    } else if (!SCHEME_BOXP(v) && !SCHEME_VECTORP(v) && !prefab_p(v)) {
+    } else if (!SCHEME_BOXP(v) && !SCHEME_VECTORP(v) && !SCHEME_HASHTRP(v) && !prefab_p(v)) {
       /* It's atomic. */
       if (get_mark)
         return SCHEME_CDR(a);