third_party/zlib/BUILD.gn

# Copyright (c) 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import("//build/config/compiler/compiler.gni")
if (current_cpu == "arm" || current_cpu == "arm64") {
  import("//build/config/arm.gni")
}

config("zlib_config") {
  include_dirs = [ "." ]
}

config("zlib_internal_config") {
  defines = [ "ZLIB_IMPLEMENTATION" ]
}

use_arm_neon_optimizations = false
if (current_cpu == "arm" || current_cpu == "arm64") {
  if (arm_use_neon) {
    use_arm_neon_optimizations = true
  }
}

# TODO(b/206642994): look into whether we should condition on the
# floating_point_fpu SABI variable, rather than sb_is_evergreen, here as we did
# in third_party/zlib/zlib.gyp.
if (is_starboard && sb_is_evergreen && target_cpu == "arm" &&
    use_arm_neon_optimizations) {
  config("zlib_neon_fpu_config") {
    cflags = [ "-mfpu=neon" ]
    asmflags = cflags
  }
}

use_x86_x64_optimizations =
    (current_cpu == "x86" || current_cpu == "x64") && !is_ios

config("zlib_adler32_simd_config") {
  if (use_x86_x64_optimizations) {
    defines = [ "ADLER32_SIMD_SSSE3" ]
  }

  if (use_arm_neon_optimizations) {
    defines = [ "ADLER32_SIMD_NEON" ]
  }
}

source_set("zlib_adler32_simd") {
  visibility = [ ":*" ]

  if (use_x86_x64_optimizations) {
    sources = [
      "adler32_simd.c",
      "adler32_simd.h",
    ]
    if (!is_win || is_clang) {
      cflags = [ "-mssse3" ]
    }
  }

  if (use_arm_neon_optimizations) {
    sources = [
      "adler32_simd.c",
      "adler32_simd.h",
    ]

    if (!is_debug) {
      # Use optimize_speed (-O3) to output the _smallest_ code.
      if(!use_cobalt_customizations) {
        configs -= [ "//build/config/compiler:default_optimization" ]
      }
      configs += [ "//build/config/compiler:optimize_speed" ]
    }
  }

  configs += [ ":zlib_internal_config" ]
  if (is_starboard && !is_debug) {
    configs -= [ "//starboard/build/config:size" ]
    configs += [ "//starboard/build/config:speed" ]
  }

  if (is_starboard && sb_is_evergreen && target_cpu == "arm" &&
      use_arm_neon_optimizations) {
    configs += [ ":zlib_neon_fpu_config" ]
  }

  public_configs = [ ":zlib_adler32_simd_config" ]
}

if (use_arm_neon_optimizations) {
  config("zlib_arm_crc32_config") {
    # Disabled for iPhone, as described in DDI0487C_a_armv8_arm:
    #  "All implementations of the ARMv8.1 architecture are required to
    #   implement the CRC32* instructions. These are optional in ARMv8.0."
    if (!is_ios && arm_version >= 8) {
      defines = [ "CRC32_ARMV8_CRC32" ]
      if (is_android) {
        defines += [ "ARMV8_OS_ANDROID" ]
      } else if (is_linux || is_chromeos) {
        defines += [ "ARMV8_OS_LINUX" ]
      } else if (is_fuchsia) {
        defines += [ "ARMV8_OS_FUCHSIA" ]
      } else if (is_win) {
        defines += [ "ARMV8_OS_WINDOWS" ]
      } else {
        assert(is_starboard, "Unsupported ARM OS")
      }
    }
  }

  source_set("zlib_arm_crc32") {
    visibility = [ ":*" ]

    if (!is_ios) {
      include_dirs = [ "." ]

      if (!use_cobalt_customizations && is_android) {
        import("//build/config/android/config.gni")
        if (defined(android_ndk_root) && android_ndk_root != "") {
          deps = [
            "//third_party/android_ndk:cpu_features",
          ]
        } else {
          assert(false, "CPU detection requires the Android NDK")
        }
      } else if (!is_win && !is_clang) {
        assert(!use_thin_lto,
               "ThinLTO fails mixing different module-level targets")
        cflags_c = [ "-march=armv8-a+crc" ]
      }

      sources = [
        "arm_features.c",
        "arm_features.h",
        "crc32_simd.c",
        "crc32_simd.h",
      ]

      if (is_starboard && use_arm_neon_optimizations) {
        sources += [
          "contrib/optimizations/slide_hash_neon.c",
          "contrib/optimizations/slide_hash_neon.h",
        ]
      }

      if (!is_debug) {
        if(!use_cobalt_customizations) {
          configs -= [ "//build/config/compiler:default_optimization" ]
        }
        configs += [ "//build/config/compiler:optimize_speed" ]
      }
    }

    configs += [ ":zlib_internal_config" ]
    if (is_starboard && !is_debug) {
      configs -= [ "//starboard/build/config:size" ]
      configs += [ "//starboard/build/config:speed" ]
    }
    if (is_starboard) {
      deps = [ "//starboard:starboard_headers_only" ]
    }

    if (is_starboard && sb_is_evergreen && target_cpu == "arm" &&
        use_arm_neon_optimizations) {
      configs += [ ":zlib_neon_fpu_config" ]
    }

    public_configs = [ ":zlib_arm_crc32_config" ]
  }
}

