The OpenD Programming Language

1 /**
2  * D header file for $(LINK2 https://opensource.apple.com/source/cctools/cctools-895/include/mach-o/getsect.h.auto.html, mach-o/getsect.h).
3  *
4  * Copyright: Copyright Digital Mars 2010-2018.
5  * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
6  * Authors:   Jacob Carlborg
7  * Version: Initial created: Mar 16, 2010
8  * Source: $(DRUNTIMESRC core/sys/darwin/mach/_getsect.d)
9  */
10 module core.sys.darwin.mach.getsect;
11 
12 extern (C):
13 nothrow:
14 @nogc:
15 
16 version (CoreDdoc)
17 {
18     import core.stdc.config : c_ulong;
19 
20     /**
21      * In reality this will be $(REF mach_header, core, sys, darwin, mach, loader)
22      * on 32-bit platforms and $(REF mach_header_64, core, sys, darwin, mach, loader)
23      * 64-bit platforms.
24      */
25     struct MachHeader;
26 
27     /**
28      * In reality this will be $(REF segment_command, core, sys, darwin, mach, loader)
29      * on 32-bit platforms and $(REF segment_command_64, core, sys, darwin, mach, loader)
30      * 64-bit platforms.
31      */
32     struct SegmentCommand;
33 
34     /**
35      * In reality this will be $(REF section, core, sys, darwin, mach, loader)
36      * on 32-bit platforms and $(REF section_64, core, sys, darwin, mach, loader)
37      * 64-bit platforms.
38      */
39     struct Section;
40 
41     /**
42      * Returns the section data of section with the given section name.
43      *
44      * Returns the section data of the given section in the given segment in the
45      * mach executable it is linked into.
46      *
47      * ---
48      * void main()
49      * {
50      *      import core.sys.darwin.mach.getsect;
51      *      int size;
52      *      assert(getsectdata("__TEXT", "__text", &size));
53      *      assert(size > 0);
54      * }
55      * ---
56      *
57      * Params:
58      *  segname = the name of the segment
59      *  sectname = the name of the section
60      *  size = this will be set to the size of the section or 0 if the section
61      *      doesn't exist
62      *
63      * Returns: a pointer to the section data or `null` if it doesn't exist
64      */
65     char* getsectdata(
66         const scope char* segname,
67         const scope char* sectname,
68         c_ulong *size
69     );
70 
71     /**
72      * Returns the section data of section with the given section name.
73      *
74      * Returns the section data of the given section in the given segment in the
75      * given framework.
76      *
77      * ---
78      * void main()
79      * {
80      *      import core.sys.darwin.mach.getsect;
81      *      int size;
82      *      assert(getsectdatafromFramework("Foundation", "__TEXT", "__text", &size));
83      *      assert(size > 0);
84      * }
85      * ---
86      *
87      * Params:
88      *  FrameworkName = the name of the framework to get the section data from
89      *  segname = the name of the segment
90      *  sectname = the name of the section
91      *  size = this will be set to the size of the section or 0 if the section
92      *      doesn't exist
93      *
94      * Returns: a pointer to the section data or `null` if it doesn't exist
95      */
96     char* getsectdatafromFramework(
97         const scope char* FrameworkName,
98         const scope char* segname,
99         const scope char* sectname,
100         c_ulong* size
101     );
102 
103     ///
104     c_ulong get_end();
105 
106     ///
107     c_ulong get_etext();
108 
109     ///
110     c_ulong get_edata();
111 
112     /**
113      * Returns the section with the given section name.
114      *
115      * Returns the section structure of the given section in the given segment
116      * in the mach executable it is linked into.
117      *
118      * ---
119      * void main()
120      * {
121      *      import core.sys.darwin.mach.getsect;
122      *      assert(getsectbyname("__TEXT", "__text"));
123      * }
124      * ---
125      *
126      * Params:
127      *  segname = the name of the segment
128      *  sectname = the name of the section
129      *
130      * Returns: a pointer to the section structure or `null` if it doesn't exist
131      */
132     const(Section)* getsectbyname(
133         const scope char* segname,
134         const scope char* sectname
135     );
136 
137     /**
138      * Returns the section data of section with the given section name.
139      *
140      * Returns the section data of the given section in the given segment in the
141      * image pointed to by the given mach header.
142      *
143      * ---
144      * void main()
145      * {
146      *      import core.sys.darwin.mach.getsect;
147      *      import core.sys.darwin.crt_externs;
148      *
149      *      auto mph = _NSGetMachExecuteHeader();
150      *      int size;
151      *      assert(getsectiondata(mph, "__TEXT", "__text", &size));
152      *      assert(size > 0);
153      * }
154      * ---
155      *
156      * Params:
157      *  mhp = the mach header to get the section data from
158      *  segname = the name of the segment
159      *  sectname = the name of the section
160      *  size = this will be set to the size of the section or 0 if the section
161      *      doesn't exist
162      *
163      * Returns: a pointer to the section data or `null` if it doesn't exist
164      */
165     ubyte* getsectiondata(
166         const scope MachHeader* mhp,
167         const scope char* segname,
168         const scope char* sectname,
169         c_ulong* size
170     );
171 
172     /**
173      * Returns the segment with the given segment name.
174      *
175      * Returns the segment structure of the given segment in the mach executable
176      * it is linked into.
177      *
178      * ---
179      * void main()
180      * {
181      *      import core.sys.darwin.mach.getsect;
182      *      assert(getsegbyname("__TEXT"));
183      * }
184      * ---
185      *
186      * Params:
187      *  segname = the name of the segment
188      *
189      * Returns: a pointer to the section structure or `null` if it doesn't exist
190      */
191     const(SegmentCommand)* getsegbyname(
192         const scope char* segname
193     );
194 
195     /**
196      * Returns the segment data of segment with the given segment name.
197      *
198      * Returns the segment data of the given segment in the image pointed to by
199      * the given mach header.
200      *
201      * ---
202      * void main()
203      * {
204      *      import core.sys.darwin.mach.getsect;
205      *      import core.sys.darwin.crt_externs;
206      *
207      *      auto mph = _NSGetMachExecuteHeader();
208      *      int size;
209      *      assert(getsegmentdata(mph, "__TEXT", &size));
210      *      assert(size > 0);
211      * }
212      * ---
213      *
214      * Params:
215      *  mhp = the mach header to get the section data from
216      *  segname = the name of the segment
217      *  size = this will be set to the size of the section or 0 if the section
218      *      doesn't exist
219      *
220      * Returns: a pointer to the section data or `null` if it doesn't exist
221      */
222     ubyte* getsegmentdata(
223         const scope MachHeader* mhp,
224         const scope char* segname,
225         c_ulong* size
226     );
227 
228     struct mach_header;
229     struct mach_header_64;
230     struct section;
231     struct section_64;
232 
233     /**
234      * Returns the section data of section with the given section name.
235      *
236      * Returns the section data of the given section in the given segment in the
237      * image pointed to by the given mach header.
238      *
239      * ---
240      * void main()
241      * {
242      *      import core.sys.darwin.mach.getsect;
243      *      import core.sys.darwin.crt_externs;
244      *
245      *      auto mph = _NSGetMachExecuteHeader();
246      *      int size;
247      *      assert(getsectdatafromheader(mph, "__TEXT", "__text", &size));
248      *      assert(size > 0);
249      * }
250      * ---
251      *
252      * Params:
253      *  mhp = the mach header to get the section data from
254      *  segname = the name of the segment
255      *  sectname = the name of the section
256      *  size = this will be set to the size of the section or 0 if the section
257      *      doesn't exist
258      *
259      * Returns: a pointer to the section data or `null` if it doesn't exist
260      */
261     ubyte* getsectdatafromheader(
262         const scope mach_header* mhp,
263         const scope char* segname,
264         const scope char* sectname,
265         c_ulong* size
266     );
267 
268     /// ditto
269     ubyte* getsectdatafromheader_64(
270         const scope mach_header_64* mhp,
271         const scope char* segname,
272         const scope char* sectname,
273         c_ulong* size
274     );
275 
276 
277     /**
278      * Returns the section with the given section name.
279      *
280      * Returns the section structure of the given section in the given segment
281      * in image pointed to by the given mach header.
282      *
283      * ---
284      * void main()
285      * {
286      *      import core.sys.darwin.mach.getsect;
287      *      import core.sys.darwin.crt_externs;
288      *
289      *      auto mph = _NSGetMachExecuteHeader();
290      *      assert(getsectbynamefromheader(mph, "__TEXT", "__text"));
291      * }
292      * ---
293      *
294      * Params:
295      *  mhp = the mach header to get the section from
296      *  segname = the name of the segment
297      *  sectname = the name of the section
298      *
299      * Returns: a pointer to the section structure or `null` if it doesn't exist
300      */
301     const(section)* getsectbynamefromheader(
302         const scope mach_header* mhp,
303         const scope char* segname,
304         const scope char* sectname
305     );
306 
307     /// ditto
308     const(section_64)* getsectbynamefromheader_64(
309         const scope mach_header_64* mhp,
310         const scope char* segname,
311         const scope char* sectname
312     );
313 
314     /**
315      * Returns the section with the given section name.
316      *
317      * Returns the section structure of the given section in the given segment
318      * in image pointed to by the given mach header.
319      *
320      * Params:
321      *  mhp = the mach header to get the section from
322      *  segname = the name of the segment
323      *  section = the name of the section
324      *  fSwap = ?
325      *
326      * Returns: a pointer to the section structure or `null` if it doesn't exist
327      */
328     const(section)* getsectbynamefromheaderwithswap(
329         const scope mach_header* mhp,
330         const scope char* segname,
331         const scope char* section,
332         int fSwap
333     );
334 
335     /// ditto
336     const(section)* getsectbynamefromheaderwithswap_64(
337         const scope mach_header_64* mhp,
338         const scope char* segname,
339         const scope char* section,
340         int fSwap
341     );
342 }
343 
344 else version (OSX)
345     version = Darwin;
346 else version (iOS)
347     version = Darwin;
348 else version (TVOS)
349     version = Darwin;
350 else version (WatchOS)
351     version = Darwin;
352 
353 version (Darwin):
354 
355 public import core.sys.darwin.mach.loader;
356 
357 import core.stdc.config : c_ulong;
358 
359 char* getsectdata(
360     const scope char* segname,
361     const scope char* sectname,
362     c_ulong *size
363 );
364 
365 char* getsectdatafromFramework(
366     const scope char* FrameworkName,
367     const scope char* segname,
368     const scope char* sectname,
369     c_ulong* size
370 );
371 
372 c_ulong get_end();
373 c_ulong get_etext();
374 c_ulong get_edata();
375 
376 // Runtime interfaces for 64-bit Mach-O programs.
377 version (D_LP64)
378 {
379     const(section_64)* getsectbyname(
380         const scope char* segname,
381         const scope char* sectname
382     );
383 
384     ubyte* getsectiondata(
385         const scope mach_header_64* mhp,
386         const scope char* segname,
387         const scope char* sectname,
388         c_ulong* size
389     );
390 
391     const(segment_command_64)* getsegbyname(
392         const scope char* segname
393     );
394 
395     ubyte* getsegmentdata(
396         const scope mach_header_64* mhp,
397         const scope char* segname,
398         c_ulong* size
399     );
400 }
401 
402 // Runtime interfaces for 32-bit Mach-O programs.
403 else
404 {
405     const(section)* getsectbyname(
406         const scope char* segname,
407         const scope char* sectname
408     );
409 
410     ubyte* getsectiondata(
411         const scope mach_header* mhp,
412         const scope char* segname,
413         const scope char* sectname,
414         c_ulong* size
415     );
416 
417     const(segment_command)* getsegbyname(
418         const scope char* segname
419     );
420 
421     ubyte* getsegmentdata(
422         const scope mach_header* mhp,
423         const scope char* segname,
424         c_ulong* size
425     );
426 }
427 
428 // Interfaces for tools working with 32-bit Mach-O files.
429 
430 ubyte* getsectdatafromheader(
431     const scope mach_header* mhp,
432     const scope char* segname,
433     const scope char* sectname,
434     c_ulong* size
435 );
436 
437 const(section)* getsectbynamefromheader(
438     const scope mach_header* mhp,
439     const scope char* segname,
440     const scope char* sectname
441 );
442 
443 const(section)* getsectbynamefromheaderwithswap(
444     const scope mach_header* mhp,
445     const scope char* segname,
446     const scope char* section,
447     int fSwap
448 );
449 
450 // Interfaces for tools working with 64-bit Mach-O files.
451 
452 ubyte* getsectdatafromheader_64(
453     const scope mach_header_64* mhp,
454     const scope char* segname,
455     const scope char* sectname,
456     c_ulong* size
457 );
458 
459 const(section_64)* getsectbynamefromheader_64(
460     const scope mach_header_64* mhp,
461     const scope char* segname,
462     const scope char* sectname
463 );
464 
465 const(section)* getsectbynamefromheaderwithswap_64(
466     const scope mach_header_64* mhp,
467     const scope char* segname,
468     const scope char* section,
469     int fSwap
470 );