Merge branch 'tracing/core-v2' into tracing-for-linus
[linux-2.6.git] / include / asm-generic / vmlinux.lds.h
1 #ifndef LOAD_OFFSET
2 #define LOAD_OFFSET 0
3 #endif
4
5 #ifndef VMLINUX_SYMBOL
6 #define VMLINUX_SYMBOL(_sym_) _sym_
7 #endif
8
9 /* Align . to a 8 byte boundary equals to maximum function alignment. */
10 #define ALIGN_FUNCTION()  . = ALIGN(8)
11
12 /* The actual configuration determine if the init/exit sections
13  * are handled as text/data or they can be discarded (which
14  * often happens at runtime)
15  */
16 #ifdef CONFIG_HOTPLUG
17 #define DEV_KEEP(sec)    *(.dev##sec)
18 #define DEV_DISCARD(sec)
19 #else
20 #define DEV_KEEP(sec)
21 #define DEV_DISCARD(sec) *(.dev##sec)
22 #endif
23
24 #ifdef CONFIG_HOTPLUG_CPU
25 #define CPU_KEEP(sec)    *(.cpu##sec)
26 #define CPU_DISCARD(sec)
27 #else
28 #define CPU_KEEP(sec)
29 #define CPU_DISCARD(sec) *(.cpu##sec)
30 #endif
31
32 #if defined(CONFIG_MEMORY_HOTPLUG)
33 #define MEM_KEEP(sec)    *(.mem##sec)
34 #define MEM_DISCARD(sec)
35 #else
36 #define MEM_KEEP(sec)
37 #define MEM_DISCARD(sec) *(.mem##sec)
38 #endif
39
40 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
41 #define MCOUNT_REC()    VMLINUX_SYMBOL(__start_mcount_loc) = .; \
42                         *(__mcount_loc)                         \
43                         VMLINUX_SYMBOL(__stop_mcount_loc) = .;
44 #else
45 #define MCOUNT_REC()
46 #endif
47
48 #ifdef CONFIG_TRACE_BRANCH_PROFILING
49 #define LIKELY_PROFILE()        VMLINUX_SYMBOL(__start_annotated_branch_profile) = .; \
50                                 *(_ftrace_annotated_branch)                           \
51                                 VMLINUX_SYMBOL(__stop_annotated_branch_profile) = .;
52 #else
53 #define LIKELY_PROFILE()
54 #endif
55
56 #ifdef CONFIG_PROFILE_ALL_BRANCHES
57 #define BRANCH_PROFILE()        VMLINUX_SYMBOL(__start_branch_profile) = .;   \
58                                 *(_ftrace_branch)                             \
59                                 VMLINUX_SYMBOL(__stop_branch_profile) = .;
60 #else
61 #define BRANCH_PROFILE()
62 #endif
63
64 #ifdef CONFIG_EVENT_TRACER
65 #define FTRACE_EVENTS() VMLINUX_SYMBOL(__start_ftrace_events) = .;      \
66                         *(_ftrace_events)                               \
67                         VMLINUX_SYMBOL(__stop_ftrace_events) = .;
68 #else
69 #define FTRACE_EVENTS()
70 #endif
71
72 #ifdef CONFIG_TRACING
73 #define TRACE_PRINTKS() VMLINUX_SYMBOL(__start___trace_bprintk_fmt) = .;      \
74                          *(__trace_printk_fmt) /* Trace_printk fmt' pointer */ \
75                          VMLINUX_SYMBOL(__stop___trace_bprintk_fmt) = .;
76 #else
77 #define TRACE_PRINTKS()
78 #endif
79
80 #ifdef CONFIG_FTRACE_SYSCALLS
81 #define TRACE_SYSCALLS() VMLINUX_SYMBOL(__start_syscalls_metadata) = .; \
82                          *(__syscalls_metadata)                         \
83                          VMLINUX_SYMBOL(__stop_syscalls_metadata) = .;
84 #else
85 #define TRACE_SYSCALLS()
86 #endif
87
88 /* .data section */
89 #define DATA_DATA                                                       \
90         *(.data)                                                        \
91         *(.data.init.refok)                                             \
92         *(.ref.data)                                                    \
93         DEV_KEEP(init.data)                                             \
94         DEV_KEEP(exit.data)                                             \
95         CPU_KEEP(init.data)                                             \
96         CPU_KEEP(exit.data)                                             \
97         MEM_KEEP(init.data)                                             \
98         MEM_KEEP(exit.data)                                             \
99         . = ALIGN(8);                                                   \
100         VMLINUX_SYMBOL(__start___markers) = .;                          \
101         *(__markers)                                                    \
102         VMLINUX_SYMBOL(__stop___markers) = .;                           \
103         . = ALIGN(32);                                                  \
104         VMLINUX_SYMBOL(__start___tracepoints) = .;                      \
105         *(__tracepoints)                                                \
106         VMLINUX_SYMBOL(__stop___tracepoints) = .;                       \
107         /* implement dynamic printk debug */                            \
108         . = ALIGN(8);                                                   \
109         VMLINUX_SYMBOL(__start___verbose) = .;                          \
110         *(__verbose)                                                    \
111         VMLINUX_SYMBOL(__stop___verbose) = .;                           \
112         LIKELY_PROFILE()                                                \
113         BRANCH_PROFILE()                                                \
114         TRACE_PRINTKS()                                                 \
115         FTRACE_EVENTS()                                                 \
116         TRACE_SYSCALLS()
117
118 #define RO_DATA(align)                                                  \
119         . = ALIGN((align));                                             \
120         .rodata           : AT(ADDR(.rodata) - LOAD_OFFSET) {           \
121                 VMLINUX_SYMBOL(__start_rodata) = .;                     \
122                 *(.rodata) *(.rodata.*)                                 \
123                 *(__vermagic)           /* Kernel version magic */      \
124                 *(__markers_strings)    /* Markers: strings */          \
125                 *(__tracepoints_strings)/* Tracepoints: strings */      \
126         }                                                               \
127                                                                         \
128         .rodata1          : AT(ADDR(.rodata1) - LOAD_OFFSET) {          \
129                 *(.rodata1)                                             \
130         }                                                               \
131                                                                         \
132         BUG_TABLE                                                       \
133                                                                         \
134         /* PCI quirks */                                                \
135         .pci_fixup        : AT(ADDR(.pci_fixup) - LOAD_OFFSET) {        \
136                 VMLINUX_SYMBOL(__start_pci_fixups_early) = .;           \
137                 *(.pci_fixup_early)                                     \
138                 VMLINUX_SYMBOL(__end_pci_fixups_early) = .;             \
139                 VMLINUX_SYMBOL(__start_pci_fixups_header) = .;          \
140                 *(.pci_fixup_header)                                    \
141                 VMLINUX_SYMBOL(__end_pci_fixups_header) = .;            \
142                 VMLINUX_SYMBOL(__start_pci_fixups_final) = .;           \
143                 *(.pci_fixup_final)                                     \
144                 VMLINUX_SYMBOL(__end_pci_fixups_final) = .;             \
145                 VMLINUX_SYMBOL(__start_pci_fixups_enable) = .;          \
146                 *(.pci_fixup_enable)                                    \
147                 VMLINUX_SYMBOL(__end_pci_fixups_enable) = .;            \
148                 VMLINUX_SYMBOL(__start_pci_fixups_resume) = .;          \
149                 *(.pci_fixup_resume)                                    \
150                 VMLINUX_SYMBOL(__end_pci_fixups_resume) = .;            \
151                 VMLINUX_SYMBOL(__start_pci_fixups_resume_early) = .;    \
152                 *(.pci_fixup_resume_early)                              \
153                 VMLINUX_SYMBOL(__end_pci_fixups_resume_early) = .;      \
154                 VMLINUX_SYMBOL(__start_pci_fixups_suspend) = .;         \
155                 *(.pci_fixup_suspend)                                   \
156                 VMLINUX_SYMBOL(__end_pci_fixups_suspend) = .;           \
157         }                                                               \
158                                                                         \
159         /* Built-in firmware blobs */                                   \
160         .builtin_fw        : AT(ADDR(.builtin_fw) - LOAD_OFFSET) {      \
161                 VMLINUX_SYMBOL(__start_builtin_fw) = .;                 \
162                 *(.builtin_fw)                                          \
163                 VMLINUX_SYMBOL(__end_builtin_fw) = .;                   \
164         }                                                               \
165                                                                         \
166         /* RapidIO route ops */                                         \
167         .rio_route        : AT(ADDR(.rio_route) - LOAD_OFFSET) {        \
168                 VMLINUX_SYMBOL(__start_rio_route_ops) = .;              \
169                 *(.rio_route_ops)                                       \
170                 VMLINUX_SYMBOL(__end_rio_route_ops) = .;                \
171         }                                                               \
172                                                                         \
173         TRACEDATA                                                       \
174                                                                         \
175         /* Kernel symbol table: Normal symbols */                       \
176         __ksymtab         : AT(ADDR(__ksymtab) - LOAD_OFFSET) {         \
177                 VMLINUX_SYMBOL(__start___ksymtab) = .;                  \
178                 *(__ksymtab)                                            \
179                 VMLINUX_SYMBOL(__stop___ksymtab) = .;                   \
180         }                                                               \
181                                                                         \
182         /* Kernel symbol table: GPL-only symbols */                     \
183         __ksymtab_gpl     : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) {     \
184                 VMLINUX_SYMBOL(__start___ksymtab_gpl) = .;              \
185                 *(__ksymtab_gpl)                                        \
186                 VMLINUX_SYMBOL(__stop___ksymtab_gpl) = .;               \
187         }                                                               \
188                                                                         \
189         /* Kernel symbol table: Normal unused symbols */                \
190         __ksymtab_unused  : AT(ADDR(__ksymtab_unused) - LOAD_OFFSET) {  \
191                 VMLINUX_SYMBOL(__start___ksymtab_unused) = .;           \
192                 *(__ksymtab_unused)                                     \
193                 VMLINUX_SYMBOL(__stop___ksymtab_unused) = .;            \
194         }                                                               \
195                                                                         \
196         /* Kernel symbol table: GPL-only unused symbols */              \
197         __ksymtab_unused_gpl : AT(ADDR(__ksymtab_unused_gpl) - LOAD_OFFSET) { \
198                 VMLINUX_SYMBOL(__start___ksymtab_unused_gpl) = .;       \
199                 *(__ksymtab_unused_gpl)                                 \
200                 VMLINUX_SYMBOL(__stop___ksymtab_unused_gpl) = .;        \
201         }                                                               \
202                                                                         \
203         /* Kernel symbol table: GPL-future-only symbols */              \
204         __ksymtab_gpl_future : AT(ADDR(__ksymtab_gpl_future) - LOAD_OFFSET) { \
205                 VMLINUX_SYMBOL(__start___ksymtab_gpl_future) = .;       \
206                 *(__ksymtab_gpl_future)                                 \
207                 VMLINUX_SYMBOL(__stop___ksymtab_gpl_future) = .;        \
208         }                                                               \
209                                                                         \
210         /* Kernel symbol table: Normal symbols */                       \
211         __kcrctab         : AT(ADDR(__kcrctab) - LOAD_OFFSET) {         \
212                 VMLINUX_SYMBOL(__start___kcrctab) = .;                  \
213                 *(__kcrctab)                                            \
214                 VMLINUX_SYMBOL(__stop___kcrctab) = .;                   \
215         }                                                               \
216                                                                         \
217         /* Kernel symbol table: GPL-only symbols */                     \
218         __kcrctab_gpl     : AT(ADDR(__kcrctab_gpl) - LOAD_OFFSET) {     \
219                 VMLINUX_SYMBOL(__start___kcrctab_gpl) = .;              \
220                 *(__kcrctab_gpl)                                        \
221                 VMLINUX_SYMBOL(__stop___kcrctab_gpl) = .;               \
222         }                                                               \
223                                                                         \
224         /* Kernel symbol table: Normal unused symbols */                \
225         __kcrctab_unused  : AT(ADDR(__kcrctab_unused) - LOAD_OFFSET) {  \
226                 VMLINUX_SYMBOL(__start___kcrctab_unused) = .;           \
227                 *(__kcrctab_unused)                                     \
228                 VMLINUX_SYMBOL(__stop___kcrctab_unused) = .;            \
229         }                                                               \
230                                                                         \
231         /* Kernel symbol table: GPL-only unused symbols */              \
232         __kcrctab_unused_gpl : AT(ADDR(__kcrctab_unused_gpl) - LOAD_OFFSET) { \
233                 VMLINUX_SYMBOL(__start___kcrctab_unused_gpl) = .;       \
234                 *(__kcrctab_unused_gpl)                                 \
235                 VMLINUX_SYMBOL(__stop___kcrctab_unused_gpl) = .;        \
236         }                                                               \
237                                                                         \
238         /* Kernel symbol table: GPL-future-only symbols */              \
239         __kcrctab_gpl_future : AT(ADDR(__kcrctab_gpl_future) - LOAD_OFFSET) { \
240                 VMLINUX_SYMBOL(__start___kcrctab_gpl_future) = .;       \
241                 *(__kcrctab_gpl_future)                                 \
242                 VMLINUX_SYMBOL(__stop___kcrctab_gpl_future) = .;        \
243         }                                                               \
244                                                                         \
245         /* Kernel symbol table: strings */                              \
246         __ksymtab_strings : AT(ADDR(__ksymtab_strings) - LOAD_OFFSET) { \
247                 *(__ksymtab_strings)                                    \
248         }                                                               \
249                                                                         \
250         /* __*init sections */                                          \
251         __init_rodata : AT(ADDR(__init_rodata) - LOAD_OFFSET) {         \
252                 *(.ref.rodata)                                          \
253                 MCOUNT_REC()                                            \
254                 DEV_KEEP(init.rodata)                                   \
255                 DEV_KEEP(exit.rodata)                                   \
256                 CPU_KEEP(init.rodata)                                   \
257                 CPU_KEEP(exit.rodata)                                   \
258                 MEM_KEEP(init.rodata)                                   \
259                 MEM_KEEP(exit.rodata)                                   \
260         }                                                               \
261                                                                         \
262         /* Built-in module parameters. */                               \
263         __param : AT(ADDR(__param) - LOAD_OFFSET) {                     \
264                 VMLINUX_SYMBOL(__start___param) = .;                    \
265                 *(__param)                                              \
266                 VMLINUX_SYMBOL(__stop___param) = .;                     \
267                 . = ALIGN((align));                                     \
268                 VMLINUX_SYMBOL(__end_rodata) = .;                       \
269         }                                                               \
270         . = ALIGN((align));
271
272 /* RODATA provided for backward compatibility.
273  * All archs are supposed to use RO_DATA() */
274 #define RODATA RO_DATA(4096)
275
276 #define SECURITY_INIT                                                   \
277         .security_initcall.init : AT(ADDR(.security_initcall.init) - LOAD_OFFSET) { \
278                 VMLINUX_SYMBOL(__security_initcall_start) = .;          \
279                 *(.security_initcall.init)                              \
280                 VMLINUX_SYMBOL(__security_initcall_end) = .;            \
281         }
282
283 /* .text section. Map to function alignment to avoid address changes
284  * during second ld run in second ld pass when generating System.map */
285 #define TEXT_TEXT                                                       \
286                 ALIGN_FUNCTION();                                       \
287                 *(.text.hot)                                            \
288                 *(.text)                                                \
289                 *(.ref.text)                                            \
290                 *(.text.init.refok)                                     \
291                 *(.exit.text.refok)                                     \
292         DEV_KEEP(init.text)                                             \
293         DEV_KEEP(exit.text)                                             \
294         CPU_KEEP(init.text)                                             \
295         CPU_KEEP(exit.text)                                             \
296         MEM_KEEP(init.text)                                             \
297         MEM_KEEP(exit.text)                                             \
298                 *(.text.unlikely)
299
300
301 /* sched.text is aling to function alignment to secure we have same
302  * address even at second ld pass when generating System.map */
303 #define SCHED_TEXT                                                      \
304                 ALIGN_FUNCTION();                                       \
305                 VMLINUX_SYMBOL(__sched_text_start) = .;                 \
306                 *(.sched.text)                                          \
307                 VMLINUX_SYMBOL(__sched_text_end) = .;
308
309 /* spinlock.text is aling to function alignment to secure we have same
310  * address even at second ld pass when generating System.map */
311 #define LOCK_TEXT                                                       \
312                 ALIGN_FUNCTION();                                       \
313                 VMLINUX_SYMBOL(__lock_text_start) = .;                  \
314                 *(.spinlock.text)                                       \
315                 VMLINUX_SYMBOL(__lock_text_end) = .;
316
317 #define KPROBES_TEXT                                                    \
318                 ALIGN_FUNCTION();                                       \
319                 VMLINUX_SYMBOL(__kprobes_text_start) = .;               \
320                 *(.kprobes.text)                                        \
321                 VMLINUX_SYMBOL(__kprobes_text_end) = .;
322
323 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
324 #define IRQENTRY_TEXT                                                   \
325                 ALIGN_FUNCTION();                                       \
326                 VMLINUX_SYMBOL(__irqentry_text_start) = .;              \
327                 *(.irqentry.text)                                       \
328                 VMLINUX_SYMBOL(__irqentry_text_end) = .;
329 #else
330 #define IRQENTRY_TEXT
331 #endif
332
333 /* Section used for early init (in .S files) */
334 #define HEAD_TEXT  *(.head.text)
335
336 /* init and exit section handling */
337 #define INIT_DATA                                                       \
338         *(.init.data)                                                   \
339         DEV_DISCARD(init.data)                                          \
340         DEV_DISCARD(init.rodata)                                        \
341         CPU_DISCARD(init.data)                                          \
342         CPU_DISCARD(init.rodata)                                        \
343         MEM_DISCARD(init.data)                                          \
344         MEM_DISCARD(init.rodata)
345
346 #define INIT_TEXT                                                       \
347         *(.init.text)                                                   \
348         DEV_DISCARD(init.text)                                          \
349         CPU_DISCARD(init.text)                                          \
350         MEM_DISCARD(init.text)
351
352 #define EXIT_DATA                                                       \
353         *(.exit.data)                                                   \
354         DEV_DISCARD(exit.data)                                          \
355         DEV_DISCARD(exit.rodata)                                        \
356         CPU_DISCARD(exit.data)                                          \
357         CPU_DISCARD(exit.rodata)                                        \
358         MEM_DISCARD(exit.data)                                          \
359         MEM_DISCARD(exit.rodata)
360
361 #define EXIT_TEXT                                                       \
362         *(.exit.text)                                                   \
363         DEV_DISCARD(exit.text)                                          \
364         CPU_DISCARD(exit.text)                                          \
365         MEM_DISCARD(exit.text)
366
367                 /* DWARF debug sections.
368                 Symbols in the DWARF debugging sections are relative to
369                 the beginning of the section so we begin them at 0.  */
370 #define DWARF_DEBUG                                                     \
371                 /* DWARF 1 */                                           \
372                 .debug          0 : { *(.debug) }                       \
373                 .line           0 : { *(.line) }                        \
374                 /* GNU DWARF 1 extensions */                            \
375                 .debug_srcinfo  0 : { *(.debug_srcinfo) }               \
376                 .debug_sfnames  0 : { *(.debug_sfnames) }               \
377                 /* DWARF 1.1 and DWARF 2 */                             \
378                 .debug_aranges  0 : { *(.debug_aranges) }               \
379                 .debug_pubnames 0 : { *(.debug_pubnames) }              \
380                 /* DWARF 2 */                                           \
381                 .debug_info     0 : { *(.debug_info                     \
382                                 .gnu.linkonce.wi.*) }                   \
383                 .debug_abbrev   0 : { *(.debug_abbrev) }                \
384                 .debug_line     0 : { *(.debug_line) }                  \
385                 .debug_frame    0 : { *(.debug_frame) }                 \
386                 .debug_str      0 : { *(.debug_str) }                   \
387                 .debug_loc      0 : { *(.debug_loc) }                   \
388                 .debug_macinfo  0 : { *(.debug_macinfo) }               \
389                 /* SGI/MIPS DWARF 2 extensions */                       \
390                 .debug_weaknames 0 : { *(.debug_weaknames) }            \
391                 .debug_funcnames 0 : { *(.debug_funcnames) }            \
392                 .debug_typenames 0 : { *(.debug_typenames) }            \
393                 .debug_varnames  0 : { *(.debug_varnames) }             \
394
395                 /* Stabs debugging sections.  */
396 #define STABS_DEBUG                                                     \
397                 .stab 0 : { *(.stab) }                                  \
398                 .stabstr 0 : { *(.stabstr) }                            \
399                 .stab.excl 0 : { *(.stab.excl) }                        \
400                 .stab.exclstr 0 : { *(.stab.exclstr) }                  \
401                 .stab.index 0 : { *(.stab.index) }                      \
402                 .stab.indexstr 0 : { *(.stab.indexstr) }                \
403                 .comment 0 : { *(.comment) }
404
405 #ifdef CONFIG_GENERIC_BUG
406 #define BUG_TABLE                                                       \
407         . = ALIGN(8);                                                   \
408         __bug_table : AT(ADDR(__bug_table) - LOAD_OFFSET) {             \
409                 VMLINUX_SYMBOL(__start___bug_table) = .;                \
410                 *(__bug_table)                                          \
411                 VMLINUX_SYMBOL(__stop___bug_table) = .;                 \
412         }
413 #else
414 #define BUG_TABLE
415 #endif
416
417 #ifdef CONFIG_PM_TRACE
418 #define TRACEDATA                                                       \
419         . = ALIGN(4);                                                   \
420         .tracedata : AT(ADDR(.tracedata) - LOAD_OFFSET) {               \
421                 VMLINUX_SYMBOL(__tracedata_start) = .;                  \
422                 *(.tracedata)                                           \
423                 VMLINUX_SYMBOL(__tracedata_end) = .;                    \
424         }
425 #else
426 #define TRACEDATA
427 #endif
428
429 #define NOTES                                                           \
430         .notes : AT(ADDR(.notes) - LOAD_OFFSET) {                       \
431                 VMLINUX_SYMBOL(__start_notes) = .;                      \
432                 *(.note.*)                                              \
433                 VMLINUX_SYMBOL(__stop_notes) = .;                       \
434         }
435
436 #define INITCALLS                                                       \
437         *(.initcallearly.init)                                          \
438         VMLINUX_SYMBOL(__early_initcall_end) = .;                       \
439         *(.initcall0.init)                                              \
440         *(.initcall0s.init)                                             \
441         *(.initcall1.init)                                              \
442         *(.initcall1s.init)                                             \
443         *(.initcall2.init)                                              \
444         *(.initcall2s.init)                                             \
445         *(.initcall3.init)                                              \
446         *(.initcall3s.init)                                             \
447         *(.initcall4.init)                                              \
448         *(.initcall4s.init)                                             \
449         *(.initcall5.init)                                              \
450         *(.initcall5s.init)                                             \
451         *(.initcallrootfs.init)                                         \
452         *(.initcall6.init)                                              \
453         *(.initcall6s.init)                                             \
454         *(.initcall7.init)                                              \
455         *(.initcall7s.init)
456
457 /**
458  * PERCPU_VADDR - define output section for percpu area
459  * @vaddr: explicit base address (optional)
460  * @phdr: destination PHDR (optional)
461  *
462  * Macro which expands to output section for percpu area.  If @vaddr
463  * is not blank, it specifies explicit base address and all percpu
464  * symbols will be offset from the given address.  If blank, @vaddr
465  * always equals @laddr + LOAD_OFFSET.
466  *
467  * @phdr defines the output PHDR to use if not blank.  Be warned that
468  * output PHDR is sticky.  If @phdr is specified, the next output
469  * section in the linker script will go there too.  @phdr should have
470  * a leading colon.
471  *
472  * Note that this macros defines __per_cpu_load as an absolute symbol.
473  * If there is no need to put the percpu section at a predetermined
474  * address, use PERCPU().
475  */
476 #define PERCPU_VADDR(vaddr, phdr)                                       \
477         VMLINUX_SYMBOL(__per_cpu_load) = .;                             \
478         .data.percpu vaddr : AT(VMLINUX_SYMBOL(__per_cpu_load)          \
479                                 - LOAD_OFFSET) {                        \
480                 VMLINUX_SYMBOL(__per_cpu_start) = .;                    \
481                 *(.data.percpu.first)                                   \
482                 *(.data.percpu.page_aligned)                            \
483                 *(.data.percpu)                                         \
484                 *(.data.percpu.shared_aligned)                          \
485                 VMLINUX_SYMBOL(__per_cpu_end) = .;                      \
486         } phdr                                                          \
487         . = VMLINUX_SYMBOL(__per_cpu_load) + SIZEOF(.data.percpu);
488
489 /**
490  * PERCPU - define output section for percpu area, simple version
491  * @align: required alignment
492  *
493  * Align to @align and outputs output section for percpu area.  This
494  * macro doesn't maniuplate @vaddr or @phdr and __per_cpu_load and
495  * __per_cpu_start will be identical.
496  *
497  * This macro is equivalent to ALIGN(align); PERCPU_VADDR( , ) except
498  * that __per_cpu_load is defined as a relative symbol against
499  * .data.percpu which is required for relocatable x86_32
500  * configuration.
501  */
502 #define PERCPU(align)                                                   \
503         . = ALIGN(align);                                               \
504         .data.percpu    : AT(ADDR(.data.percpu) - LOAD_OFFSET) {        \
505                 VMLINUX_SYMBOL(__per_cpu_load) = .;                     \
506                 VMLINUX_SYMBOL(__per_cpu_start) = .;                    \
507                 *(.data.percpu.first)                                   \
508                 *(.data.percpu.page_aligned)                            \
509                 *(.data.percpu)                                         \
510                 *(.data.percpu.shared_aligned)                          \
511                 VMLINUX_SYMBOL(__per_cpu_end) = .;                      \
512         }