Add BoringSSL GYP files.

BUG=none

Review URL: https://codereview.chromium.org/377783004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@282169 0039d316-1c4b-4281-b951-d872f2087c98

DEPS

@@ -85,7 +85,7 @@ vars = {
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling BoringSSL
   # and whatever else without interference from each other.
-  "boringssl_revision": "8af663956519f7302284c0c36b413c0495986e14",
+  "boringssl_revision": "2f1f89d6afefb89aa19257b5c624e3b3eb15203d",
 }
 
 deps = {

build/all.gyp

@@ -211,6 +211,11 @@
             '../net/third_party/nss/ssl.gyp:*',
           ],
         }],
+        ['use_openssl==1', {
+          'dependencies': [
+            '../third_party/boringssl/boringssl.gyp:*',
+          ],
+        }],
         ['enable_app_list==1', {
           'dependencies': [
             '../ui/app_list/app_list.gyp:*',

third_party/boringssl/boringssl.gyp

+# 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.
+
+{
+  'includes': [
+    'boringssl_tests.gypi',
+  ],
+  'targets': [
+    {
+      'target_name': 'boringssl',
+      'type': 'static_library',
+      'includes': [
+        'boringssl.gypi',
+      ],
+      'sources': [
+        '<@(boringssl_lib_sources)',
+      ],
+      'conditions': [
+        ['target_arch == "arm"', {
+          'sources': [ '<@(boringssl_linux_arm_sources)' ],
+        }],
+        ['target_arch == "ia32"', {
+          'conditions': [
+            ['OS == "mac"', {
+              'sources': [ '<@(boringssl_mac_x86_sources)' ],
+            }],
+            ['OS == "linux"', {
+              'sources': [ '<@(boringssl_linux_x86_sources)' ],
+            }],
+            ['OS != "mac" and OS != "linux"', {
+              'defines': [ 'OPENSSL_NO_ASM' ],
+            }],
+          ]
+        }],
+        ['target_arch == "x64"', {
+          'conditions': [
+            ['OS == "mac"', {
+              'sources': [ '<@(boringssl_mac_x86_64_sources)' ],
+            }],
+            ['OS == "linux"', {
+              'sources': [ '<@(boringssl_linux_x86_64_sources)' ],
+            }],
+            ['OS == "win"', {
+              'sources': [ '<@(boringssl_win_x86_64_sources)' ],
+            }],
+            ['OS != "mac" and OS != "linux" and OS != "win"', {
+              'defines': [ 'OPENSSL_NO_ASM' ],
+            }],
+          ]
+        }],
+        ['target_arch != "arm" and target_arch != "x86" and target_arch != "x64"', {
+          'defines': [ 'OPENSSL_NO_ASM' ],
+        }],
+      ],
+      'include_dirs': [
+        'src/include',
+        # This is for arm_arch.h, which is needed by some asm files. Since the
+        # asm files are generated and kept in a different directory, they
+        # cannot use relative paths to find this file.
+        'src/crypto',
+      ],
+      'direct_dependent_settings': {
+        'include_dirs': [
+          'src/include',
+        ],
+      },
+    },
+    {
+      'target_name': 'boringssl_unittests',
+      'type': 'executable',
+      'sources': [
+        'boringssl_unittest.cc',
+       ],
+      'dependencies': [
+        '<@(boringssl_test_targets)',
+        '../../base/base.gyp:base',
+        '../../base/base.gyp:run_all_unittests',
+        '../../base/base.gyp:test_support_base',
+        '../../testing/gtest.gyp:gtest',
+      ],
+    },
+  ],
+}

third_party/boringssl/boringssl_tests.gypi

+# 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.
+
+# This file is created by update_gypi_and_asm.py. Do not edit manually.
+
+{
+  'targets': [
+    {
+      'target_name': 'boringssl_sha1_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/sha/sha1_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_gcm_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/modes/gcm_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_err_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/err/err_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_dsa_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/dsa/dsa_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_dh_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/dh/dh_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_aead_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/cipher/aead_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_cipher_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/cipher/cipher_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_hmac_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/hmac/hmac_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_lhash_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/lhash/lhash_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_bio_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/bio/bio_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_md5_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/md5/md5_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_rsa_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/rsa/rsa_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_example_sign',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/evp/example_sign.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_bn_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/bn/bn_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_bytestring_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/bytestring/bytestring_test.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_example_mul',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/ec/example_mul.c',
+      ],
+    },
+    {
+      'target_name': 'boringssl_ecdsa_test',
+      'type': 'executable',
+      'dependencies': [
+        'boringssl',
+      ],
+      'sources': [
+        'src/crypto/ecdsa/ecdsa_test.c',
+      ],
+    },
+  ],
+  'variables': {
+    'boringssl_test_targets': [
+      'boringssl_aead_test',
+      'boringssl_bio_test',
+      'boringssl_bn_test',
+      'boringssl_bytestring_test',
+      'boringssl_cipher_test',
+      'boringssl_dh_test',
+      'boringssl_dsa_test',
+      'boringssl_ecdsa_test',
+      'boringssl_err_test',
+      'boringssl_example_mul',
+      'boringssl_example_sign',
+      'boringssl_gcm_test',
+      'boringssl_hmac_test',
+      'boringssl_lhash_test',
+      'boringssl_md5_test',
+      'boringssl_rsa_test',
+      'boringssl_sha1_test',
+    ],
+  }
+}

third_party/boringssl/boringssl_unittest.cc

+// 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.
+
+#include <stdarg.h>
+
+#include <string>
+
+#include "base/base_paths.h"
+#include "base/command_line.h"
+#include "base/files/file_path.h"
+#include "base/logging.h"
+#include "base/path_service.h"
+#include "base/process/launch.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+void TestProcess(const std::string& name,
+                 const std::vector<base::CommandLine::StringType>& args) {
+  base::FilePath exe_dir;
+  ASSERT_TRUE(PathService::Get(base::DIR_EXE, &exe_dir));
+  base::FilePath test_binary =
+      exe_dir.AppendASCII("boringssl_" + name);
+  base::CommandLine cmd(test_binary);
+
+  for (size_t i = 0; i < args.size(); ++i) {
+    cmd.AppendArgNative(args[i]);
+  }
+
+  std::string output;
+  EXPECT_TRUE(base::GetAppOutput(cmd, &output));
+
+  const bool ok = output.size() >= 5 &&
+                  memcmp("PASS\n", &output[output.size() - 5], 5) == 0 &&
+                  (output.size() == 5 || output[output.size() - 6] == '\n');
+
+  EXPECT_TRUE(ok) << output;
+}
+
+void TestSimple(const std::string& name) {
+  std::vector<base::CommandLine::StringType> empty;
+  TestProcess(name, empty);
+}
+
+bool BoringSSLPath(base::FilePath* result) {
+  if (!PathService::Get(base::DIR_SOURCE_ROOT, result))
+    return false;
+
+  *result = result->Append(FILE_PATH_LITERAL("third_party"));
+  *result = result->Append(FILE_PATH_LITERAL("boringssl"));
+  *result = result->Append(FILE_PATH_LITERAL("src"));
+  return true;
+}
+
+bool CryptoCipherPath(base::FilePath *result) {
+  if (!BoringSSLPath(result))
+    return false;
+
+  *result = result->Append(FILE_PATH_LITERAL("crypto"));
+  *result = result->Append(FILE_PATH_LITERAL("cipher"));
+  return true;
+}
+
+}  // anonymous namespace
+
+TEST(BoringSSL, AES128GCM) {
+  base::FilePath data_file;
+  ASSERT_TRUE(CryptoCipherPath(&data_file));
+  data_file = data_file.Append(FILE_PATH_LITERAL("aes_128_gcm_tests.txt"));
+
+  std::vector<base::CommandLine::StringType> args;
+  args.push_back(FILE_PATH_LITERAL("aes-128-gcm"));
+  args.push_back(data_file.value());
+
+  TestProcess("aead_test", args);
+}
+
+TEST(BoringSSL, AES256GCM) {
+  base::FilePath data_file;
+  ASSERT_TRUE(CryptoCipherPath(&data_file));
+  data_file = data_file.Append(FILE_PATH_LITERAL("aes_256_gcm_tests.txt"));
+
+  std::vector<base::CommandLine::StringType> args;
+  args.push_back(FILE_PATH_LITERAL("aes-256-gcm"));
+  args.push_back(data_file.value());
+
+  TestProcess("aead_test", args);
+}
+
+TEST(BoringSSL, ChaCha20Poly1305) {
+  base::FilePath data_file;
+  ASSERT_TRUE(CryptoCipherPath(&data_file));
+  data_file =
+      data_file.Append(FILE_PATH_LITERAL("chacha20_poly1305_tests.txt"));
+
+  std::vector<base::CommandLine::StringType> args;
+  args.push_back(FILE_PATH_LITERAL("chacha20-poly1305"));
+  args.push_back(data_file.value());
+
+  TestProcess("aead_test", args);
+}
+
+TEST(BoringSSL, RC4MD5) {
+  base::FilePath data_file;
+  ASSERT_TRUE(CryptoCipherPath(&data_file));
+  data_file = data_file.Append(FILE_PATH_LITERAL("rc4_md5_tests.txt"));
+
+  std::vector<base::CommandLine::StringType> args;
+  args.push_back(FILE_PATH_LITERAL("rc4-md5"));
+  args.push_back(data_file.value());
+
+  TestProcess("aead_test", args);
+}
+
+TEST(BoringSSL, BIO) {
+  TestSimple("bio_test");
+}
+
+TEST(BoringSSL, BN) {
+  TestSimple("bn_test");
+}
+
+TEST(BoringSSL, ByteString) {
+  TestSimple("bytestring_test");
+}
+
+TEST(BoringSSL, Cipher) {
+  base::FilePath data_file;
+  ASSERT_TRUE(CryptoCipherPath(&data_file));
+  data_file = data_file.Append(FILE_PATH_LITERAL("cipher_test.txt"));
+
+  std::vector<base::CommandLine::StringType> args;
+  args.push_back(data_file.value());
+
+  TestProcess("cipher_test", args);
+}
+
+TEST(BoringSSL, DH) {
+  TestSimple("dh_test");
+}
+
+TEST(BoringSSL, DSA) {
+  TestSimple("dsa_test");
+}
+
+TEST(BoringSSL, ECDSA) {
+  TestSimple("ecdsa_test");
+}
+
+TEST(BoringSSL, ERR) {
+  TestSimple("err_test");
+}
+
+TEST(BoringSSL, GCM) {
+  TestSimple("gcm_test");
+}
+
+TEST(BoringSSL, HMAC) {
+  TestSimple("hmac_test");
+}
+
+TEST(BoringSSL, LH) {
+  TestSimple("lhash_test");
+}
+
+TEST(BoringSSL, MD5) {
+  TestSimple("md5_test");
+}
+
+TEST(BoringSSL, RSA) {
+  TestSimple("rsa_test");
+}
+
+TEST(BoringSSL, SHA1) {
+  TestSimple("sha1_test");
+}
+
+TEST(BoringSSL, ExampleMul) {
+  TestSimple("example_mul");
+}
+
+TEST(BoringSSL, ExampleSign) {
+  TestSimple("example_sign");
+}

