当前位置： 首页 > news >正文

protobuf2.5.0 arm_linux

news 2025/8/1 19:11:13

**

protobuf-2.5.0 ARM Linux编译

**
将以下三个文件拷贝替换到:protobuf-2.5.0/src/google/protobuf

1 replace file: atomicops.h

// Protocol Buffers - Google's data interchange format
// Copyright 2012 Google Inc.  All rights reserved.
// http://code.google.com/p/protobuf/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.// The routines exported by this module are subtle.  If you use them, even if
// you get the code right, it will depend on careful reasoning about atomicity
// and memory ordering; it will be less readable, and harder to maintain.  If
// you plan to use these routines, you should have a good reason, such as solid
// evidence that performance would otherwise suffer, or there being no
// alternative.  You should assume only properties explicitly guaranteed by the
// specifications in this file.  You are almost certainly _not_ writing code
// just for the x86; if you assume x86 semantics, x86 hardware bugs and
// implementations on other archtectures will cause your code to break.  If you
// do not know what you are doing, avoid these routines, and use a Mutex.
//
// It is incorrect to make direct assignments to/from an atomic variable.
// You should use one of the Load or Store routines.  The NoBarrier
// versions are provided when no barriers are needed:
//   NoBarrier_Store()
//   NoBarrier_Load()
// Although there are currently no compiler enforcement, you are encouraged
// to use these.// This header and the implementations for each platform (located in
// atomicops_internals_*) must be kept in sync with the upstream code (V8).#ifndef GOOGLE_PROTOBUF_ATOMICOPS_H_
#define GOOGLE_PROTOBUF_ATOMICOPS_H_// Don't include this file for people not concerned about thread safety.
#ifndef GOOGLE_PROTOBUF_NO_THREAD_SAFETY#include <google/protobuf/stubs/platform_macros.h>namespace google {
namespace protobuf {
namespace internal {typedef int32 Atomic32;
#ifdef GOOGLE_PROTOBUF_ARCH_64_BIT
// We need to be able to go between Atomic64 and AtomicWord implicitly.  This
// means Atomic64 and AtomicWord should be the same type on 64-bit.
#if defined(GOOGLE_PROTOBUF_OS_NACL)
// NaCl's intptr_t is not actually 64-bits on 64-bit!
// http://code.google.com/p/nativeclient/issues/detail?id=1162
typedef int64 Atomic64;
#else
typedef intptr_t Atomic64;
#endif
#endif// Use AtomicWord for a machine-sized pointer.  It will use the Atomic32 or
// Atomic64 routines below, depending on your architecture.
typedef intptr_t AtomicWord;// Atomically execute:
//      result = *ptr;
//      if (*ptr == old_value)
//        *ptr = new_value;
//      return result;
//
// I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value".
// Always return the old value of "*ptr"
//
// This routine implies no memory barriers.
Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,Atomic32 old_value,Atomic32 new_value);// Atomically store new_value into *ptr, returning the previous value held in
// *ptr.  This routine implies no memory barriers.
Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value);// Atomically increment *ptr by "increment".  Returns the new value of
// *ptr with the increment applied.  This routine implies no memory barriers.
Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,Atomic32 increment);// These following lower-level operations are typically useful only to people
// implementing higher-level synchronization operations like spinlocks,
// mutexes, and condition-variables.  They combine CompareAndSwap(), a load, or
// a store with appropriate memory-ordering instructions.  "Acquire" operations
// ensure that no later memory access can be reordered ahead of the operation.
// "Release" operations ensure that no previous memory access can be reordered
// after the operation.  "Barrier" operations have both "Acquire" and "Release"
// semantics.   A MemoryBarrier() has "Barrier" semantics, but does no memory
// access.
Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,Atomic32 old_value,Atomic32 new_value);
Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,Atomic32 old_value,Atomic32 new_value);void MemoryBarrier();
void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value);
void Acquire_Store(volatile Atomic32* ptr, Atomic32 value);
void Release_Store(volatile Atomic32* ptr, Atomic32 value);Atomic32 NoBarrier_Load(volatile const Atomic32* ptr);
Atomic32 Acquire_Load(volatile const Atomic32* ptr);
Atomic32 Release_Load(volatile const Atomic32* ptr);// 64-bit atomic operations (only available on 64-bit processors).
#ifdef GOOGLE_PROTOBUF_ARCH_64_BIT
Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,Atomic64 old_value,Atomic64 new_value);
Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value);
Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,Atomic64 old_value,Atomic64 new_value);
Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,Atomic64 old_value,Atomic64 new_value);
void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value);
void Acquire_Store(volatile Atomic64* ptr, Atomic64 value);
void Release_Store(volatile Atomic64* ptr, Atomic64 value);
Atomic64 NoBarrier_Load(volatile const Atomic64* ptr);
Atomic64 Acquire_Load(volatile const Atomic64* ptr);
Atomic64 Release_Load(volatile const Atomic64* ptr);
#endif  // GOOGLE_PROTOBUF_ARCH_64_BIT}  // namespace internal
}  // namespace protobuf
}  // namespace google// Include our platform specific implementation.
#define GOOGLE_PROTOBUF_ATOMICOPS_ERROR \
#error "Atomic operations are not supported on your platform"// MSVC.
#if defined(_MSC_VER)
#if defined(GOOGLE_PROTOBUF_ARCH_IA32) || defined(GOOGLE_PROTOBUF_ARCH_X64)
#include <google/protobuf/stubs/atomicops_internals_x86_msvc.h>
#else
GOOGLE_PROTOBUF_ATOMICOPS_ERROR
#endif// Apple.
#elif defined(GOOGLE_PROTOBUF_OS_APPLE)
#include <google/protobuf/stubs/atomicops_internals_macosx.h>// GCC.
#elif defined(__GNUC__)
#if defined(GOOGLE_PROTOBUF_ARCH_IA32) || defined(GOOGLE_PROTOBUF_ARCH_X64)
//#include <google/protobuf/stubs/atomicops_internals_x86_gcc.h>
#elif defined(GOOGLE_PROTOBUF_ARCH_ARM)
//#include <google/protobuf/stubs/atomicops_internals_arm64_gcc.h>
#elif defined(GOOGLE_PROTOBUF_ARCH_X64)
//#include <google/protobuf/stubs/atomicops_internals_arm64_gcc.h>
#elif defined(GOOGLE_PROTOBUF_ARCH_ARM_QNX)
#include <google/protobuf/stubs/atomicops_internals_arm_qnx.h>
#elif defined(GOOGLE_PROTOBUF_ARCH_MIPS)
#include <google/protobuf/stubs/atomicops_internals_mips_gcc.h>
#elif defined(__pnacl__)
#include <google/protobuf/stubs/atomicops_internals_pnacl.h>
#else
//#include <google/protobuf/stubs/atomicops_internals_arm64_gcc.h>
GOOGLE_PROTOBUF_ATOMICOPS_ERROR
#endif
//#include <google/protobuf/stubs/atomicops_internals_arm64_gcc.h>
// Unknown.
#else
GOOGLE_PROTOBUF_ATOMICOPS_ERROR
#endif
#include <google/protobuf/stubs/atomicops_internals_arm64_gcc.h>
// On some platforms we need additional declarations to make AtomicWord
// compatible with our other Atomic* types.
#if defined(GOOGLE_PROTOBUF_OS_APPLE)
#include <google/protobuf/stubs/atomicops_internals_atomicword_compat.h>
#endif#undef GOOGLE_PROTOBUF_ATOMICOPS_ERROR#endif  // GOOGLE_PROTOBUF_NO_THREAD_SAFETY#endif  // GOOGLE_PROTOBUF_ATOMICOPS_H_

