Shulou(Shulou.com)06/03 Report--

This article introduces the relevant knowledge of "what is the application of visibility attributes in cpython". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

GCC attribute syntax

GCC's attribute syntax can add attributes to functions, structures, classes, enumerations, variables, tags, etc. For example, by adding the attribute _ _ attribute__ ((noreturn)) to the function, you can let the compiler know that the function will not be returned to the caller and optimize accordingly.

There is also a keyword similar to gcc attribute syntax in the Windows special modifier-- _ _ declspec. In the pursuit of cross-platform versatility, gcc _ _ attribute__ and windows _ declspec are usually added at the same time to determine the platform and decide which method to use at compile time

_ _ declspec (attribute) declaration statement / / for example _ _ declspec (dllimport) int ipositional declaration spec (dllexport) void func ()

Q: where exactly is Q: _ _ attribute__ ((attribute list)) written?

A: add different attributes to the same object, or the same attribute acts on different objects, some immediately after the keyword or after the entire declaration. You can refer to the official documents for details.

/ / can be immediately followed by the struct, class, union, enum keywords, or after the closing parenthesis, the former struct _ _ attribute__ ((aligned (8) S {short f [3];}; / / add attributes aligned (8) / / use typedef int T1 _ attribute__ ((deprecated)) in the typdef declaration / / when T1 is used anywhere, the deprecated attribute generates an alarm / / function _ _ attribute__ ((attribute list)) void foo1 (void); void foo2 (void) _ _ attribute__ ((attribute list))

Q: what attributes are available?

A: for functions, structures, classes and other different objects, they all have their own supported attributes, which are divided into the most commonly used common attributes and special attributes for specific CPU architecture. For more information, please refer to the official documentation.

Visibility attribute

The visibility attribute is used to specify visibility and can be used for functions, class, struct, union, enum, using syntax consistency.

Void _ attribute__ ((visibility ("protected") f () {/ * Do something. * /;} int I _ attribute__ ((visibility ("hidden")

Attribute value:

Default: has external external linkage, can be referenced by other external modules, and may be overridden

Hidden: can only be referenced in the same shared object (which can be simply understood as a library file)

Internal: cannot be referenced directly by other modules, but can be referenced indirectly through pointers

Protected: can be referenced but cannot be overridden

How to use visibility attribute

Before we talk about the use of the visibility property, let's take a look at

_ _ declspec (attribute) declaration statement / / for example _ _ declspec (dllimport) int ipositional declaration spec (dllexport) void func ()

Here we take a look at a classic template in gcc wiki that can be used to define shared libraries

/ * define macros: identifiers: FOX_HELPER_DLL_IMPORT default, specified functions, class, struct, etc. are publicly rewritable. Do not compile, import directly. Identifiers: FOX_HELPER_DLL_EXPORT default, specified functions, class, struct, etc., are publicly rewritable. Compile and export to dynamic library (DLL or so) identifiers: FOX_HELPER_DLL_LOCAL hidden, specified function, class, struct, etc. can only be referenced in the same shared object * / / * for win32 and Cygwin, use _ _ declspec () to specify the attribute * / # if defined _ WIN32 | | defined _ CYGWIN__ # define FOX_HELPER_DLL_IMPORT _ declspec (dllimport) / / import from dll. Other modules can be seen in # define FOX_HELPER_DLL_EXPORT _ declspec (dllexport) / / exported to dll. For other modules, see # define FOX_HELPER_DLL_LOCAL#else / * for gcc Use _ _ attribute__ ((visibility ("attribute value")) to specify visibility * / # if _ GNUC__ > = 4 # define FOX_HELPER_DLL_IMPORT _ attribute__ ((visibility ("default") # define FOX_HELPER_DLL_EXPORT _ _ attribute__ ((visibility ("default") # define FOX_HELPER_DLL_LOCAL _ attribute__ ((visibility ("hidden") ) # else / * Macro has been referenced in the code Even if no attributes are added, define macros * / # define FOX_HELPER_DLL_IMPORT # define FOX_HELPER_DLL_EXPORT # define FOX_HELPER_DLL_LOCAL # endif#endif/* define macro FOX_API and FOX_LOCAL identifiers: FOX_API default, specify functions, class, struct, etc. are publicly rewritable, either compile the export, or import the identifier: FOX_LOCAL hidden Specified functions, class, struct, etc. can only be referenced in the same shared object * / # ifdef FOX_DLL / / if FOX needs to be compiled into a dynamic library # ifdef FOX_DLL_EXPORTS / / if you are building (rather than using) FOX # define FOX_API FOX_HELPER_DLL_EXPORT / / export dynamic library # else # define FOX_API FOX_HELPER_DLL_IMPORT / / do not build Directly import the dynamic library # endif / / FOX_DLL_EXPORTS # define FOX_LOCAL FOX_HELPER_DLL_LOCAL / / define FOX_LOCAL#else / / No FOX_DLL macros are defined, then FOX is a static library without adding any attributes # define FX_API # define FOX_LOCAL#endif / / FOX_DLL

Citation method:

/ / declare a publicly rewritable (default) function extern FOX_API PublicFunc1 (); / / extern _ _ attribute__ ((visibility ("default") PublicFunc1 (); / / declare a function extern FOX_LOCAL PublicFunc2 () that only uses (hidden) internally; / / extern _ _ attribute__ ((visibility ("hidden") PublicFunc2 (); / / declare a publicly rewritable (default) class class FOX_API PublicClass1 / / class _ _ attribute__ ((visibility ("default")) PublicClass1; / / declares a class class FOX_LOCAL PublicClass2; / / class _ attribute__ ((visibility ("hidden") that is only internally used (hidden)) PublicClass2; practical application-cpython

Friends who have studied cpython may look familiar when they see the above demo. Yes, there is a similar code in cpython. Of course, clang is also compatible with cpython.

# ifndef Py_EXPORTS_H#define Py_EXPORTS_H/* defines macros: identifiers: Py_IMPORTED_SYMBOL default, specified functions, class, struct, etc. are publicly rewritable. Do not compile, directly import identifiers: Py_EXPORTED_SYMBOL default, specify functions, class, struct, etc., are publicly rewritable. Compile and export to dynamic library (DLL or so) identifiers: Py_LOCAL_SYMBOL hidden, specified function, class, struct, etc. can only be referenced in the same shared object * / / * for win32 and Cygwin, use _ _ declspec () to specify the attribute * / # if defined (_ WIN32) | | defined (_ _ CYGWIN__) # define Py_IMPORTED_SYMBOL _ declspec (dllimport) / / import from dll. Other modules can be seen in # define Py_EXPORTED_SYMBOL _ declspec (dllexport) / / exported to dll. Other modules can see that the # define Py_LOCAL_SYMBOL#else / / _ has_attribute parameter is the attribute name, which can be evaluated whether the current compilation target supports this attribute, which is 1, and does not support 0 / / the following three lines of code are compatible with the non-clang compiler. For the non-clang compiler, the _ _ has_attribute (x) expression goes directly to 0 # ifndef _ _ has_attribute # define _ has_attribute (x) 0 # endif / / if the gcc version > = 4 or if the clang determines that the compilation target supports the visibility attribute Then add the attribute # if (defined (_ _ GNUC__) & & (_ _ GNUC__ > = 4)) | | (defined (_ _ clang__) & & _ has_attribute (visibility)) # define Py_IMPORTED_SYMBOL _ attribute__ ((visibility ("default") # define Py_EXPORTED_SYMBOL _ attribute__ ((visibility ("default") # define Py _ LOCAL_SYMBOL _ attribute__ ((visibility ("hidden") # else # define Py_IMPORTED_SYMBOL # define Py_EXPORTED_SYMBOL # define Py_LOCAL_SYMBOL # endif#endif#endif / * Py_EXPORTS_H * /

Py_LOCAL_SYMBOL: no references have been found in the source code

Py_IMPORTED_SYMBOL: used in the Windows compiler or cygwin to define the macro PyAPI_FUNC,PyAPI_DATA when building a non-core module, meaning to import the core module directly to prevent the compiler from compiling again. The reason is referred to here.

Py_EXPORTED_SYMBOL: define macros PyAPI_FUNC,PyAPI_DATA, PyMODINIT_FUNC

Some macro identifiers that will be used in the following code are explained first:

The Py_ENABLE_SHARED value is 1. On windows platform, the Python core is in DLL by default, which allows external connectivity.

HAVE_DECLSPEC_DLL all windows compilers and cygwin are defined to support _ _ declspec ().

Py_BUILD_CORE builds the Python kernel. Provides access to Python internals, but should not be used by third-party modules.

Py_BUILD_CORE_MODULE builds a Python stdlib module as a dynamic library, and the "PyInit_xxx" symbol is exported on Windows.

/ * for differences in the construction of different platforms, please refer to: https://docs.python.org/zh-cn/3/extending/windows.html#a-cookbook-approach*//* first deals with windows platform and cygwin * / # if defined (Py_ENABLE_SHARED) | | defined (_ _ CYGWIN__) # if defined (HAVE_DECLSPEC_DLL) / / build Python kernel Non-Python stdlib module # if defined (Py_BUILD_CORE) & &! defined (Py_BUILD_CORE_MODULE) # define PyAPI_FUNC (RTYPE) Py_EXPORTED_SYMBOL RTYPE# define PyAPI_DATA (RTYPE) extern Py_EXPORTED_SYMBOL RTYPE / / Core module initialization functions do not require external linking Unless Cygwin handles embedding # if defined (_ _ CYGWIN__) # define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject*# else / * _ _ CYGWIN__ * / # define PyMODINIT_FUNC PyObject*# endif / * _ CYGWIN__ * / # else / * Py_BUILD_CORE * / / Core construction is over Next, to build an extension module (non-core module) or embedded environment, you need to import common functions and data first / / using cygwin will automatically import common functions to prevent compilation, if not using cygwin Then you need to explicitly import # if! defined (_ _ CYGWIN__) # define PyAPI_FUNC (RTYPE) Py_IMPORTED_SYMBOL RTYPE# endif / *! _ CYGWIN__ * / # define PyAPI_DATA (RTYPE) extern Py_IMPORTED_SYMBOL RTYPE / / according to the syntax of C language Compile and export the initialization function of non-core module # if defined (_ _ cplusplus) # define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject*# else / * _ _ cplusplus * / # define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject*# Endif / * _ cplusplus * / # endif / * Py_BUILD_CORE * / # endif / * HAVE_DECLSPEC_DLL * / # endif / * Py_ENABLE_SHARED * / / * if PyAPI_FUNC is still not defined PyAPI_DATA, PyMODINIT_FUNC, indicates that it is not a windows platform or cygwin. By default, * / # ifndef PyAPI_FUNC / / _ _ attribute__ ((visibility ("default") RTYPE# define PyAPI_FUNC (RTYPE) Py_EXPORTED_SYMBOL RTYPE#endif#ifndef PyAPI_DATA / / extern _ _ attribute__ ((visibility ("default")) RTYPE# define PyAPI_DATA (RTYPE) extern Py_EXPORTED_SYMBOL RTYPE#endif// is defined by default, whether core module or non-core module All require external linking # ifndef PyMODINIT_FUNC# if defined (_ _ cplusplus) / / extern "C" _ attribute__ ((visibility ("default") PyObject*# define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject*# else / * _ _ cplusplus * / / _ attribute__ ((visibility ("default") PyObject * # define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject*# endif / * _ _ cplusplus * / # endif

Note: the Windows platform / compiler mentioned above defaults to Microsoft Visual compliant, but in theory other compilers can also support it.

What we are studying today is gcc, and then we will analyze how PyAPI_FUNC, PyAPI_DATA, and PyMODINIT_FUNC are used according to the way gcc is handled.

PyAPI_FUNC

Take the _ Py_hashtable_compare_direct method in pycore_hashtable.h as an example

Extern "C" PyAPI_FUNC (int) _ Py_hashtable_compare_direct {/ / function body}

Replace it according to the way define is used, and this is equivalent to

Extern "C" Py_EXPORTED_SYMBOL int _ Py_hashtable_compare_direct {/ / function outline}

Continue to replace

Extern "C" _ attribute__ ((visibility ("default")) int _ Py_hashtable_compare_direct {/ / function outline}

At this point, it is clear that a public function int _ Py_hashtable_compare_direct that can be called or overridden by other modules is actually defined.

Conclusion: the function specified by PyAPI_FUNC can be accessed by each module.

PyAPI_DATA

Take PyBool_Type in boolobject.h as an example

PyAPI_DATA (PyTypeObject) PyBool_Type; / / PyTypeObject is a structure

Replace

Extern Py_EXPORTED_SYMBOL PyTypeObject PyBool_Type

Continue to replace

Extern _ _ attribute__ ((visibility ("default") PyTypeObject PyBool_Type

The result is a declaration of a PyTypeObject structure variable that can be accessed by other modules.

Conclusion: PyAPI_DATA specified variables can be accessed by other modules.

PyMODINIT_FUNC

Take the module initialization function in arraymodule.h as an example

PyMODINIT_FUNCPyInit_array (void) {return PyModuleDef_Init (& arraymodule);}

Replace

/ / c language Py_EXPORTED_SYMBOL PyObject* PyInit_array (void) {return PyModuleDef_Init (& arraymodule);} / / C++extern "C" Py_EXPORTED_SYMBOL PyObject* PyInit_array (void) {return PyModuleDef_Init (& arraymodule);}

As you can see here, the PyInit_array () function calls the PyModuleDef_Init () method to initialize arraymodule, and then returns a pointer variable to the PyObject structure.

Continue to replace

/ / c language _ attribute__ ((visibility ("default")) PyObject* PyInit_array (void) {return PyModuleDef_Init (& arraymodule);} / / C++extern "C" _ attribute__ ((visibility ("default") PyObject* PyInit_array (void) {return PyModuleDef_Init (& arraymodule);}

The result is a module initialization function that can be accessed by other modules, which initializes the arraymodule and returns the pointer variable of the PyObject structure

Conclusion: PyMODINIT_FUNC specifies that the module initialization function can be accessed by other modules and returns the pointer variable of the PyObject structure.

Summary

GCC's attribute syntax can add attributes to functions, structures, classes, enumerations, variables, tags, etc. Syntax:

_ _ attribute__ ((attribute list))

The location is usually after the keyword, or after the entire declaration, specifically refer to the official document

Visibility attribute

Extern _ attribute__ ((visibility ("default") PublicFunc1 (); class _ attribute__ ((visibility ("default") PublicClass1

Default: has external external linkage, can be referenced by other external modules, and may be overridden

Hidden: can only be referenced in the same shared object (which can be simply understood as a library file)

Internal: cannot be referenced directly by other modules, but can be referenced indirectly through pointers

Protected: can be referenced but cannot be overridden

Cpython of the actual application of the visibility attribute

PyAPI_FUNC: specifies that the function can be accessed by each module

PyAPI_DATA: the specified variable can be accessed by other modules

PyMODINIT_FUNC: specifies that the module initialization function can be accessed by other modules and returns the pointer variable of the PyObject structure

This is the end of the content of "what is the application of visibility attributes in cpython". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.