Move from cmp --> eq, and provide a good implementation for interning

16 files changed, 120 insertions, 78 deletions

diff --git a/src/core/lib/channel/compress_filter.c b/src/core/lib/channel/compress_filter.c
index e04f3dc7db..392d4d7231 100644
--- a/src/core/lib/channel/compress_filter.c
+++ b/src/core/lib/channel/compress_filter.c
@@ -90,8 +90,8 @@ static grpc_mdelem compression_md_filter(grpc_exec_ctx *exec_ctx,
   call_data *calld = elem->call_data;
   channel_data *channeld = elem->channel_data;
 
-  if (grpc_slice_cmp(GRPC_MDKEY(md),
-                     GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST) == 0) {
+  if (grpc_slice_eq(GRPC_MDKEY(md),
+                    GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST)) {
     if (!grpc_compression_algorithm_parse(GRPC_MDVALUE(md),
                                           &calld->compression_algorithm)) {
       char *val = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_ASCII);
diff --git a/src/core/lib/channel/http_client_filter.c b/src/core/lib/channel/http_client_filter.c
index fea6c9b345..e415877eb8 100644
--- a/src/core/lib/channel/http_client_filter.c
+++ b/src/core/lib/channel/http_client_filter.c
@@ -99,7 +99,7 @@ static grpc_mdelem client_recv_filter(grpc_exec_ctx *exec_ctx, void *user_data,
   grpc_call_element *elem = user_data;
   if (grpc_mdelem_eq(md, GRPC_MDELEM_STATUS_200)) {
     return GRPC_MDNULL;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_STATUS) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_STATUS)) {
     char *message_string;
     char *val = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_ASCII);
     gpr_asprintf(&message_string, "Received http2 header with status: %s", val);
@@ -109,7 +109,7 @@ static grpc_mdelem client_recv_filter(grpc_exec_ctx *exec_ctx, void *user_data,
     grpc_call_element_send_close_with_message(exec_ctx, elem,
                                               GRPC_STATUS_CANCELLED, &message);
     return GRPC_MDNULL;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_MESSAGE) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_MESSAGE)) {
     grpc_slice pct_decoded_msg =
         grpc_permissive_percent_decode_slice(GRPC_MDVALUE(md));
     if (grpc_slice_is_equivalent(pct_decoded_msg, GRPC_MDVALUE(md))) {
@@ -122,7 +122,7 @@ static grpc_mdelem client_recv_filter(grpc_exec_ctx *exec_ctx, void *user_data,
   } else if (grpc_mdelem_eq(md,
                             GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC)) {
     return GRPC_MDNULL;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_CONTENT_TYPE) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_CONTENT_TYPE)) {
     if (grpc_slice_buf_start_eq(GRPC_MDVALUE(md), EXPECTED_CONTENT_TYPE,
                                 EXPECTED_CONTENT_TYPE_LENGTH) &&
         (GRPC_SLICE_START_PTR(GRPC_MDVALUE(md))[EXPECTED_CONTENT_TYPE_LENGTH] ==
@@ -187,15 +187,12 @@ static void send_done(grpc_exec_ctx *exec_ctx, void *elemp, grpc_error *error) {
 static grpc_mdelem client_strip_filter(grpc_exec_ctx *exec_ctx, void *user_data,
                                        grpc_mdelem md) {
   /* eat the things we'd like to set ourselves */
-  if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_METHOD) == 0)
-    return GRPC_MDNULL;
-  if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_SCHEME) == 0)
-    return GRPC_MDNULL;
-  if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_TE) == 0) return GRPC_MDNULL;
-  if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_CONTENT_TYPE) == 0)
-    return GRPC_MDNULL;
-  if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_USER_AGENT) == 0)
+  if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_METHOD)) return GRPC_MDNULL;
+  if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_SCHEME)) return GRPC_MDNULL;
+  if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_TE)) return GRPC_MDNULL;
+  if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_CONTENT_TYPE))
     return GRPC_MDNULL;
+  if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_USER_AGENT)) return GRPC_MDNULL;
   return md;
 }
 
