recordmcount.pl 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647
  1. #!/usr/bin/env perl
  2. # SPDX-License-Identifier: GPL-2.0-only
  3. # (c) 2008, Steven Rostedt <srostedt@redhat.com>
  4. #
  5. # recordmcount.pl - makes a section called __mcount_loc that holds
  6. # all the offsets to the calls to mcount.
  7. #
  8. #
  9. # What we want to end up with this is that each object file will have a
  10. # section called __mcount_loc that will hold the list of pointers to mcount
  11. # callers. After final linking, the vmlinux will have within .init.data the
  12. # list of all callers to mcount between __start_mcount_loc and __stop_mcount_loc.
  13. # Later on boot up, the kernel will read this list, save the locations and turn
  14. # them into nops. When tracing or profiling is later enabled, these locations
  15. # will then be converted back to pointers to some function.
  16. #
  17. # This is no easy feat. This script is called just after the original
  18. # object is compiled and before it is linked.
  19. #
  20. # When parse this object file using 'objdump', the references to the call
  21. # sites are offsets from the section that the call site is in. Hence, all
  22. # functions in a section that has a call site to mcount, will have the
  23. # offset from the beginning of the section and not the beginning of the
  24. # function.
  25. #
  26. # But where this section will reside finally in vmlinx is undetermined at
  27. # this point. So we can't use this kind of offsets to record the final
  28. # address of this call site.
  29. #
  30. # The trick is to change the call offset referring the start of a section to
  31. # referring a function symbol in this section. During the link step, 'ld' will
  32. # compute the final address according to the information we record.
  33. #
  34. # e.g.
  35. #
  36. # .section ".sched.text", "ax"
  37. # [...]
  38. # func1:
  39. # [...]
  40. # call mcount (offset: 0x10)
  41. # [...]
  42. # ret
  43. # .globl fun2
  44. # func2: (offset: 0x20)
  45. # [...]
  46. # [...]
  47. # ret
  48. # func3:
  49. # [...]
  50. # call mcount (offset: 0x30)
  51. # [...]
  52. #
  53. # Both relocation offsets for the mcounts in the above example will be
  54. # offset from .sched.text. If we choose global symbol func2 as a reference and
  55. # make another file called tmp.s with the new offsets:
  56. #
  57. # .section __mcount_loc
  58. # .quad func2 - 0x10
  59. # .quad func2 + 0x10
  60. #
  61. # We can then compile this tmp.s into tmp.o, and link it back to the original
  62. # object.
  63. #
  64. # In our algorithm, we will choose the first global function we meet in this
  65. # section as the reference. But this gets hard if there is no global functions
  66. # in this section. In such a case we have to select a local one. E.g. func1:
  67. #
  68. # .section ".sched.text", "ax"
  69. # func1:
  70. # [...]
  71. # call mcount (offset: 0x10)
  72. # [...]
  73. # ret
  74. # func2:
  75. # [...]
  76. # call mcount (offset: 0x20)
  77. # [...]
  78. # .section "other.section"
  79. #
  80. # If we make the tmp.s the same as above, when we link together with
  81. # the original object, we will end up with two symbols for func1:
  82. # one local, one global. After final compile, we will end up with
  83. # an undefined reference to func1 or a wrong reference to another global
  84. # func1 in other files.
  85. #
  86. # Since local objects can reference local variables, we need to find
  87. # a way to make tmp.o reference the local objects of the original object
  88. # file after it is linked together. To do this, we convert func1
  89. # into a global symbol before linking tmp.o. Then after we link tmp.o
  90. # we will only have a single symbol for func1 that is global.
  91. # We can convert func1 back into a local symbol and we are done.
  92. #
  93. # Here are the steps we take:
  94. #
  95. # 1) Record all the local and weak symbols by using 'nm'
  96. # 2) Use objdump to find all the call site offsets and sections for
  97. # mcount.
  98. # 3) Compile the list into its own object.
  99. # 4) Do we have to deal with local functions? If not, go to step 8.
  100. # 5) Make an object that converts these local functions to global symbols
  101. # with objcopy.
  102. # 6) Link together this new object with the list object.
  103. # 7) Convert the local functions back to local symbols and rename
  104. # the result as the original object.
  105. # 8) Link the object with the list object.
  106. # 9) Move the result back to the original object.
  107. #
  108. use warnings;
  109. use strict;
  110. my $P = $0;
  111. $P =~ s@.*/@@g;
  112. my $V = '0.1';
  113. if ($#ARGV != 11) {
  114. print "usage: $P arch endian bits objdump objcopy cc ld nm rm mv is_module inputfile\n";
  115. print "version: $V\n";
  116. exit(1);
  117. }
  118. my ($arch, $endian, $bits, $objdump, $objcopy, $cc,
  119. $ld, $nm, $rm, $mv, $is_module, $inputfile) = @ARGV;
  120. # This file refers to mcount and shouldn't be ftraced, so lets' ignore it
  121. if ($inputfile =~ m,kernel/trace/ftrace\.o$,) {
  122. exit(0);
  123. }
  124. # Acceptable sections to record.
  125. my %text_sections = (
  126. ".text" => 1,
  127. ".init.text" => 1,
  128. ".ref.text" => 1,
  129. ".sched.text" => 1,
  130. ".spinlock.text" => 1,
  131. ".irqentry.text" => 1,
  132. ".softirqentry.text" => 1,
  133. ".kprobes.text" => 1,
  134. ".cpuidle.text" => 1,
  135. ".text.unlikely" => 1,
  136. );
  137. # Acceptable section-prefixes to record.
  138. my %text_section_prefixes = (
  139. ".text." => 1,
  140. );
  141. # Note: we are nice to C-programmers here, thus we skip the '||='-idiom.
  142. $objdump = 'objdump' if (!$objdump);
  143. $objcopy = 'objcopy' if (!$objcopy);
  144. $cc = 'gcc' if (!$cc);
  145. $ld = 'ld' if (!$ld);
  146. $nm = 'nm' if (!$nm);
  147. $rm = 'rm' if (!$rm);
  148. $mv = 'mv' if (!$mv);
  149. #print STDERR "running: $P '$arch' '$objdump' '$objcopy' '$cc' '$ld' " .
  150. # "'$nm' '$rm' '$mv' '$inputfile'\n";
  151. my %locals; # List of local (static) functions
  152. my %weak; # List of weak functions
  153. my %convert; # List of local functions used that needs conversion
  154. my $type;
  155. my $local_regex; # Match a local function (return function)
  156. my $weak_regex; # Match a weak function (return function)
  157. my $section_regex; # Find the start of a section
  158. my $function_regex; # Find the name of a function
  159. # (return offset and func name)
  160. my $mcount_regex; # Find the call site to mcount (return offset)
  161. my $mcount_adjust; # Address adjustment to mcount offset
  162. my $alignment; # The .align value to use for $mcount_section
  163. my $section_type; # Section header plus possible alignment command
  164. my $can_use_local = 0; # If we can use local function references
  165. # Shut up recordmcount if user has older objcopy
  166. my $quiet_recordmcount = ".tmp_quiet_recordmcount";
  167. my $print_warning = 1;
  168. $print_warning = 0 if ( -f $quiet_recordmcount);
  169. ##
  170. # check_objcopy - whether objcopy supports --globalize-symbols
  171. #
  172. # --globalize-symbols came out in 2.17, we must test the version
  173. # of objcopy, and if it is less than 2.17, then we can not
  174. # record local functions.
  175. sub check_objcopy
  176. {
  177. open (IN, "$objcopy --version |") or die "error running $objcopy";
  178. while (<IN>) {
  179. if (/objcopy.*\s(\d+)\.(\d+)/) {
  180. $can_use_local = 1 if ($1 > 2 || ($1 == 2 && $2 >= 17));
  181. last;
  182. }
  183. }
  184. close (IN);
  185. if (!$can_use_local && $print_warning) {
  186. print STDERR "WARNING: could not find objcopy version or version " .
  187. "is less than 2.17.\n" .
  188. "\tLocal function references are disabled.\n";
  189. open (QUIET, ">$quiet_recordmcount");
  190. printf QUIET "Disables the warning from recordmcount.pl\n";
  191. close QUIET;
  192. }
  193. }
  194. if ($arch =~ /(x86(_64)?)|(i386)/) {
  195. if ($bits == 64) {
  196. $arch = "x86_64";
  197. } else {
  198. $arch = "i386";
  199. }
  200. }
  201. #
  202. # We base the defaults off of i386, the other archs may
  203. # feel free to change them in the below if statements.
  204. #
  205. $local_regex = "^[0-9a-fA-F]+\\s+t\\s+(\\S+)";
  206. $weak_regex = "^[0-9a-fA-F]+\\s+([wW])\\s+(\\S+)";
  207. $section_regex = "Disassembly of section\\s+(\\S+):";
  208. $function_regex = "^([0-9a-fA-F]+)\\s+<([^^]*?)>:";
  209. $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\s(mcount|__fentry__)\$";
  210. $section_type = '@progbits';
  211. $mcount_adjust = 0;
  212. $type = ".long";
  213. if ($arch eq "x86_64") {
  214. $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\s(mcount|__fentry__)([+-]0x[0-9a-zA-Z]+)?\$";
  215. $type = ".quad";
  216. $alignment = 8;
  217. $mcount_adjust = -1;
  218. # force flags for this arch
  219. $ld .= " -m elf_x86_64";
  220. $objdump .= " -M x86-64";
  221. $objcopy .= " -O elf64-x86-64";
  222. $cc .= " -m64";
  223. } elsif ($arch eq "i386") {
  224. $alignment = 4;
  225. $mcount_adjust = -1;
  226. # force flags for this arch
  227. $ld .= " -m elf_i386";
  228. $objdump .= " -M i386";
  229. $objcopy .= " -O elf32-i386";
  230. $cc .= " -m32";
  231. } elsif ($arch eq "s390" && $bits == 64) {
  232. if ($cc =~ /-DCC_USING_HOTPATCH/) {
  233. $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*c0 04 00 00 00 00\\s*(brcl\\s*0,|jgnop\\s*)[0-9a-f]+ <([^\+]*)>\$";
  234. $mcount_adjust = 0;
  235. } else {
  236. $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*R_390_(PC|PLT)32DBL\\s+_mcount\\+0x2\$";
  237. $mcount_adjust = -14;
  238. }
  239. $alignment = 8;
  240. $type = ".quad";
  241. $ld .= " -m elf64_s390";
  242. $cc .= " -m64";
  243. } elsif ($arch eq "sh") {
  244. $alignment = 2;
  245. # force flags for this arch
  246. $ld .= " -m shlelf_linux";
  247. if ($endian eq "big") {
  248. $objcopy .= " -O elf32-shbig-linux";
  249. } else {
  250. $objcopy .= " -O elf32-sh-linux";
  251. }
  252. } elsif ($arch eq "powerpc") {
  253. my $ldemulation;
  254. $local_regex = "^[0-9a-fA-F]+\\s+t\\s+(\\.?\\S+)";
  255. # See comment in the sparc64 section for why we use '\w'.
  256. $function_regex = "^([0-9a-fA-F]+)\\s+<(\\.?\\w*?)>:";
  257. $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\s\\.?_mcount\$";
  258. if ($endian eq "big") {
  259. $cc .= " -mbig-endian ";
  260. $ld .= " -EB ";
  261. $ldemulation = "ppc"
  262. } else {
  263. $cc .= " -mlittle-endian ";
  264. $ld .= " -EL ";
  265. $ldemulation = "lppc"
  266. }
  267. if ($bits == 64) {
  268. $type = ".quad";
  269. $cc .= " -m64 ";
  270. $ld .= " -m elf64".$ldemulation." ";
  271. } else {
  272. $cc .= " -m32 ";
  273. $ld .= " -m elf32".$ldemulation." ";
  274. }
  275. } elsif ($arch eq "arm") {
  276. $alignment = 2;
  277. $section_type = '%progbits';
  278. $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*R_ARM_(CALL|PC24|THM_CALL)" .
  279. "\\s+(__gnu_mcount_nc|mcount)\$";
  280. } elsif ($arch eq "arm64") {
  281. $alignment = 3;
  282. $section_type = '%progbits';
  283. $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*R_AARCH64_CALL26\\s+_mcount\$";
  284. $type = ".quad";
  285. } elsif ($arch eq "ia64") {
  286. $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\s_mcount\$";
  287. $type = "data8";
  288. if ($is_module eq "0") {
  289. $cc .= " -mconstant-gp";
  290. }
  291. } elsif ($arch eq "sparc64") {
  292. # In the objdump output there are giblets like:
  293. # 0000000000000000 <igmp_net_exit-0x18>:
  294. # As there's some data blobs that get emitted into the
  295. # text section before the first instructions and the first
  296. # real symbols. We don't want to match that, so to combat
  297. # this we use '\w' so we'll match just plain symbol names,
  298. # and not those that also include hex offsets inside of the
  299. # '<>' brackets. Actually the generic function_regex setting
  300. # could safely use this too.
  301. $function_regex = "^([0-9a-fA-F]+)\\s+<(\\w*?)>:";
  302. # Sparc64 calls '_mcount' instead of plain 'mcount'.
  303. $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\s_mcount\$";
  304. $alignment = 8;
  305. $type = ".xword";
  306. $ld .= " -m elf64_sparc";
  307. $cc .= " -m64";
  308. $objcopy .= " -O elf64-sparc";
  309. } elsif ($arch eq "mips") {
  310. # To enable module support, we need to enable the -mlong-calls option
  311. # of gcc for module, after using this option, we can not get the real
  312. # offset of the calling to _mcount, but the offset of the lui
  313. # instruction or the addiu one. herein, we record the address of the
  314. # first one, and then we can replace this instruction by a branch
  315. # instruction to jump over the profiling function to filter the
  316. # indicated functions, or switch back to the lui instruction to trace
  317. # them, which means dynamic tracing.
  318. #
  319. # c: 3c030000 lui v1,0x0
  320. # c: R_MIPS_HI16 _mcount
  321. # c: R_MIPS_NONE *ABS*
  322. # c: R_MIPS_NONE *ABS*
  323. # 10: 64630000 daddiu v1,v1,0
  324. # 10: R_MIPS_LO16 _mcount
  325. # 10: R_MIPS_NONE *ABS*
  326. # 10: R_MIPS_NONE *ABS*
  327. # 14: 03e0082d move at,ra
  328. # 18: 0060f809 jalr v1
  329. #
  330. # for the kernel:
  331. #
  332. # 10: 03e0082d move at,ra
  333. # 14: 0c000000 jal 0 <loongson_halt>
  334. # 14: R_MIPS_26 _mcount
  335. # 14: R_MIPS_NONE *ABS*
  336. # 14: R_MIPS_NONE *ABS*
  337. # 18: 00020021 nop
  338. if ($is_module eq "0") {
  339. $mcount_regex = "^\\s*([0-9a-fA-F]+): R_MIPS_26\\s+_mcount\$";
  340. } else {
  341. $mcount_regex = "^\\s*([0-9a-fA-F]+): R_MIPS_HI16\\s+_mcount\$";
  342. }
  343. $objdump .= " -Melf-trad".$endian."mips ";
  344. if ($endian eq "big") {
  345. $endian = " -EB ";
  346. $ld .= " -melf".$bits."btsmip";
  347. } else {
  348. $endian = " -EL ";
  349. $ld .= " -melf".$bits."ltsmip";
  350. }
  351. $cc .= " -mno-abicalls -fno-pic -mabi=" . $bits . $endian;
  352. $ld .= $endian;
  353. if ($bits == 64) {
  354. $function_regex =
  355. "^([0-9a-fA-F]+)\\s+<(.|[^\$]L.*?|\$[^L].*?|[^\$][^L].*?)>:";
  356. $type = ".dword";
  357. }
  358. } elsif ($arch eq "microblaze") {
  359. # Microblaze calls '_mcount' instead of plain 'mcount'.
  360. $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\s_mcount\$";
  361. } elsif ($arch eq "riscv") {
  362. $function_regex = "^([0-9a-fA-F]+)\\s+<([^.0-9][0-9a-zA-Z_\\.]+)>:";
  363. $mcount_regex = "^\\s*([0-9a-fA-F]+):\\sR_RISCV_CALL(_PLT)?\\s_?mcount\$";
  364. $type = ".quad";
  365. $alignment = 2;
  366. } elsif ($arch eq "nds32") {
  367. $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*R_NDS32_HI20_RELA\\s+_mcount\$";
  368. $alignment = 2;
  369. } elsif ($arch eq "csky") {
  370. $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*R_CKCORE_PCREL_JSR_IMM26BY2\\s+_mcount\$";
  371. $alignment = 2;
  372. } else {
  373. die "Arch $arch is not supported with CONFIG_FTRACE_MCOUNT_RECORD";
  374. }
  375. my $text_found = 0;
  376. my $read_function = 0;
  377. my $opened = 0;
  378. my $mcount_section = "__mcount_loc";
  379. my $dirname;
  380. my $filename;
  381. my $prefix;
  382. my $ext;
  383. if ($inputfile =~ m,^(.*)/([^/]*)$,) {
  384. $dirname = $1;
  385. $filename = $2;
  386. } else {
  387. $dirname = ".";
  388. $filename = $inputfile;
  389. }
  390. if ($filename =~ m,^(.*)(\.\S),) {
  391. $prefix = $1;
  392. $ext = $2;
  393. } else {
  394. $prefix = $filename;
  395. $ext = "";
  396. }
  397. my $mcount_s = $dirname . "/.tmp_mc_" . $prefix . ".s";
  398. my $mcount_o = $dirname . "/.tmp_mc_" . $prefix . ".o";
  399. check_objcopy();
  400. #
  401. # Step 1: find all the local (static functions) and weak symbols.
  402. # 't' is local, 'w/W' is weak
  403. #
  404. open (IN, "$nm $inputfile|") || die "error running $nm";
  405. while (<IN>) {
  406. if (/$local_regex/) {
  407. $locals{$1} = 1;
  408. } elsif (/$weak_regex/) {
  409. $weak{$2} = $1;
  410. }
  411. }
  412. close(IN);
  413. my @offsets; # Array of offsets of mcount callers
  414. my $ref_func; # reference function to use for offsets
  415. my $offset = 0; # offset of ref_func to section beginning
  416. ##
  417. # update_funcs - print out the current mcount callers
  418. #
  419. # Go through the list of offsets to callers and write them to
  420. # the output file in a format that can be read by an assembler.
  421. #
  422. sub update_funcs
  423. {
  424. return unless ($ref_func and @offsets);
  425. # Sanity check on weak function. A weak function may be overwritten by
  426. # another function of the same name, making all these offsets incorrect.
  427. if (defined $weak{$ref_func}) {
  428. die "$inputfile: ERROR: referencing weak function" .
  429. " $ref_func for mcount\n";
  430. }
  431. # is this function static? If so, note this fact.
  432. if (defined $locals{$ref_func}) {
  433. # only use locals if objcopy supports globalize-symbols
  434. if (!$can_use_local) {
  435. return;
  436. }
  437. $convert{$ref_func} = 1;
  438. }
  439. # Loop through all the mcount caller offsets and print a reference
  440. # to the caller based from the ref_func.
  441. if (!$opened) {
  442. open(FILE, ">$mcount_s") || die "can't create $mcount_s\n";
  443. $opened = 1;
  444. print FILE "\t.section $mcount_section,\"a\",$section_type\n";
  445. print FILE "\t.align $alignment\n" if (defined($alignment));
  446. }
  447. foreach my $cur_offset (@offsets) {
  448. printf FILE "\t%s %s + %d\n", $type, $ref_func, $cur_offset - $offset;
  449. }
  450. }
  451. #
  452. # Step 2: find the sections and mcount call sites
  453. #
  454. open(IN, "LANG=C $objdump -hdr $inputfile|") || die "error running $objdump";
  455. my $text;
  456. # read headers first
  457. my $read_headers = 1;
  458. while (<IN>) {
  459. if ($read_headers && /$mcount_section/) {
  460. #
  461. # Somehow the make process can execute this script on an
  462. # object twice. If it does, we would duplicate the mcount
  463. # section and it will cause the function tracer self test
  464. # to fail. Check if the mcount section exists, and if it does,
  465. # warn and exit.
  466. #
  467. print STDERR "ERROR: $mcount_section already in $inputfile\n" .
  468. "\tThis may be an indication that your build is corrupted.\n" .
  469. "\tDelete $inputfile and try again. If the same object file\n" .
  470. "\tstill causes an issue, then disable CONFIG_DYNAMIC_FTRACE.\n";
  471. exit(-1);
  472. }
  473. # is it a section?
  474. if (/$section_regex/) {
  475. $read_headers = 0;
  476. # Only record text sections that we know are safe
  477. $read_function = defined($text_sections{$1});
  478. if (!$read_function) {
  479. foreach my $prefix (keys %text_section_prefixes) {
  480. if (substr($1, 0, length $prefix) eq $prefix) {
  481. $read_function = 1;
  482. last;
  483. }
  484. }
  485. }
  486. # print out any recorded offsets
  487. update_funcs();
  488. # reset all markers and arrays
  489. $text_found = 0;
  490. undef($ref_func);
  491. undef(@offsets);
  492. # section found, now is this a start of a function?
  493. } elsif ($read_function && /$function_regex/) {
  494. $text_found = 1;
  495. $text = $2;
  496. # if this is either a local function or a weak function
  497. # keep looking for functions that are global that
  498. # we can use safely.
  499. if (!defined($locals{$text}) && !defined($weak{$text})) {
  500. $ref_func = $text;
  501. $read_function = 0;
  502. $offset = hex $1;
  503. } else {
  504. # if we already have a function, and this is weak, skip it
  505. if (!defined($ref_func) && !defined($weak{$text}) &&
  506. # PPC64 can have symbols that start with .L and
  507. # gcc considers these special. Don't use them!
  508. $text !~ /^\.L/) {
  509. $ref_func = $text;
  510. $offset = hex $1;
  511. }
  512. }
  513. }
  514. # is this a call site to mcount? If so, record it to print later
  515. if ($text_found && /$mcount_regex/) {
  516. push(@offsets, (hex $1) + $mcount_adjust);
  517. }
  518. }
  519. # dump out anymore offsets that may have been found
  520. update_funcs();
  521. # If we did not find any mcount callers, we are done (do nothing).
  522. if (!$opened) {
  523. exit(0);
  524. }
  525. close(FILE);
  526. #
  527. # Step 3: Compile the file that holds the list of call sites to mcount.
  528. #
  529. `$cc -o $mcount_o -c $mcount_s`;
  530. my @converts = keys %convert;
  531. #
  532. # Step 4: Do we have sections that started with local functions?
  533. #
  534. if ($#converts >= 0) {
  535. my $globallist = "";
  536. my $locallist = "";
  537. foreach my $con (@converts) {
  538. $globallist .= " --globalize-symbol $con";
  539. $locallist .= " --localize-symbol $con";
  540. }
  541. my $globalobj = $dirname . "/.tmp_gl_" . $filename;
  542. my $globalmix = $dirname . "/.tmp_mx_" . $filename;
  543. #
  544. # Step 5: set up each local function as a global
  545. #
  546. `$objcopy $globallist $inputfile $globalobj`;
  547. #
  548. # Step 6: Link the global version to our list.
  549. #
  550. `$ld -r $globalobj $mcount_o -o $globalmix`;
  551. #
  552. # Step 7: Convert the local functions back into local symbols
  553. #
  554. `$objcopy $locallist $globalmix $inputfile`;
  555. # Remove the temp files
  556. `$rm $globalobj $globalmix`;
  557. } else {
  558. my $mix = $dirname . "/.tmp_mx_" . $filename;
  559. #
  560. # Step 8: Link the object with our list of call sites object.
  561. #
  562. `$ld -r $inputfile $mcount_o -o $mix`;
  563. #
  564. # Step 9: Move the result back to the original object.
  565. #
  566. `$mv $mix $inputfile`;
  567. }
  568. # Clean up the temp files
  569. `$rm $mcount_o $mcount_s`;
  570. exit(0);