2 replace file: atomicops_internals_arm64_gcc.h

// Protocol Buffers - Google's data interchange format
// Copyright 2012 Google Inc.  All rights reserved.
// http://code.google.com/p/protobuf/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.// This file is an internal atomic implementation, use atomicops.h instead.#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM64_GCC_H_
#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM64_GCC_H_namespace google {
namespace protobuf {
namespace internal {inline void MemoryBarrier() {__asm__ __volatile__ (  // NOLINT"dmb ish                                  \n\t"  // Data memory barrier.::: "memory");  // NOLINT
}inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,Atomic32 old_value,Atomic32 new_value) {Atomic32 prev;int32_t temp;__asm__ __volatile__ (  // NOLINT"0:                                    \n\t""ldxr %w[prev], %[ptr]                 \n\t"  // Load the previous value."cmp %w[prev], %w[old_value]           \n\t""bne 1f                                \n\t""stxr %w[temp], %w[new_value], %[ptr]  \n\t"  // Try to store the new value."cbnz %w[temp], 0b                     \n\t"  // Retry if it did not work."1:                                    \n\t""clrex                                 \n\t"  // In case we didn't swap.: [prev]"=&r" (prev),[temp]"=&r" (temp),[ptr]"+Q" (*ptr): [old_value]"r" (old_value),[new_value]"r" (new_value): "memory", "cc");  // NOLINTreturn prev;
}inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,Atomic32 new_value) {Atomic32 result;int32_t temp;__asm__ __volatile__ (  // NOLINT"0:                                    \n\t""ldxr %w[result], %[ptr]               \n\t"  // Load the previous value."stxr %w[temp], %w[new_value], %[ptr]  \n\t"  // Try to store the new value."cbnz %w[temp], 0b                     \n\t"  // Retry if it did not work.: [result]"=&r" (result),[temp]"=&r" (temp),[ptr]"+Q" (*ptr): [new_value]"r" (new_value): "memory");  // NOLINTreturn result;
}inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,Atomic32 increment) {Atomic32 result;int32_t temp;__asm__ __volatile__ (  // NOLINT"0:                                       \n\t""ldxr %w[result], %[ptr]                  \n\t"  // Load the previous value."add %w[result], %w[result], %w[increment]\n\t""stxr %w[temp], %w[result], %[ptr]        \n\t"  // Try to store the result."cbnz %w[temp], 0b                        \n\t"  // Retry on failure.: [result]"=&r" (result),[temp]"=&r" (temp),[ptr]"+Q" (*ptr): [increment]"r" (increment): "memory");  // NOLINTreturn result;
}inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,Atomic32 increment) {MemoryBarrier();Atomic32 result = NoBarrier_AtomicIncrement(ptr, increment);MemoryBarrier();return result;
}inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,Atomic32 old_value,Atomic32 new_value) {Atomic32 prev;int32_t temp;__asm__ __volatile__ (  // NOLINT"0:                                    \n\t""ldxr %w[prev], %[ptr]                 \n\t"  // Load the previous value."cmp %w[prev], %w[old_value]           \n\t""bne 1f                                \n\t""stxr %w[temp], %w[new_value], %[ptr]  \n\t"  // Try to store the new value."cbnz %w[temp], 0b                     \n\t"  // Retry if it did not work."dmb ish                               \n\t"  // Data memory barrier."1:                                    \n\t"// If the compare failed the 'dmb' is unnecessary, but we still need a// 'clrex'."clrex                                 \n\t": [prev]"=&r" (prev),[temp]"=&r" (temp),[ptr]"+Q" (*ptr): [old_value]"r" (old_value),[new_value]"r" (new_value): "memory", "cc");  // NOLINTreturn prev;
}inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,Atomic32 old_value,Atomic32 new_value) {Atomic32 prev;int32_t temp;MemoryBarrier();__asm__ __volatile__ (  // NOLINT"0:                                    \n\t""ldxr %w[prev], %[ptr]                 \n\t"  // Load the previous value."cmp %w[prev], %w[old_value]           \n\t""bne 1f                                \n\t""stxr %w[temp], %w[new_value], %[ptr]  \n\t"  // Try to store the new value."cbnz %w[temp], 0b                     \n\t"  // Retry if it did not work."1:                                    \n\t"// If the compare failed the we still need a 'clrex'."clrex                                 \n\t": [prev]"=&r" (prev),[temp]"=&r" (temp),[ptr]"+Q" (*ptr): [old_value]"r" (old_value),[new_value]"r" (new_value): "memory", "cc");  // NOLINTreturn prev;
}inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {*ptr = value;
}inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {*ptr = value;MemoryBarrier();
}inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {MemoryBarrier();*ptr = value;
}/*inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {return *ptr;
}*//*inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {Atomic32 value = *ptr;MemoryBarrier();return value;
}*//*inline Atomic32 Release_Load(volatile const Atomic32* ptr) {MemoryBarrier();return *ptr;
}*/// 64-bit versions of the operations.
// See the 32-bit versions for comments.inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,Atomic64 old_value,Atomic64 new_value) {Atomic64 prev;int32_t temp;__asm__ __volatile__ (  // NOLINT"0:                                    \n\t""ldxr %[prev], %[ptr]                  \n\t""cmp %[prev], %[old_value]             \n\t""bne 1f                                \n\t""stxr %w[temp], %[new_value], %[ptr]   \n\t""cbnz %w[temp], 0b                     \n\t""1:                                    \n\t""clrex                                 \n\t": [prev]"=&r" (prev),[temp]"=&r" (temp),[ptr]"+Q" (*ptr): [old_value]"r" (old_value),[new_value]"r" (new_value): "memory", "cc");  // NOLINTreturn prev;
}inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,Atomic64 new_value) {Atomic64 result;int32_t temp;__asm__ __volatile__ (  // NOLINT"0:                                    \n\t""ldxr %[result], %[ptr]                \n\t""stxr %w[temp], %[new_value], %[ptr]   \n\t""cbnz %w[temp], 0b                     \n\t": [result]"=&r" (result),[temp]"=&r" (temp),[ptr]"+Q" (*ptr): [new_value]"r" (new_value): "memory");  // NOLINTreturn result;
}inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,Atomic64 increment) {Atomic64 result;int32_t temp;__asm__ __volatile__ (  // NOLINT"0:                                     \n\t""ldxr %[result], %[ptr]                 \n\t""add %[result], %[result], %[increment] \n\t""stxr %w[temp], %[result], %[ptr]       \n\t""cbnz %w[temp], 0b                      \n\t": [result]"=&r" (result),[temp]"=&r" (temp),[ptr]"+Q" (*ptr): [increment]"r" (increment): "memory");  // NOLINTreturn result;
}inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,Atomic64 increment) {MemoryBarrier();Atomic64 result = NoBarrier_AtomicIncrement(ptr, increment);MemoryBarrier();return result;
}inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,Atomic64 old_value,Atomic64 new_value) {Atomic64 prev;int32_t temp;__asm__ __volatile__ (  // NOLINT"0:                                    \n\t""ldxr %[prev], %[ptr]                  \n\t""cmp %[prev], %[old_value]             \n\t""bne 1f                                \n\t""stxr %w[temp], %[new_value], %[ptr]   \n\t""cbnz %w[temp], 0b                     \n\t""dmb ish                               \n\t""1:                                    \n\t""clrex                                 \n\t": [prev]"=&r" (prev),[temp]"=&r" (temp),[ptr]"+Q" (*ptr): [old_value]"r" (old_value),[new_value]"r" (new_value): "memory", "cc");  // NOLINTreturn prev;
}inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,Atomic64 old_value,Atomic64 new_value) {Atomic64 prev;int32_t temp;MemoryBarrier();__asm__ __volatile__ (  // NOLINT"0:                                    \n\t""ldxr %[prev], %[ptr]                  \n\t""cmp %[prev], %[old_value]             \n\t""bne 1f                                \n\t""stxr %w[temp], %[new_value], %[ptr]   \n\t""cbnz %w[temp], 0b                     \n\t""1:                                    \n\t""clrex                                 \n\t": [prev]"=&r" (prev),[temp]"=&r" (temp),[ptr]"+Q" (*ptr): [old_value]"r" (old_value),[new_value]"r" (new_value): "memory", "cc");  // NOLINTreturn prev;
}inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {*ptr = value;
}inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {*ptr = value;MemoryBarrier();
}inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {MemoryBarrier();*ptr = value;
}inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {return *ptr;
}inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {Atomic64 value = *ptr;MemoryBarrier();return value;
}inline Atomic64 Release_Load(volatile const Atomic64* ptr) {MemoryBarrier();return *ptr;
}}  // namespace internal
}  // namespace protobuf
}  // namespace google#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM64_GCC_H_