config("zlib_inflate_chunk_simd_config") {
  if (use_x86_x64_optimizations) {
    defines = [ "INFLATE_CHUNK_SIMD_SSE2" ]

    if (current_cpu == "x64") {
      defines += [ "INFLATE_CHUNK_READ_64LE" ]
    }

    if (is_starboard && current_cpu == "x86") {
      cflags = [ "-msse2" ]
    }
  }

  if (use_arm_neon_optimizations) {
    defines = [ "INFLATE_CHUNK_SIMD_NEON" ]
    if (current_cpu == "arm64") {
      defines += [ "INFLATE_CHUNK_READ_64LE" ]
    }
  }
}

source_set("zlib_inflate_chunk_simd") {
  visibility = [ ":*" ]

  if (use_x86_x64_optimizations || use_arm_neon_optimizations) {
    include_dirs = [ "." ]

    sources = [
      "contrib/optimizations/chunkcopy.h",
      "contrib/optimizations/inffast_chunk.c",
      "contrib/optimizations/inffast_chunk.h",
      "contrib/optimizations/inflate.c",
    ]

    if (!is_win && use_cobalt_customizations) {
      cflags_c = [ "-Wno-unused-function" ]
      if (is_clang_16) {
        cflags_c += [
          # inffast_chunk.c a function definition without a prototype
          "-Wno-deprecated-non-prototype",
        ]
      }
    }

    if (use_arm_neon_optimizations && !is_debug) {
      # Here we trade better performance on newer/bigger ARMv8 cores
      # for less perf on ARMv7, per crbug.com/772870#c40
      if(!use_cobalt_customizations) {
        configs -= [ "//build/config/compiler:default_optimization" ]
      }
      configs += [ "//build/config/compiler:optimize_speed" ]
    }
  }

  if (!use_cobalt_customizations) {
    configs -= [ "//build/config/compiler:chromium_code" ]
  }
  configs += [
    ":zlib_internal_config",
    "//build/config/compiler:no_chromium_code",
  ]
  if (is_starboard && !is_debug) {
    configs -= [ "//starboard/build/config:size" ]
    configs += [ "//starboard/build/config:speed" ]
  }

  if (is_starboard && sb_is_evergreen && target_cpu == "arm" &&
      use_arm_neon_optimizations) {
    configs += [ ":zlib_neon_fpu_config" ]
  }

  public_configs = [ ":zlib_inflate_chunk_simd_config" ]
}

config("zlib_crc32_simd_config") {
  if (use_x86_x64_optimizations) {
    defines = [ "CRC32_SIMD_SSE42_PCLMUL" ]
  }
}