third_party/boringssl/linux-x86/crypto/bn/x86-mont.S

+#if defined(__i386__)
+.file	"src/crypto/bn/asm/x86-mont.S"
+.text
+.globl	bn_mul_mont
+.type	bn_mul_mont,@function
+.align	16
+bn_mul_mont:
+.L_bn_mul_mont_begin:
+	pushl	%ebp
+	pushl	%ebx
+	pushl	%esi
+	pushl	%edi
+	xorl	%eax,%eax
+	movl	40(%esp),%edi
+	cmpl	$4,%edi
+	jl	.L000just_leave
+	leal	20(%esp),%esi
+	leal	24(%esp),%edx
+	movl	%esp,%ebp
+	addl	$2,%edi
+	negl	%edi
+	leal	-32(%esp,%edi,4),%esp
+	negl	%edi
+	movl	%esp,%eax
+	subl	%edx,%eax
+	andl	$2047,%eax
+	subl	%eax,%esp
+	xorl	%esp,%edx
+	andl	$2048,%edx
+	xorl	$2048,%edx
+	subl	%edx,%esp
+	andl	$-64,%esp
+	movl	(%esi),%eax
+	movl	4(%esi),%ebx
+	movl	8(%esi),%ecx
+	movl	12(%esi),%edx
+	movl	16(%esi),%esi
+	movl	(%esi),%esi
+	movl	%eax,4(%esp)
+	movl	%ebx,8(%esp)
+	movl	%ecx,12(%esp)
+	movl	%edx,16(%esp)
+	movl	%esi,20(%esp)
+	leal	-3(%edi),%ebx
+	movl	%ebp,24(%esp)
+	movl	8(%esp),%esi
+	leal	1(%ebx),%ebp
+	movl	12(%esp),%edi
+	xorl	%ecx,%ecx
+	movl	%esi,%edx
+	andl	$1,%ebp
+	subl	%edi,%edx
+	leal	4(%edi,%ebx,4),%eax
+	orl	%edx,%ebp
+	movl	(%edi),%edi
+	jz	.L001bn_sqr_mont
+	movl	%eax,28(%esp)
+	movl	(%esi),%eax
+	xorl	%edx,%edx
+.align	16
+.L002mull:
+	movl	%edx,%ebp
+	mull	%edi
+	addl	%eax,%ebp
+	leal	1(%ecx),%ecx
+	adcl	$0,%edx
+	movl	(%esi,%ecx,4),%eax
+	cmpl	%ebx,%ecx
+	movl	%ebp,28(%esp,%ecx,4)
+	jl	.L002mull
+	movl	%edx,%ebp
+	mull	%edi
+	movl	20(%esp),%edi
+	addl	%ebp,%eax
+	movl	16(%esp),%esi
+	adcl	$0,%edx
+	imull	32(%esp),%edi
+	movl	%eax,32(%esp,%ebx,4)
+	xorl	%ecx,%ecx
+	movl	%edx,36(%esp,%ebx,4)
+	movl	%ecx,40(%esp,%ebx,4)
+	movl	(%esi),%eax
+	mull	%edi
+	addl	32(%esp),%eax
+	movl	4(%esi),%eax
+	adcl	$0,%edx
+	incl	%ecx
+	jmp	.L0032ndmadd
+.align	16
+.L0041stmadd:
+	movl	%edx,%ebp
+	mull	%edi
+	addl	32(%esp,%ecx,4),%ebp
+	leal	1(%ecx),%ecx
+	adcl	$0,%edx
+	addl	%eax,%ebp
+	movl	(%esi,%ecx,4),%eax
+	adcl	$0,%edx
+	cmpl	%ebx,%ecx
+	movl	%ebp,28(%esp,%ecx,4)
+	jl	.L0041stmadd
+	movl	%edx,%ebp
+	mull	%edi
+	addl	32(%esp,%ebx,4),%eax
+	movl	20(%esp),%edi
+	adcl	$0,%edx
+	movl	16(%esp),%esi
+	addl	%eax,%ebp
+	adcl	$0,%edx
+	imull	32(%esp),%edi
+	xorl	%ecx,%ecx
+	addl	36(%esp,%ebx,4),%edx
+	movl	%ebp,32(%esp,%ebx,4)
+	adcl	$0,%ecx
+	movl	(%esi),%eax
+	movl	%edx,36(%esp,%ebx,4)
+	movl	%ecx,40(%esp,%ebx,4)
+	mull	%edi
+	addl	32(%esp),%eax
+	movl	4(%esi),%eax
+	adcl	$0,%edx
+	movl	$1,%ecx
+.align	16
+.L0032ndmadd:
+	movl	%edx,%ebp
+	mull	%edi
+	addl	32(%esp,%ecx,4),%ebp
+	leal	1(%ecx),%ecx
+	adcl	$0,%edx
+	addl	%eax,%ebp
+	movl	(%esi,%ecx,4),%eax
+	adcl	$0,%edx
+	cmpl	%ebx,%ecx
+	movl	%ebp,24(%esp,%ecx,4)
+	jl	.L0032ndmadd
+	movl	%edx,%ebp
+	mull	%edi
+	addl	32(%esp,%ebx,4),%ebp
+	adcl	$0,%edx
+	addl	%eax,%ebp
+	adcl	$0,%edx
+	movl	%ebp,28(%esp,%ebx,4)
+	xorl	%eax,%eax
+	movl	12(%esp),%ecx
+	addl	36(%esp,%ebx,4),%edx
+	adcl	40(%esp,%ebx,4),%eax
+	leal	4(%ecx),%ecx
+	movl	%edx,32(%esp,%ebx,4)
+	cmpl	28(%esp),%ecx
+	movl	%eax,36(%esp,%ebx,4)
+	je	.L005common_tail
+	movl	(%ecx),%edi
+	movl	8(%esp),%esi
+	movl	%ecx,12(%esp)
+	xorl	%ecx,%ecx
+	xorl	%edx,%edx
+	movl	(%esi),%eax
+	jmp	.L0041stmadd
+.align	16
+.L001bn_sqr_mont:
+	movl	%ebx,(%esp)
+	movl	%ecx,12(%esp)
+	movl	%edi,%eax
+	mull	%edi
+	movl	%eax,32(%esp)
+	movl	%edx,%ebx
+	shrl	$1,%edx
+	andl	$1,%ebx
+	incl	%ecx
+.align	16
+.L006sqr:
+	movl	(%esi,%ecx,4),%eax
+	movl	%edx,%ebp
+	mull	%edi
+	addl	%ebp,%eax
+	leal	1(%ecx),%ecx
+	adcl	$0,%edx
+	leal	(%ebx,%eax,2),%ebp
+	shrl	$31,%eax
+	cmpl	(%esp),%ecx
+	movl	%eax,%ebx
+	movl	%ebp,28(%esp,%ecx,4)
+	jl	.L006sqr
+	movl	(%esi,%ecx,4),%eax
+	movl	%edx,%ebp
+	mull	%edi
+	addl	%ebp,%eax
+	movl	20(%esp),%edi
+	adcl	$0,%edx
+	movl	16(%esp),%esi
+	leal	(%ebx,%eax,2),%ebp
+	imull	32(%esp),%edi
+	shrl	$31,%eax
+	movl	%ebp,32(%esp,%ecx,4)
+	leal	(%eax,%edx,2),%ebp
+	movl	(%esi),%eax
+	shrl	$31,%edx
+	movl	%ebp,36(%esp,%ecx,4)
+	movl	%edx,40(%esp,%ecx,4)
+	mull	%edi
+	addl	32(%esp),%eax
+	movl	%ecx,%ebx
+	adcl	$0,%edx
+	movl	4(%esi),%eax
+	movl	$1,%ecx
+.align	16
+.L0073rdmadd:
+	movl	%edx,%ebp
+	mull	%edi
+	addl	32(%esp,%ecx,4),%ebp
+	adcl	$0,%edx
+	addl	%eax,%ebp
+	movl	4(%esi,%ecx,4),%eax
+	adcl	$0,%edx
+	movl	%ebp,28(%esp,%ecx,4)
+	movl	%edx,%ebp
+	mull	%edi
+	addl	36(%esp,%ecx,4),%ebp
+	leal	2(%ecx),%ecx
+	adcl	$0,%edx
+	addl	%eax,%ebp
+	movl	(%esi,%ecx,4),%eax
+	adcl	$0,%edx
+	cmpl	%ebx,%ecx
+	movl	%ebp,24(%esp,%ecx,4)
+	jl	.L0073rdmadd
+	movl	%edx,%ebp
+	mull	%edi
+	addl	32(%esp,%ebx,4),%ebp
+	adcl	$0,%edx
+	addl	%eax,%ebp
+	adcl	$0,%edx
+	movl	%ebp,28(%esp,%ebx,4)
+	movl	12(%esp),%ecx
+	xorl	%eax,%eax
+	movl	8(%esp),%esi
+	addl	36(%esp,%ebx,4),%edx
+	adcl	40(%esp,%ebx,4),%eax
+	movl	%edx,32(%esp,%ebx,4)
+	cmpl	%ebx,%ecx
+	movl	%eax,36(%esp,%ebx,4)
+	je	.L005common_tail
+	movl	4(%esi,%ecx,4),%edi
+	leal	1(%ecx),%ecx
+	movl	%edi,%eax
+	movl	%ecx,12(%esp)
+	mull	%edi
+	addl	32(%esp,%ecx,4),%eax
+	adcl	$0,%edx
+	movl	%eax,32(%esp,%ecx,4)
+	xorl	%ebp,%ebp
+	cmpl	%ebx,%ecx
+	leal	1(%ecx),%ecx
+	je	.L008sqrlast
+	movl	%edx,%ebx
+	shrl	$1,%edx
+	andl	$1,%ebx
+.align	16
+.L009sqradd:
+	movl	(%esi,%ecx,4),%eax
+	movl	%edx,%ebp
+	mull	%edi
+	addl	%ebp,%eax
+	leal	(%eax,%eax,1),%ebp
+	adcl	$0,%edx
+	shrl	$31,%eax
+	addl	32(%esp,%ecx,4),%ebp
+	leal	1(%ecx),%ecx
+	adcl	$0,%eax
+	addl	%ebx,%ebp
+	adcl	$0,%eax
+	cmpl	(%esp),%ecx
+	movl	%ebp,28(%esp,%ecx,4)
+	movl	%eax,%ebx
+	jle	.L009sqradd
+	movl	%edx,%ebp
+	addl	%edx,%edx
+	shrl	$31,%ebp
+	addl	%ebx,%edx
+	adcl	$0,%ebp
+.L008sqrlast:
+	movl	20(%esp),%edi
+	movl	16(%esp),%esi
+	imull	32(%esp),%edi
+	addl	32(%esp,%ecx,4),%edx
+	movl	(%esi),%eax
+	adcl	$0,%ebp
+	movl	%edx,32(%esp,%ecx,4)
+	movl	%ebp,36(%esp,%ecx,4)
+	mull	%edi
+	addl	32(%esp),%eax
+	leal	-1(%ecx),%ebx
+	adcl	$0,%edx
+	movl	$1,%ecx
+	movl	4(%esi),%eax
+	jmp	.L0073rdmadd
+.align	16
+.L005common_tail:
+	movl	16(%esp),%ebp
+	movl	4(%esp),%edi
+	leal	32(%esp),%esi
+	movl	(%esi),%eax
+	movl	%ebx,%ecx
+	xorl	%edx,%edx
+.align	16
+.L010sub:
+	sbbl	(%ebp,%edx,4),%eax
+	movl	%eax,(%edi,%edx,4)
+	decl	%ecx
+	movl	4(%esi,%edx,4),%eax
+	leal	1(%edx),%edx
+	jge	.L010sub
+	sbbl	$0,%eax
+.align	16
+.L011copy:
+	movl	(%esi,%ebx,4),%edx
+	movl	(%edi,%ebx,4),%ebp
+	xorl	%ebp,%edx
+	andl	%eax,%edx
+	xorl	%ebp,%edx
+	movl	%ecx,(%esi,%ebx,4)
+	movl	%edx,(%edi,%ebx,4)
+	decl	%ebx
+	jge	.L011copy
+	movl	24(%esp),%esp
+	movl	$1,%eax
+.L000just_leave:
+	popl	%edi
+	popl	%esi
+	popl	%ebx
+	popl	%ebp
+	ret
+.size	bn_mul_mont,.-.L_bn_mul_mont_begin
+.byte	77,111,110,116,103,111,109,101,114,121,32,77,117,108,116,105
+.byte	112,108,105,99,97,116,105,111,110,32,102,111,114,32,120,56
+.byte	54,44,32,67,82,89,80,84,79,71,65,77,83,32,98,121
+.byte	32,60,97,112,112,114,111,64,111,112,101,110,115,115,108,46
+.byte	111,114,103,62,0
+#endif
\ No newline at end of file