diff --git a/src/core/lib/channel/http_server_filter.c b/src/core/lib/channel/http_server_filter.c
index 0d11c71d06..bdd1e18837 100644
--- a/src/core/lib/channel/http_server_filter.c
+++ b/src/core/lib/channel/http_server_filter.c
@@ -87,7 +87,7 @@ typedef struct channel_data { uint8_t unused; } channel_data;
 static grpc_mdelem server_filter_outgoing_metadata(grpc_exec_ctx *exec_ctx,
                                                    void *user_data,
                                                    grpc_mdelem md) {
-  if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_MESSAGE) == 0) {
+  if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_MESSAGE)) {
     grpc_slice pct_encoded_msg = grpc_percent_encode_slice(
         GRPC_MDVALUE(md), grpc_compatible_percent_encoding_unreserved_bytes);
     if (grpc_slice_is_equivalent(pct_encoded_msg, GRPC_MDVALUE(md))) {
@@ -126,7 +126,7 @@ static grpc_mdelem server_filter(grpc_exec_ctx *exec_ctx, void *user_data,
     } else if (grpc_mdelem_eq(md, GRPC_MDELEM_METHOD_GET)) {
       calld->seen_method = 1;
       *calld->recv_cacheable_request = true;
-    } else if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_SCHEME) == 0) {
+    } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_SCHEME)) {
       calld->seen_scheme = 1;
     } else if (grpc_mdelem_eq(md, GRPC_MDELEM_TE_TRAILERS)) {
       calld->seen_te_trailers = 1;
@@ -134,7 +134,7 @@ static grpc_mdelem server_filter(grpc_exec_ctx *exec_ctx, void *user_data,
     /* TODO(klempner): Track that we've seen all the headers we should
        require */
     return GRPC_MDNULL;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_CONTENT_TYPE) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_CONTENT_TYPE)) {
     if (grpc_slice_buf_start_eq(GRPC_MDVALUE(md), EXPECTED_CONTENT_TYPE,
                                 EXPECTED_CONTENT_TYPE_LENGTH) &&
         (GRPC_SLICE_START_PTR(GRPC_MDVALUE(md))[EXPECTED_CONTENT_TYPE_LENGTH] ==
@@ -154,9 +154,9 @@ static grpc_mdelem server_filter(grpc_exec_ctx *exec_ctx, void *user_data,
       gpr_free(val);
     }
     return GRPC_MDNULL;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_TE) == 0 ||
-             grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_METHOD) == 0 ||
-             grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_SCHEME) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_TE) ||
+             grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_METHOD) ||
+             grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_SCHEME)) {
     char *key = grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_ASCII);
     char *value = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_ASCII);
     gpr_log(GPR_ERROR, "Invalid %s: header: '%s'", key, value);
