grpc 1.39.0 → 1.41.0

data/src/core/lib/iomgr/tcp_uv.cc

@@ -1,421 +0,0 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/port.h"
-
-#ifdef GRPC_UV
-#include <limits.h>
-#include <string.h>
-
-#include <grpc/slice_buffer.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/iomgr_custom.h"
-#include "src/core/lib/iomgr/resolve_address_custom.h"
-#include "src/core/lib/iomgr/resource_quota.h"
-#include "src/core/lib/iomgr/tcp_custom.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
-
-#include <uv.h>
-
-#define IGNORE_CONST(addr) ((grpc_sockaddr*)(uintptr_t)(addr))
-
-typedef struct uv_socket_t {
-  uv_connect_t connect_req;
-  uv_write_t write_req;
-  uv_shutdown_t shutdown_req;
-  uv_tcp_t* handle;
-  uv_buf_t* write_buffers;
-
-  char* read_buf;
-  size_t read_len;
-
-  int pending_connections;
-  grpc_custom_socket* accept_socket;
-  grpc_error_handle accept_error;
-
-  grpc_custom_connect_callback connect_cb;
-  grpc_custom_write_callback write_cb;
-  grpc_custom_read_callback read_cb;
-  grpc_custom_accept_callback accept_cb;
-  grpc_custom_close_callback close_cb;
-
-} uv_socket_t;
-
-static grpc_error_handle tcp_error_create(const char* desc, int status) {
-  if (status == 0) {
-    return GRPC_ERROR_NONE;
-  }
-  grpc_error_handle error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(desc);
-  /* All tcp errors are marked with UNAVAILABLE so that application may
-   * choose to retry. */
-  error = grpc_error_set_int(error, GRPC_ERROR_INT_GRPC_STATUS,
-                             GRPC_STATUS_UNAVAILABLE);
-  return grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR,
-                            grpc_slice_from_static_string(uv_strerror(status)));
-}
-
-static void uv_socket_destroy(grpc_custom_socket* socket) {
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  gpr_free(uv_socket->handle);
-  gpr_free(uv_socket);
-}
-
-static void alloc_uv_buf(uv_handle_t* handle, size_t suggested_size,
-                         uv_buf_t* buf) {
-  uv_socket_t* uv_socket =
-      (uv_socket_t*)((grpc_custom_socket*)handle->data)->impl;
-  (void)suggested_size;
-  buf->base = uv_socket->read_buf;
-  buf->len = uv_socket->read_len;
-}
-
-static void uv_read_callback(uv_stream_t* stream, ssize_t nread,
-                             const uv_buf_t* buf) {
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  if (nread == 0) {
-    // Nothing happened. Wait for the next callback
-    return;
-  }
-  // TODO(murgatroid99): figure out what the return value here means
-  uv_read_stop(stream);
-  if (nread == UV_EOF) {
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("EOF");
-  } else if (nread < 0) {
-    error = tcp_error_create("TCP Read failed", nread);
-  }
-  grpc_custom_socket* socket = (grpc_custom_socket*)stream->data;
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  uv_socket->read_cb(socket, (size_t)nread, error);
-}
-
-static void uv_close_callback(uv_handle_t* handle) {
-  grpc_custom_socket* socket = (grpc_custom_socket*)handle->data;
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  if (uv_socket->accept_socket) {
-    uv_socket->accept_cb(socket, uv_socket->accept_socket,
-                         GRPC_ERROR_CREATE_FROM_STATIC_STRING("socket closed"));
-  }
-  uv_socket->close_cb(socket);
-}
-
-static void uv_socket_read(grpc_custom_socket* socket, char* buffer,
-                           size_t length, grpc_custom_read_callback read_cb) {
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  int status;
-  grpc_error_handle error;
-  uv_socket->read_cb = read_cb;
-  uv_socket->read_buf = buffer;
-  uv_socket->read_len = length;
-  // TODO(murgatroid99): figure out what the return value here means
-  status =
-      uv_read_start((uv_stream_t*)uv_socket->handle, (uv_alloc_cb)alloc_uv_buf,
-                    (uv_read_cb)uv_read_callback);
-  if (status != 0) {
-    error = tcp_error_create("TCP Read failed at start", status);
-    uv_socket->read_cb(socket, 0, error);
-  }
-}
-
-static void uv_write_callback(uv_write_t* req, int status) {
-  grpc_custom_socket* socket = (grpc_custom_socket*)req->data;
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  gpr_free(uv_socket->write_buffers);
-  uv_socket->write_cb(socket, tcp_error_create("TCP Write failed", status));
-}
-
-void uv_socket_write(grpc_custom_socket* socket,
-                     grpc_slice_buffer* write_slices,
-                     grpc_custom_write_callback write_cb) {
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  uv_socket->write_cb = write_cb;
-  uv_buf_t* uv_buffers;
-  uv_write_t* write_req;
-
-  uv_buffers = (uv_buf_t*)gpr_malloc(sizeof(uv_buf_t) * write_slices->count);
-  for (size_t i = 0; i < write_slices->count; i++) {
-    uv_buffers[i].base = (char*)GRPC_SLICE_START_PTR(write_slices->slices[i]);
-    uv_buffers[i].len = GRPC_SLICE_LENGTH(write_slices->slices[i]);
-  }
-
-  uv_socket->write_buffers = uv_buffers;
-  write_req = &uv_socket->write_req;
-  write_req->data = socket;
-  // TODO(murgatroid99): figure out what the return value here means
-  uv_write(write_req, (uv_stream_t*)uv_socket->handle, uv_buffers,
-           write_slices->count, uv_write_callback);
-}
-
-static void shutdown_callback(uv_shutdown_t* req, int status) {}
-
-static void uv_socket_shutdown(grpc_custom_socket* socket) {
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  uv_shutdown_t* req = &uv_socket->shutdown_req;
-  uv_shutdown(req, (uv_stream_t*)uv_socket->handle, shutdown_callback);
-}
-
-static void uv_socket_close(grpc_custom_socket* socket,
-                            grpc_custom_close_callback close_cb) {
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  uv_socket->close_cb = close_cb;
-  uv_close((uv_handle_t*)uv_socket->handle, uv_close_callback);
-}
-
-static grpc_error_handle uv_socket_init_helper(uv_socket_t* uv_socket,
-                                               int domain) {
-  uv_tcp_t* tcp = (uv_tcp_t*)gpr_malloc(sizeof(uv_tcp_t));
-  uv_socket->handle = tcp;
-  int status = uv_tcp_init_ex(uv_default_loop(), tcp, (unsigned int)domain);
-  if (status != 0) {
-    return tcp_error_create("Failed to initialize UV tcp handle", status);
-  }
-#if defined(GPR_LINUX) && defined(SO_REUSEPORT)
-  if (domain == AF_INET || domain == AF_INET6) {
-    int enable = 1;
-    int fd;
-    uv_fileno((uv_handle_t*)tcp, &fd);
-    // TODO Handle error here.
-    setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(enable));
-  }
-#endif
-  uv_socket->write_buffers = nullptr;
-  uv_socket->read_len = 0;
-  uv_tcp_nodelay(uv_socket->handle, 1);
-  // Node uses a garbage collector to call destructors, so we don't
-  // want to hold the uv loop open with active gRPC objects.
-  uv_unref((uv_handle_t*)uv_socket->handle);
-  uv_socket->pending_connections = 0;
-  uv_socket->accept_socket = nullptr;
-  uv_socket->accept_error = GRPC_ERROR_NONE;
-  return GRPC_ERROR_NONE;
-}
-
-static grpc_error_handle uv_socket_init(grpc_custom_socket* socket,
-                                        int domain) {
-  uv_socket_t* uv_socket = (uv_socket_t*)gpr_malloc(sizeof(uv_socket_t));
-  grpc_error_handle error = uv_socket_init_helper(uv_socket, domain);
-  if (error != GRPC_ERROR_NONE) {
-    return error;
-  }
-  uv_socket->handle->data = socket;
-  socket->impl = uv_socket;
-  return GRPC_ERROR_NONE;
-}
-
-static grpc_error_handle uv_socket_getpeername(grpc_custom_socket* socket,
-                                               const grpc_sockaddr* addr,
-                                               int* addr_len) {
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  int err = uv_tcp_getpeername(uv_socket->handle,
-                               (struct sockaddr*)IGNORE_CONST(addr), addr_len);
-  return tcp_error_create("getpeername failed", err);
-}
-
-static grpc_error_handle uv_socket_getsockname(grpc_custom_socket* socket,
-                                               const grpc_sockaddr* addr,
-                                               int* addr_len) {
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  int err = uv_tcp_getsockname(uv_socket->handle,
-                               (struct sockaddr*)IGNORE_CONST(addr), addr_len);
-  return tcp_error_create("getsockname failed", err);
-}
-
-static void accept_new_connection(grpc_custom_socket* socket) {
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  if (uv_socket->pending_connections == 0 || !uv_socket->accept_socket) {
-    return;
-  }
-  grpc_custom_socket* new_socket = uv_socket->accept_socket;
-  grpc_error_handle error = uv_socket->accept_error;
-  uv_socket->accept_socket = nullptr;
-  uv_socket->accept_error = GRPC_ERROR_NONE;
-  uv_socket->pending_connections -= 1;
-  if (uv_socket->accept_error != GRPC_ERROR_NONE) {
-    uv_stream_t phony_handle;
-    uv_accept((uv_stream_t*)uv_socket->handle, &phony_handle);
-    uv_socket->accept_cb(socket, new_socket, error);
-  } else {
-    uv_socket_t* uv_new_socket = (uv_socket_t*)gpr_malloc(sizeof(uv_socket_t));
-    uv_socket_init_helper(uv_new_socket, AF_UNSPEC);
-    // UV documentation says this is guaranteed to succeed
-    GPR_ASSERT(uv_accept((uv_stream_t*)uv_socket->handle,
-                         (uv_stream_t*)uv_new_socket->handle) == 0);
-    new_socket->impl = uv_new_socket;
-    uv_new_socket->handle->data = new_socket;
-    uv_socket->accept_cb(socket, new_socket, error);
-  }
-}
-
-static void uv_on_connect(uv_stream_t* server, int status) {
-  grpc_custom_socket* socket = (grpc_custom_socket*)server->data;
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  if (status < 0) {
-    switch (status) {
-      case UV_EINTR:
-      case UV_EAGAIN:
-        return;
-      default:
-        uv_socket->accept_error = tcp_error_create("accept failed", status);
-    }
-  }
-  uv_socket->pending_connections += 1;
-  accept_new_connection(socket);
-}
-
-void uv_socket_accept(grpc_custom_socket* socket,
-                      grpc_custom_socket* new_socket,
-                      grpc_custom_accept_callback accept_cb) {
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  uv_socket->accept_cb = accept_cb;
-  GPR_ASSERT(uv_socket->accept_socket == nullptr);
-  uv_socket->accept_socket = new_socket;
-  accept_new_connection(socket);
-}
-
-static grpc_error_handle uv_socket_bind(grpc_custom_socket* socket,
-                                        const grpc_sockaddr* addr, size_t len,
-                                        int flags) {
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  int status =
-      uv_tcp_bind((uv_tcp_t*)uv_socket->handle, (struct sockaddr*)addr, 0);
-  return tcp_error_create("Failed to bind to port", status);
-}
-
-static grpc_error_handle uv_socket_listen(grpc_custom_socket* socket) {
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  int status =
-      uv_listen((uv_stream_t*)uv_socket->handle, SOMAXCONN, uv_on_connect);
-  return tcp_error_create("Failed to listen to port", status);
-}
-
-static void uv_tc_on_connect(uv_connect_t* req, int status) {
-  grpc_custom_socket* socket = (grpc_custom_socket*)req->data;
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  grpc_error_handle error;
-  if (status == UV_ECANCELED) {
-    // This should only happen if the handle is already closed
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Timeout occurred");
-  } else {
-    error = tcp_error_create("Failed to connect to remote host", status);
-  }
-  uv_socket->connect_cb(socket, error);
-}
-
-static void uv_socket_connect(grpc_custom_socket* socket,
-                              const grpc_sockaddr* addr, size_t len,
-                              grpc_custom_connect_callback connect_cb) {
-  uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  uv_socket->connect_cb = connect_cb;
-  uv_socket->connect_req.data = socket;
-  int status = uv_tcp_connect(&uv_socket->connect_req, uv_socket->handle,
-                              (struct sockaddr*)addr, uv_tc_on_connect);
-  if (status != 0) {
-    // The callback will not be called
-    uv_socket->connect_cb(socket, tcp_error_create("connect failed", status));
-  }
-}
-
-static grpc_resolved_addresses* handle_addrinfo_result(
-    struct addrinfo* result) {
-  struct addrinfo* resp;
-  size_t i;
-  grpc_resolved_addresses* addresses =
-      (grpc_resolved_addresses*)gpr_malloc(sizeof(grpc_resolved_addresses));
-  addresses->naddrs = 0;
-  for (resp = result; resp != nullptr; resp = resp->ai_next) {
-    addresses->naddrs++;
-  }
-  addresses->addrs = (grpc_resolved_address*)gpr_malloc(
-      sizeof(grpc_resolved_address) * addresses->naddrs);
-  for (resp = result, i = 0; resp != nullptr; resp = resp->ai_next, i++) {
-    memcpy(&addresses->addrs[i].addr, resp->ai_addr, resp->ai_addrlen);
-    addresses->addrs[i].len = resp->ai_addrlen;
-  }
-  // addrinfo objects are allocated by libuv (e.g. in uv_getaddrinfo)
-  // and not by gpr_malloc
-  uv_freeaddrinfo(result);
-  return addresses;
-}
-
-static void uv_resolve_callback(uv_getaddrinfo_t* req, int status,
-                                struct addrinfo* res) {
-  grpc_custom_resolver* r = (grpc_custom_resolver*)req->data;
-  gpr_free(req);
-  grpc_resolved_addresses* result = nullptr;
-  if (status == 0) {
-    result = handle_addrinfo_result(res);
-  }
-  grpc_custom_resolve_callback(r, result,
-                               tcp_error_create("getaddrinfo failed", status));
-}
-
-static grpc_error_handle uv_resolve(const char* host, const char* port,
-                                    grpc_resolved_addresses** result) {
-  int status;
-  uv_getaddrinfo_t req;
-  struct addrinfo hints;
-  memset(&hints, 0, sizeof(struct addrinfo));
-  hints.ai_family = AF_UNSPEC;     /* ipv4 or ipv6 */
-  hints.ai_socktype = SOCK_STREAM; /* stream socket */
-  hints.ai_flags = AI_PASSIVE;     /* for wildcard IP address */
-  status = uv_getaddrinfo(uv_default_loop(), &req, NULL, host, port, &hints);
-  if (status != 0) {
-    *result = nullptr;
-  } else {
-    *result = handle_addrinfo_result(req.addrinfo);
-  }
-  return tcp_error_create("getaddrinfo failed", status);
-}
-
-static void uv_resolve_async(grpc_custom_resolver* r, const char* host,
-                             const char* port) {
-  int status;
-  uv_getaddrinfo_t* req =
-      (uv_getaddrinfo_t*)gpr_malloc(sizeof(uv_getaddrinfo_t));
-  req->data = r;
-  struct addrinfo hints;
-  memset(&hints, 0, sizeof(struct addrinfo));
-  hints.ai_family = GRPC_AF_UNSPEC;     /* ipv4 or ipv6 */
-  hints.ai_socktype = GRPC_SOCK_STREAM; /* stream socket */
-  hints.ai_flags = GRPC_AI_PASSIVE;     /* for wildcard IP address */
-  status = uv_getaddrinfo(uv_default_loop(), req, uv_resolve_callback, host,
-                          port, &hints);
-  if (status != 0) {
-    gpr_free(req);
-    grpc_error_handle error = tcp_error_create("getaddrinfo failed", status);
-    grpc_custom_resolve_callback(r, NULL, error);
-  }
-}
-
-grpc_custom_resolver_vtable uv_resolver_vtable = {uv_resolve, uv_resolve_async};
-
-grpc_socket_vtable grpc_uv_socket_vtable = {
-    uv_socket_init,     uv_socket_connect,     uv_socket_destroy,
-    uv_socket_shutdown, uv_socket_close,       uv_socket_write,
-    uv_socket_read,     uv_socket_getpeername, uv_socket_getsockname,
-    uv_socket_bind,     uv_socket_listen,      uv_socket_accept};
-
-#endif