third_party/boringssl/linux-x86_64/crypto/bn/rsaz-avx2.S

+#if defined(__x86_64__)
+.text	
+
+.globl	rsaz_avx2_eligible
+.type	rsaz_avx2_eligible,@function
+rsaz_avx2_eligible:
+	xorl	%eax,%eax
+	.byte	0xf3,0xc3
+.size	rsaz_avx2_eligible,.-rsaz_avx2_eligible
+
+.globl	rsaz_1024_sqr_avx2
+.globl	rsaz_1024_mul_avx2
+.globl	rsaz_1024_norm2red_avx2
+.globl	rsaz_1024_red2norm_avx2
+.globl	rsaz_1024_scatter5_avx2
+.globl	rsaz_1024_gather5_avx2
+.type	rsaz_1024_sqr_avx2,@function
+rsaz_1024_sqr_avx2:
+rsaz_1024_mul_avx2:
+rsaz_1024_norm2red_avx2:
+rsaz_1024_red2norm_avx2:
+rsaz_1024_scatter5_avx2:
+rsaz_1024_gather5_avx2:
+.byte	0x0f,0x0b
+	.byte	0xf3,0xc3
+.size	rsaz_1024_sqr_avx2,.-rsaz_1024_sqr_avx2
+#endif
\ No newline at end of file