2 * Copyright (c) 2017-20 David Lamparter, for NetDEF, Inc.
4 * Permission to use, copy, modify, and distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
34 XREFT_THREADSCHED
= 0x100,
40 XREFT_INSTALL_ELEMENT
= 0x301,
43 /* struct xref is the "const" part; struct xrefdata is the writable part. */
48 /* this may be NULL, depending on the type of the xref.
49 * if it is NULL, the xref has no unique ID and cannot be accessed
50 * through that mechanism.
52 struct xrefdata
*xrefdata
;
54 /* type isn't generally needed at runtime */
62 /* -- 32 bytes (on 64bit) -- */
64 /* type-specific bits appended by embedding this struct */
67 PREDECL_RBTREE_UNIQ(xrefdata_uid
);
70 /* pointer back to the const part; this will be initialized at
71 * program startup by xref_block_add(). (Creating structs with
72 * cyclic pointers to each other is not easily possible for
73 * function-scoped static variables.)
75 * There is no xrefdata w/o xref, but there are xref w/o xrefdata.
77 const struct xref
*xref
;
79 /* base32(crockford) of unique ID. not all bytes are used, but
80 * let's pad to 16 for simplicity
85 * if hashstr is NULL, no UID is assigned/calculated. Use macro
86 * string concatenation if multiple values need to be fed in.
87 * (This is here to not make the UID calculation independent of
93 /* -- 32 bytes (on 64bit) -- */
94 struct xrefdata_uid_item xui
;
97 static inline int xrefdata_uid_cmp(const struct xrefdata
*a
,
98 const struct xrefdata
*b
)
100 return strcmp(a
->uid
, b
->uid
);
103 DECLARE_RBTREE_UNIQ(xrefdata_uid
, struct xrefdata
, xui
, xrefdata_uid_cmp
);
104 extern struct xrefdata_uid_head xrefdata_uid
;
106 /* linker "magic" is used to create an array of pointers to struct xref.
107 * the result is a contiguous block of pointers, each pointing to an xref
108 * somewhere in the code. The linker gives us start and end pointers, we
109 * stuff those into the struct below and hook up a constructor to run at
110 * program startup with the struct passed.
112 * Placing the xrefs themselves into an array doesn't work because they'd
113 * need to be constant size, but we're embedding struct xref into other
114 * container structs with extra data. Also this means that external code
115 * (like the python xref dumper) can safely ignore extra data at the end of
116 * xrefs without needing to account for size in iterating the array.
118 * If you're curious, this is also how __attribute__((constructor)) (and
119 * destructor) are implemented - there are 2 arrays, ".init_array" and
120 * ".fini_array", containing function pointers. The magic turns out to be
121 * quite mundane, actually ;)
123 * The slightly tricky bit is that this is a per-object (i.e. per shared
124 * library & daemon) thing and we need a bit of help (in XREF_SETUP) to
125 * initialize correctly.
129 struct xref_block
*next
;
130 const struct xref
* const *start
;
131 const struct xref
* const *stop
;
134 extern struct xref_block
*xref_blocks
;
135 extern void xref_block_add(struct xref_block
*block
);
136 extern void xref_gcc_workaround(const struct xref
*xref
);
138 #ifndef HAVE_SECTION_SYMS
139 /* we have a build system patch to use GNU ld on Solaris; if that doesn't
140 * work we end up on Solaris ld which doesn't support the section start/end
143 #define XREF_SETUP() \
144 CPP_NOTICE("Missing linker support for section arrays. Solaris ld?")
146 /* the actual symbols that the linker provides for us. Note these are
147 * _symbols_ referring to the actual section start/end, i.e. they are very
148 * much NOT _pointers_, rather the symbol *value* is the pointer. Declaring
149 * them as size-1 arrays is the "best" / "right" thing.
151 extern const struct xref
* const __start_xref_array
[1] DSO_LOCAL
;
152 extern const struct xref
* const __stop_xref_array
[1] DSO_LOCAL
;
154 #if defined(__has_feature)
155 #if __has_feature(address_sanitizer)
156 /* no redzone around each of the xref_p please, we're building an array out
157 * of variables here. kinda breaks things if there's redzones between each
160 #define xref_array_attr used, section("xref_array"), no_sanitize("address")
163 #ifndef xref_array_attr
164 #define xref_array_attr used, section("xref_array")
167 /* this macro is invoked once for each standalone DSO through
169 * }-> FRR_COREMOD_SETUP -> XREF_SETUP
172 #define XREF_SETUP() \
173 static const struct xref _dummy_xref = { \
174 /* .xrefdata = */ NULL, \
175 /* .type = */ XREFT_NONE, \
176 /* .line = */ __LINE__, \
177 /* .file = */ __FILE__, \
178 /* .func = */ "dummy", \
180 static const struct xref * const _dummy_xref_p \
181 __attribute__((xref_array_attr)) = &_dummy_xref; \
182 static void __attribute__((used, _CONSTRUCTOR(1100))) \
184 static struct xref_block _xref_block = { \
186 .start = __start_xref_array, \
187 .stop = __stop_xref_array, \
189 xref_block_add(&_xref_block); \
192 MACRO_REQUIRE_SEMICOLON() /* end */
194 /* the following blurb emits an ELF note indicating start and end of the xref
195 * array in the binary. This is technically the "correct" entry point for
196 * external tools reading xrefs out of an ELF shared library or executable.
198 * right now, the extraction tools use the section header for "xref_array"
199 * instead; however, section headers are technically not necessarily preserved
200 * for fully linked libraries or executables. (In practice they are only
201 * stripped by obfuscation tools.)
203 * conversely, for reading xrefs out of a single relocatable object file (e.g.
204 * bar.o), section headers are the right thing to look at since the note is
205 * only emitted for the final binary once.
207 * FRR itself does not need this note to operate correctly, so if you have
208 * some build issue with it just add -DFRR_XREF_NO_NOTE to your build flags
211 #ifdef FRR_XREF_NO_NOTE
215 #if __SIZEOF_POINTER__ == 4
216 #define _NOTE_2PTRSIZE "8"
217 #define _NOTE_PTR ".long"
218 #elif __SIZEOF_POINTER__ == 8
219 #define _NOTE_2PTRSIZE "16"
220 #define _NOTE_PTR ".quad"
222 #error unsupported pointer size
226 # define asmspecial "%"
228 # define asmspecial "@"
233 " .type _frr_xref_note," asmspecial "object" "\n"\
234 " .pushsection .note.FRR,\"a\"," asmspecial "note" "\n"\
236 "_frr_xref_note:" "\n"\
238 " .long " _NOTE_2PTRSIZE "\n"\
239 " .ascii \"XREF\"" "\n"\
240 " .ascii \"FRRouting\\0\\0\\0\"" "\n"\
241 " " _NOTE_PTR " __start_xref_array-." "\n"\
242 " " _NOTE_PTR " __stop_xref_array-." "\n"\
243 " .size _frr_xref_note, .-_frr_xref_note" "\n"\
249 #endif /* HAVE_SECTION_SYMS */
251 /* emit the array entry / pointer to xref */
252 #if defined(__clang__) || !defined(__cplusplus)
253 #define XREF_LINK(dst) \
254 static const struct xref * const NAMECTR(xref_p_) \
255 __attribute__((xref_array_attr)) \
259 #else /* GCC && C++ */
260 /* workaround for GCC bug 41091 (dated 2009), added in 2021...
262 * this breaks extraction of xrefs with xrelfo.py (because the xref_array
263 * entry will be missing), but provides full runtime functionality. To get
264 * the proper list of xrefs from C++ code, build with clang...
267 const struct xref
* const ptr
;
269 _xref_p(const struct xref
*_ptr
) : ptr(_ptr
)
271 xref_gcc_workaround(_ptr
);
275 #define XREF_LINK(dst) \
276 static const struct _xref_p __attribute__((used)) \
277 NAMECTR(xref_p_)(&(dst)) \
281 /* initializer for a "struct xref" */
282 #define XREF_INIT(type_, xrefdata_, func_) \
284 /* .xrefdata = */ (xrefdata_), \
285 /* .type = */ (type_), \
286 /* .line = */ __LINE__, \
287 /* .file = */ __FILE__, \
288 /* .func = */ func_, \
292 /* use with XREF_INIT when outside of a function, i.e. no __func__ */
293 #define XREF_NO_FUNC "<global>"
299 #endif /* _FRR_XREF_H */