data/src/core/lib/iomgr/timer_uv.cc

@@ -1,66 +0,0 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/port.h"
-
-#ifdef GRPC_UV
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/debug/trace.h"
-#include "src/core/lib/iomgr/iomgr_custom.h"
-#include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/iomgr/timer_custom.h"
-
-#include <uv.h>
-
-static void timer_close_callback(uv_handle_t* handle) { gpr_free(handle); }
-
-static void stop_uv_timer(uv_timer_t* handle) {
-  uv_timer_stop(handle);
-  uv_unref((uv_handle_t*)handle);
-  uv_close((uv_handle_t*)handle, timer_close_callback);
-}
-
-void run_expired_timer(uv_timer_t* handle) {
-  grpc_custom_timer* timer_wrapper = (grpc_custom_timer*)handle->data;
-  grpc_custom_timer_callback(timer_wrapper, GRPC_ERROR_NONE);
-}
-
-static void timer_start(grpc_custom_timer* t) {
-  uv_timer_t* uv_timer;
-  uv_timer = (uv_timer_t*)gpr_malloc(sizeof(uv_timer_t));
-  uv_timer_init(uv_default_loop(), uv_timer);
-  uv_timer->data = t;
-  t->timer = (void*)uv_timer;
-  uv_timer_start(uv_timer, run_expired_timer, t->timeout_ms, 0);
-  // Node uses a garbage collector to call destructors, so we don't
-  // want to hold the uv loop open with active gRPC objects.
-  uv_unref((uv_handle_t*)uv_timer);
-}
-
-static void timer_stop(grpc_custom_timer* t) {
-  stop_uv_timer((uv_timer_t*)t->timer);
-}
-
-grpc_custom_timer_vtable uv_timer_vtable = {timer_start, timer_stop};
-
-#endif