@@ -167,24 +167,24 @@ static grpc_mdelem server_filter(grpc_exec_ctx *exec_ctx, void *user_data,
     gpr_free(value);
     grpc_call_element_send_cancel(exec_ctx, elem);
     return GRPC_MDNULL;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_PATH) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_PATH)) {
     if (calld->seen_path) {
       gpr_log(GPR_ERROR, "Received :path twice");
       return GRPC_MDNULL;
     }
     calld->seen_path = 1;
     return md;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_AUTHORITY) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_AUTHORITY)) {
     calld->seen_authority = 1;
     return md;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_HOST) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_HOST)) {
     /* translate host to :authority since :authority may be
        omitted */
     grpc_mdelem authority = grpc_mdelem_from_slices(
         exec_ctx, GRPC_MDSTR_AUTHORITY, grpc_slice_ref(GRPC_MDVALUE(md)));
     calld->seen_authority = 1;
     return authority;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_PAYLOAD_BIN) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_PAYLOAD_BIN)) {
     /* Retrieve the payload from the value of the 'grpc-internal-payload-bin'
        header field */
     calld->seen_payload_bin = 1;
diff --git a/src/core/lib/compression/compression.c b/src/core/lib/compression/compression.c
index f8777a6f6c..80c1aaed5b 100644
--- a/src/core/lib/compression/compression.c
+++ b/src/core/lib/compression/compression.c
@@ -47,13 +47,13 @@ int grpc_compression_algorithm_parse(grpc_slice name,
    * doesn't matter, given that we are comparing against string literals, but
    * because this way we needn't have "name" nil-terminated (useful for slice
    * data, for example) */
-  if (grpc_slice_cmp(name, GRPC_MDSTR_IDENTITY) == 0) {
+  if (grpc_slice_eq(name, GRPC_MDSTR_IDENTITY)) {
     *algorithm = GRPC_COMPRESS_NONE;
     return 1;
-  } else if (grpc_slice_cmp(name, GRPC_MDSTR_GZIP) == 0) {
+  } else if (grpc_slice_eq(name, GRPC_MDSTR_GZIP)) {
     *algorithm = GRPC_COMPRESS_GZIP;
     return 1;
-  } else if (grpc_slice_cmp(name, GRPC_MDSTR_DEFLATE) == 0) {
+  } else if (grpc_slice_eq(name, GRPC_MDSTR_DEFLATE)) {
     *algorithm = GRPC_COMPRESS_DEFLATE;
     return 1;
   } else {
@@ -83,10 +83,10 @@ int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
 
 grpc_compression_algorithm grpc_compression_algorithm_from_slice(
     grpc_slice str) {
-  if (grpc_slice_cmp(str, GRPC_MDSTR_IDENTITY) == 0) return GRPC_COMPRESS_NONE;
-  if (grpc_slice_cmp(str, GRPC_MDSTR_DEFLATE) == 0)
+  if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_COMPRESS_NONE;
+  if (grpc_slice_eq(str, GRPC_MDSTR_DEFLATE))
     return GRPC_COMPRESS_DEFLATE;
-  if (grpc_slice_cmp(str, GRPC_MDSTR_GZIP) == 0) return GRPC_COMPRESS_GZIP;
+  if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_COMPRESS_GZIP;
   return GRPC_COMPRESS_ALGORITHMS_COUNT;
 }
 
diff --git a/src/core/lib/iomgr/resource_quota.c b/src/core/lib/iomgr/resource_quota.c
index 3b63773071..8622a3610c 100644
--- a/src/core/lib/iomgr/resource_quota.c
+++ b/src/core/lib/iomgr/resource_quota.c
@@ -367,7 +367,8 @@ static void ru_slice_unref(grpc_exec_ctx *exec_ctx, void *p) {
 }
 
 static const grpc_slice_refcount_vtable ru_slice_vtable = {
-    ru_slice_ref, ru_slice_unref, grpc_slice_default_hash_impl};
+    ru_slice_ref, ru_slice_unref, grpc_slice_default_eq_impl,
+    grpc_slice_default_hash_impl};
 
 static grpc_slice ru_slice_create(grpc_resource_user *resource_user,
                                   size_t size) {
diff --git a/src/core/lib/security/transport/client_auth_filter.c b/src/core/lib/security/transport/client_auth_filter.c
index d680c1ef13..13c0277109 100644
--- a/src/core/lib/security/transport/client_auth_filter.c
+++ b/src/core/lib/security/transport/client_auth_filter.c
@@ -256,13 +256,13 @@ static void auth_start_transport_op(grpc_exec_ctx *exec_ctx,
       grpc_mdelem md = l->md;
       /* Pointer comparison is OK for md_elems created from the same context.
        */
-      if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_AUTHORITY) == 0) {
+      if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_AUTHORITY)) {
         if (calld->have_host) {
           grpc_slice_unref_internal(exec_ctx, calld->host);
         }
         calld->host = grpc_slice_ref_internal(GRPC_MDVALUE(md));
         calld->have_host = true;
-      } else if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_PATH) == 0) {
+      } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_PATH)) {
         if (calld->have_method) {
           grpc_slice_unref_internal(exec_ctx, calld->method);
         }
diff --git a/src/core/lib/security/transport/server_auth_filter.c b/src/core/lib/security/transport/server_auth_filter.c
index 1c4843fc14..1d14cfef53 100644
--- a/src/core/lib/security/transport/server_auth_filter.c
+++ b/src/core/lib/security/transport/server_auth_filter.c
@@ -90,8 +90,8 @@ static grpc_mdelem remove_consumed_md(grpc_exec_ctx *exec_ctx, void *user_data,
   size_t i;
   for (i = 0; i < calld->num_consumed_md; i++) {
     const grpc_metadata *consumed_md = &calld->consumed_md[i];
-    if (grpc_slice_cmp(GRPC_MDKEY(md), consumed_md->key) == 0 &&
-        grpc_slice_cmp(GRPC_MDKEY(md), consumed_md->value) == 0)
+    if (grpc_slice_eq(GRPC_MDKEY(md), consumed_md->key) &&
+        grpc_slice_eq(GRPC_MDKEY(md), consumed_md->value))
       return GRPC_MDNULL;
   }
   return md;
diff --git a/src/core/lib/slice/slice.c b/src/core/lib/slice/slice.c
index 64988bae64..2ae97b3035 100644
--- a/src/core/lib/slice/slice.c
+++ b/src/core/lib/slice/slice.c
@@ -79,7 +79,8 @@ static void noop_ref(void *unused) {}
 static void noop_unref(grpc_exec_ctx *exec_ctx, void *unused) {}
 
 static const grpc_slice_refcount_vtable noop_refcount_vtable = {
-    noop_ref, noop_unref, grpc_slice_default_hash_impl};
+    noop_ref, noop_unref, grpc_slice_default_eq_impl,
+    grpc_slice_default_hash_impl};
 static grpc_slice_refcount noop_refcount = {&noop_refcount_vtable};
 
 grpc_slice grpc_slice_from_static_buffer(const void *s, size_t len) {
@@ -117,7 +118,8 @@ static void new_slice_unref(grpc_exec_ctx *exec_ctx, void *p) {
 }
 
 static const grpc_slice_refcount_vtable new_slice_vtable = {
-    new_slice_ref, new_slice_unref, grpc_slice_default_hash_impl};
+    new_slice_ref, new_slice_unref, grpc_slice_default_eq_impl,
+    grpc_slice_default_hash_impl};
 
 grpc_slice grpc_slice_new_with_user_data(void *p, size_t len,
                                          void (*destroy)(void *),
@@ -164,7 +166,8 @@ static void new_with_len_unref(grpc_exec_ctx *exec_ctx, void *p) {
 }
 
 static const grpc_slice_refcount_vtable new_with_len_vtable = {
-    new_with_len_ref, new_with_len_unref, grpc_slice_default_hash_impl};
+    new_with_len_ref, new_with_len_unref, grpc_slice_default_eq_impl,
+    grpc_slice_default_hash_impl};
 
 grpc_slice grpc_slice_new_with_len(void *p, size_t len,
                                    void (*destroy)(void *, size_t)) {
@@ -211,7 +214,8 @@ static void malloc_unref(grpc_exec_ctx *exec_ctx, void *p) {
 }
 
 static const grpc_slice_refcount_vtable malloc_vtable = {
-    malloc_ref, malloc_unref, grpc_slice_default_hash_impl};
+    malloc_ref, malloc_unref, grpc_slice_default_eq_impl,
+    grpc_slice_default_hash_impl};
 
 grpc_slice grpc_slice_malloc(size_t length) {
   grpc_slice slice;
@@ -363,11 +367,20 @@ grpc_slice grpc_slice_split_head(grpc_slice *source, size_t split) {
   return head;
 }
 
-int grpc_slice_cmp(grpc_slice a, grpc_slice b) {
-  if (GRPC_SLICE_START_PTR(a) == GRPC_SLICE_START_PTR(b) &&
-      GRPC_SLICE_LENGTH(a) == GRPC_SLICE_LENGTH(b)) {
-    return 0;
+int grpc_slice_default_eq_impl(grpc_slice a, grpc_slice b) {
+  return GRPC_SLICE_LENGTH(a) == GRPC_SLICE_LENGTH(b) &&
+         0 == memcmp(GRPC_SLICE_START_PTR(a), GRPC_SLICE_START_PTR(b),
+                     GRPC_SLICE_LENGTH(a));
+}
+
+int grpc_slice_eq(grpc_slice a, grpc_slice b) {
+  if (a.refcount && b.refcount && a.refcount->vtable == b.refcount->vtable) {
+    return a.refcount->vtable->eq(a, b);
   }
+  return grpc_slice_default_eq_impl(a, b);
+}
+
+int grpc_slice_cmp(grpc_slice a, grpc_slice b) {
   int d = (int)(GRPC_SLICE_LENGTH(a) - GRPC_SLICE_LENGTH(b));
   if (d != 0) return d;
   return memcmp(GRPC_SLICE_START_PTR(a), GRPC_SLICE_START_PTR(b),
@@ -383,7 +396,7 @@ int grpc_slice_str_cmp(grpc_slice a, const char *b) {
 
 int grpc_slice_is_equivalent(grpc_slice a, grpc_slice b) {
   if (a.refcount == NULL || b.refcount == NULL) {
-    return grpc_slice_cmp(a, b) == 0;
+    return grpc_slice_eq(a, b);
   }
   return a.data.refcounted.length == b.data.refcounted.length &&
          a.data.refcounted.bytes == b.data.refcounted.bytes;
diff --git a/src/core/lib/slice/slice_intern.c b/src/core/lib/slice/slice_intern.c
index 2d93284926..3cae8a98f3 100644
--- a/src/core/lib/slice/slice_intern.c
+++ b/src/core/lib/slice/slice_intern.c
@@ -110,17 +110,30 @@ static void interned_slice_unref(grpc_exec_ctx *exec_ctx, void *p) {
   }
 }
 
-static uint32_t interned_slice_hash(void *p, grpc_slice slice) {
-  interned_slice_refcount *s = p;
+static uint32_t interned_slice_hash(grpc_slice slice) {
+  interned_slice_refcount *s = (interned_slice_refcount *)slice.refcount;
   if (slice.data.refcounted.bytes == (uint8_t *)(s + 1) &&
       slice.data.refcounted.length == s->length) {
     return s->hash;
   }
-  return grpc_slice_default_hash_impl(p, slice);
+  return grpc_slice_default_hash_impl(slice);
+}
+
+static int interned_slice_eq(grpc_slice a, grpc_slice b) {
+  interned_slice_refcount *sa = (interned_slice_refcount *)a.refcount;
+  interned_slice_refcount *sb = (interned_slice_refcount *)b.refcount;
+  if (a.data.refcounted.bytes == (uint8_t *)(sa + 1) &&
+      b.data.refcounted.bytes == (uint8_t *)(sb + 1)) {
+    return a.data.refcounted.length == b.data.refcounted.length &&
+           a.data.refcounted.bytes == b.data.refcounted.bytes;
+  } else {
+    return grpc_slice_default_eq_impl(a, b);
+  }
 }
 
 static const grpc_slice_refcount_vtable interned_slice_vtable = {
-    interned_slice_ref, interned_slice_unref, interned_slice_hash};
+    interned_slice_ref, interned_slice_unref, interned_slice_eq,
+    interned_slice_hash};
 
 static void grow_shard(slice_shard *shard) {
   size_t capacity = shard->capacity * 2;
@@ -157,22 +170,31 @@ static grpc_slice materialize(interned_slice_refcount *s) {
   return slice;
 }
 
-uint32_t grpc_slice_default_hash_impl(void *unused_refcnt, grpc_slice s) {
+uint32_t grpc_slice_default_hash_impl(grpc_slice s) {
   return gpr_murmur_hash3(GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s),
                           g_hash_seed);
 }
 
-uint32_t grpc_static_slice_hash(void *unused_refcnt, grpc_slice s) {
+uint32_t grpc_static_slice_hash(grpc_slice s) {
   int id = grpc_static_metadata_index(s);
   if (id == -1) {
-    return grpc_slice_default_hash_impl(unused_refcnt, s);
+    return grpc_slice_default_hash_impl(s);
   }
   return static_metadata_hash_values[id];
 }
 
+int grpc_static_slice_eq(grpc_slice a, grpc_slice b) {
+  int id_a = grpc_static_metadata_index(a);
+  int id_b = grpc_static_metadata_index(b);
+  if (id_a == -1 || id_b == -1) {
+    return grpc_slice_default_eq_impl(a, b);
+  }
+  return id_a == id_b;
+}
+
 uint32_t grpc_slice_hash(grpc_slice s) {
-  return s.refcount == NULL ? grpc_slice_default_hash_impl(NULL, s)
-                            : s.refcount->vtable->hash(s.refcount, s);
+  return s.refcount == NULL ? grpc_slice_default_hash_impl(s)
+                            : s.refcount->vtable->hash(s);
 }
 
 void grpc_slice_static_intern(grpc_slice *slice) {
@@ -185,7 +207,7 @@ void grpc_slice_static_intern(grpc_slice *slice) {
     static_metadata_hash_ent ent =
         static_metadata_hash[(hash + i) % GPR_ARRAY_SIZE(static_metadata_hash)];
     if (ent.hash == hash && ent.idx < GRPC_STATIC_MDSTR_COUNT &&
-        0 == grpc_slice_cmp(grpc_static_slice_table[ent.idx], *slice)) {
+        grpc_slice_eq(grpc_static_slice_table[ent.idx], *slice)) {
       grpc_slice_unref(*slice);
       *slice = grpc_static_slice_table[ent.idx];
       return;
@@ -208,7 +230,7 @@ grpc_slice grpc_slice_intern(grpc_slice slice) {
     static_metadata_hash_ent ent =
         static_metadata_hash[(hash + i) % GPR_ARRAY_SIZE(static_metadata_hash)];
     if (ent.hash == hash && ent.idx < GRPC_STATIC_MDSTR_COUNT &&
-        0 == grpc_slice_cmp(grpc_static_slice_table[ent.idx], slice)) {
+        grpc_slice_eq(grpc_static_slice_table[ent.idx], slice)) {
       return grpc_static_slice_table[ent.idx];
     }
   }
@@ -221,7 +243,7 @@ grpc_slice grpc_slice_intern(grpc_slice slice) {
   /* search for an existing string */
   size_t idx = TABLE_IDX(hash, shard->capacity);
   for (s = shard->strs[idx]; s; s = s->bucket_next) {
-    if (s->hash == hash && grpc_slice_cmp(slice, materialize(s)) == 0) {
+    if (s->hash == hash && grpc_slice_eq(slice, materialize(s))) {
       if (gpr_atm_no_barrier_fetch_add(&s->refcnt, 1) == 0) {
         /* If we get here, we've added a ref to something that was about to
          * die - drop it immediately.
@@ -283,7 +305,7 @@ void grpc_slice_intern_init(void) {
   max_static_metadata_hash_probe = 0;
   for (size_t i = 0; i < GRPC_STATIC_MDSTR_COUNT; i++) {
     static_metadata_hash_values[i] =
-        grpc_slice_default_hash_impl(NULL, grpc_static_slice_table[i]);
+        grpc_slice_default_hash_impl(grpc_static_slice_table[i]);
     for (size_t j = 0; j < GPR_ARRAY_SIZE(static_metadata_hash); j++) {
       size_t slot = (static_metadata_hash_values[i] + j) %
                     GPR_ARRAY_SIZE(static_metadata_hash);
diff --git a/src/core/lib/slice/slice_internal.h b/src/core/lib/slice/slice_internal.h
index 211d5f06be..cb85d57213 100644
--- a/src/core/lib/slice/slice_internal.h
+++ b/src/core/lib/slice/slice_internal.h
@@ -55,6 +55,7 @@ void grpc_test_only_set_slice_hash_seed(uint32_t key);
 // if slice matches a static slice, consume it and replace it with the static
 // slice, otherwise do nothing: this is a fast interning for well known strings
 void grpc_slice_static_intern(grpc_slice *slice);
-uint32_t grpc_static_slice_hash(void *refcnt, grpc_slice s);
+uint32_t grpc_static_slice_hash(grpc_slice s);
+int grpc_static_slice_eq(grpc_slice a, grpc_slice b);
 
 #endif /* GRPC_CORE_LIB_SLICE_SLICE_INTERNAL_H */
diff --git a/src/core/lib/surface/call.c b/src/core/lib/surface/call.c
index 0ca97337e2..af53a5b246 100644
--- a/src/core/lib/surface/call.c
+++ b/src/core/lib/surface/call.c
@@ -252,8 +252,8 @@ grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx,
                MAX_SEND_EXTRA_METADATA_COUNT);
     for (i = 0; i < args->add_initial_metadata_count; i++) {
       call->send_extra_metadata[i].md = args->add_initial_metadata[i];
-      if (grpc_slice_cmp(GRPC_MDKEY(args->add_initial_metadata[i]),
-                         GRPC_MDSTR_PATH) == 0) {
+      if (grpc_slice_eq(GRPC_MDKEY(args->add_initial_metadata[i]),
+                        GRPC_MDSTR_PATH)) {
         path = grpc_slice_ref_internal(
             GRPC_MDVALUE(args->add_initial_metadata[i]));
       }
@@ -916,12 +916,12 @@ static grpc_compression_algorithm decode_compression(grpc_mdelem md) {
 
 static grpc_mdelem recv_common_filter(grpc_exec_ctx *exec_ctx, grpc_call *call,
                                       grpc_mdelem elem) {
-  if (grpc_slice_cmp(GRPC_MDKEY(elem), GRPC_MDSTR_GRPC_STATUS) == 0) {
+  if (grpc_slice_eq(GRPC_MDKEY(elem), GRPC_MDSTR_GRPC_STATUS)) {
     GPR_TIMER_BEGIN("status", 0);
     set_status_code(call, STATUS_FROM_WIRE, decode_status(elem));
     GPR_TIMER_END("status", 0);
     return GRPC_MDNULL;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(elem), GRPC_MDSTR_GRPC_MESSAGE) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(elem), GRPC_MDSTR_GRPC_MESSAGE)) {
     GPR_TIMER_BEGIN("status-details", 0);
     set_status_details(exec_ctx, call, STATUS_FROM_WIRE,
                        grpc_slice_ref_internal(GRPC_MDVALUE(elem)));
@@ -955,13 +955,12 @@ static grpc_mdelem recv_initial_filter(grpc_exec_ctx *exec_ctx, void *args,
   elem = recv_common_filter(exec_ctx, call, elem);
   if (GRPC_MDISNULL(elem)) {
     return GRPC_MDNULL;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(elem), GRPC_MDSTR_GRPC_ENCODING) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(elem), GRPC_MDSTR_GRPC_ENCODING)) {
     GPR_TIMER_BEGIN("incoming_compression_algorithm", 0);
     set_incoming_compression_algorithm(call, decode_compression(elem));
     GPR_TIMER_END("incoming_compression_algorithm", 0);
     return GRPC_MDNULL;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(elem),
-                            GRPC_MDSTR_GRPC_ACCEPT_ENCODING) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(elem), GRPC_MDSTR_GRPC_ACCEPT_ENCODING)) {
     GPR_TIMER_BEGIN("encodings_accepted_by_peer", 0);
     set_encodings_accepted_by_peer(exec_ctx, call, elem);
     GPR_TIMER_END("encodings_accepted_by_peer", 0);
diff --git a/src/core/lib/surface/channel.c b/src/core/lib/surface/channel.c
index 501545b5c0..6f2a88ae68 100644
--- a/src/core/lib/surface/channel.c
+++ b/src/core/lib/surface/channel.c
@@ -125,7 +125,8 @@ grpc_channel *grpc_channel_create(grpc_exec_ctx *exec_ctx, const char *target,
           }
           channel->default_authority = grpc_mdelem_from_slices(
               exec_ctx, GRPC_MDSTR_AUTHORITY,
-              grpc_slice_from_copied_string(args->args[i].value.string));
+              grpc_slice_intern(
+                  grpc_slice_from_copied_string(args->args[i].value.string)));
         }
       } else if (0 ==
                  strcmp(args->args[i].key, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG)) {
@@ -141,7 +142,8 @@ grpc_channel *grpc_channel_create(grpc_exec_ctx *exec_ctx, const char *target,
           } else {
             channel->default_authority = grpc_mdelem_from_slices(
                 exec_ctx, GRPC_MDSTR_AUTHORITY,
-                grpc_slice_from_copied_string(args->args[i].value.string));
+                grpc_slice_intern(
+                    grpc_slice_from_copied_string(args->args[i].value.string)));
           }
         }
       } else if (0 == strcmp(args->args[i].key,
diff --git a/src/core/lib/surface/server.c b/src/core/lib/surface/server.c
index b21e1d8113..1c29873a65 100644
--- a/src/core/lib/surface/server.c
+++ b/src/core/lib/surface/server.c
@@ -624,8 +624,8 @@ static void start_new_rpc(grpc_exec_ctx *exec_ctx, grpc_call_element *elem) {
                                       chand->registered_method_slots];
       if (!rm) break;
       if (!rm->has_host) continue;
-      if (grpc_slice_cmp(rm->host, calld->host) != 0) continue;
-      if (grpc_slice_cmp(rm->method, calld->path) != 0) continue;
+      if (!grpc_slice_eq(rm->host, calld->host)) continue;
+      if (!grpc_slice_eq(rm->method, calld->path)) continue;
       if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
           !calld->recv_idempotent_request) {
         continue;
@@ -642,7 +642,7 @@ static void start_new_rpc(grpc_exec_ctx *exec_ctx, grpc_call_element *elem) {
                                       chand->registered_method_slots];
       if (!rm) break;
       if (rm->has_host) continue;
-      if (grpc_slice_cmp(rm->method, calld->path) != 0) continue;
+      if (!grpc_slice_eq(rm->method, calld->path)) continue;
       if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
           !calld->recv_idempotent_request) {
         continue;
@@ -739,13 +739,13 @@ static grpc_mdelem server_filter(grpc_exec_ctx *exec_ctx, void *user_data,
                                  grpc_mdelem md) {
   grpc_call_element *elem = user_data;
   call_data *calld = elem->call_data;
-  if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_PATH) == 0) {
+  if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_PATH)) {
     if (!calld->path_set) {
       calld->path = grpc_slice_ref(GRPC_MDVALUE(md));
       calld->path_set = true;
     }
     return GRPC_MDNULL;
-  } else if (grpc_slice_cmp(GRPC_MDKEY(md), GRPC_MDSTR_AUTHORITY) == 0) {
+  } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_AUTHORITY)) {
     if (!calld->host_set) {
       calld->host = grpc_slice_ref(GRPC_MDVALUE(md));
       calld->host_set = true;
diff --git a/src/core/lib/transport/metadata.c b/src/core/lib/transport/metadata.c
index 2082d1bac2..f9f5ac9dd2 100644
--- a/src/core/lib/transport/metadata.c
+++ b/src/core/lib/transport/metadata.c
@@ -279,8 +279,7 @@ grpc_mdelem grpc_mdelem_create(
   idx = TABLE_IDX(hash, shard->capacity);
   /* search for an existing pair */
   for (md = shard->elems[idx]; md; md = md->bucket_next) {
-    if (grpc_slice_cmp(key, md->key) == 0 &&
-        grpc_slice_cmp(value, md->value) == 0) {
+    if (grpc_slice_eq(key, md->key) && grpc_slice_eq(value, md->value)) {
       REF_MD_LOCKED(shard, md);
       gpr_mu_unlock(&shard->mu);
       GPR_TIMER_END("grpc_mdelem_from_metadata_strings", 0);
@@ -496,7 +495,8 @@ void *grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void *),
 
 bool grpc_mdelem_eq(grpc_mdelem a, grpc_mdelem b) {
   if (a.payload == b.payload) return true;
+  if (GRPC_MDELEM_IS_INTERNED(a) && GRPC_MDELEM_IS_INTERNED(b)) return false;
   if (GRPC_MDISNULL(a) || GRPC_MDISNULL(b)) return false;
-  return 0 == grpc_slice_cmp(GRPC_MDKEY(a), GRPC_MDKEY(b)) &&
-         0 == grpc_slice_cmp(GRPC_MDVALUE(a), GRPC_MDVALUE(b));
+  return grpc_slice_eq(GRPC_MDKEY(a), GRPC_MDKEY(b)) &&
+         grpc_slice_eq(GRPC_MDVALUE(a), GRPC_MDVALUE(b));
 }
diff --git a/src/core/lib/transport/metadata.h b/src/core/lib/transport/metadata.h
index 6d0afbe789..f4ba86c854 100644
--- a/src/core/lib/transport/metadata.h
+++ b/src/core/lib/transport/metadata.h
@@ -86,17 +86,21 @@ typedef struct grpc_mdelem_data {
   /* there is a private part to this in metadata.c */
 } grpc_mdelem_data;
 
+/* GRPC_MDELEM_STORAGE_* enum values that can be treated as interned always have
+   this bit set in their integer value */
+#define GRPC_MDELEM_STORAGE_INTERNED_BIT 1
+
 typedef enum {
   /* memory pointed to by grpc_mdelem::payload is owned by an external system */
   GRPC_MDELEM_STORAGE_EXTERNAL = 0,
   /* memory pointed to by grpc_mdelem::payload is interned by the metadata
      system */
-  GRPC_MDELEM_STORAGE_INTERNED = 1,
+  GRPC_MDELEM_STORAGE_INTERNED = GRPC_MDELEM_STORAGE_INTERNED_BIT,
   /* memory pointed to by grpc_mdelem::payload is allocated by the metadata
      system */
   GRPC_MDELEM_STORAGE_ALLOCATED = 2,
   /* memory is in the static metadata table */
-  GRPC_MDELEM_STORAGE_STATIC = 3,
+  GRPC_MDELEM_STORAGE_STATIC = 2 | GRPC_MDELEM_STORAGE_INTERNED_BIT,
 } grpc_mdelem_data_storage;
 
 struct grpc_mdelem {
@@ -111,6 +115,9 @@ struct grpc_mdelem {
   ((grpc_mdelem_data_storage)((md).payload & (uintptr_t)3))
 #define GRPC_MAKE_MDELEM(data, storage) \
   ((grpc_mdelem){((uintptr_t)(data)) | ((uintptr_t)storage)})
+#define GRPC_MDELEM_IS_INTERNED(md)          \
+  ((grpc_mdelem_data_storage)((md).payload & \
+                              (uintptr_t)GRPC_MDELEM_STORAGE_INTERNED_BIT))
 
 /* Unrefs the slices. */
 grpc_mdelem grpc_mdelem_from_slices(grpc_exec_ctx *exec_ctx, grpc_slice key,
diff --git a/src/core/lib/transport/static_metadata.c b/src/core/lib/transport/static_metadata.c
index 575f442a9b..374a5fd615 100644
--- a/src/core/lib/transport/static_metadata.c
+++ b/src/core/lib/transport/static_metadata.c
@@ -117,7 +117,7 @@ static uint8_t g_raw_bytes[] = {
 static void static_ref(void *unused) {}
 static void static_unref(grpc_exec_ctx *exec_ctx, void *unused) {}
 static const grpc_slice_refcount_vtable static_vtable = {
-    static_ref, static_unref, grpc_static_slice_hash};
+    static_ref, static_unref, grpc_static_slice_eq, grpc_static_slice_hash};
 static grpc_slice_refcount g_refcnt = {&static_vtable};
 
 bool grpc_is_static_metadata_string(grpc_slice slice) {