3 replace file: platform_macros.h

// Protocol Buffers - Google's data interchange format
// Copyright 2012 Google Inc.  All rights reserved.
// http://code.google.com/p/protobuf/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.#ifndef GOOGLE_PROTOBUF_PLATFORM_MACROS_H_
#define GOOGLE_PROTOBUF_PLATFORM_MACROS_H_
#define  __arm64__
#include <google/protobuf/stubs/common.h>// Processor architecture detection.  For more info on what's defined, see:
//   http://msdn.microsoft.com/en-us/library/b0084kay.aspx
//   http://www.agner.org/optimize/calling_conventions.pdf
//   or with gcc, run: "echo | gcc -E -dM -"
/*#if defined(_M_X64) || defined(__x86_64__)
#define GOOGLE_PROTOBUF_ARCH_X64 1
#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
#elif defined(_M_IX86) || defined(__i386__)
#define GOOGLE_PROTOBUF_ARCH_IA32 1
#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
#elif defined(__QNX__)
#define GOOGLE_PROTOBUF_ARCH_ARM_QNX 1
#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
#elif defined(__ARMEL__)
#define GOOGLE_PROTOBUF_ARCH_ARM 1
#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
#elif defined(__MIPSEL__)
#define GOOGLE_PROTOBUF_ARCH_MIPS 1
#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
#elif defined(__pnacl__)
#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
#elif defined(__ppc__)
#define GOOGLE_PROTOBUF_ARCH_PPC 1
#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
#elif defined(__aarch64__)*/
//#define GOOGLE_PROTOBUF_ARCH_ARM 1
//#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
/*#else
#error Host architecture was not detected as supported by protobuf
#endif*/
#define GOOGLE_PROTOBUF_ARCH_X64 1
#define GOOGLE_PROTOBUF_ARCH_64_BIT 1#if defined(__APPLE__)
#define GOOGLE_PROTOBUF_OS_APPLE
#elif defined(__native_client__)
#define GOOGLE_PROTOBUF_OS_NACL
#endif#endif  // GOOGLE_PROTOBUF_PLATFORM_MACROS_H_