source_set("zlib_crc32_simd") {
  visibility = [ ":*" ]

  if (use_x86_x64_optimizations) {
    sources = [
      "crc32_simd.c",
      "crc32_simd.h",
    ]

    if (!is_win || is_clang) {
      cflags = [
        "-msse4.2",
        "-mpclmul",
      ]
    }
  }

  configs += [ ":zlib_internal_config" ]

  public_configs = [ ":zlib_crc32_simd_config" ]
}

source_set("zlib_x86_simd") {
  visibility = [ ":*" ]

  if (use_x86_x64_optimizations) {
    sources = [
      "crc_folding.c",
      "fill_window_sse.c",
    ]

    if (!is_win || is_clang) {
      cflags = [
        "-msse4.2",
        "-mpclmul",
      ]
    }
  } else {
    sources = [
      "simd_stub.c",
    ]
  }

  if (!use_cobalt_customizations) {
    configs -= [ "//build/config/compiler:chromium_code" ]
  }
  configs += [
    ":zlib_internal_config",
    "//build/config/compiler:no_chromium_code",
  ]
}

config("zlib_warnings") {
  if (is_clang && use_x86_x64_optimizations) {
    cflags = [ "-Wno-incompatible-pointer-types" ]
  }
}

component("zlib_hidden") {
  if (!is_win) {
    # Don't stomp on "libzlib" on other platforms.
    output_name = "chrome_zlib"
  }

  sources = [
    "adler32.c",
    "chromeconf.h",
    "compress.c",
    "crc32.c",
    "crc32.h",
    "deflate.c",
    "deflate.h",
    "gzclose.c",
    "gzguts.h",
    "gzlib.c",
    "gzread.c",
    "gzwrite.c",
    "infback.c",
    "inffast.c",
    "inffast.h",
    "inffixed.h",
    "inflate.h",
    "inftrees.c",
    "inftrees.h",
    "trees.c",
    "trees.h",
    "uncompr.c",
    "x86.h",
    "zconf.h",
    "zlib.h",
    "zutil.c",
    "zutil.h",
  ]

  defines = []
  deps = []
  cflags_c = []

  if (is_clang_16 && use_cobalt_customizations) {
    cflags_c += [
      "-Wno-deprecated-non-prototype",
      "-Wno-unused-but-set-variable",
    ]
  }

  if (use_x86_x64_optimizations || use_arm_neon_optimizations) {
    deps += [
      ":zlib_adler32_simd",
      ":zlib_inflate_chunk_simd",
    ]

    if (use_x86_x64_optimizations) {
      sources += [
        "arm_stub.c",
        "x86.c",
      ]
      if (!is_win) {
        cflags_c += [ "-Wno-missing-braces" ]
      }
      deps += [ ":zlib_crc32_simd" ]
    } else if (use_arm_neon_optimizations) {
      if (!is_starboard) {
        # The slide_hash_neon sources are moved to zlib_arm_crc32 so that they
        # can be compiled with ARM NEON support.
        sources += [
          "contrib/optimizations/slide_hash_neon.c",
          "contrib/optimizations/slide_hash_neon.h",
        ]
      }
      deps += [ ":zlib_arm_crc32" ]
    }
  } else {
    sources += [
      "arm_stub.c",
      "inflate.c",
    ]
  }

  if (is_starboard) {
    check_includes = false
    sources += [ "inflate.c" ]
    sources -= [
      "gzclose.c",
      "gzguts.h",
      "gzlib.c",
      "gzread.c",
      "gzwrite.c",
    ]
  } else if (!is_native_target_build) {
    configs -= [ "//build/config/compiler:chromium_code" ]
  }
  configs += [
    ":zlib_internal_config",
    "//build/config/compiler:no_chromium_code",

    # Must be after no_chromium_code for warning flags to be ordered correctly.
    ":zlib_warnings",
  ]

  public_configs = [ ":zlib_config" ]

  deps += [ ":zlib_x86_simd" ]
  allow_circular_includes_from = deps
}

