Add submodule dependency filesHEADmaster

Change-Id: Iaf8d18082d3991dec7c0ebbea540f092188eb4ec

27 files changed, 4127 insertions, 0 deletions

diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/32-bit-toolchain.cmake b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/32-bit-toolchain.cmake
new file mode 100644
index 000000000..f3a10b708
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/32-bit-toolchain.cmake
@@ -0,0 +1,7 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+set(CMAKE_SYSTEM_PROCESSOR "x86")
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32 -msse2" CACHE STRING "c++ flags")
+set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} -m32 -msse2" CACHE STRING "c flags")
+set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -m32 -msse2" CACHE STRING "asm flags")
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/BUILD.toplevel b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/BUILD.toplevel
new file mode 100644
index 000000000..be3fd96c9
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/BUILD.toplevel
@@ -0,0 +1,130 @@
+# Copyright (c) 2016, Google Inc.
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+licenses(["notice"])
+
+exports_files(["LICENSE"])
+
+load(
+    ":BUILD.generated.bzl",
+    "crypto_headers",
+    "crypto_internal_headers",
+    "crypto_sources",
+    "crypto_sources_linux_x86_64",
+    "crypto_sources_mac_x86_64",
+    "ssl_headers",
+    "ssl_internal_headers",
+    "ssl_c_sources",
+    "ssl_cc_sources",
+    "tool_sources",
+    "tool_headers",
+)
+
+config_setting(
+    name = "linux_x86_64",
+    values = {"cpu": "k8"},
+)
+
+config_setting(
+    name = "mac_x86_64",
+    values = {"cpu": "darwin"},
+)
+
+boringssl_copts = [
+    # Assembler option --noexecstack adds .note.GNU-stack to each object to
+    # ensure that binaries can be built with non-executable stack.
+    "-Wa,--noexecstack",
+
+    # This is needed on Linux systems (at least) to get rwlock in pthread.
+    "-D_XOPEN_SOURCE=700",
+
+    # This list of warnings should match those in the top-level CMakeLists.txt.
+    "-Wall",
+    "-Werror",
+    "-Wformat=2",
+    "-Wsign-compare",
+    "-Wmissing-field-initializers",
+    "-Wwrite-strings",
+    "-Wshadow",
+    "-fno-common",
+
+    # Modern build environments should be able to set this to use atomic
+    # operations for reference counting rather than locks. However, it's
+    # known not to work on some Android builds.
+    # "-DOPENSSL_C11_ATOMIC",
+] + select({
+    ":linux_x86_64": [],
+    ":mac_x86_64": [],
+    "//conditions:default": ["-DOPENSSL_NO_ASM"],
+})
+
+crypto_sources_asm = select({
+    ":linux_x86_64": crypto_sources_linux_x86_64,
+    ":mac_x86_64": crypto_sources_mac_x86_64,
+    "//conditions:default": [],
+})
+
+# For C targets only (not C++), compile with C11 support.
+boringssl_copts_c11 = boringssl_copts + [
+    "-std=c11",
+    "-Wmissing-prototypes",
+    "-Wold-style-definition",
+    "-Wstrict-prototypes",
+]
+
+# For C targets only (not C++), compile with C11 support.
+boringssl_copts_cxx = boringssl_copts + [
+    "-std=c++11",
+    "-Wmissing-declarations",
+]
+
+cc_library(
+    name = "crypto",
+    srcs = crypto_sources + crypto_internal_headers + crypto_sources_asm,
+    hdrs = crypto_headers,
+    copts = boringssl_copts_c11,
+    includes = ["src/include"],
+    linkopts = select({
+        ":mac_x86_64": [],
+        "//conditions:default": ["-lpthread"],
+    }),
+    visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "ssl",
+    srcs = ssl_c_sources + ssl_internal_headers,
+    hdrs = ssl_headers,
+    copts = boringssl_copts_c11,
+    includes = ["src/include"],
+    visibility = ["//visibility:public"],
+    deps = [":crypto", ":ssl_cc"],
+)
+
+cc_library(
+    name = "ssl_cc",
+    srcs = ssl_cc_sources + ssl_internal_headers,
+    hdrs = ssl_headers,
+    copts = boringssl_copts,
+    includes = ["src/include"],
+    deps = [":crypto"],
+)
+
+cc_binary(
+    name = "bssl",
+    srcs = tool_sources + tool_headers,
+    copts = boringssl_copts_cxx,
+    visibility = ["//visibility:public"],
+    deps = [":ssl"],
+)
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/all_tests.go b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/all_tests.go
new file mode 100644
index 000000000..3cf23206b
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/all_tests.go
@@ -0,0 +1,383 @@
+/* Copyright (c) 2015, Google Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"path"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+)
+
+// TODO(davidben): Link tests with the malloc shim and port -malloc-test to this runner.
+
+var (
+	useValgrind     = flag.Bool("valgrind", false, "If true, run code under valgrind")
+	useCallgrind    = flag.Bool("callgrind", false, "If true, run code under valgrind to generate callgrind traces.")
+	useGDB          = flag.Bool("gdb", false, "If true, run BoringSSL code under gdb")
+	useSDE          = flag.Bool("sde", false, "If true, run BoringSSL code under Intel's SDE for each supported chip")
+	buildDir        = flag.String("build-dir", "build", "The build directory to run the tests from.")
+	numWorkers      = flag.Int("num-workers", 1, "Runs the given number of workers when testing.")
+	jsonOutput      = flag.String("json-output", "", "The file to output JSON results to.")
+	mallocTest      = flag.Int64("malloc-test", -1, "If non-negative, run each test with each malloc in turn failing from the given number onwards.")
+	mallocTestDebug = flag.Bool("malloc-test-debug", false, "If true, ask each test to abort rather than fail a malloc. This can be used with a specific value for --malloc-test to identity the malloc failing that is causing problems.")
+)
+
+type test struct {
+	args []string
+	// cpu, if not empty, contains an Intel CPU code to simulate. Run
+	// `sde64 -help` to get a list of these codes.
+	cpu string
+}
+
+type result struct {
+	Test   test
+	Passed bool
+	Error  error
+}
+
+// testOutput is a representation of Chromium's JSON test result format. See
+// https://www.chromium.org/developers/the-json-test-results-format
+type testOutput struct {
+	Version           int                   `json:"version"`
+	Interrupted       bool                  `json:"interrupted"`
+	PathDelimiter     string                `json:"path_delimiter"`
+	SecondsSinceEpoch float64               `json:"seconds_since_epoch"`
+	NumFailuresByType map[string]int        `json:"num_failures_by_type"`
+	Tests             map[string]testResult `json:"tests"`
+}
+
+type testResult struct {
+	Actual       string `json:"actual"`
+	Expected     string `json:"expected"`
+	IsUnexpected bool   `json:"is_unexpected"`
+}
+
+// sdeCPUs contains a list of CPU code that we run all tests under when *useSDE
+// is true.
+var sdeCPUs = []string{
+	"p4p", // Pentium4 Prescott
+	"mrm", // Merom
+	"pnr", // Penryn
+	"nhm", // Nehalem
+	"wsm", // Westmere
+	"snb", // Sandy Bridge
+	"ivb", // Ivy Bridge
+	"hsw", // Haswell
+	"bdw", // Broadwell
+	"skx", // Skylake Server
+	"skl", // Skylake Client
+	"cnl", // Cannonlake
+	"knl", // Knights Landing
+	"slt", // Saltwell
+	"slm", // Silvermont
+	"glm", // Goldmont
+}
+
+func newTestOutput() *testOutput {
+	return &testOutput{
+		Version:           3,
+		PathDelimiter:     ".",
+		SecondsSinceEpoch: float64(time.Now().UnixNano()) / float64(time.Second/time.Nanosecond),
+		NumFailuresByType: make(map[string]int),
+		Tests:             make(map[string]testResult),
+	}
+}
+
+func (t *testOutput) addResult(name, result string) {
+	if _, found := t.Tests[name]; found {
+		panic(name)
+	}
+	t.Tests[name] = testResult{
+		Actual:       result,
+		Expected:     "PASS",
+		IsUnexpected: result != "PASS",
+	}
+	t.NumFailuresByType[result]++
+}
+
+func (t *testOutput) writeTo(name string) error {
+	file, err := os.Create(name)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	out, err := json.MarshalIndent(t, "", "  ")
+	if err != nil {
+		return err
+	}
+	_, err = file.Write(out)
+	return err
+}
+
+func valgrindOf(dbAttach bool, path string, args ...string) *exec.Cmd {
+	valgrindArgs := []string{"--error-exitcode=99", "--track-origins=yes", "--leak-check=full", "--quiet"}
+	if dbAttach {
+		valgrindArgs = append(valgrindArgs, "--db-attach=yes", "--db-command=xterm -e gdb -nw %f %p")
+	}
+	valgrindArgs = append(valgrindArgs, path)
+	valgrindArgs = append(valgrindArgs, args...)
+
+	return exec.Command("valgrind", valgrindArgs...)
+}
+
+func callgrindOf(path string, args ...string) *exec.Cmd {
+	valgrindArgs := []string{"-q", "--tool=callgrind", "--dump-instr=yes", "--collect-jumps=yes", "--callgrind-out-file=" + *buildDir + "/callgrind/callgrind.out.%p"}
+	valgrindArgs = append(valgrindArgs, path)
+	valgrindArgs = append(valgrindArgs, args...)
+
+	return exec.Command("valgrind", valgrindArgs...)
+}
+
+func gdbOf(path string, args ...string) *exec.Cmd {
+	xtermArgs := []string{"-e", "gdb", "--args"}
+	xtermArgs = append(xtermArgs, path)
+	xtermArgs = append(xtermArgs, args...)
+
+	return exec.Command("xterm", xtermArgs...)
+}
+
+func sdeOf(cpu, path string, args ...string) *exec.Cmd {
+	sdeArgs := []string{"-" + cpu, "--", path}
+	sdeArgs = append(sdeArgs, args...)
+	return exec.Command("sde", sdeArgs...)
+}
+
+type moreMallocsError struct{}
+
+func (moreMallocsError) Error() string {
+	return "child process did not exhaust all allocation calls"
+}
+
+var errMoreMallocs = moreMallocsError{}
+
+func runTestOnce(test test, mallocNumToFail int64) (passed bool, err error) {
+	prog := path.Join(*buildDir, test.args[0])
+	args := test.args[1:]
+	var cmd *exec.Cmd
+	if *useValgrind {
+		cmd = valgrindOf(false, prog, args...)
+	} else if *useCallgrind {
+		cmd = callgrindOf(prog, args...)
+	} else if *useGDB {
+		cmd = gdbOf(prog, args...)
+	} else if *useSDE {
+		cmd = sdeOf(test.cpu, prog, args...)
+	} else {
+		cmd = exec.Command(prog, args...)
+	}
+	var outBuf bytes.Buffer
+	cmd.Stdout = &outBuf
+	cmd.Stderr = &outBuf
+	if mallocNumToFail >= 0 {
+		cmd.Env = os.Environ()
+		cmd.Env = append(cmd.Env, "MALLOC_NUMBER_TO_FAIL="+strconv.FormatInt(mallocNumToFail, 10))
+		if *mallocTestDebug {
+			cmd.Env = append(cmd.Env, "MALLOC_ABORT_ON_FAIL=1")
+		}
+		cmd.Env = append(cmd.Env, "_MALLOC_CHECK=1")
+	}
+
+	if err := cmd.Start(); err != nil {
+		return false, err
+	}
+	if err := cmd.Wait(); err != nil {
+		if exitError, ok := err.(*exec.ExitError); ok {
+			if exitError.Sys().(syscall.WaitStatus).ExitStatus() == 88 {
+				return false, errMoreMallocs
+			}
+		}
+		fmt.Print(string(outBuf.Bytes()))
+		return false, err
+	}
+
+	// Account for Windows line-endings.
+	stdout := bytes.Replace(outBuf.Bytes(), []byte("\r\n"), []byte("\n"), -1)
+
+	if bytes.HasSuffix(stdout, []byte("PASS\n")) &&
+		(len(stdout) == 5 || stdout[len(stdout)-6] == '\n') {
+		return true, nil
+	}
+
+	// Also accept a googletest-style pass line. This is left here in
+	// transition until the tests are all converted and this script made
+	// unnecessary.
+	if bytes.Contains(stdout, []byte("\n[  PASSED  ]")) {
+		return true, nil
+	}
+
+	fmt.Print(string(outBuf.Bytes()))
+	return false, nil
+}
+
+func runTest(test test) (bool, error) {
+	if *mallocTest < 0 {
+		return runTestOnce(test, -1)
+	}
+
+	for mallocNumToFail := int64(*mallocTest); ; mallocNumToFail++ {
+		if passed, err := runTestOnce(test, mallocNumToFail); err != errMoreMallocs {
+			if err != nil {
+				err = fmt.Errorf("at malloc %d: %s", mallocNumToFail, err)
+			}
+			return passed, err
+		}
+	}
+}
+
+// shortTestName returns the short name of a test. Except for evp_test, it
+// assumes that any argument which ends in .txt is a path to a data file and not
+// relevant to the test's uniqueness.
+func shortTestName(test test) string {
+	var args []string
+	for _, arg := range test.args {
+		if test.args[0] == "crypto/evp/evp_test" || !strings.HasSuffix(arg, ".txt") {
+			args = append(args, arg)
+		}
+	}
+	return strings.Join(args, " ") + test.cpuMsg()
+}
+
+// setWorkingDirectory walks up directories as needed until the current working
+// directory is the top of a BoringSSL checkout.
+func setWorkingDirectory() {
+	for i := 0; i < 64; i++ {
+		if _, err := os.Stat("BUILDING.md"); err == nil {
+			return
+		}
+		os.Chdir("..")
+	}
+
+	panic("Couldn't find BUILDING.md in a parent directory!")
+}
+
+func parseTestConfig(filename string) ([]test, error) {
+	in, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer in.Close()
+
+	decoder := json.NewDecoder(in)
+	var testArgs [][]string
+	if err := decoder.Decode(&testArgs); err != nil {
+		return nil, err
+	}
+
+	var result []test
+	for _, args := range testArgs {
+		result = append(result, test{args: args})
+	}
+	return result, nil
+}
+
+func worker(tests <-chan test, results chan<- result, done *sync.WaitGroup) {
+	defer done.Done()
+	for test := range tests {
+		passed, err := runTest(test)
+		results <- result{test, passed, err}
+	}
+}
+
+func (t test) cpuMsg() string {
+	if len(t.cpu) == 0 {
+		return ""
+	}
+
+	return fmt.Sprintf(" (for CPU %q)", t.cpu)
+}
+
+func main() {
+	flag.Parse()
+	setWorkingDirectory()
+
+	testCases, err := parseTestConfig("util/all_tests.json")
+	if err != nil {
+		fmt.Printf("Failed to parse input: %s\n", err)
+		os.Exit(1)
+	}
+
+	var wg sync.WaitGroup
+	tests := make(chan test, *numWorkers)
+	results := make(chan result, *numWorkers)
+
+	for i := 0; i < *numWorkers; i++ {
+		wg.Add(1)
+		go worker(tests, results, &wg)
+	}
+
+	go func() {
+		for _, test := range testCases {
+			if *useSDE {
+				for _, cpu := range sdeCPUs {
+					testForCPU := test
+					testForCPU.cpu = cpu
+					tests <- testForCPU
+				}
+			} else {
+				tests <- test
+			}
+		}
+		close(tests)
+
+		wg.Wait()
+		close(results)
+	}()
+
+	testOutput := newTestOutput()
+	var failed []test
+	for testResult := range results {
+		test := testResult.Test
+		args := test.args
+
+		fmt.Printf("%s%s\n", strings.Join(args, " "), test.cpuMsg())
+		name := shortTestName(test)
+		if testResult.Error != nil {
+			fmt.Printf("%s failed to complete: %s\n", args[0], testResult.Error)
+			failed = append(failed, test)
+			testOutput.addResult(name, "CRASHED")
+		} else if !testResult.Passed {
+			fmt.Printf("%s failed to print PASS on the last line.\n", args[0])
+			failed = append(failed, test)
+			testOutput.addResult(name, "FAIL")
+		} else {
+			testOutput.addResult(name, "PASS")
+		}
+	}
+
+	if *jsonOutput != "" {
+		if err := testOutput.writeTo(*jsonOutput); err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %s\n", err)
+		}
+	}
+
+	if len(failed) > 0 {
+		fmt.Printf("\n%d of %d tests failed:\n", len(failed), len(testCases))
+		for _, test := range failed {
+			fmt.Printf("\t%s%s\n", strings.Join(test.args, ""), test.cpuMsg())
+		}
+		os.Exit(1)
+	}
+
+	fmt.Printf("\nAll tests passed!\n")
+}
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/all_tests.json b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/all_tests.json
new file mode 100644
index 000000000..a6e672f6f
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/all_tests.json
@@ -0,0 +1,59 @@
+[
+	["crypto/aes/aes_test", "crypto/aes/aes_tests.txt"],
+	["crypto/asn1/asn1_test"],
+	["crypto/base64/base64_test"],
+	["crypto/bio/bio_test"],
+	["crypto/bn/bn_test", "crypto/bn/bn_tests.txt"],
+	["crypto/bytestring/bytestring_test"],
+	["crypto/cipher/aead_test", "aes-128-gcm", "crypto/cipher/test/aes_128_gcm_tests.txt"],
+	["crypto/cipher/aead_test", "aes-256-gcm", "crypto/cipher/test/aes_256_gcm_tests.txt"],
+	["crypto/cipher/aead_test", "aes-128-gcm-siv", "crypto/cipher/test/aes_128_gcm_siv_tests.txt"],
+	["crypto/cipher/aead_test", "aes-256-gcm-siv", "crypto/cipher/test/aes_256_gcm_siv_tests.txt"],
+	["crypto/cipher/aead_test", "chacha20-poly1305", "crypto/cipher/test/chacha20_poly1305_tests.txt"],
+	["crypto/cipher/aead_test", "aes-128-cbc-sha1-tls", "crypto/cipher/test/aes_128_cbc_sha1_tls_tests.txt"],
+	["crypto/cipher/aead_test", "aes-128-cbc-sha1-tls-implicit-iv", "crypto/cipher/test/aes_128_cbc_sha1_tls_implicit_iv_tests.txt"],
+	["crypto/cipher/aead_test", "aes-128-cbc-sha256-tls", "crypto/cipher/test/aes_128_cbc_sha256_tls_tests.txt"],
+	["crypto/cipher/aead_test", "aes-256-cbc-sha1-tls", "crypto/cipher/test/aes_256_cbc_sha1_tls_tests.txt"],
+	["crypto/cipher/aead_test", "aes-256-cbc-sha1-tls-implicit-iv", "crypto/cipher/test/aes_256_cbc_sha1_tls_implicit_iv_tests.txt"],
+	["crypto/cipher/aead_test", "aes-256-cbc-sha256-tls", "crypto/cipher/test/aes_256_cbc_sha256_tls_tests.txt"],
+	["crypto/cipher/aead_test", "aes-256-cbc-sha384-tls", "crypto/cipher/test/aes_256_cbc_sha384_tls_tests.txt"],
+	["crypto/cipher/aead_test", "des-ede3-cbc-sha1-tls", "crypto/cipher/test/des_ede3_cbc_sha1_tls_tests.txt"],
+	["crypto/cipher/aead_test", "des-ede3-cbc-sha1-tls-implicit-iv", "crypto/cipher/test/des_ede3_cbc_sha1_tls_implicit_iv_tests.txt"],
+	["crypto/cipher/aead_test", "aes-128-cbc-sha1-ssl3", "crypto/cipher/test/aes_128_cbc_sha1_ssl3_tests.txt"],
+	["crypto/cipher/aead_test", "aes-256-cbc-sha1-ssl3", "crypto/cipher/test/aes_256_cbc_sha1_ssl3_tests.txt"],
+	["crypto/cipher/aead_test", "des-ede3-cbc-sha1-ssl3", "crypto/cipher/test/des_ede3_cbc_sha1_ssl3_tests.txt"],
+	["crypto/cipher/aead_test", "aes-128-ctr-hmac-sha256", "crypto/cipher/test/aes_128_ctr_hmac_sha256.txt"],
+	["crypto/cipher/aead_test", "aes-256-ctr-hmac-sha256", "crypto/cipher/test/aes_256_ctr_hmac_sha256.txt"],
+	["crypto/cipher/cipher_test", "crypto/cipher/test/cipher_tests.txt"],
+	["crypto/cmac/cmac_test"],
+	["crypto/constant_time_test"],
+	["crypto/crypto_test"],
+	["crypto/curve25519/ed25519_test", "crypto/curve25519/ed25519_tests.txt"],
+	["crypto/curve25519/spake25519_test"],
+	["crypto/digest/digest_test"],
+	["crypto/ec/example_mul"],
+	["crypto/ec/p256-x86_64_test", "crypto/ec/p256-x86_64_tests.txt"],
+	["crypto/ecdh/ecdh_test", "crypto/ecdh/ecdh_tests.txt"],
+	["crypto/ecdsa/ecdsa_sign_test", "crypto/ecdsa/ecdsa_sign_tests.txt"],
+	["crypto/ecdsa/ecdsa_test"],
+	["crypto/ecdsa/ecdsa_verify_test", "crypto/ecdsa/ecdsa_verify_tests.txt"],
+	["crypto/evp/evp_test", "crypto/evp/evp_tests.txt"],
+	["crypto/evp/pbkdf_test"],
+	["crypto/hkdf/hkdf_test"],
+	["crypto/hmac/hmac_test", "crypto/hmac/hmac_tests.txt"],
+	["crypto/lhash/lhash_test"],
+	["crypto/modes/gcm_test"],
+	["crypto/obj/obj_test"],
+	["crypto/pkcs8/pkcs12_test"],
+	["crypto/pkcs8/pkcs8_test"],
+	["crypto/poly1305/poly1305_test", "crypto/poly1305/poly1305_tests.txt"],
+	["crypto/pool/pool_test"],
+	["crypto/refcount_test"],
+	["crypto/thread_test"],
+	["crypto/x509/pkcs7_test"],
+	["crypto/x509/x509_test"],
+	["crypto/x509v3/tab_test"],
+	["crypto/x509v3/v3name_test"],
+	["decrepit/decrepit_test"],
+	["ssl/ssl_test"]
+]
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/DEPS b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/DEPS
new file mode 100644
index 000000000..55eeb8632
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/DEPS
@@ -0,0 +1,144 @@
+# Copyright (c) 2015, Google Inc.
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+vars = {
+  'chromium_git': 'https://chromium.googlesource.com',
+}
+
+deps = {
+  'boringssl/util/bot/gyp':
+    Var('chromium_git') + '/external/gyp.git' + '@' + 'e7079f0e0e14108ab0dba58728ff219637458563',
+}
+
+deps_os = {
+  'android': {
+    'boringssl/util/bot/android_tools':
+      Var('chromium_git') + '/android_tools.git' + '@' + 'b43a6a289a7588b1769814f04dd6c7d7176974cc',
+  },
+}
+
+recursedeps = [
+  # android_tools pulls in the NDK from a separate repository.
+  'boringssl/util/bot/android_tools',
+]
+
+hooks = [
+  {
+    'name': 'cmake_linux64',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=linux*',
+                '--no_auth',
+                '--bucket', 'chromium-tools',
+                '-s', 'boringssl/util/bot/cmake-linux64.tar.gz.sha1',
+    ],
+  },
+  {
+    'name': 'cmake_mac',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=darwin',
+                '--no_auth',
+                '--bucket', 'chromium-tools',
+                '-s', 'boringssl/util/bot/cmake-mac.tar.gz.sha1',
+    ],
+  },
+  {
+    'name': 'cmake_win32',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=win32',
+                '--no_auth',
+                '--bucket', 'chromium-tools',
+                '-s', 'boringssl/util/bot/cmake-win32.zip.sha1',
+    ],
+  },
+  {
+    'name': 'perl_win32',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=win32',
+                '--no_auth',
+                '--bucket', 'chromium-tools',
+                '-s', 'boringssl/util/bot/perl-win32.zip.sha1',
+    ],
+  },
+  {
+    'name': 'yasm_win32',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=win32',
+                '--no_auth',
+                '--bucket', 'chromium-tools',
+                '-s', 'boringssl/util/bot/yasm-win32.exe.sha1',
+    ],
+  },
+  {
+    'name': 'win_toolchain',
+    'pattern': '.',
+    'action': [ 'python',
+                'boringssl/util/bot/vs_toolchain.py',
+                'update',
+    ],
+  },
+  {
+    'name': 'clang',
+    'pattern': '.',
+    'action': [ 'python',
+                'boringssl/util/bot/update_clang.py',
+    ],
+  },
+  {
+    'name': 'cmake_linux64_extract',
+    'pattern': '.',
+    'action': [ 'python',
+                'boringssl/util/bot/extract.py',
+                'boringssl/util/bot/cmake-linux64.tar.gz',
+                'boringssl/util/bot/cmake-linux64/',
+    ],
+  },
+  {
+    'name': 'cmake_mac_extract',
+    'pattern': '.',
+    'action': [ 'python',
+                'boringssl/util/bot/extract.py',
+                'boringssl/util/bot/cmake-mac.tar.gz',
+                'boringssl/util/bot/cmake-mac/',
+    ],
+  },
+  {
+    'name': 'cmake_win32_extract',
+    'pattern': '.',
+    'action': [ 'python',
+                'boringssl/util/bot/extract.py',
+                'boringssl/util/bot/cmake-win32.zip',
+                'boringssl/util/bot/cmake-win32/',
+    ],
+  },
+  {
+    'name': 'perl_win32_extract',
+    'pattern': '.',
+    'action': [ 'python',
+                'boringssl/util/bot/extract.py',
+                '--no-prefix',
+                'boringssl/util/bot/perl-win32.zip',
+                'boringssl/util/bot/perl-win32/',
+    ],
+  },
+]
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/README b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/README
new file mode 100644
index 000000000..b7a4332e8
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/README
@@ -0,0 +1,3 @@
+This directory contains tools for setting up a hermetic toolchain on the
+continuous integration bots. It is in the repository for convenience and can be
+ignored in development.
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/UPDATING b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/UPDATING
new file mode 100644
index 000000000..2007d46f2
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/UPDATING
@@ -0,0 +1,47 @@
+This directory consumes tools from other repositories for use on the
+bots. To update to newer revisions, follow these instructions:
+
+DEPS: Set all revisions to those used in Chromium, found at
+   https://chromium.googlesource.com/chromium/src/+/master/DEPS (Search for the
+   corresponding repository name.)
+
+go/bootstrap.py: Set TOOLSET_VERSION to the latest release of Go, found at
+    https://golang.org/dl/.
+
+update_clang.py: Set CLANG_REVISION and CLANG_SUB_REVISION to the values used in
+    Chromium, found at
+    https://chromium.googlesource.com/chromium/src/+/master/tools/clang/scripts/update.py
+
+vs_toolchain.py: Set the hash in TOOLCHAIN_HASH to the toolchain
+    used in Chromium, found at _GetDesiredVsToolchainHashes
+    https://chromium.googlesource.com/chromium/src/+/master/build/vs_toolchain.py
+    This may require taking other updates to that file. If updating MSVS
+    version, also update TOOLCHAIN_VERSION accordingly.
+
+The .sha1 files correspond to files downloaded from Google Cloud Storage. To
+update, place the updated files in their intended location and run:
+
+    upload_to_google_storage.py -b chromium-tools FILE
+
+cmake-linux64.tar.gz: Download the latest CMake source tarball, found at
+    https://cmake.org/download/. Build it with:
+
+        ./bootstrap --prefix=$PWD/cmake-linux64 && make && make install
+        tar -czf cmake-linux64.tar.gz cmake-linux64/
+
+cmake-mac.tar.gz: Follow the same instructions as above on a Mac, but replace
+    cmake-linux64 with cmake-mac.
+
+cmake-win32.zip: Update to the latest prebuilt release of CMake, found at
+    https://cmake.org/download/. Use the file labeled "Windows ZIP". The
+    download will be named cmake-VERSION-win32-x86.zip.
+
+perl-win32.zip: Update to the latest 32-bit prebuilt "PortableZip" edition of
+    Strawberry Perl, found at http://strawberryperl.com/releases.html. The
+    download will be named strawberry-perl-VERSION-32bit-portable.zip.
+
+yasm-win32.exe: Update to the appropriate release of Yasm. Use the same version
+    as Chromium, found at
+    https://chromium.googlesource.com/chromium/src/+/master/third_party/yasm/README.chromium
+    Use the release at http://yasm.tortall.net/Download.html labeled
+    "Win32 .exe". The download will be named yasm-VERSION-win32.exe.
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/cmake-linux64.tar.gz.sha1 b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/cmake-linux64.tar.gz.sha1
new file mode 100644
index 000000000..404570f6a
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/cmake-linux64.tar.gz.sha1
@@ -0,0 +1 @@
+6ea4ad07a4bab113ea74c45fafb14b8d0b0feab5
\ No newline at end of file
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/cmake-mac.tar.gz.sha1 b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/cmake-mac.tar.gz.sha1
new file mode 100644
index 000000000..19c9b61ff
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/cmake-mac.tar.gz.sha1
@@ -0,0 +1 @@
+f3166dab96234c9516ece56dc2851bf4c8e70fe8
\ No newline at end of file
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/cmake-win32.zip.sha1 b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/cmake-win32.zip.sha1
new file mode 100644
index 000000000..6bb460eb8
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/cmake-win32.zip.sha1
@@ -0,0 +1 @@
+ed4e1939d246374b0bae724a1a4200fd60e7efe8
\ No newline at end of file
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/extract.py b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/extract.py
new file mode 100644
index 000000000..e36ce99b1
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/extract.py
@@ -0,0 +1,157 @@
+# Copyright (c) 2015, Google Inc.
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+"""Extracts archives."""
+
+
+import hashlib
+import optparse
+import os
+import os.path
+import tarfile
+import shutil
+import sys
+import zipfile
+
+
+def CheckedJoin(output, path):
+  """
+  CheckedJoin returns os.path.join(output, path). It does sanity checks to
+  ensure the resulting path is under output, but shouldn't be used on untrusted
+  input.
+  """
+  path = os.path.normpath(path)
+  if os.path.isabs(path) or path.startswith('.'):
+    raise ValueError(path)
+  return os.path.join(output, path)
+
+
+def IterateZip(path):
+  """
+  IterateZip opens the zip file at path and returns a generator of
+  (filename, mode, fileobj) tuples for each file in it.
+  """
+  with zipfile.ZipFile(path, 'r') as zip_file:
+    for info in zip_file.infolist():
+      if info.filename.endswith('/'):
+        continue
+      yield (info.filename, None, zip_file.open(info))
+
+
+def IterateTar(path):
+  """
+  IterateTar opens the tar.gz file at path and returns a generator of
+  (filename, mode, fileobj) tuples for each file in it.
+  """
+  with tarfile.open(path, 'r:gz') as tar_file:
+    for info in tar_file:
+      if info.isdir():
+        continue
+      if not info.isfile():
+        raise ValueError('Unknown entry type "%s"' % (info.name, ))
+      yield (info.name, info.mode, tar_file.extractfile(info))
+
+
+def main(args):
+  parser = optparse.OptionParser(usage='Usage: %prog ARCHIVE OUTPUT')
+  parser.add_option('--no-prefix', dest='no_prefix', action='store_true',
+                    help='Do not remove a prefix from paths in the archive.')
+  options, args = parser.parse_args(args)
+
+  if len(args) != 2:
+    parser.print_help()
+    return 1
+
+  archive, output = args
+
+  if not os.path.exists(archive):
+    # Skip archives that weren't downloaded.
+    return 0
+
+  with open(archive) as f:
+    sha256 = hashlib.sha256()
+    while True:
+      chunk = f.read(1024 * 1024)
+      if not chunk:
+        break
+      sha256.update(chunk)
+    digest = sha256.hexdigest()
+
+  stamp_path = os.path.join(output, ".boringssl_archive_digest")
+  if os.path.exists(stamp_path):
+    with open(stamp_path) as f:
+      if f.read().strip() == digest:
+        print "Already up-to-date."
+        return 0
+
+  if archive.endswith('.zip'):
+    entries = IterateZip(archive)
+  elif archive.endswith('.tar.gz'):
+    entries = IterateTar(archive)
+  else:
+    raise ValueError(archive)
+
+  try:
+    if os.path.exists(output):
+      print "Removing %s" % (output, )
+      shutil.rmtree(output)
+
+    print "Extracting %s to %s" % (archive, output)
+    prefix = None
+    num_extracted = 0
+    for path, mode, inp in entries:
+      # Even on Windows, zip files must always use forward slashes.
+      if '\\' in path or path.startswith('/'):
+        raise ValueError(path)
+
+      if not options.no_prefix:
+        new_prefix, rest = path.split('/', 1)
+
+        # Ensure the archive is consistent.
+        if prefix is None:
+          prefix = new_prefix
+        if prefix != new_prefix:
+          raise ValueError((prefix, new_prefix))
+      else:
+        rest = path
+
+      # Extract the file into the output directory.
+      fixed_path = CheckedJoin(output, rest)
+      if not os.path.isdir(os.path.dirname(fixed_path)):
+        os.makedirs(os.path.dirname(fixed_path))
+      with open(fixed_path, 'wb') as out:
+        shutil.copyfileobj(inp, out)
+
+      # Fix up permissions if needbe.
+      # TODO(davidben): To be extra tidy, this should only track the execute bit
+      # as in git.
+      if mode is not None:
+        os.chmod(fixed_path, mode)
+
+      # Print every 100 files, so bots do not time out on large archives.
+      num_extracted += 1
+      if num_extracted % 100 == 0:
+        print "Extracted %d files..." % (num_extracted,)
+  finally:
+    entries.close()
+
+  with open(stamp_path, 'w') as f:
+    f.write(digest)
+
+  print "Done. Extracted %d files." % (num_extracted,)
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main(sys.argv[1:]))
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/go/bootstrap.py b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/go/bootstrap.py
new file mode 100755
index 000000000..bb64e25b4
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/go/bootstrap.py
@@ -0,0 +1,296 @@
+#!/usr/bin/env python
+# Copyright 2014 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.
+
+# Modified from go/bootstrap.py in Chromium infrastructure's repository to patch
+# out everything but the core toolchain.
+#
+# https://chromium.googlesource.com/infra/infra/
+
+"""Prepares a local hermetic Go installation.
+
+- Downloads and unpacks the Go toolset in ../golang.
+"""
+
+import contextlib
+import logging
+import os
+import platform
+import shutil
+import stat
+import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib
+import zipfile
+
+# TODO(vadimsh): Migrate to new golang.org/x/ paths once Golang moves to
+# git completely.
+
+LOGGER = logging.getLogger(__name__)
+
+
+# /path/to/util/bot
+ROOT = os.path.dirname(os.path.abspath(__file__))
+
+# Where to install Go toolset to. GOROOT would be <TOOLSET_ROOT>/go.
+TOOLSET_ROOT = os.path.join(os.path.dirname(ROOT), 'golang')
+
+# Default workspace with infra go code.
+WORKSPACE = os.path.join(ROOT, 'go')
+
+# Platform depended suffix for executable files.
+EXE_SFX = '.exe' if sys.platform == 'win32' else ''
+
+# Pinned version of Go toolset to download.
+TOOLSET_VERSION = 'go1.8'
+
+# Platform dependent portion of a download URL. See http://golang.org/dl/.
+TOOLSET_VARIANTS = {
+  ('darwin', 'x86-64'): 'darwin-amd64.tar.gz',
+  ('linux2', 'x86-32'): 'linux-386.tar.gz',
+  ('linux2', 'x86-64'): 'linux-amd64.tar.gz',
+  ('win32', 'x86-32'): 'windows-386.zip',
+  ('win32', 'x86-64'): 'windows-amd64.zip',
+}
+
+# Download URL root.
+DOWNLOAD_URL_PREFIX = 'https://storage.googleapis.com/golang'
+
+
+class Failure(Exception):
+  """Bootstrap failed."""
+
+
+def get_toolset_url():
+  """URL of a platform specific Go toolset archive."""
+  # TODO(vadimsh): Support toolset for cross-compilation.
+  arch = {
+    'amd64': 'x86-64',
+    'x86_64': 'x86-64',
+    'i386': 'x86-32',
+    'x86': 'x86-32',
+  }.get(platform.machine().lower())
+  variant = TOOLSET_VARIANTS.get((sys.platform, arch))
+  if not variant:
+    # TODO(vadimsh): Compile go lang from source.
+    raise Failure('Unrecognized platform')
+  return '%s/%s.%s' % (DOWNLOAD_URL_PREFIX, TOOLSET_VERSION, variant)
+
+
+def read_file(path):
+  """Returns contents of a given file or None if not readable."""
+  assert isinstance(path, (list, tuple))
+  try:
+    with open(os.path.join(*path), 'r') as f:
+      return f.read()
+  except IOError:
+    return None
+
+
+def write_file(path, data):
+  """Writes |data| to a file."""
+  assert isinstance(path, (list, tuple))
+  with open(os.path.join(*path), 'w') as f:
+    f.write(data)
+
+
+def remove_directory(path):
+  """Recursively removes a directory."""
+  assert isinstance(path, (list, tuple))
+  p = os.path.join(*path)
+  if not os.path.exists(p):
+    return
+  LOGGER.info('Removing %s', p)
+  # Crutch to remove read-only file (.git/* in particular) on Windows.
+  def onerror(func, path, _exc_info):
+    if not os.access(path, os.W_OK):
+      os.chmod(path, stat.S_IWUSR)
+      func(path)
+    else:
+      raise
+  shutil.rmtree(p, onerror=onerror if sys.platform == 'win32' else None)
+
+
+def install_toolset(toolset_root, url):
+  """Downloads and installs Go toolset.
+
+  GOROOT would be <toolset_root>/go/.
+  """
+  if not os.path.exists(toolset_root):
+    os.makedirs(toolset_root)
+  pkg_path = os.path.join(toolset_root, url[url.rfind('/')+1:])
+
+  LOGGER.info('Downloading %s...', url)
+  download_file(url, pkg_path)
+
+  LOGGER.info('Extracting...')
+  if pkg_path.endswith('.zip'):
+    with zipfile.ZipFile(pkg_path, 'r') as f:
+      f.extractall(toolset_root)
+  elif pkg_path.endswith('.tar.gz'):
+    with tarfile.open(pkg_path, 'r:gz') as f:
+      f.extractall(toolset_root)
+  else:
+    raise Failure('Unrecognized archive format')
+
+  LOGGER.info('Validating...')
+  if not check_hello_world(toolset_root):
+    raise Failure('Something is not right, test program doesn\'t work')
+
+
+def download_file(url, path):
+  """Fetches |url| to |path|."""
+  last_progress = [0]
+  def report(a, b, c):
+    progress = int(a * b * 100.0 / c)
+    if progress != last_progress[0]:
+      print >> sys.stderr, 'Downloading... %d%%' % progress
+      last_progress[0] = progress
+  # TODO(vadimsh): Use something less crippled, something that validates SSL.
+  urllib.urlretrieve(url, path, reporthook=report)
+
+
+@contextlib.contextmanager
+def temp_dir(path):
+  """Creates a temporary directory, then deletes it."""
+  tmp = tempfile.mkdtemp(dir=path)
+  try:
+    yield tmp
+  finally:
+    remove_directory([tmp])
+
+
+def check_hello_world(toolset_root):
+  """Compiles and runs 'hello world' program to verify that toolset works."""
+  with temp_dir(toolset_root) as tmp:
+    path = os.path.join(tmp, 'hello.go')
+    write_file([path], r"""
+        package main
+        func main() { println("hello, world\n") }
+    """)
+    out = subprocess.check_output(
+        [get_go_exe(toolset_root), 'run', path],
+        env=get_go_environ(toolset_root, tmp),
+        stderr=subprocess.STDOUT)
+    if out.strip() != 'hello, world':
+      LOGGER.error('Failed to run sample program:\n%s', out)
+      return False
+    return True
+
+
+def ensure_toolset_installed(toolset_root):
+  """Installs or updates Go toolset if necessary.
+
+  Returns True if new toolset was installed.
+  """
+  installed = read_file([toolset_root, 'INSTALLED_TOOLSET'])
+  available = get_toolset_url()
+  if installed == available:
+    LOGGER.debug('Go toolset is up-to-date: %s', TOOLSET_VERSION)
+    return False
+
+  LOGGER.info('Installing Go toolset.')
+  LOGGER.info('  Old toolset is %s', installed)
+  LOGGER.info('  New toolset is %s', available)
+  remove_directory([toolset_root])
+  install_toolset(toolset_root, available)
+  LOGGER.info('Go toolset installed: %s', TOOLSET_VERSION)
+  write_file([toolset_root, 'INSTALLED_TOOLSET'], available)
+  return True
+
+
+def get_go_environ(
+    toolset_root,
+    workspace=None):
+  """Returns a copy of os.environ with added GO* environment variables.
+
+  Overrides GOROOT, GOPATH and GOBIN. Keeps everything else. Idempotent.
+
+  Args:
+    toolset_root: GOROOT would be <toolset_root>/go.
+    workspace: main workspace directory or None if compiling in GOROOT.
+  """
+  env = os.environ.copy()
+  env['GOROOT'] = os.path.join(toolset_root, 'go')
+  if workspace:
+    env['GOBIN'] = os.path.join(workspace, 'bin')
+  else:
+    env.pop('GOBIN', None)
+
+  all_go_paths = []
+  if workspace:
+    all_go_paths.append(workspace)
+  env['GOPATH'] = os.pathsep.join(all_go_paths)
+
+  # New PATH entries.
+  paths_to_add = [
+    os.path.join(env['GOROOT'], 'bin'),
+    env.get('GOBIN'),
+  ]
+
+  # Make sure not to add duplicates entries to PATH over and over again when
+  # get_go_environ is invoked multiple times.
+  path = env['PATH'].split(os.pathsep)
+  paths_to_add = [p for p in paths_to_add if p and p not in path]
+  env['PATH'] = os.pathsep.join(paths_to_add + path)
+
+  return env
+
+
+def get_go_exe(toolset_root):
+  """Returns path to go executable."""
+  return os.path.join(toolset_root, 'go', 'bin', 'go' + EXE_SFX)
+
+
+def bootstrap(logging_level):
+  """Installs all dependencies in default locations.
+
+  Supposed to be called at the beginning of some script (it modifies logger).
+
+  Args:
+    logging_level: logging level of bootstrap process.
+  """
+  logging.basicConfig()
+  LOGGER.setLevel(logging_level)
+  ensure_toolset_installed(TOOLSET_ROOT)
+
+
+def prepare_go_environ():
+  """Returns dict with environment variables to set to use Go toolset.
+
+  Installs or updates the toolset if necessary.
+  """
+  bootstrap(logging.INFO)
+  return get_go_environ(TOOLSET_ROOT, WORKSPACE)
+
+
+def find_executable(name, workspaces):
+  """Returns full path to an executable in some bin/ (in GOROOT or GOBIN)."""
+  basename = name
+  if EXE_SFX and basename.endswith(EXE_SFX):
+    basename = basename[:-len(EXE_SFX)]
+  roots = [os.path.join(TOOLSET_ROOT, 'go', 'bin')]
+  for path in workspaces:
+    roots.extend([
+      os.path.join(path, 'bin'),
+    ])
+  for root in roots:
+    full_path = os.path.join(root, basename + EXE_SFX)
+    if os.path.exists(full_path):
+      return full_path
+  return name
+
+
+def main(args):
+  if args:
+    print >> sys.stderr, sys.modules[__name__].__doc__,
+    return 2
+  bootstrap(logging.DEBUG)
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main(sys.argv[1:]))
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/go/env.py b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/go/env.py
new file mode 100755
index 000000000..820968c9b
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/go/env.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+# Copyright 2014 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.
+
+# Modified from go/env.py in Chromium infrastructure's repository to patch out
+# everything but the core toolchain.
+#
+# https://chromium.googlesource.com/infra/infra/
+
+"""Can be used to point environment variable to hermetic Go toolset.
+
+Usage (on linux and mac):
+$ eval `./env.py`
+$ go version
+
+Or it can be used to wrap a command:
+
+$ ./env.py go version
+"""
+
+assert __name__ == '__main__'
+
+import imp
+import os
+import subprocess
+import sys
+
+# Do not want to mess with sys.path, load the module directly.
+bootstrap = imp.load_source(
+    'bootstrap', os.path.join(os.path.dirname(__file__), 'bootstrap.py'))
+
+old = os.environ.copy()
+new = bootstrap.prepare_go_environ()
+
+if len(sys.argv) == 1:
+  for key, value in sorted(new.iteritems()):
+    if old.get(key) != value:
+      print 'export %s="%s"' % (key, value)
+else:
+  exe = sys.argv[1]
+  if exe == 'python':
+    exe = sys.executable
+  else:
+    # Help Windows to find the executable in new PATH, do it only when
+    # executable is referenced by name (and not by path).
+    if os.sep not in exe:
+      exe = bootstrap.find_executable(exe, [bootstrap.WORKSPACE])
+  sys.exit(subprocess.call([exe] + sys.argv[2:], env=new))
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/perl-win32.zip.sha1 b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/perl-win32.zip.sha1
new file mode 100644
index 000000000..8874fbbb6
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/perl-win32.zip.sha1
@@ -0,0 +1 @@
+3db2b4964d56f6e23cc48ced40a6cee05419a0af
\ No newline at end of file
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/update_clang.py b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/update_clang.py
new file mode 100644
index 000000000..7e9111315
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/update_clang.py
@@ -0,0 +1,71 @@
+# Copyright (c) 2015, Google Inc.
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+import os.path
+import shutil
+import sys
+import tarfile
+import tempfile
+import urllib
+
+# CLANG_REVISION and CLANG_SUB_REVISION determine the build of clang
+# to use. These should be synced with tools/clang/scripts/update.py in
+# Chromium.
+CLANG_REVISION = "296320"
+CLANG_SUB_REVISION = "1"
+
+PACKAGE_VERSION = "%s-%s" % (CLANG_REVISION, CLANG_SUB_REVISION)
+LLVM_BUILD_DIR = os.path.join(os.path.dirname(__file__), "llvm-build")
+STAMP_FILE = os.path.join(LLVM_BUILD_DIR, "cr_build_revision")
+
+CDS_URL = "https://commondatastorage.googleapis.com/chromium-browser-clang"
+
+def DownloadFile(url, path):
+  """DownloadFile fetches |url| to |path|."""
+  last_progress = [0]
+  def report(a, b, c):
+    progress = int(a * b * 100.0 / c)
+    if progress != last_progress[0]:
+      print >> sys.stderr, "Downloading... %d%%" % progress
+      last_progress[0] = progress
+  urllib.urlretrieve(url, path, reporthook=report)
+
+def main(args):
+  # For now, only download clang on Linux.
+  if not sys.platform.startswith("linux"):
+    return 0
+
+  if os.path.exists(STAMP_FILE):
+    with open(STAMP_FILE) as f:
+      if f.read().strip() == PACKAGE_VERSION:
+        print >> sys.stderr, "Clang already at %s" % (PACKAGE_VERSION,)
+        return 0
+
+  if os.path.exists(LLVM_BUILD_DIR):
+    shutil.rmtree(LLVM_BUILD_DIR)
+
+  print >> sys.stderr, "Downloading Clang %s" % (PACKAGE_VERSION,)
+  cds_full_url = "%s/Linux_x64/clang-%s.tgz" % (CDS_URL, PACKAGE_VERSION)
+  with tempfile.NamedTemporaryFile() as temp:
+    DownloadFile(cds_full_url, temp.name)
+    with tarfile.open(temp.name, "r:gz") as tar_file:
+      tar_file.extractall(LLVM_BUILD_DIR)
+
+  with open(STAMP_FILE, "wb") as stamp_file:
+    stamp_file.write(PACKAGE_VERSION)
+
+  return 0
+
+if __name__ == "__main__":
+  sys.exit(main(sys.argv[1:]))
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/vs_env.py b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/vs_env.py
new file mode 100644
index 000000000..184750063
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/vs_env.py
@@ -0,0 +1,37 @@
+# Copyright (c) 2015, Google Inc.
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+import subprocess
+import sys
+
+import vs_toolchain
+# vs_toolchain adds gyp to sys.path.
+import gyp.MSVSVersion
+
+if len(sys.argv) < 2:
+  print >>sys.stderr, "Usage: vs_env.py TARGET_ARCH CMD..."
+  sys.exit(1)
+
+target_arch = sys.argv[1]
+cmd = sys.argv[2:]
+
+vs_toolchain.SetEnvironmentAndGetRuntimeDllDirs()
+vs_version = gyp.MSVSVersion.SelectVisualStudioVersion()
+
+# Using shell=True is somewhat ugly, but the alternative is to pull in a copy
+# of the Chromium GN build's setup_toolchain.py which runs the setup script,
+# then 'set', and then parses the environment variables out. (GYP internally
+# does the same thing.)
+sys.exit(subprocess.call(vs_version.SetupScript(target_arch) + ["&&"] + cmd,
+                         shell=True))
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/vs_toolchain.py b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/vs_toolchain.py
new file mode 100644
index 000000000..2e87272ea
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/vs_toolchain.py
@@ -0,0 +1,113 @@
+# Copyright 2014 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 json
+import os
+import pipes
+import shutil
+import subprocess
+import sys
+
+
+script_dir = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, os.path.join(script_dir, 'gyp', 'pylib'))
+json_data_file = os.path.join(script_dir, 'win_toolchain.json')
+
+
+import gyp
+
+
+TOOLCHAIN_VERSION = '2015'
+TOOLCHAIN_HASH = 'd3cb0e37bdd120ad0ac4650b674b09e81be45616'
+
+
+def SetEnvironmentAndGetRuntimeDllDirs():
+  """Sets up os.environ to use the depot_tools VS toolchain with gyp, and
+  returns the location of the VS runtime DLLs so they can be copied into
+  the output directory after gyp generation.
+  """
+  vs_runtime_dll_dirs = None
+  depot_tools_win_toolchain = \
+      bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', '1')))
+  if sys.platform in ('win32', 'cygwin') and depot_tools_win_toolchain:
+    if not os.path.exists(json_data_file):
+      Update()
+    with open(json_data_file, 'r') as tempf:
+      toolchain_data = json.load(tempf)
+
+    toolchain = toolchain_data['path']
+    version = toolchain_data['version']
+    win_sdk = toolchain_data.get('win_sdk')
+    if not win_sdk:
+      win_sdk = toolchain_data['win8sdk']
+    wdk = toolchain_data['wdk']
+    # TODO(scottmg): The order unfortunately matters in these. They should be
+    # split into separate keys for x86 and x64. (See CopyVsRuntimeDlls call
+    # below). http://crbug.com/345992
+    vs_runtime_dll_dirs = toolchain_data['runtime_dirs']
+
+    os.environ['GYP_MSVS_OVERRIDE_PATH'] = toolchain
+    os.environ['GYP_MSVS_VERSION'] = version
+    # We need to make sure windows_sdk_path is set to the automated
+    # toolchain values in GYP_DEFINES, but don't want to override any
+    # otheroptions.express
+    # values there.
+    gyp_defines_dict = gyp.NameValueListToDict(gyp.ShlexEnv('GYP_DEFINES'))
+    gyp_defines_dict['windows_sdk_path'] = win_sdk
+    os.environ['GYP_DEFINES'] = ' '.join('%s=%s' % (k, pipes.quote(str(v)))
+        for k, v in gyp_defines_dict.iteritems())
+    os.environ['WINDOWSSDKDIR'] = win_sdk
+    os.environ['WDK_DIR'] = wdk
+    # Include the VS runtime in the PATH in case it's not machine-installed.
+    runtime_path = ';'.join(vs_runtime_dll_dirs)
+    os.environ['PATH'] = runtime_path + ';' + os.environ['PATH']
+  return vs_runtime_dll_dirs
+
+
+def FindDepotTools():
+  """Returns the path to depot_tools in $PATH."""
+  for path in os.environ['PATH'].split(os.pathsep):
+    if os.path.isfile(os.path.join(path, 'gclient.py')):
+      return path
+  raise Exception("depot_tools not found!")
+
+
+def Update():
+  """Requests an update of the toolchain to the specific hashes we have at
+  this revision. The update outputs a .json of the various configuration
+  information required to pass to gyp which we use in |GetToolchainDir()|.
+  """
+  depot_tools_win_toolchain = \
+      bool(int(os.environ.get('DEPOT_TOOLS_WIN_TOOLCHAIN', '1')))
+  if sys.platform in ('win32', 'cygwin') and depot_tools_win_toolchain:
+    depot_tools_path = FindDepotTools()
+    # Necessary so that get_toolchain_if_necessary.py will put the VS toolkit
+    # in the correct directory.
+    os.environ['GYP_MSVS_VERSION'] = TOOLCHAIN_VERSION
+    get_toolchain_args = [
+        sys.executable,
+        os.path.join(depot_tools_path,
+                    'win_toolchain',
+                    'get_toolchain_if_necessary.py'),
+        '--output-json', json_data_file, TOOLCHAIN_HASH,
+      ]
+    subprocess.check_call(get_toolchain_args)
+
+  return 0
+
+
+def main():
+  if not sys.platform.startswith(('win32', 'cygwin')):
+    return 0
+  commands = {
+      'update': Update,
+  }
+  if len(sys.argv) < 2 or sys.argv[1] not in commands:
+    print >>sys.stderr, 'Expected one of: %s' % ', '.join(commands)
+    return 1
+  return commands[sys.argv[1]](*sys.argv[2:])
+
+
+if __name__ == '__main__':
+  sys.exit(main())
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/yasm-win32.exe.sha1 b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/yasm-win32.exe.sha1
new file mode 100644
index 000000000..5b8c9aaeb
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/bot/yasm-win32.exe.sha1
@@ -0,0 +1 @@
+4c4d1951181a610923523cb10d83d9ae9952fbf3
\ No newline at end of file
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/diff_asm.go b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/diff_asm.go
new file mode 100644
index 000000000..0a0888b05
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/diff_asm.go
@@ -0,0 +1,112 @@
+/* Copyright (c) 2016, Google Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"syscall"
+)
+
+var (
+	boringsslDir = flag.String("boringssl", ".", "The path to the BoringSSL checkout.")
+	opensslDir   = flag.String("openssl", filepath.Join("..", "openssl"), "The path to the OpenSSL checkout.")
+)
+
+func mapName(path string) string {
+	switch filepath.ToSlash(path) {
+	case "crypto/rand/asm/rdrand-x86_64.pl":
+		return ""
+	case "crypto/ec/asm/p256-x86_64-asm.pl":
+		return filepath.FromSlash("crypto/ec/asm/ecp_nistz256-x86_64.pl")
+	}
+	return path
+}
+
+func diff(from, to string) error {
+	cmd := exec.Command("diff", "-u", "--", from, to)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	err := cmd.Run()
+	// diff returns exit code 1 if the files differ but it was otherwise
+	// successful.
+	if exitError, ok := err.(*exec.ExitError); ok && exitError.Sys().(syscall.WaitStatus).ExitStatus() == 1 {
+		return nil
+	}
+	return err
+}
+
+func main() {
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "Usage: diff_asm [flag...] [filter...]\n")
+		fmt.Fprintf(os.Stderr, "Filter arguments limit to assembly files which match arguments.\n")
+		fmt.Fprintf(os.Stderr, "If not using a filter, piping to `diffstat` may be useful.\n\n")
+		flag.PrintDefaults()
+	}
+	flag.Parse()
+
+	// Find all the assembly files.
+	var files []string
+	err := filepath.Walk(*boringsslDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return nil
+		}
+
+		path, err = filepath.Rel(*boringsslDir, path)
+		if err != nil {
+			return err
+		}
+
+		dir := filepath.Base(filepath.Dir(path))
+		if !info.IsDir() && (dir == "asm" || dir == "perlasm") && strings.HasSuffix(filepath.Base(path), ".pl") {
+			files = append(files, path)
+		}
+
+		return nil
+	})
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error finding assembly: %s\n", err)
+		os.Exit(1)
+	}
+
+	for _, file := range files {
+		opensslFile := mapName(file)
+		if len(opensslFile) == 0 {
+			continue
+		}
+
+		if flag.NArg() > 0 {
+			var found bool
+			for _, arg := range flag.Args() {
+				if strings.Contains(file, arg) {
+					found = true
+					break
+				}
+			}
+			if !found {
+				continue
+			}
+		}
+
+		if err := diff(filepath.Join(*opensslDir, opensslFile), filepath.Join(*boringsslDir, file)); err != nil {
+			fmt.Fprintf(os.Stderr, "Error comparing %s: %s\n", file, err)
+			os.Exit(1)
+		}
+	}
+}
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/doc.config b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/doc.config
new file mode 100644
index 000000000..f7e8baa11
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/doc.config
@@ -0,0 +1,57 @@
+{
+  "BaseDirectory": "..",
+  "Sections": [{
+    "Name": "Low-level infrastructure",
+    "Headers": [
+      "include/openssl/base64.h",
+      "include/openssl/bio.h",
+      "include/openssl/buf.h",
+      "include/openssl/bytestring.h",
+      "include/openssl/err.h",
+      "include/openssl/cpu.h",
+      "include/openssl/crypto.h",
+      "include/openssl/ex_data.h",
+      "include/openssl/lhash.h",
+      "include/openssl/mem.h",
+      "include/openssl/obj.h",
+      "include/openssl/pool.h",
+      "include/openssl/rand.h",
+      "include/openssl/stack.h"
+    ]
+  },{
+    "Name": "Low-level crypto primitives",
+    "Headers": [
+      "include/openssl/aes.h",
+      "include/openssl/bn.h",
+      "include/openssl/cmac.h",
+      "include/openssl/curve25519.h",
+      "include/openssl/des.h",
+      "include/openssl/dh.h",
+      "include/openssl/dsa.h",
+      "include/openssl/ec.h",
+      "include/openssl/ec_key.h",
+      "include/openssl/ecdh.h",
+      "include/openssl/ecdsa.h",
+      "include/openssl/engine.h",
+      "include/openssl/hkdf.h",
+      "include/openssl/hmac.h",
+      "include/openssl/md5.h",
+      "include/openssl/rc4.h",
+      "include/openssl/rsa.h",
+      "include/openssl/sha.h"
+    ]
+  },{
+    "Name": "Crypto interfaces",
+    "Headers": [
+      "include/openssl/digest.h",
+      "include/openssl/cipher.h",
+      "include/openssl/aead.h",
+      "include/openssl/evp.h"
+    ]
+  },{
+    "Name": "SSL implementation",
+    "Headers": [
+      "include/openssl/ssl.h"
+    ]
+  }]
+}
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/doc.css b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/doc.css
new file mode 100644
index 000000000..a868e4444
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/doc.css
@@ -0,0 +1,70 @@
+#main {
+  margin-left: auto;
+  margin-right: auto;
+  max-width: 55em;
+  text-align: justify;
+}
+
+h2 {
+  font-family: monospace;
+  background-color: #b2c9db;
+  padding: 7px;
+  border-radius: 7px;
+}
+
+div.title {
+  margin-bottom: 2em;
+}
+
+ol {
+  list-style: none;
+  margin-bottom: 4em;
+}
+
+li a {
+  color: black;
+}
+
+li.header {
+  margin-top: 1em;
+  margin-bottom: 0.3em;
+  font-weight: bold;
+}
+
+div.decl p:first-child {
+  margin-top: 2.5em;
+}
+
+div.decl p:first-child .first-word {
+  font-weight: bold;
+  font-family: monospace;
+}
+
+.sectionpreamble {
+  margin-top: 5em;
+}
+
+.sectionpreamble p:first-child {
+  font-weight: bold;
+  font-size: 1.5em;
+}
+
+.section pre {
+  background-color: #b2c9db;
+  padding: 5px;
+  border-radius: 5px;
+}
+
+td {
+  padding: 2px;
+}
+
+tr:nth-child(even) {
+  background-color: #eee;
+}
+
+tr.header td {
+  font-weight: bold;
+  padding-top: 1em;
+  padding-bottom: 0.5em;
+}
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/doc.go b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/doc.go
new file mode 100644
index 000000000..987794c92
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/doc.go
@@ -0,0 +1,728 @@
+// doc generates HTML files from the comments in header files.
+//
+// doc expects to be given the path to a JSON file via the --config option.
+// From that JSON (which is defined by the Config struct) it reads a list of
+// header file locations and generates HTML files for each in the current
+// directory.
+
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"html/template"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// Config describes the structure of the config JSON file.
+type Config struct {
+	// BaseDirectory is a path to which other paths in the file are
+	// relative.
+	BaseDirectory string
+	Sections      []ConfigSection
+}
+
+type ConfigSection struct {
+	Name string
+	// Headers is a list of paths to header files.
+	Headers []string
+}
+
+// HeaderFile is the internal representation of a header file.
+type HeaderFile struct {
+	// Name is the basename of the header file (e.g. "ex_data.html").
+	Name string
+	// Preamble contains a comment for the file as a whole. Each string
+	// is a separate paragraph.
+	Preamble []string
+	Sections []HeaderSection
+	// AllDecls maps all decls to their URL fragments.
+	AllDecls map[string]string
+}
+
+type HeaderSection struct {
+	// Preamble contains a comment for a group of functions.
+	Preamble []string
+	Decls    []HeaderDecl
+	// Anchor, if non-empty, is the URL fragment to use in anchor tags.
+	Anchor string
+	// IsPrivate is true if the section contains private functions (as
+	// indicated by its name).
+	IsPrivate bool
+}
+
+type HeaderDecl struct {
+	// Comment contains a comment for a specific function. Each string is a
+	// paragraph. Some paragraph may contain \n runes to indicate that they
+	// are preformatted.
+	Comment []string
+	// Name contains the name of the function, if it could be extracted.
+	Name string
+	// Decl contains the preformatted C declaration itself.
+	Decl string
+	// Anchor, if non-empty, is the URL fragment to use in anchor tags.
+	Anchor string
+}
+
+const (
+	cppGuard     = "#if defined(__cplusplus)"
+	commentStart = "/* "
+	commentEnd   = " */"
+)
+
+func extractComment(lines []string, lineNo int) (comment []string, rest []string, restLineNo int, err error) {
+	if len(lines) == 0 {
+		return nil, lines, lineNo, nil
+	}
+
+	restLineNo = lineNo
+	rest = lines
+
+	if !strings.HasPrefix(rest[0], commentStart) {
+		panic("extractComment called on non-comment")
+	}
+	commentParagraph := rest[0][len(commentStart):]
+	rest = rest[1:]
+	restLineNo++
+
+	for len(rest) > 0 {
+		i := strings.Index(commentParagraph, commentEnd)
+		if i >= 0 {
+			if i != len(commentParagraph)-len(commentEnd) {
+				err = fmt.Errorf("garbage after comment end on line %d", restLineNo)
+				return
+			}
+			commentParagraph = commentParagraph[:i]
+			if len(commentParagraph) > 0 {
+				comment = append(comment, commentParagraph)
+			}
+			return
+		}
+
+		line := rest[0]
+		if !strings.HasPrefix(line, " *") {
+			err = fmt.Errorf("comment doesn't start with block prefix on line %d: %s", restLineNo, line)
+			return
+		}
+		if len(line) == 2 || line[2] != '/' {
+			line = line[2:]
+		}
+		if strings.HasPrefix(line, "   ") {
+			/* Identing the lines of a paragraph marks them as
+			* preformatted. */
+			if len(commentParagraph) > 0 {
+				commentParagraph += "\n"
+			}
+			line = line[3:]
+		}
+		if len(line) > 0 {
+			commentParagraph = commentParagraph + line
+			if len(commentParagraph) > 0 && commentParagraph[0] == ' ' {
+				commentParagraph = commentParagraph[1:]
+			}
+		} else {
+			comment = append(comment, commentParagraph)
+			commentParagraph = ""
+		}
+		rest = rest[1:]
+		restLineNo++
+	}
+
+	err = errors.New("hit EOF in comment")
+	return
+}
+
+func extractDecl(lines []string, lineNo int) (decl string, rest []string, restLineNo int, err error) {
+	if len(lines) == 0 || len(lines[0]) == 0 {
+		return "", lines, lineNo, nil
+	}
+
+	rest = lines
+	restLineNo = lineNo
+
+	var stack []rune
+	for len(rest) > 0 {
+		line := rest[0]
+		for _, c := range line {
+			switch c {
+			case '(', '{', '[':
+				stack = append(stack, c)
+			case ')', '}', ']':
+				if len(stack) == 0 {
+					err = fmt.Errorf("unexpected %c on line %d", c, restLineNo)
+					return
+				}
+				var expected rune
+				switch c {
+				case ')':
+					expected = '('
+				case '}':
+					expected = '{'
+				case ']':
+					expected = '['
+				default:
+					panic("internal error")
+				}
+				if last := stack[len(stack)-1]; last != expected {
+					err = fmt.Errorf("found %c when expecting %c on line %d", c, last, restLineNo)
+					return
+				}
+				stack = stack[:len(stack)-1]
+			}
+		}
+		if len(decl) > 0 {
+			decl += "\n"
+		}
+		decl += line
+		rest = rest[1:]
+		restLineNo++
+
+		if len(stack) == 0 && (len(decl) == 0 || decl[len(decl)-1] != '\\') {
+			break
+		}
+	}
+
+	return
+}
+
+func skipLine(s string) string {
+	i := strings.Index(s, "\n")
+	if i > 0 {
+		return s[i:]
+	}
+	return ""
+}
+
+func getNameFromDecl(decl string) (string, bool) {
+	for strings.HasPrefix(decl, "#if") || strings.HasPrefix(decl, "#elif") {
+		decl = skipLine(decl)
+	}
+
+	if strings.HasPrefix(decl, "typedef ") {
+		return "", false
+	}
+
+	for _, prefix := range []string{"struct ", "enum ", "#define "} {
+		if !strings.HasPrefix(decl, prefix) {
+			continue
+		}
+
+		decl = strings.TrimPrefix(decl, prefix)
+
+		for len(decl) > 0 && decl[0] == ' ' {
+			decl = decl[1:]
+		}
+
+		// struct and enum types can be the return type of a
+		// function.
+		if prefix[0] != '#' && strings.Index(decl, "{") == -1 {
+			break
+		}
+
+		i := strings.IndexAny(decl, "( ")
+		if i < 0 {
+			return "", false
+		}
+		return decl[:i], true
+	}
+	decl = strings.TrimPrefix(decl, "OPENSSL_EXPORT ")
+	decl = strings.TrimPrefix(decl, "STACK_OF(")
+	decl = strings.TrimPrefix(decl, "LHASH_OF(")
+	i := strings.Index(decl, "(")
+	if i < 0 {
+		return "", false
+	}
+	j := strings.LastIndex(decl[:i], " ")
+	if j < 0 {
+		return "", false
+	}
+	for j+1 < len(decl) && decl[j+1] == '*' {
+		j++
+	}
+	return decl[j+1 : i], true
+}
+
+func sanitizeAnchor(name string) string {
+	return strings.Replace(name, " ", "-", -1)
+}
+
+func isPrivateSection(name string) bool {
+	return strings.HasPrefix(name, "Private functions") || strings.HasPrefix(name, "Private structures") || strings.Contains(name, "(hidden)")
+}
+
+func (config *Config) parseHeader(path string) (*HeaderFile, error) {
+	headerPath := filepath.Join(config.BaseDirectory, path)
+
+	headerFile, err := os.Open(headerPath)
+	if err != nil {
+		return nil, err
+	}
+	defer headerFile.Close()
+
+	scanner := bufio.NewScanner(headerFile)
+	var lines, oldLines []string
+	for scanner.Scan() {
+		lines = append(lines, scanner.Text())
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+
+	lineNo := 1
+	found := false
+	for i, line := range lines {
+		if line == cppGuard {
+			lines = lines[i+1:]
+			lineNo += i + 1
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		return nil, errors.New("no C++ guard found")
+	}
+
+	if len(lines) == 0 || lines[0] != "extern \"C\" {" {
+		return nil, errors.New("no extern \"C\" found after C++ guard")
+	}
+	lineNo += 2
+	lines = lines[2:]
+
+	header := &HeaderFile{
+		Name:     filepath.Base(path),
+		AllDecls: make(map[string]string),
+	}
+
+	for i, line := range lines {
+		if len(line) > 0 {
+			lines = lines[i:]
+			lineNo += i
+			break
+		}
+	}
+
+	oldLines = lines
+	if len(lines) > 0 && strings.HasPrefix(lines[0], commentStart) {
+		comment, rest, restLineNo, err := extractComment(lines, lineNo)
+		if err != nil {
+			return nil, err
+		}
+
+		if len(rest) > 0 && len(rest[0]) == 0 {
+			if len(rest) < 2 || len(rest[1]) != 0 {
+				return nil, errors.New("preamble comment should be followed by two blank lines")
+			}
+			header.Preamble = comment
+			lineNo = restLineNo + 2
+			lines = rest[2:]
+		} else {
+			lines = oldLines
+		}
+	}
+
+	allAnchors := make(map[string]struct{})
+
+	for {
+		// Start of a section.
+		if len(lines) == 0 {
+			return nil, errors.New("unexpected end of file")
+		}
+		line := lines[0]
+		if line == cppGuard {
+			break
+		}
+
+		if len(line) == 0 {
+			return nil, fmt.Errorf("blank line at start of section on line %d", lineNo)
+		}
+
+		var section HeaderSection
+
+		if strings.HasPrefix(line, commentStart) {
+			comment, rest, restLineNo, err := extractComment(lines, lineNo)
+			if err != nil {
+				return nil, err
+			}
+			if len(rest) > 0 && len(rest[0]) == 0 {
+				anchor := sanitizeAnchor(firstSentence(comment))
+				if len(anchor) > 0 {
+					if _, ok := allAnchors[anchor]; ok {
+						return nil, fmt.Errorf("duplicate anchor: %s", anchor)
+					}
+					allAnchors[anchor] = struct{}{}
+				}
+
+				section.Preamble = comment
+				section.IsPrivate = len(comment) > 0 && isPrivateSection(comment[0])
+				section.Anchor = anchor
+				lines = rest[1:]
+				lineNo = restLineNo + 1
+			}
+		}
+
+		for len(lines) > 0 {
+			line := lines[0]
+			if len(line) == 0 {
+				lines = lines[1:]
+				lineNo++
+				break
+			}
+			if line == cppGuard {
+				return nil, errors.New("hit ending C++ guard while in section")
+			}
+
+			var comment []string
+			var decl string
+			if strings.HasPrefix(line, commentStart) {
+				comment, lines, lineNo, err = extractComment(lines, lineNo)
+				if err != nil {
+					return nil, err
+				}
+			}
+			if len(lines) == 0 {
+				return nil, errors.New("expected decl at EOF")
+			}
+			declLineNo := lineNo
+			decl, lines, lineNo, err = extractDecl(lines, lineNo)
+			if err != nil {
+				return nil, err
+			}
+			name, ok := getNameFromDecl(decl)
+			if !ok {
+				name = ""
+			}
+			if last := len(section.Decls) - 1; len(name) == 0 && len(comment) == 0 && last >= 0 {
+				section.Decls[last].Decl += "\n" + decl
+			} else {
+				// As a matter of style, comments should start
+				// with the name of the thing that they are
+				// commenting on. We make an exception here for
+				// #defines (because we often have blocks of
+				// them) and collective comments, which are
+				// detected by starting with “The” or “These”.
+				if len(comment) > 0 &&
+					!strings.HasPrefix(comment[0], name) &&
+					!strings.HasPrefix(comment[0], "A "+name) &&
+					!strings.HasPrefix(comment[0], "An "+name) &&
+					!strings.HasPrefix(decl, "#define ") &&
+					!strings.HasPrefix(comment[0], "The ") &&
+					!strings.HasPrefix(comment[0], "These ") {
+					return nil, fmt.Errorf("Comment for %q doesn't seem to match line %s:%d\n", name, path, declLineNo)
+				}
+				anchor := sanitizeAnchor(name)
+				// TODO(davidben): Enforce uniqueness. This is
+				// skipped because #ifdefs currently result in
+				// duplicate table-of-contents entries.
+				allAnchors[anchor] = struct{}{}
+
+				header.AllDecls[name] = anchor
+
+				section.Decls = append(section.Decls, HeaderDecl{
+					Comment: comment,
+					Name:    name,
+					Decl:    decl,
+					Anchor:  anchor,
+				})
+			}
+
+			if len(lines) > 0 && len(lines[0]) == 0 {
+				lines = lines[1:]
+				lineNo++
+			}
+		}
+
+		header.Sections = append(header.Sections, section)
+	}
+
+	return header, nil
+}
+
+func firstSentence(paragraphs []string) string {
+	if len(paragraphs) == 0 {
+		return ""
+	}
+	s := paragraphs[0]
+	i := strings.Index(s, ". ")
+	if i >= 0 {
+		return s[:i]
+	}
+	if lastIndex := len(s) - 1; s[lastIndex] == '.' {
+		return s[:lastIndex]
+	}
+	return s
+}
+
+func markupPipeWords(allDecls map[string]string, s string) template.HTML {
+	ret := ""
+
+	for {
+		i := strings.Index(s, "|")
+		if i == -1 {
+			ret += s
+			break
+		}
+		ret += s[:i]
+		s = s[i+1:]
+
+		i = strings.Index(s, "|")
+		j := strings.Index(s, " ")
+		if i > 0 && (j == -1 || j > i) {
+			ret += "<tt>"
+			anchor, isLink := allDecls[s[:i]]
+			if isLink {
+				ret += fmt.Sprintf("<a href=\"%s\">", template.HTMLEscapeString(anchor))
+			}
+			ret += s[:i]
+			if isLink {
+				ret += "</a>"
+			}
+			ret += "</tt>"
+			s = s[i+1:]
+		} else {
+			ret += "|"
+		}
+	}
+
+	return template.HTML(ret)
+}
+
+func markupFirstWord(s template.HTML) template.HTML {
+	start := 0
+again:
+	end := strings.Index(string(s[start:]), " ")
+	if end > 0 {
+		end += start
+		w := strings.ToLower(string(s[start:end]))
+		// The first word was already marked up as an HTML tag. Don't
+		// mark it up further.
+		if strings.ContainsRune(w, '<') {
+			return s
+		}
+		if w == "a" || w == "an" {
+			start = end + 1
+			goto again
+		}
+		return s[:start] + "<span class=\"first-word\">" + s[start:end] + "</span>" + s[end:]
+	}
+	return s
+}
+
+func newlinesToBR(html template.HTML) template.HTML {
+	s := string(html)
+	if !strings.Contains(s, "\n") {
+		return html
+	}
+	s = strings.Replace(s, "\n", "<br>", -1)
+	s = strings.Replace(s, " ", "&nbsp;", -1)
+	return template.HTML(s)
+}
+
+func generate(outPath string, config *Config) (map[string]string, error) {
+	allDecls := make(map[string]string)
+
+	headerTmpl := template.New("headerTmpl")
+	headerTmpl.Funcs(template.FuncMap{
+		"firstSentence":   firstSentence,
+		"markupPipeWords": func(s string) template.HTML { return markupPipeWords(allDecls, s) },
+		"markupFirstWord": markupFirstWord,
+		"newlinesToBR":    newlinesToBR,
+	})
+	headerTmpl, err := headerTmpl.Parse(`<!DOCTYPE html>
+<html>
+  <head>
+    <title>BoringSSL - {{.Name}}</title>
+    <meta charset="utf-8">
+    <link rel="stylesheet" type="text/css" href="doc.css">
+  </head>
+
+  <body>
+    <div id="main">
+    <div class="title">
+      <h2>{{.Name}}</h2>
+      <a href="headers.html">All headers</a>
+    </div>
+
+    {{range .Preamble}}<p>{{. | html | markupPipeWords}}</p>{{end}}
+
+    <ol>
+      {{range .Sections}}
+        {{if not .IsPrivate}}
+          {{if .Anchor}}<li class="header"><a href="#{{.Anchor}}">{{.Preamble | firstSentence | html | markupPipeWords}}</a></li>{{end}}
+          {{range .Decls}}
+            {{if .Anchor}}<li><a href="#{{.Anchor}}"><tt>{{.Name}}</tt></a></li>{{end}}
+          {{end}}
+        {{end}}
+      {{end}}
+    </ol>
+
+    {{range .Sections}}
+      {{if not .IsPrivate}}
+        <div class="section" {{if .Anchor}}id="{{.Anchor}}"{{end}}>
+        {{if .Preamble}}
+          <div class="sectionpreamble">
+          {{range .Preamble}}<p>{{. | html | markupPipeWords}}</p>{{end}}
+          </div>
+        {{end}}
+
+        {{range .Decls}}
+          <div class="decl" {{if .Anchor}}id="{{.Anchor}}"{{end}}>
+          {{range .Comment}}
+            <p>{{. | html | markupPipeWords | newlinesToBR | markupFirstWord}}</p>
+          {{end}}
+          <pre>{{.Decl}}</pre>
+          </div>
+        {{end}}
+        </div>
+      {{end}}
+    {{end}}
+    </div>
+  </body>
+</html>`)
+	if err != nil {
+		return nil, err
+	}
+
+	headerDescriptions := make(map[string]string)
+	var headers []*HeaderFile
+
+	for _, section := range config.Sections {
+		for _, headerPath := range section.Headers {
+			header, err := config.parseHeader(headerPath)
+			if err != nil {
+				return nil, errors.New("while parsing " + headerPath + ": " + err.Error())
+			}
+			headerDescriptions[header.Name] = firstSentence(header.Preamble)
+			headers = append(headers, header)
+
+			for name, anchor := range header.AllDecls {
+				allDecls[name] = fmt.Sprintf("%s#%s", header.Name+".html", anchor)
+			}
+		}
+	}
+
+	for _, header := range headers {
+		filename := filepath.Join(outPath, header.Name+".html")
+		file, err := os.OpenFile(filename, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
+		if err != nil {
+			panic(err)
+		}
+		defer file.Close()
+		if err := headerTmpl.Execute(file, header); err != nil {
+			return nil, err
+		}
+	}
+
+	return headerDescriptions, nil
+}
+
+func generateIndex(outPath string, config *Config, headerDescriptions map[string]string) error {
+	indexTmpl := template.New("indexTmpl")
+	indexTmpl.Funcs(template.FuncMap{
+		"baseName": filepath.Base,
+		"headerDescription": func(header string) string {
+			return headerDescriptions[header]
+		},
+	})
+	indexTmpl, err := indexTmpl.Parse(`<!DOCTYPE html5>
+
+  <head>
+    <title>BoringSSL - Headers</title>
+    <meta charset="utf-8">
+    <link rel="stylesheet" type="text/css" href="doc.css">
+  </head>
+
+  <body>
+    <div id="main">
+      <div class="title">
+        <h2>BoringSSL Headers</h2>
+      </div>
+      <table>
+        {{range .Sections}}
+	  <tr class="header"><td colspan="2">{{.Name}}</td></tr>
+	  {{range .Headers}}
+	    <tr><td><a href="{{. | baseName}}.html">{{. | baseName}}</a></td><td>{{. | baseName | headerDescription}}</td></tr>
+	  {{end}}
+	{{end}}
+      </table>
+    </div>
+  </body>
+</html>`)
+
+	if err != nil {
+		return err
+	}
+
+	file, err := os.OpenFile(filepath.Join(outPath, "headers.html"), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+
+	if err := indexTmpl.Execute(file, config); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func copyFile(outPath string, inFilePath string) error {
+	bytes, err := ioutil.ReadFile(inFilePath)
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(filepath.Join(outPath, filepath.Base(inFilePath)), bytes, 0666)
+}
+
+func main() {
+	var (
+		configFlag *string = flag.String("config", "doc.config", "Location of config file")
+		outputDir  *string = flag.String("out", ".", "Path to the directory where the output will be written")
+		config     Config
+	)
+
+	flag.Parse()
+
+	if len(*configFlag) == 0 {
+		fmt.Printf("No config file given by --config\n")
+		os.Exit(1)
+	}
+
+	if len(*outputDir) == 0 {
+		fmt.Printf("No output directory given by --out\n")
+		os.Exit(1)
+	}
+
+	configBytes, err := ioutil.ReadFile(*configFlag)
+	if err != nil {
+		fmt.Printf("Failed to open config file: %s\n", err)
+		os.Exit(1)
+	}
+
+	if err := json.Unmarshal(configBytes, &config); err != nil {
+		fmt.Printf("Failed to parse config file: %s\n", err)
+		os.Exit(1)
+	}
+
+	headerDescriptions, err := generate(*outputDir, &config)
+	if err != nil {
+		fmt.Printf("Failed to generate output: %s\n", err)
+		os.Exit(1)
+	}
+
+	if err := generateIndex(*outputDir, &config, headerDescriptions); err != nil {
+		fmt.Printf("Failed to generate index: %s\n", err)
+		os.Exit(1)
+	}
+
+	if err := copyFile(*outputDir, "doc.css"); err != nil {
+		fmt.Printf("Failed to copy static file: %s\n", err)
+		os.Exit(1)
+	}
+}
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/generate-asm-lcov.py b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/generate-asm-lcov.py
new file mode 100755
index 000000000..257ae841c
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/generate-asm-lcov.py
@@ -0,0 +1,152 @@
+#!/usr/bin/python
+# Copyright (c) 2016, Google Inc.
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+import os
+import os.path
+import subprocess
+import sys
+
+# The LCOV output format for each source file is:
+#
+# SF:<filename>
+# DA:<line>,<execution count>
+# ...
+# end_of_record
+#
+# The <execution count> can either be 0 for an unexecuted instruction or a
+# value representing the number of executions. The DA line should be omitted
+# for lines not representing an instruction.
+
+SECTION_SEPERATOR = '-' * 80
+
+def is_asm(l):
+  """Returns whether a line should be considered to be an instruction."""
+  l = l.strip()
+  # Empty lines
+  if l == '':
+    return False
+  # Comments
+  if l.startswith('#'):
+    return False
+  # Assembly Macros
+  if l.startswith('.'):
+    return False
+  # Label
+  if l.endswith(':'):
+    return False
+  return True
+
+def merge(callgrind_files, srcs):
+  """Calls callgrind_annotate over the set of callgrind output
+  |callgrind_files| using the sources |srcs| and merges the results
+  together."""
+  out = ''
+  for file in callgrind_files:
+    data = subprocess.check_output(['callgrind_annotate', file] + srcs)
+    out += '%s\n%s\n' % (data, SECTION_SEPERATOR)
+  return out
+
+def parse(filename, data, current):
+  """Parses an annotated execution flow |data| from callgrind_annotate for
+  source |filename| and updates the current execution counts from |current|."""
+  with open(filename) as f:
+    source = f.read().split('\n')
+
+  out = current
+  if out == None:
+    out = [0 if is_asm(l) else None for l in source]
+
+  # Lines are of the following formats:
+  #   -- line: Indicates that analysis continues from a different place.
+  #   Ir     : Indicates the start of a file.
+  #   =>     : Indicates a call/jump in the control flow.
+  #   <Count> <Code>: Indicates that the line has been executed that many times.
+  line = None
+  for l in data:
+    l = l.strip() + ' '
+    if l.startswith('-- line'):
+      line = int(l.split(' ')[2]) - 1
+    elif l.strip() == 'Ir':
+      line = 0
+    elif line != None and l.strip() and '=>' not in l and 'unidentified lines' not in l:
+      count = l.split(' ')[0].replace(',', '').replace('.', '0')
+      instruction = l.split(' ', 1)[1].strip()
+      if count != '0' or is_asm(instruction):
+        if out[line] == None:
+          out[line] = 0
+        out[line] += int(count)
+      line += 1
+
+  return out
+
+
+def generate(data):
+  """Parses the merged callgrind_annotate output |data| and generates execution
+  counts for all annotated files."""
+  out = {}
+  data = [p.strip() for p in data.split(SECTION_SEPERATOR)]
+
+
+  # Most sections are ignored, but a section with:
+  #  User-annotated source: <file>
+  # precedes a listing of execution count for that <file>.
+  for i in range(len(data)):
+    if 'User-annotated source' in data[i] and i < len(data) - 1:
+      filename = data[i].split(':', 1)[1].strip()
+      res = data[i + 1]
+      if filename not in out:
+        out[filename] = None
+      if 'No information' in res:
+        res = []
+      else:
+        res = res.split('\n')
+      out[filename] = parse(filename, res, out[filename])
+  return out
+
+def output(data):
+  """Takes a dictionary |data| of filenames and execution counts and generates
+  a LCOV coverage output."""
+  out = ''
+  for filename, counts in data.iteritems():
+    out += 'SF:%s\n' % (os.path.abspath(filename))
+    for line, count in enumerate(counts):
+      if count != None:
+        out += 'DA:%d,%s\n' % (line + 1, count)
+    out += 'end_of_record\n'
+  return out
+
+if __name__ == '__main__':
+  if len(sys.argv) != 3:
+    print '%s <Callgrind Folder> <Build Folder>' % (__file__)
+    sys.exit()
+
+  cg_folder = sys.argv[1]
+  build_folder = sys.argv[2]
+
+  cg_files = []
+  for (cwd, _, files) in os.walk(cg_folder):
+    for f in files:
+      if f.startswith('callgrind.out'):
+        cg_files.append(os.path.abspath(os.path.join(cwd, f)))
+
+  srcs = []
+  for (cwd, _, files) in os.walk(build_folder):
+    for f in files:
+      fn = os.path.join(cwd, f)
+      if fn.endswith('.S'):
+        srcs.append(fn)
+
+  annotated = merge(cg_files, srcs)
+  lcov = generate(annotated)
+  print output(lcov)
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/generate-coverage.sh b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/generate-coverage.sh
new file mode 100755
index 000000000..e16a9a442
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/generate-coverage.sh
@@ -0,0 +1,59 @@
+#!/bin/sh
+# Copyright (c) 2016, Google Inc.
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+set -xe
+
+SRC=$PWD
+
+BUILD=$(mktemp -d '/tmp/boringssl.XXXXXX')
+BUILD_SRC=$(mktemp -d '/tmp/boringssl-src.XXXXXX')
+LCOV=$(mktemp -d '/tmp/boringssl-lcov.XXXXXX')
+
+if [ -n "$1" ]; then
+  LCOV=$(readlink -f "$1")
+  mkdir -p "$LCOV"
+fi
+
+cd "$BUILD"
+cmake "$SRC" -GNinja -DGCOV=1
+ninja
+
+cp -r "$SRC/crypto" "$SRC/decrepit" "$SRC/include" "$SRC/ssl" "$SRC/tool" \
+  "$BUILD_SRC"
+cp -r "$BUILD"/* "$BUILD_SRC"
+mkdir "$BUILD/callgrind/"
+
+cd "$SRC"
+go run "$SRC/util/all_tests.go" -build-dir "$BUILD" -callgrind -num-workers 16
+util/generate-asm-lcov.py "$BUILD/callgrind" "$BUILD" > "$BUILD/asm.info"
+
+go run "util/all_tests.go" -build-dir "$BUILD"
+
+cd "$SRC/ssl/test/runner"
+go test -shim-path "$BUILD/ssl/test/bssl_shim" -num-workers 1
+
+cd "$LCOV"
+lcov -c -d "$BUILD" -b "$BUILD" -o "$BUILD/lcov.info"
+lcov -r "$BUILD/lcov.info" "*_test.c" -o "$BUILD/lcov-1.info"
+lcov -r "$BUILD/lcov-1.info" "*_test.cc" -o "$BUILD/lcov-2.info"
+cat "$BUILD/lcov-2.info" "$BUILD/asm.info" > "$BUILD/final.info"
+sed -i "s;$BUILD;$BUILD_SRC;g" "$BUILD/final.info"
+sed -i "s;$SRC;$BUILD_SRC;g" "$BUILD/final.info"
+genhtml -p "$BUILD_SRC" "$BUILD/final.info"
+
+rm -rf "$BUILD"
+rm -rf "$BUILD_SRC"
+
+xdg-open index.html
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/generate_build_files.py b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/generate_build_files.py
new file mode 100644
index 000000000..a3435f2bc
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/generate_build_files.py
@@ -0,0 +1,735 @@
+# Copyright (c) 2015, Google Inc.
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+"""Enumerates source files for consumption by various build systems."""
+
+import optparse
+import os
+import subprocess
+import sys
+import json
+
+
+# OS_ARCH_COMBOS maps from OS and platform to the OpenSSL assembly "style" for
+# that platform and the extension used by asm files.
+OS_ARCH_COMBOS = [
+    ('linux', 'arm', 'linux32', [], 'S'),
+    ('linux', 'aarch64', 'linux64', [], 'S'),
+    ('linux', 'ppc64le', 'ppc64le', [], 'S'),
+    ('linux', 'x86', 'elf', ['-fPIC', '-DOPENSSL_IA32_SSE2'], 'S'),
+    ('linux', 'x86_64', 'elf', [], 'S'),
+    ('mac', 'x86', 'macosx', ['-fPIC', '-DOPENSSL_IA32_SSE2'], 'S'),
+    ('mac', 'x86_64', 'macosx', [], 'S'),
+    ('win', 'x86', 'win32n', ['-DOPENSSL_IA32_SSE2'], 'asm'),
+    ('win', 'x86_64', 'nasm', [], 'asm'),
+]
+
+# NON_PERL_FILES enumerates assembly files that are not processed by the
+# perlasm system.
+NON_PERL_FILES = {
+    ('linux', 'arm'): [
+        'src/crypto/curve25519/asm/x25519-asm-arm.S',
+        'src/crypto/poly1305/poly1305_arm_asm.S',
+    ],
+    ('linux', 'x86_64'): [
+        'src/crypto/curve25519/asm/x25519-asm-x86_64.S',
+    ],
+    ('mac', 'x86_64'): [
+        'src/crypto/curve25519/asm/x25519-asm-x86_64.S',
+    ],
+}
+
+PREFIX = None
+
+
+def PathOf(x):
+  return x if not PREFIX else os.path.join(PREFIX, x)
+
+
+class Android(object):
+
+  def __init__(self):
+    self.header = \
+"""# Copyright (C) 2015 The Android Open Source Project
+#
+# 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.
+
+# This file is created by generate_build_files.py. Do not edit manually.
+
+"""
+
+  def PrintVariableSection(self, out, name, files):
+    out.write('%s := \\\n' % name)
+    for f in sorted(files):
+      out.write('  %s\\\n' % f)
+    out.write('\n')
+
+  def WriteFiles(self, files, asm_outputs):
+    # New Android.bp format
+    with open('sources.bp', 'w+') as blueprint:
+      blueprint.write(self.header.replace('#', '//'))
+
+      blueprint.write('cc_defaults {\n')
+      blueprint.write('    name: "libcrypto_sources",\n')
+      blueprint.write('    srcs: [\n')
+      for f in sorted(files['crypto']):
+        blueprint.write('        "%s",\n' % f)
+      blueprint.write('    ],\n')
+      blueprint.write('    target: {\n')
+
+      for ((osname, arch), asm_files) in asm_outputs:
+        if osname != 'linux' or arch == 'ppc64le':
+          continue
+        if arch == 'aarch64':
+          arch = 'arm64'
+
+        blueprint.write('        android_%s: {\n' % arch)
+        blueprint.write('            srcs: [\n')
+        for f in sorted(asm_files):
+          blueprint.write('                "%s",\n' % f)
+        blueprint.write('            ],\n')
+        blueprint.write('        },\n')
+
+        if arch == 'x86' or arch == 'x86_64':
+          blueprint.write('        linux_%s: {\n' % arch)
+          blueprint.write('            srcs: [\n')
+          for f in sorted(asm_files):
+            blueprint.write('                "%s",\n' % f)
+          blueprint.write('            ],\n')
+          blueprint.write('        },\n')
+
+      blueprint.write('    },\n')
+      blueprint.write('}\n\n')
+
+      blueprint.write('cc_defaults {\n')
+      blueprint.write('    name: "libssl_sources",\n')
+      blueprint.write('    srcs: [\n')
+      for f in sorted(files['ssl']):
+        blueprint.write('        "%s",\n' % f)
+      blueprint.write('    ],\n')
+      blueprint.write('}\n\n')
+
+      blueprint.write('cc_defaults {\n')
+      blueprint.write('    name: "bssl_sources",\n')
+      blueprint.write('    srcs: [\n')
+      for f in sorted(files['tool']):
+        blueprint.write('        "%s",\n' % f)
+      blueprint.write('    ],\n')
+      blueprint.write('}\n\n')
+
+      blueprint.write('cc_defaults {\n')
+      blueprint.write('    name: "boringssl_test_support_sources",\n')
+      blueprint.write('    srcs: [\n')
+      for f in sorted(files['test_support']):
+        blueprint.write('        "%s",\n' % f)
+      blueprint.write('    ],\n')
+      blueprint.write('}\n\n')
+
+      blueprint.write('cc_defaults {\n')
+      blueprint.write('    name: "boringssl_crypto_test_sources",\n')
+      blueprint.write('    srcs: [\n')
+      for f in sorted(files['crypto_test']):
+        blueprint.write('        "%s",\n' % f)
+      blueprint.write('    ],\n')
+      blueprint.write('}\n\n')
+
+      blueprint.write('cc_defaults {\n')
+      blueprint.write('    name: "boringssl_ssl_test_sources",\n')
+      blueprint.write('    srcs: [\n')
+      for f in sorted(files['ssl_test']):
+        blueprint.write('        "%s",\n' % f)
+      blueprint.write('    ],\n')
+      blueprint.write('}\n\n')
+
+      blueprint.write('cc_defaults {\n')
+      blueprint.write('    name: "boringssl_tests_sources",\n')
+      blueprint.write('    srcs: [\n')
+      for f in sorted(files['test']):
+        blueprint.write('        "%s",\n' % f)
+      blueprint.write('    ],\n')
+      blueprint.write('}\n')
+
+    # Legacy Android.mk format, only used by Trusty in new branches
+    with open('sources.mk', 'w+') as makefile:
+      makefile.write(self.header)
+
+      self.PrintVariableSection(makefile, 'crypto_sources', files['crypto'])
+
+      for ((osname, arch), asm_files) in asm_outputs:
+        if osname != 'linux':
+          continue
+        self.PrintVariableSection(
+            makefile, '%s_%s_sources' % (osname, arch), asm_files)
+
+
+class Bazel(object):
+  """Bazel outputs files suitable for including in Bazel files."""
+
+  def __init__(self):
+    self.firstSection = True
+    self.header = \
+"""# This file is created by generate_build_files.py. Do not edit manually.
+
+"""
+
+  def PrintVariableSection(self, out, name, files):
+    if not self.firstSection:
+      out.write('\n')
+    self.firstSection = False
+
+    out.write('%s = [\n' % name)
+    for f in sorted(files):
+      out.write('    "%s",\n' % PathOf(f))
+    out.write(']\n')
+
+  def WriteFiles(self, files, asm_outputs):
+    with open('BUILD.generated.bzl', 'w+') as out:
+      out.write(self.header)
+
+      self.PrintVariableSection(out, 'ssl_headers', files['ssl_headers'])
+      self.PrintVariableSection(
+          out, 'ssl_internal_headers', files['ssl_internal_headers'])
+      self.PrintVariableSection(out, 'ssl_sources', files['ssl'])
+      self.PrintVariableSection(out, 'ssl_c_sources', files['ssl_c'])
+      self.PrintVariableSection(out, 'ssl_cc_sources', files['ssl_cc'])
+      self.PrintVariableSection(out, 'crypto_headers', files['crypto_headers'])
+      self.PrintVariableSection(
+          out, 'crypto_internal_headers', files['crypto_internal_headers'])
+      self.PrintVariableSection(out, 'crypto_sources', files['crypto'])
+      self.PrintVariableSection(out, 'tool_sources', files['tool'])
+      self.PrintVariableSection(out, 'tool_headers', files['tool_headers'])
+
+      for ((osname, arch), asm_files) in asm_outputs:
+        self.PrintVariableSection(
+            out, 'crypto_sources_%s_%s' % (osname, arch), asm_files)
+
+    with open('BUILD.generated_tests.bzl', 'w+') as out:
+      out.write(self.header)
+
+      out.write('test_support_sources = [\n')
+      for filename in sorted(files['test_support'] +
+                             files['test_support_headers'] +
+                             files['crypto_internal_headers'] +
+                             files['ssl_internal_headers']):
+        if os.path.basename(filename) == 'malloc.cc':
+          continue
+        out.write('    "%s",\n' % PathOf(filename))
+
+      out.write(']\n\n')
+
+      self.PrintVariableSection(out, 'crypto_test_sources',
+                                files['crypto_test'])
+      self.PrintVariableSection(out, 'ssl_test_sources', files['ssl_test'])
+
+      out.write('def create_tests(copts, crypto, ssl):\n')
+      name_counts = {}
+      for test in files['tests']:
+        name = os.path.basename(test[0])
+        name_counts[name] = name_counts.get(name, 0) + 1
+
+      first = True
+      for test in files['tests']:
+        name = os.path.basename(test[0])
+        if name_counts[name] > 1:
+          if '/' in test[1]:
+            name += '_' + os.path.splitext(os.path.basename(test[1]))[0]
+          else:
+            name += '_' + test[1].replace('-', '_')
+
+        if not first:
+          out.write('\n')
+        first = False
+
+        src_prefix = 'src/' + test[0]
+        for src in files['test']:
+          if src.startswith(src_prefix):
+            src = src
+            break
+        else:
+          raise ValueError("Can't find source for %s" % test[0])
+
+        out.write('  native.cc_test(\n')
+        out.write('      name = "%s",\n' % name)
+        out.write('      size = "small",\n')
+        out.write('      srcs = ["%s"] + test_support_sources,\n' %
+            PathOf(src))
+
+        data_files = []
+        if len(test) > 1:
+
+          out.write('      args = [\n')
+          for arg in test[1:]:
+            if '/' in arg:
+              out.write('          "$(location %s)",\n' %
+                  PathOf(os.path.join('src', arg)))
+              data_files.append('src/%s' % arg)
+            else:
+              out.write('          "%s",\n' % arg)
+          out.write('      ],\n')
+
+        out.write('      copts = copts + ["-DBORINGSSL_SHARED_LIBRARY"],\n')
+
+        if len(data_files) > 0:
+          out.write('      data = [\n')
+          for filename in data_files:
+            out.write('          "%s",\n' % PathOf(filename))
+          out.write('      ],\n')
+
+        if 'ssl/' in test[0]:
+          out.write('      deps = [\n')
+          out.write('          crypto,\n')
+          out.write('          ssl,\n')
+          out.write('      ],\n')
+        else:
+          out.write('      deps = [crypto],\n')
+        out.write('  )\n')
+
+
+class GN(object):
+
+  def __init__(self):
+    self.firstSection = True
+    self.header = \
+"""# Copyright (c) 2016 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.
+
+# This file is created by generate_build_files.py. Do not edit manually.
+
+"""
+
+  def PrintVariableSection(self, out, name, files):
+    if not self.firstSection:
+      out.write('\n')
+    self.firstSection = False
+
+    out.write('%s = [\n' % name)
+    for f in sorted(files):
+      out.write('  "%s",\n' % f)
+    out.write(']\n')
+
+  def WriteFiles(self, files, asm_outputs):
+    with open('BUILD.generated.gni', 'w+') as out:
+      out.write(self.header)
+
+      self.PrintVariableSection(out, 'crypto_sources',
+                                files['crypto'] + files['crypto_headers'] +
+                                files['crypto_internal_headers'])
+      self.PrintVariableSection(out, 'ssl_sources',
+                                files['ssl'] + files['ssl_headers'] +
+                                files['ssl_internal_headers'])
+
+      for ((osname, arch), asm_files) in asm_outputs:
+        self.PrintVariableSection(
+            out, 'crypto_sources_%s_%s' % (osname, arch), asm_files)
+
+      fuzzers = [os.path.splitext(os.path.basename(fuzzer))[0]
+                 for fuzzer in files['fuzz']]
+      self.PrintVariableSection(out, 'fuzzers', fuzzers)
+
+    with open('BUILD.generated_tests.gni', 'w+') as out:
+      self.firstSection = True
+      out.write(self.header)
+
+      self.PrintVariableSection(out, 'test_support_sources',
+                                files['test_support'] +
+                                files['test_support_headers'])
+      self.PrintVariableSection(out, 'crypto_test_sources',
+                                files['crypto_test'])
+      self.PrintVariableSection(out, 'ssl_test_sources', files['ssl_test'])
+      out.write('\n')
+
+      out.write('template("create_tests") {\n')
+
+      all_tests = []
+      for test in sorted(files['test']):
+        test_name = 'boringssl_%s' % os.path.splitext(os.path.basename(test))[0]
+        all_tests.append(test_name)
+
+        out.write('  executable("%s") {\n' % test_name)
+        out.write('    sources = [\n')
+        out.write('      "%s",\n' % test)
+        out.write('    ]\n')
+        out.write('    sources += test_support_sources\n')
+        out.write('    if (defined(invoker.configs_exclude)) {\n')
+        out.write('      configs -= invoker.configs_exclude\n')
+        out.write('    }\n')
+        out.write('    configs += invoker.configs\n')
+        out.write('    deps = invoker.deps\n')
+        out.write('  }\n')
+        out.write('\n')
+
+      out.write('  group(target_name) {\n')
+      out.write('    deps = [\n')
+      for test_name in sorted(all_tests):
+        out.write('      ":%s",\n' % test_name)
+      out.write('    ]\n')
+      out.write('  }\n')
+      out.write('}\n')
+
+
+class GYP(object):
+
+  def __init__(self):
+    self.header = \
+"""# Copyright (c) 2016 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.
+
+# This file is created by generate_build_files.py. Do not edit manually.
+
+"""
+
+  def PrintVariableSection(self, out, name, files):
+    out.write('    \'%s\': [\n' % name)
+    for f in sorted(files):
+      out.write('      \'%s\',\n' % f)
+    out.write('    ],\n')
+
+  def WriteFiles(self, files, asm_outputs):
+    with open('boringssl.gypi', 'w+') as gypi:
+      gypi.write(self.header + '{\n  \'variables\': {\n')
+
+      self.PrintVariableSection(gypi, 'boringssl_ssl_sources',
+                                files['ssl'] + files['ssl_headers'] +
+                                files['ssl_internal_headers'])
+      self.PrintVariableSection(gypi, 'boringssl_crypto_sources',
+                                files['crypto'] + files['crypto_headers'] +
+                                files['crypto_internal_headers'])
+
+      for ((osname, arch), asm_files) in asm_outputs:
+        self.PrintVariableSection(gypi, 'boringssl_%s_%s_sources' %
+                                  (osname, arch), asm_files)
+
+      gypi.write('  }\n}\n')
+
+
+def FindCMakeFiles(directory):
+  """Returns list of all CMakeLists.txt files recursively in directory."""
+  cmakefiles = []
+
+  for (path, _, filenames) in os.walk(directory):
+    for filename in filenames:
+      if filename == 'CMakeLists.txt':
+        cmakefiles.append(os.path.join(path, filename))
+
+  return cmakefiles
+
+
+def NoTests(dent, is_dir):
+  """Filter function that can be passed to FindCFiles in order to remove test
+  sources."""
+  if is_dir:
+    return dent != 'test'
+  return 'test.' not in dent and not dent.startswith('example_')
+
+
+def OnlyTests(dent, is_dir):
+  """Filter function that can be passed to FindCFiles in order to remove
+  non-test sources."""
+  if is_dir:
+    return dent != 'test'
+  return '_test.' in dent or dent.startswith('example_')
+
+
+def AllFiles(dent, is_dir):
+  """Filter function that can be passed to FindCFiles in order to include all
+  sources."""
+  return True
+
+
+def NotGTestMain(dent, is_dir):
+  return dent != 'gtest_main.cc'
+
+
+def SSLHeaderFiles(dent, is_dir):
+  return dent in ['ssl.h', 'tls1.h', 'ssl23.h', 'ssl3.h', 'dtls1.h']
+
+
+def FindCFiles(directory, filter_func):
+  """Recurses through directory and returns a list of paths to all the C source
+  files that pass filter_func."""
+  cfiles = []
+
+  for (path, dirnames, filenames) in os.walk(directory):
+    for filename in filenames:
+      if not filename.endswith('.c') and not filename.endswith('.cc'):
+        continue
+      if not filter_func(filename, False):
+        continue
+      cfiles.append(os.path.join(path, filename))
+
+    for (i, dirname) in enumerate(dirnames):
+      if not filter_func(dirname, True):
+        del dirnames[i]
+
+  return cfiles
+
+
+def FindHeaderFiles(directory, filter_func):
+  """Recurses through directory and returns a list of paths to all the header files that pass filter_func."""
+  hfiles = []
+
+  for (path, dirnames, filenames) in os.walk(directory):
+    for filename in filenames:
+      if not filename.endswith('.h'):
+        continue
+      if not filter_func(filename, False):
+        continue
+      hfiles.append(os.path.join(path, filename))
+
+      for (i, dirname) in enumerate(dirnames):
+        if not filter_func(dirname, True):
+          del dirnames[i]
+
+  return hfiles
+
+
+def ExtractPerlAsmFromCMakeFile(cmakefile):
+  """Parses the contents of the CMakeLists.txt file passed as an argument and
+  returns a list of all the perlasm() directives found in the file."""
+  perlasms = []
+  with open(cmakefile) as f:
+    for line in f:
+      line = line.strip()
+      if not line.startswith('perlasm('):
+        continue
+      if not line.endswith(')'):
+        raise ValueError('Bad perlasm line in %s' % cmakefile)
+      # Remove "perlasm(" from start and ")" from end
+      params = line[8:-1].split()
+      if len(params) < 2:
+        raise ValueError('Bad perlasm line in %s' % cmakefile)
+      perlasms.append({
+          'extra_args': params[2:],
+          'input': os.path.join(os.path.dirname(cmakefile), params[1]),
+          'output': os.path.join(os.path.dirname(cmakefile), params[0]),
+      })
+
+  return perlasms
+
+
+def ReadPerlAsmOperations():
+  """Returns a list of all perlasm() directives found in CMake config files in
+  src/."""
+  perlasms = []
+  cmakefiles = FindCMakeFiles('src')
+
+  for cmakefile in cmakefiles:
+    perlasms.extend(ExtractPerlAsmFromCMakeFile(cmakefile))
+
+  return perlasms
+
+
+def PerlAsm(output_filename, input_filename, perlasm_style, extra_args):
+  """Runs the a perlasm script and puts the output into output_filename."""
+  base_dir = os.path.dirname(output_filename)
+  if not os.path.isdir(base_dir):
+    os.makedirs(base_dir)
+  subprocess.check_call(
+      ['perl', input_filename, perlasm_style] + extra_args + [output_filename])
+
+
+def ArchForAsmFilename(filename):
+  """Returns the architectures that a given asm file should be compiled for
+  based on substrings in the filename."""
+
+  if 'x86_64' in filename or 'avx2' in filename:
+    return ['x86_64']
+  elif ('x86' in filename and 'x86_64' not in filename) or '586' in filename:
+    return ['x86']
+  elif 'armx' in filename:
+    return ['arm', 'aarch64']
+  elif 'armv8' in filename:
+    return ['aarch64']
+  elif 'arm' in filename:
+    return ['arm']
+  elif 'ppc' in filename:
+    return ['ppc64le']
+  else:
+    raise ValueError('Unknown arch for asm filename: ' + filename)
+
+
+def WriteAsmFiles(perlasms):
+  """Generates asm files from perlasm directives for each supported OS x
+  platform combination."""
+  asmfiles = {}
+
+  for osarch in OS_ARCH_COMBOS:
+    (osname, arch, perlasm_style, extra_args, asm_ext) = osarch
+    key = (osname, arch)
+    outDir = '%s-%s' % key
+
+    for perlasm in perlasms:
+      filename = os.path.basename(perlasm['input'])
+      output = perlasm['output']
+      if not output.startswith('src'):
+        raise ValueError('output missing src: %s' % output)
+      output = os.path.join(outDir, output[4:])
+      if output.endswith('-armx.${ASM_EXT}'):
+        output = output.replace('-armx',
+                                '-armx64' if arch == 'aarch64' else '-armx32')
+      output = output.replace('${ASM_EXT}', asm_ext)
+
+      if arch in ArchForAsmFilename(filename):
+        PerlAsm(output, perlasm['input'], perlasm_style,
+                perlasm['extra_args'] + extra_args)
+        asmfiles.setdefault(key, []).append(output)
+
+  for (key, non_perl_asm_files) in NON_PERL_FILES.iteritems():
+    asmfiles.setdefault(key, []).extend(non_perl_asm_files)
+
+  return asmfiles
+
+
+def IsGTest(path):
+  with open(path) as f:
+    return "#include <gtest/gtest.h>" in f.read()
+
+
+def main(platforms):
+  crypto_c_files = FindCFiles(os.path.join('src', 'crypto'), NoTests)
+  ssl_source_files = FindCFiles(os.path.join('src', 'ssl'), NoTests)
+  tool_c_files = FindCFiles(os.path.join('src', 'tool'), NoTests)
+  tool_h_files = FindHeaderFiles(os.path.join('src', 'tool'), AllFiles)
+
+  # Generate err_data.c
+  with open('err_data.c', 'w+') as err_data:
+    subprocess.check_call(['go', 'run', 'err_data_generate.go'],
+                          cwd=os.path.join('src', 'crypto', 'err'),
+                          stdout=err_data)
+  crypto_c_files.append('err_data.c')
+
+  test_support_c_files = FindCFiles(os.path.join('src', 'crypto', 'test'),
+                                    NotGTestMain)
+  test_support_h_files = (
+      FindHeaderFiles(os.path.join('src', 'crypto', 'test'), AllFiles) +
+      FindHeaderFiles(os.path.join('src', 'ssl', 'test'), AllFiles))
+
+  test_c_files = []
+  crypto_test_files = ['src/crypto/test/gtest_main.cc']
+  # TODO(davidben): Remove this loop once all tests are converted.
+  for path in FindCFiles(os.path.join('src', 'crypto'), OnlyTests):
+    if IsGTest(path):
+      crypto_test_files.append(path)
+    else:
+      test_c_files.append(path)
+
+  ssl_test_files = FindCFiles(os.path.join('src', 'ssl'), OnlyTests)
+  ssl_test_files.append('src/crypto/test/gtest_main.cc')
+
+  fuzz_c_files = FindCFiles(os.path.join('src', 'fuzz'), NoTests)
+
+  ssl_h_files = (
+      FindHeaderFiles(
+          os.path.join('src', 'include', 'openssl'),
+          SSLHeaderFiles))
+
+  def NotSSLHeaderFiles(filename, is_dir):
+    return not SSLHeaderFiles(filename, is_dir)
+  crypto_h_files = (
+      FindHeaderFiles(
+          os.path.join('src', 'include', 'openssl'),
+          NotSSLHeaderFiles))
+
+  ssl_internal_h_files = FindHeaderFiles(os.path.join('src', 'ssl'), NoTests)
+  crypto_internal_h_files = FindHeaderFiles(
+      os.path.join('src', 'crypto'), NoTests)
+
+  with open('src/util/all_tests.json', 'r') as f:
+    tests = json.load(f)
+  # For now, GTest-based tests are specified manually.
+  tests = [test for test in tests if test[0] not in ['crypto/crypto_test',
+                                                     'decrepit/decrepit_test',
+                                                     'ssl/ssl_test']]
+  test_binaries = set([test[0] for test in tests])
+  test_sources = set([
+      test.replace('.cc', '').replace('.c', '').replace(
+          'src/',
+          '')
+      for test in test_c_files])
+  if test_binaries != test_sources:
+    print 'Test sources and configured tests do not match'
+    a = test_binaries.difference(test_sources)
+    if len(a) > 0:
+      print 'These tests are configured without sources: ' + str(a)
+    b = test_sources.difference(test_binaries)
+    if len(b) > 0:
+      print 'These test sources are not configured: ' + str(b)
+
+  files = {
+      'crypto': crypto_c_files,
+      'crypto_headers': crypto_h_files,
+      'crypto_internal_headers': crypto_internal_h_files,
+      'crypto_test': sorted(crypto_test_files),
+      'fuzz': fuzz_c_files,
+      'ssl': ssl_source_files,
+      'ssl_c': [s for s in ssl_source_files if s.endswith('.c')],
+      'ssl_cc': [s for s in ssl_source_files if s.endswith('.cc')],
+      'ssl_headers': ssl_h_files,
+      'ssl_internal_headers': ssl_internal_h_files,
+      'ssl_test': sorted(ssl_test_files),
+      'tool': tool_c_files,
+      'tool_headers': tool_h_files,
+      'test': test_c_files,
+      'test_support': test_support_c_files,
+      'test_support_headers': test_support_h_files,
+      'tests': tests,
+  }
+
+  asm_outputs = sorted(WriteAsmFiles(ReadPerlAsmOperations()).iteritems())
+
+  for platform in platforms:
+    platform.WriteFiles(files, asm_outputs)
+
+  return 0
+
+
+if __name__ == '__main__':
+  parser = optparse.OptionParser(usage='Usage: %prog [--prefix=<path>]'
+      ' [android|bazel|gn|gyp]')
+  parser.add_option('--prefix', dest='prefix',
+      help='For Bazel, prepend argument to all source files')
+  options, args = parser.parse_args(sys.argv[1:])
+  PREFIX = options.prefix
+
+  if not args:
+    parser.print_help()
+    sys.exit(1)
+
+  platforms = []
+  for s in args:
+    if s == 'android':
+      platforms.append(Android())
+    elif s == 'bazel':
+      platforms.append(Bazel())
+    elif s == 'gn':
+      platforms.append(GN())
+    elif s == 'gyp':
+      platforms.append(GYP())
+    else:
+      parser.print_help()
+      sys.exit(1)
+
+  sys.exit(main(platforms))
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/make_errors.go b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/make_errors.go
new file mode 100644
index 000000000..c1aef82d5
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/make_errors.go
@@ -0,0 +1,388 @@
+// Copyright (c) 2014, Google Inc.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+// OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+package main
+
+import (
+	"bufio"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// ssl.h reserves values 1000 and above for error codes corresponding to
+// alerts. If automatically assigned reason codes exceed this value, this script
+// will error. This must be kept in sync with SSL_AD_REASON_OFFSET in ssl.h.
+const reservedReasonCode = 1000
+
+var resetFlag *bool = flag.Bool("reset", false, "If true, ignore current assignments and reassign from scratch")
+
+func makeErrors(reset bool) error {
+	topLevelPath, err := findToplevel()
+	if err != nil {
+		return err
+	}
+
+	dirName, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+
+	lib := filepath.Base(dirName)
+	headerPath := filepath.Join(topLevelPath, "include", "openssl", lib+".h")
+	errDir := filepath.Join(topLevelPath, "crypto", "err")
+	dataPath := filepath.Join(errDir, lib+".errordata")
+
+	headerFile, err := os.Open(headerPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("No header %s. Run in the right directory or touch the file.", headerPath)
+		}
+
+		return err
+	}
+
+	prefix := strings.ToUpper(lib)
+	reasons, err := parseHeader(prefix, headerFile)
+	headerFile.Close()
+
+	if reset {
+		err = nil
+		// Retain any reason codes above reservedReasonCode.
+		newReasons := make(map[string]int)
+		for key, value := range reasons {
+			if value >= reservedReasonCode {
+				newReasons[key] = value
+			}
+		}
+		reasons = newReasons
+	}
+
+	if err != nil {
+		return err
+	}
+
+	dir, err := os.Open(".")
+	if err != nil {
+		return err
+	}
+	defer dir.Close()
+
+	filenames, err := dir.Readdirnames(-1)
+	if err != nil {
+		return err
+	}
+
+	for _, name := range filenames {
+		if !strings.HasSuffix(name, ".c") {
+			continue
+		}
+
+		if err := addReasons(reasons, name, prefix); err != nil {
+			return err
+		}
+	}
+
+	assignNewValues(reasons, reservedReasonCode)
+
+	headerFile, err = os.Open(headerPath)
+	if err != nil {
+		return err
+	}
+	defer headerFile.Close()
+
+	newHeaderFile, err := os.OpenFile(headerPath+".tmp", os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0666)
+	if err != nil {
+		return err
+	}
+	defer newHeaderFile.Close()
+
+	if err := writeHeaderFile(newHeaderFile, headerFile, prefix, reasons); err != nil {
+		return err
+	}
+	os.Rename(headerPath+".tmp", headerPath)
+
+	dataFile, err := os.OpenFile(dataPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+	if err != nil {
+		return err
+	}
+
+	outputStrings(dataFile, lib, reasons)
+	dataFile.Close()
+
+	return nil
+}
+
+func findToplevel() (path string, err error) {
+	path = ".."
+	buildingPath := filepath.Join(path, "BUILDING.md")
+
+	_, err = os.Stat(buildingPath)
+	if err != nil && os.IsNotExist(err) {
+		path = filepath.Join("..", path)
+		buildingPath = filepath.Join(path, "BUILDING.md")
+		_, err = os.Stat(buildingPath)
+	}
+	if err != nil {
+		return "", errors.New("Cannot find BUILDING.md file at the top-level")
+	}
+	return path, nil
+}
+
+type assignment struct {
+	key   string
+	value int
+}
+
+type assignmentsSlice []assignment
+
+func (a assignmentsSlice) Len() int {
+	return len(a)
+}
+
+func (a assignmentsSlice) Less(i, j int) bool {
+	return a[i].value < a[j].value
+}
+
+func (a assignmentsSlice) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func outputAssignments(w io.Writer, assignments map[string]int) {
+	var sorted assignmentsSlice
+
+	for key, value := range assignments {
+		sorted = append(sorted, assignment{key, value})
+	}
+
+	sort.Sort(sorted)
+
+	for _, assignment := range sorted {
+		fmt.Fprintf(w, "#define %s %d\n", assignment.key, assignment.value)
+	}
+}
+
+func parseDefineLine(line, lib string) (key string, value int, ok bool) {
+	if !strings.HasPrefix(line, "#define ") {
+		return
+	}
+
+	fields := strings.Fields(line)
+	if len(fields) != 3 {
+		return
+	}
+
+	key = fields[1]
+	if !strings.HasPrefix(key, lib+"_R_") {
+		return
+	}
+
+	var err error
+	if value, err = strconv.Atoi(fields[2]); err != nil {
+		return
+	}
+
+	ok = true
+	return
+}
+
+func writeHeaderFile(w io.Writer, headerFile io.Reader, lib string, reasons map[string]int) error {
+	var last []byte
+	var haveLast, sawDefine bool
+	newLine := []byte("\n")
+
+	scanner := bufio.NewScanner(headerFile)
+	for scanner.Scan() {
+		line := scanner.Text()
+		_, _, ok := parseDefineLine(line, lib)
+		if ok {
+			sawDefine = true
+			continue
+		}
+
+		if haveLast {
+			w.Write(last)
+			w.Write(newLine)
+		}
+
+		if len(line) > 0 || !sawDefine {
+			last = []byte(line)
+			haveLast = true
+		} else {
+			haveLast = false
+		}
+		sawDefine = false
+	}
+
+	if err := scanner.Err(); err != nil {
+		return err
+	}
+
+	outputAssignments(w, reasons)
+	w.Write(newLine)
+
+	if haveLast {
+		w.Write(last)
+		w.Write(newLine)
+	}
+
+	return nil
+}
+
+func outputStrings(w io.Writer, lib string, assignments map[string]int) {
+	lib = strings.ToUpper(lib)
+	prefixLen := len(lib + "_R_")
+
+	keys := make([]string, 0, len(assignments))
+	for key := range assignments {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	for _, key := range keys {
+		fmt.Fprintf(w, "%s,%d,%s\n", lib, assignments[key], key[prefixLen:])
+	}
+}
+
+func assignNewValues(assignments map[string]int, reserved int) {
+	// Needs to be in sync with the reason limit in
+	// |ERR_reason_error_string|.
+	max := 99
+
+	for _, value := range assignments {
+		if reserved >= 0 && value >= reserved {
+			continue
+		}
+		if value > max {
+			max = value
+		}
+	}
+
+	max++
+
+	// Sort the keys, so this script is reproducible.
+	keys := make([]string, 0, len(assignments))
+	for key, value := range assignments {
+		if value == -1 {
+			keys = append(keys, key)
+		}
+	}
+	sort.Strings(keys)
+
+	for _, key := range keys {
+		if reserved >= 0 && max >= reserved {
+			// If this happens, try passing -reset. Otherwise bump
+			// up reservedReasonCode.
+			panic("Automatically-assigned values exceeded limit!")
+		}
+		assignments[key] = max
+		max++
+	}
+}
+
+func handleDeclareMacro(line, join, macroName string, m map[string]int) {
+	if i := strings.Index(line, macroName); i >= 0 {
+		contents := line[i+len(macroName):]
+		if i := strings.Index(contents, ")"); i >= 0 {
+			contents = contents[:i]
+			args := strings.Split(contents, ",")
+			for i := range args {
+				args[i] = strings.TrimSpace(args[i])
+			}
+			if len(args) != 2 {
+				panic("Bad macro line: " + line)
+			}
+			token := args[0] + join + args[1]
+			if _, ok := m[token]; !ok {
+				m[token] = -1
+			}
+		}
+	}
+}
+
+func addReasons(reasons map[string]int, filename, prefix string) error {
+	file, err := os.Open(filename)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	reasonPrefix := prefix + "_R_"
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		handleDeclareMacro(line, "_R_", "OPENSSL_DECLARE_ERROR_REASON(", reasons)
+
+		for len(line) > 0 {
+			i := strings.Index(line, prefix+"_")
+			if i == -1 {
+				break
+			}
+
+			line = line[i:]
+			end := strings.IndexFunc(line, func(r rune) bool {
+				return !(r == '_' || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9'))
+			})
+			if end == -1 {
+				end = len(line)
+			}
+
+			var token string
+			token, line = line[:end], line[end:]
+
+			switch {
+			case strings.HasPrefix(token, reasonPrefix):
+				if _, ok := reasons[token]; !ok {
+					reasons[token] = -1
+				}
+			}
+		}
+	}
+
+	return scanner.Err()
+}
+
+func parseHeader(lib string, file io.Reader) (reasons map[string]int, err error) {
+	reasons = make(map[string]int)
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		key, value, ok := parseDefineLine(scanner.Text(), lib)
+		if !ok {
+			continue
+		}
+
+		reasons[key] = value
+	}
+
+	err = scanner.Err()
+	return
+}
+
+func main() {
+	flag.Parse()
+
+	if err := makeErrors(*resetFlag); err != nil {
+		fmt.Fprintf(os.Stderr, "%s\n", err)
+		os.Exit(1)
+	}
+}
diff --git a/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/run_android_tests.go b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/run_android_tests.go
new file mode 100644
index 000000000..92deac0bc
--- /dev/null
+++ b/roms/edk2/CryptoPkg/Library/OpensslLib/openssl/boringssl/util/run_android_tests.go
@@ -0,0 +1,325 @@
+// Copyright (c) 2016, Google Inc.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+// OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+var (
+	buildDir     = flag.String("build-dir", "build", "Specifies the build directory to push.")
+	adbPath      = flag.String("adb", "adb", "Specifies the adb binary to use. Defaults to looking in PATH.")
+	device       = flag.String("device", "", "Specifies the device or emulator. See adb's -s argument.")
+	aarch64      = flag.Bool("aarch64", false, "Build the test runners for aarch64 instead of arm.")
+	arm          = flag.Int("arm", 7, "Which arm revision to build for.")
+	suite        = flag.String("suite", "all", "Specifies the test suites to run (all, unit, or ssl).")
+	allTestsArgs = flag.String("all-tests-args", "", "Specifies space-separated arguments to pass to all_tests.go")
+	runnerArgs   = flag.String("runner-args", "", "Specifies space-separated arguments to pass to ssl/test/runner")
+	jsonOutput   = flag.String("json-output", "", "The file to output JSON results to.")
+)
+
+func enableUnitTests() bool {
+	return *suite == "all" || *suite == "unit"
+}
+
+func enableSSLTests() bool {
+	return *suite == "all" || *suite == "ssl"
+}
+
+func adb(args ...string) error {
+	if len(*device) > 0 {
+		args = append([]string{"-s", *device}, args...)
+	}
+	cmd := exec.Command(*adbPath, args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+func adbShell(shellCmd string) (int, error) {
+	var args []string
+	if len(*device) > 0 {
+		args = append([]string{"-s", *device}, args...)
+	}
+	args = append(args, "shell")
+
+	const delimiter = "___EXIT_CODE___"
+
+	// Older versions of adb and Android do not preserve the exit
+	// code, so work around this.
+	// https://code.google.com/p/android/issues/detail?id=3254
+	shellCmd += "; echo " + delimiter + " $?"
+	args = append(args, shellCmd)
+
+	cmd := exec.Command(*adbPath, args...)
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return 0, err
+	}
+	cmd.Stderr = os.Stderr
+	if err := cmd.Start(); err != nil {
+		return 0, err
+	}
+
+	var stdoutBytes bytes.Buffer
+	for {
+		var buf [1024]byte
+		n, err := stdout.Read(buf[:])
+		stdoutBytes.Write(buf[:n])
+		os.Stdout.Write(buf[:n])
+		if err != nil {
+			break
+		}
+	}
+
+	if err := cmd.Wait(); err != nil {
+		return 0, err
+	}
+
+	stdoutStr := stdoutBytes.String()
+	idx := strings.LastIndex(stdoutStr, delimiter)
+	if idx < 0 {
+		return 0, fmt.Errorf("Could not find delimiter in output.")
+	}
+
+	return strconv.Atoi(strings.TrimSpace(stdoutStr[idx+len(delimiter):]))
+}
+
+func goTool(args ...string) error {
+	cmd := exec.Command("go", args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	cmd.Env = os.Environ()
+	if *aarch64 {
+		cmd.Env = append(cmd.Env, "GOARCH=arm64")
+	} else {
+		cmd.Env = append(cmd.Env, "GOARCH=arm")
+		cmd.Env = append(cmd.Env, fmt.Sprintf("GOARM=%d", *arm))
+	}
+	return cmd.Run()
+}
+
+// setWorkingDirectory walks up directories as needed until the current working
+// directory is the top of a BoringSSL checkout.
+func setWorkingDirectory() {
+	for i := 0; i < 64; i++ {
+		if _, err := os.Stat("BUILDING.md"); err == nil {
+			return
+		}
+		os.Chdir("..")
+	}
+
+	panic("Couldn't find BUILDING.md in a parent directory!")
+}
+
+type test []string
+
+func parseTestConfig(filename string) ([]test, error) {
+	in, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer in.Close()
+
+	decoder := json.NewDecoder(in)
+	var result []test
+	if err := decoder.Decode(&result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func copyFile(dst, src string) error {
+	srcFile, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer srcFile.Close()
+
+	srcInfo, err := srcFile.Stat()
+	if err != nil {
+		return err
+	}
+
+	dir := filepath.Dir(dst)
+	if err := os.MkdirAll(dir, 0777); err != nil {
+		return err
+	}
+
+	dstFile, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY, srcInfo.Mode())
+	if err != nil {
+		return err
+	}
+	defer dstFile.Close()
+
+	_, err = io.Copy(dstFile, srcFile)
+	return err
+}
+
+func main() {
+	flag.Parse()
+
+	if *suite == "all" && *jsonOutput != "" {
+		fmt.Printf("To use -json-output flag, select only one test suite with -suite.\n")
+		os.Exit(1)
+	}
+
+	setWorkingDirectory()
+
+	// Clear the target directory.
+	if err := adb("shell", "rm -Rf /data/local/tmp/boringssl-tmp"); err != nil {
+		fmt.Printf("Failed to clear target directory: %s\n", err)
+		os.Exit(1)
+	}
+
+	// Stage everything in a temporary directory.
+	tmpDir, err := ioutil.TempDir("", "boringssl-android")
+	if err != nil {
+		fmt.Printf("Error making temporary directory: %s\n", err)
+		os.Exit(1)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	var binaries, files []string
+
+	if enableUnitTests() {
+		files = append(files,
+			"util/all_tests.json",
+			"BUILDING.md",
+		)
+
+		tests, err := parseTestConfig("util/all_tests.json")
+		if err != nil {
+			fmt.Printf("Failed to parse input: %s\n", err)
+			os.Exit(1)
+		}
+
+		seenBinary := make(map[string]struct{})
+		for _, test := range tests {
+			if _, ok := seenBinary[test[0]]; !ok {
+				binaries = append(binaries, test[0])
+				seenBinary[test[0]] = struct{}{}
+			}
+			for _, arg := range test[1:] {
+				if strings.Contains(arg, "/") {
+					files = append(files, arg)
+				}
+			}
+		}
+
+		fmt.Printf("Building all_tests...\n")
+		if err := goTool("build", "-o", filepath.Join(tmpDir, "util/all_tests"), "util/all_tests.go"); err != nil {
+			fmt.Printf("Error building all_tests.go: %s\n", err)
+			os.Exit(1)
+		}
+	}
+
+	if enableSSLTests() {
+		binaries = append(binaries, "ssl/test/bssl_shim")
+		files = append(files,
+			"BUILDING.md",
+			"ssl/test/runner/cert.pem",
+			"ssl/test/runner/channel_id_key.pem",
+			"ssl/test/runner/ecdsa_p224_cert.pem",
+			"ssl/test/runner/ecdsa_p224_key.pem",
+			"ssl/test/runner/ecdsa_p256_cert.pem",
+			"ssl/test/runner/ecdsa_p256_key.pem",
+			"ssl/test/runner/ecdsa_p384_cert.pem",
+			"ssl/test/runner/ecdsa_p384_key.pem",
+			"ssl/test/runner/ecdsa_p521_cert.pem",
+			"ssl/test/runner/ecdsa_p521_key.pem",
+			"ssl/test/runner/key.pem",
+			"ssl/test/runner/rsa_1024_cert.pem",
+			"ssl/test/runner/rsa_1024_key.pem",
+			"ssl/test/runner/rsa_chain_cert.pem",
+			"ssl/test/runner/rsa_chain_key.pem",
+			"util/all_tests.json",
+		)
+
+		fmt.Printf("Building runner...\n")
+		if err := goTool("test", "-c", "-o", filepath.Join(tmpDir, "ssl/test/runner/runner"), "./ssl/test/runner/"); err != nil {
+			fmt.Printf("Error building runner: %s\n", err)
+			os.Exit(1)
+		}
+	}
+
+	fmt.Printf("Copying test binaries...\n")
+	for _, binary := range binaries {
+		if err := copyFile(filepath.Join(tmpDir, "build", binary), filepath.Join(*buildDir, binary)); err != nil {
+			fmt.Printf("Failed to copy %s: %s\n", binary, err)
+			os.Exit(1)
+		}
+	}
+
+	fmt.Printf("Copying data files...\n")
+	for _, file := range files {
+		if err := copyFile(filepath.Join(tmpDir, file), file); err != nil {
+			fmt.Printf("Failed to copy %s: %s\n", file, err)
+			os.Exit(1)
+		}
+	}
+
+	fmt.Printf("Uploading files...\n")
+	if err := adb("push", "-p", tmpDir, "/data/local/tmp/boringssl-tmp"); err != nil {
+		fmt.Printf("Failed to push runner: %s\n", err)
+		os.Exit(1)
+	}
+
+	var unitTestExit int
+	if enableUnitTests() {
+		fmt.Printf("Running unit tests...\n")
+		unitTestExit, err = adbShell(fmt.Sprintf("cd /data/local/tmp/boringssl-tmp && ./util/all_tests -json-output results.json %s", *allTestsArgs))
+		if err != nil {
+			fmt.Printf("Failed to run unit tests: %s\n", err)
+			os.Exit(1)
+		}
+	}
+
+	var sslTestExit int
+	if enableSSLTests() {
+		fmt.Printf("Running SSL tests...\n")
+		sslTestExit, err = adbShell(fmt.Sprintf("cd /data/local/tmp/boringssl-tmp/ssl/test/runner && ./runner -json-output ../../../results.json %s", *runnerArgs))
+		if err != nil {
+			fmt.Printf("Failed to run SSL tests: %s\n", err)
+			os.Exit(1)
+		}
+	}
+
+	if *jsonOutput != "" {
+		if err := adb("pull", "-p", "/data/local/tmp/boringssl-tmp/results.json", *jsonOutput); err != nil {
+			fmt.Printf("Failed to extract results.json: %s\n", err)
+			os.Exit(1)
+		}
+	}
+
+	if unitTestExit != 0 {
+		os.Exit(unitTestExit)
+	}
+
+	if sslTestExit != 0 {
+		os.Exit(sslTestExit)
+	}
+}