./configure -prefix=/home/GaoRui/WorkSpace/protobuf_test_build/protobuf_bin

make

make install

http://www.dtcms.com/a/304890.html

相关文章：

  • STM32系统定时器（SysTick）详解：从原理到实战的精确延时与任务调度
  • 《计算机组成原理与汇编语言程序设计》实验报告五 循环结构及子程序
  • 译 | 结合聚类与注意力机制的强化学习在个性化促销中的应用
  • 图像增强11种几何变换方法示例
  • C++基础：模拟实现priority_queue(堆)，详细介绍仿函数
  • 游戏盾从哪些方面保护网站业务？
  • GTSuite许可证性能优化建议
  • 第4章唯一ID生成器——4.4 基于数据库的自增主键的趋势递增的唯一ID
  • 前缀和-974.和可被k整除的子数组-力扣(LeetCode)
  • 实现视频实时马赛克
  • OpenShift AI - 将 Python 库安装到 Workbench 共享存储中
  • 【跨国数仓迁移最佳实践3】资源消耗减少50%！解析跨国数仓迁移至MaxCompute背后的性能优化技术
  • 深度学习篇---PaddleDetection模型选择
  • 《HCIA-Datacom 认证》希赛三色笔记：Vlan间三层通信过程解析
  • 用LangGraph实现聊天机器人记忆功能的深度解析
  • JVM知识点（1）
  • 通过管理工具（hgdbdeveloper）新建用户无法授权
  • 子数组和 问题汇总
  • AI应用：电路板设计
  • C++ 模板类型 ＜T＞，对函数参数传递兼容性检查
  • 【Linux系统编程】Ext2文件系统
  • 001 Configuration结构体构造
  • 【C++篇】“内存泄露”的宝藏手段：智能指针
  • OpenCV 学习探秘之三：从图像读取到特征识别，再到机器学习等函数接口的全面实战应用与解析
  • Excel批量加密工具,一键保护多个文件
  • 【图像处理基石】如何对遥感图像进行实例分割？
  • 【RAG搭建Agent应用实战】基于检索增强生成（RAG）搭建特定场景Agent应用
  • Spring Boot 防重放攻击全面指南：原理、方案与最佳实践
  • AI产品经理手册（Ch3-5）AI Product Manager‘s Handbook学习笔记
  • 【Linux基础】find在linux中查找文件