if (use_cobalt_customizations) {
  config("zlib_all_dependent_config") {
    # To prevent Zlib ever from redefining const keyword in zconf.h
    defines = [ "STDC" ]
  }

  group("zlib") {
    all_dependent_configs = [":zlib_all_dependent_config" ]
    public_deps = [ ":zlib_hidden" ]
  }
}

config("minizip_warnings") {
  visibility = [ ":*" ]

  if (is_clang) {
    # zlib uses `if ((a == b))` for some reason.
    cflags = [ "-Wno-parentheses-equality" ]
    if (is_clang_16 && use_cobalt_customizations) {
      cflags += [
        "-Wno-misleading-indentation",
        "-Wno-unused-but-set-variable"
      ]
    }
  }
}

static_library("minizip") {
  sources = [
    "contrib/minizip/ioapi.c",
    "contrib/minizip/ioapi.h",
    "contrib/minizip/iowin32.c",
    "contrib/minizip/iowin32.h",
    "contrib/minizip/unzip.c",
    "contrib/minizip/unzip.h",
    "contrib/minizip/zip.c",
    "contrib/minizip/zip.h",
  ]

  if (!is_win) {
    sources -= [
      "contrib/minizip/iowin32.c",
      "contrib/minizip/iowin32.h",
    ]
  }

  if (is_mac || is_ios || is_android || is_nacl) {
    # Mac, Android and the BSDs don't have fopen64, ftello64, or fseeko64. We
    # use fopen, ftell, and fseek instead on these systems.
    defines = [ "USE_FILE32API" ]
  }

  deps = [
    ":zlib",
  ]

  if (is_starboard) {
    sources += [
      "contrib/minizip/iostarboard.c",
      "contrib/minizip/iostarboard.h",
    ]
    deps += [ "//starboard:starboard_headers_only" ]
  } else if (!is_native_target_build) {
    configs -= [ "//build/config/compiler:chromium_code" ]
  }
  configs += [
    "//build/config/compiler:no_chromium_code",

    # Must be after no_chromium_code for warning flags to be ordered correctly.
    ":minizip_warnings",
  ]

  public_configs = [ ":zlib_config" ]
}

if (!is_starboard) {
  executable("zlib_bench") {
    include_dirs = [ "." ]

    sources = [
      "contrib/bench/zlib_bench.cc",
    ]

    if (!is_debug) {
      if (!is_native_target_build) {
        configs -= [ "//build/config/compiler:default_optimization" ]
      }
      configs += [ "//build/config/compiler:optimize_speed" ]
    }

    if (!use_cobalt_customizations) {
      configs -= [ "//build/config/compiler:chromium_code" ]
    }
    configs += [ "//build/config/compiler:no_chromium_code" ]

    deps = [
      ":zlib",
    ]
  }
}

static_library("zip") {
  sources = [
    "google/zip.cc",
    "google/zip.h",
    "google/zip_internal.cc",
    "google/zip_internal.h",
    "google/zip_reader.cc",
    "google/zip_reader.h",
    "google/zip_writer.cc",
    "google/zip_writer.h",
  ]

  deps = [
    ":minizip",
    "//base",
  ]
}

target(gtest_target_type, "zip_unittests") {
  testonly = true

  sources = [
    "google/compression_utils_unittest.cc",
    "google/zip_reader_unittest.cc",
    "google/zip_unittest.cc",
    "google/compression_utils.cc",
    "google/compression_utils.h",
    "google/compression_utils_portable.cc",
    "google/compression_utils_portable.h",
  ]

  deps = [
    ":minizip",
    ":zip",
    ":zlib",
    "//base/test:run_all_unittests",
    "//base/test:test_support",
    "//starboard/common",
    "//testing/gmock",
    "//testing/gtest",
    "//third_party/zlib/google/test:zip_unittest_files",
  ]

  if (is_starboard) {
    configs -= [ "//starboard/build/config:size" ]
    configs += [ "//starboard/build/config:speed" ]

    data_deps = [ "//third_party/zlib/google/test:zip_unittest_files" ]
  }
}