data/third_party/upb/third_party/wyhash/wyhash.h

@@ -1,145 +0,0 @@
-/* Copyright 2020 王一 Wang Yi <godspeed_china@yeah.net>
-   This is free and unencumbered software released into the public domain. http://unlicense.org/
-   See github.com/wangyi-fudan/wyhash/ LICENSE
- */
-#ifndef wyhash_final_version
-#define wyhash_final_version
-//defines that change behavior
-#ifndef WYHASH_CONDOM
-#define WYHASH_CONDOM 1 //0: read 8 bytes before and after boundaries, dangerous but fastest. 1: normal valid behavior 2: extra protection against entropy loss (probability=2^-63), aka. "blind multiplication"
-#endif
-#define WYHASH_32BIT_MUM 0	//faster on 32 bit system
-//includes
-#include <stdint.h>
-#include <string.h>
-#if defined(_MSC_VER) && defined(_M_X64)
-  #include <intrin.h>
-  #pragma intrinsic(_umul128)
-#endif
-#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
-  #define _likely_(x)	__builtin_expect(x,1)
-  #define _unlikely_(x)	__builtin_expect(x,0)
-#else
-  #define _likely_(x) (x)
-  #define _unlikely_(x) (x)
-#endif
-//mum function
-static inline uint64_t _wyrot(uint64_t x) { return (x>>32)|(x<<32); }
-static inline void _wymum(uint64_t *A, uint64_t *B){
-#if(WYHASH_32BIT_MUM)
-  uint64_t hh=(*A>>32)*(*B>>32), hl=(*A>>32)*(unsigned)*B, lh=(unsigned)*A*(*B>>32), ll=(uint64_t)(unsigned)*A*(unsigned)*B;
-  #if(WYHASH_CONDOM>1)
-  *A^=_wyrot(hl)^hh; *B^=_wyrot(lh)^ll;
-  #else
-  *A=_wyrot(hl)^hh; *B=_wyrot(lh)^ll;
-  #endif
-#elif defined(__SIZEOF_INT128__)
-  __uint128_t r=*A; r*=*B; 
-  #if(WYHASH_CONDOM>1)
-  *A^=(uint64_t)r; *B^=(uint64_t)(r>>64);
-  #else
-  *A=(uint64_t)r; *B=(uint64_t)(r>>64);
-  #endif
-#elif defined(_MSC_VER) && defined(_M_X64)
-  #if(WYHASH_CONDOM>1)
-  uint64_t  a,  b;
-  a=_umul128(*A,*B,&b);
-  *A^=a;  *B^=b;
-  #else
-  *A=_umul128(*A,*B,B);
-  #endif
-#else
-  uint64_t ha=*A>>32, hb=*B>>32, la=(uint32_t)*A, lb=(uint32_t)*B, hi, lo;
-  uint64_t rh=ha*hb, rm0=ha*lb, rm1=hb*la, rl=la*lb, t=rl+(rm0<<32), c=t<rl;
-  lo=t+(rm1<<32); c+=lo<t; hi=rh+(rm0>>32)+(rm1>>32)+c;
-  #if(WYHASH_CONDOM>1)
-  *A^=lo;  *B^=hi;
-  #else
-  *A=lo;  *B=hi;
-  #endif
-#endif
-}
-static inline uint64_t _wymix(uint64_t A, uint64_t B){ _wymum(&A,&B); return A^B; }
-//read functions
-#ifndef WYHASH_LITTLE_ENDIAN
-  #if defined(_WIN32) || defined(__LITTLE_ENDIAN__) || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-    #define WYHASH_LITTLE_ENDIAN 1
-  #elif defined(__BIG_ENDIAN__) || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-    #define WYHASH_LITTLE_ENDIAN 0
-  #endif
-#endif
-#if (WYHASH_LITTLE_ENDIAN)
-static inline uint64_t _wyr8(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return v;}
-static inline uint64_t _wyr4(const uint8_t *p) { unsigned v; memcpy(&v, p, 4); return v;}
-#elif defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
-static inline uint64_t _wyr8(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return __builtin_bswap64(v);}
-static inline uint64_t _wyr4(const uint8_t *p) { unsigned v; memcpy(&v, p, 4); return __builtin_bswap32(v);}
-#elif defined(_MSC_VER)
-static inline uint64_t _wyr8(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return _byteswap_uint64(v);}
-static inline uint64_t _wyr4(const uint8_t *p) { unsigned v; memcpy(&v, p, 4); return _byteswap_ulong(v);}
-#endif
-static inline uint64_t _wyr3(const uint8_t *p, unsigned k) { return (((uint64_t)p[0])<<16)|(((uint64_t)p[k>>1])<<8)|p[k-1];}
-//wyhash function
-static inline uint64_t _wyfinish16(const uint8_t *p, uint64_t len, uint64_t seed, const uint64_t *secret, uint64_t i){
-#if(WYHASH_CONDOM>0)
-  uint64_t a, b;
-  if(_likely_(i<=8)){
-    if(_likely_(i>=4)){ a=_wyr4(p); b=_wyr4(p+i-4); }
-    else if (_likely_(i)){ a=_wyr3(p,i); b=0; }
-    else a=b=0;
-  } 
-  else{ a=_wyr8(p); b=_wyr8(p+i-8); }
-  return _wymix(secret[1]^len,_wymix(a^secret[1], b^seed));
-#else
-  #define oneshot_shift ((i<8)*((8-i)<<3))
-  return _wymix(secret[1]^len,_wymix((_wyr8(p)<<oneshot_shift)^secret[1],(_wyr8(p+i-8)>>oneshot_shift)^seed));
-#endif
-}
-
-static inline uint64_t _wyfinish(const uint8_t *p, uint64_t len, uint64_t seed, const uint64_t *secret, uint64_t i){
-  if(_likely_(i<=16)) return _wyfinish16(p,len,seed,secret,i);
-  return _wyfinish(p+16,len,_wymix(_wyr8(p)^secret[1],_wyr8(p+8)^seed),secret,i-16);
-}
-
-static inline uint64_t wyhash(const void *key, uint64_t len, uint64_t seed, const uint64_t *secret){
-  const uint8_t *p=(const uint8_t *)key;
-  uint64_t i=len; seed^=*secret;
-  if(_unlikely_(i>64)){
-    uint64_t see1=seed;
-    do{
-      seed=_wymix(_wyr8(p)^secret[1],_wyr8(p+8)^seed)^_wymix(_wyr8(p+16)^secret[2],_wyr8(p+24)^seed);
-      see1=_wymix(_wyr8(p+32)^secret[3],_wyr8(p+40)^see1)^_wymix(_wyr8(p+48)^secret[4],_wyr8(p+56)^see1);
-      p+=64; i-=64;
-    }while(i>64);
-    seed^=see1;
-  }
-  return _wyfinish(p,len,seed,secret,i);
-}
-//utility functions
-const uint64_t _wyp[5] = {0xa0761d6478bd642full, 0xe7037ed1a0b428dbull, 0x8ebc6af09c88c6e3ull, 0x589965cc75374cc3ull, 0x1d8e4e27c47d124full};
-static inline uint64_t wyhash64(uint64_t A, uint64_t B){  A^=_wyp[0]; B^=_wyp[1];  _wymum(&A,&B);  return _wymix(A^_wyp[0],B^_wyp[1]);}
-static inline uint64_t wyrand(uint64_t *seed){  *seed+=_wyp[0]; return _wymix(*seed,*seed^_wyp[1]);}
-static inline double wy2u01(uint64_t r){ const double _wynorm=1.0/(1ull<<52); return (r>>12)*_wynorm;}
-static inline double wy2gau(uint64_t r){ const double _wynorm=1.0/(1ull<<20); return ((r&0x1fffff)+((r>>21)&0x1fffff)+((r>>42)&0x1fffff))*_wynorm-3.0;}
-static inline uint64_t wy2u0k(uint64_t r, uint64_t k){ _wymum(&r,&k); return k; }
-
-static inline void make_secret(uint64_t seed, uint64_t *secret){
-  uint8_t c[] = {15, 23, 27, 29, 30, 39, 43, 45, 46, 51, 53, 54, 57, 58, 60, 71, 75, 77, 78, 83, 85, 86, 89, 90, 92, 99, 101, 102, 105, 106, 108, 113, 114, 116, 120, 135, 139, 141, 142, 147, 149, 150, 153, 154, 156, 163, 165, 166, 169, 170, 172, 177, 178, 180, 184, 195, 197, 198, 201, 202, 204, 209, 210, 212, 216, 225, 226, 228, 232, 240 };
-  for(size_t i=0;i<5;i++){
-    uint8_t ok;
-    do{
-      ok=1; secret[i]=0;
-      for(size_t j=0;j<64;j+=8) secret[i]|=((uint64_t)c[wyrand(&seed)%sizeof(c)])<<j;
-      if(secret[i]%2==0){ ok=0; continue; }
-      for(size_t j=0;j<i;j++)
-#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
-        if(__builtin_popcountll(secret[j]^secret[i])!=32){ ok=0; break; }
-#elif defined(_MSC_VER) && defined(_M_X64)
-        if(_mm_popcnt_u64(secret[j]^secret[i])!=32){ ok=0; break; }
-#endif
-       if(!ok)continue;
-       for(uint64_t j=3;j<0x100000000ull;j+=2) if(secret[i]%j==0){ ok=0; break; }
-    }while(!ok);
-  }
-}
-#endif

data/third_party/upb/upb/upb.int.h

@@ -1,29 +0,0 @@
-
-#ifndef UPB_INT_H_
-#define UPB_INT_H_
-
-#include "upb/upb.h"
-
-struct mem_block;
-typedef struct mem_block mem_block;
-
-struct upb_arena {
-  _upb_arena_head head;
-  uint32_t *cleanups;
-
-  /* Allocator to allocate arena blocks.  We are responsible for freeing these
-   * when we are destroyed. */
-  upb_alloc *block_alloc;
-  uint32_t last_size;
-
-  /* When multiple arenas are fused together, each arena points to a parent
-   * arena (root points to itself). The root tracks how many live arenas
-   * reference it. */
-  uint32_t refcount;  /* Only used when a->parent == a */
-  struct upb_arena *parent;
-
-  /* Linked list of blocks to free/cleanup. */
-  mem_block *freelist, *freelist_tail;
-};
-
-#endif  /* UPB_INT_H_ */