1/*
2 * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25/* hsdis-demo.c -- dump a range of addresses as native instructions
26   This demonstrates the protocol required by the HotSpot PrintAssembly option.
27*/
28
29#include <stdio.h>
30#include <stdlib.h>
31#include <string.h>
32#include <inttypes.h>
33
34#include "hsdis.h"
35
36
37void greet(const char*);
38void disassemble(uintptr_t, uintptr_t);
39void end_of_file();
40
41const char* options = NULL;
42int         raw     = 0;
43int         xml     = 0;
44
45int main(int ac, char** av) {
46  int greeted = 0;
47  int i;
48  for (i = 1; i < ac; i++) {
49    const char* arg = av[i];
50    if (arg[0] == '-') {
51      if (!strcmp(arg, "-xml"))
52        xml ^= 1;
53      else if (!strcmp(arg, "-raw"))
54        raw ^= 1;
55      else if (!strncmp(arg, "-options=", 9))
56        options = arg+9;
57      else
58        { printf("Usage: %s [-xml] [name...]\n", av[0]); exit(2); }
59      continue;
60    }
61    greet(arg);
62    greeted = 1;
63  }
64  if (!greeted)
65    greet("world");
66  printf("...And now for something completely different:\n");
67  void *start = (void*) &main;
68  void *end = (void*) &end_of_file;
69#if defined(__ia64) || (defined(__powerpc__) && !defined(ABI_ELFv2))
70  /* On IA64 and PPC function pointers are pointers to function descriptors */
71  start = *((void**)start);
72  end = *((void**)end);
73#endif
74  disassemble(start, (end > start) ? end : start + 64);
75  printf("Cheers!\n");
76}
77
78void greet(const char* whom) {
79  printf("Hello, %s!\n", whom);
80}
81
82void end_of_file() { }
83
84/* don't disassemble after this point... */
85
86#include "dlfcn.h"
87
88#define DECODE_INSTRUCTIONS_VIRTUAL_NAME "decode_instructions_virtual"
89#define DECODE_INSTRUCTIONS_NAME "decode_instructions"
90#define HSDIS_NAME               "hsdis"
91static void* decode_instructions_pv = 0;
92static void* decode_instructions_sv = 0;
93static const char* hsdis_path[] = {
94  HSDIS_NAME"-"LIBARCH LIB_EXT,
95  "./" HSDIS_NAME"-"LIBARCH LIB_EXT,
96#ifdef TARGET_DIR
97  TARGET_DIR"/"HSDIS_NAME"-"LIBARCH LIB_EXT,
98#endif
99  NULL
100};
101
102static const char* load_decode_instructions() {
103  void* dllib = NULL;
104  const char* *next_in_path = hsdis_path;
105  while (1) {
106    decode_instructions_pv = dlsym(dllib, DECODE_INSTRUCTIONS_VIRTUAL_NAME);
107    decode_instructions_sv = dlsym(dllib, DECODE_INSTRUCTIONS_NAME);
108    if (decode_instructions_pv != NULL || decode_instructions_sv != NULL)
109      return NULL;
110    if (dllib != NULL)
111      return "plugin does not defined "DECODE_INSTRUCTIONS_VIRTUAL_NAME" and "DECODE_INSTRUCTIONS_NAME;
112    for (dllib = NULL; dllib == NULL; ) {
113      const char* next_lib = (*next_in_path++);
114      if (next_lib == NULL)
115        return "cannot find plugin "HSDIS_NAME LIB_EXT;
116      dllib = dlopen(next_lib, RTLD_LAZY);
117    }
118  }
119}
120
121
122static const char* lookup(void* addr) {
123#if defined(__ia64) || defined(__powerpc__)
124  /* On IA64 and PPC function pointers are pointers to function descriptors */
125#define CHECK_NAME(fn) \
126  if (addr == *((void**) &fn))  return #fn;
127#else
128#define CHECK_NAME(fn) \
129  if (addr == (void*) &fn)  return #fn;
130#endif
131
132  CHECK_NAME(main);
133  CHECK_NAME(greet);
134  return NULL;
135}
136
137/* does the event match the tag, followed by a null, space, or slash? */
138#define MATCH(event, tag) \
139  (!strncmp(event, tag, sizeof(tag)-1) && \
140   (!event[sizeof(tag)-1] || strchr(" /", event[sizeof(tag)-1])))
141
142
143static const char event_cookie[] = "event_cookie"; /* demo placeholder */
144static void* simple_handle_event(void* cookie, const char* event, void* arg) {
145  if (MATCH(event, "/insn")) {
146    // follow each complete insn by a nice newline
147    printf("\n");
148  }
149  return NULL;
150}
151
152static void* handle_event(void* cookie, const char* event, void* arg) {
153#define NS_DEMO "demo:"
154  if (cookie != event_cookie)
155    printf("*** bad event cookie %p != %p\n", cookie, event_cookie);
156
157  if (xml) {
158    /* We could almost do a printf(event, arg),
159       but for the sake of a better demo,
160       we dress the result up as valid XML.
161    */
162    const char* fmt = strchr(event, ' ');
163    int evlen = (fmt ? fmt - event : strlen(event));
164    if (!fmt) {
165      if (event[0] != '/') {
166        printf("<"NS_DEMO"%.*s>", evlen, event);
167      } else {
168        printf("</"NS_DEMO"%.*s>", evlen-1, event+1);
169      }
170    } else {
171      if (event[0] != '/') {
172        printf("<"NS_DEMO"%.*s", evlen, event);
173        printf(fmt, arg);
174        printf(">");
175      } else {
176        printf("<"NS_DEMO"%.*s_done", evlen-1, event+1);
177        printf(fmt, arg);
178        printf("/></"NS_DEMO"%.*s>", evlen-1, event+1);
179      }
180    }
181  }
182
183  if (MATCH(event, "insn")) {
184    const char* name = lookup(arg);
185    if (name)  printf("%s:\n", name);
186
187    /* basic action for <insn>: */
188    printf(" %p\t", arg);
189
190  } else if (MATCH(event, "/insn")) {
191    // follow each complete insn by a nice newline
192    printf("\n");
193  } else if (MATCH(event, "mach")) {
194    printf("Decoding for CPU '%s'\n", (char*) arg);
195
196  } else if (MATCH(event, "addr")) {
197    /* basic action for <addr/>: */
198    const char* name = lookup(arg);
199    if (name) {
200      printf("&%s (%p)", name, arg);
201      /* return non-null to notify hsdis not to print the addr */
202      return arg;
203    }
204  }
205
206  /* null return is always safe; can mean "I ignored it" */
207  return NULL;
208}
209
210#define fprintf_callback \
211  (decode_instructions_printf_callback_ftype)&fprintf
212
213void disassemble(uintptr_t from, uintptr_t to) {
214  const char* err = load_decode_instructions();
215  if (err != NULL) {
216    printf("%s: %s\n", err, dlerror());
217    exit(1);
218  }
219  decode_func_vtype decode_instructions_v
220    = (decode_func_vtype) decode_instructions_pv;
221  decode_func_stype decode_instructions_s
222    = (decode_func_stype) decode_instructions_sv;
223  void* res;
224  if (decode_instructions_pv != NULL) {
225    printf("\nDecoding from %p to %p...with %s\n", from, to, DECODE_INSTRUCTIONS_VIRTUAL_NAME);
226    if (raw) {
227      res = (*decode_instructions_v)(from, to,
228                                     (unsigned char*)from, to - from,
229                                     simple_handle_event, stdout,
230                                     NULL, stdout,
231                                     options, 0);
232    } else {
233      res = (*decode_instructions_v)(from, to,
234                                    (unsigned char*)from, to - from,
235                                     handle_event, (void*) event_cookie,
236                                     fprintf_callback, stdout,
237                                     options, 0);
238    }
239    if (res != (void*)to)
240      printf("*** Result was %p!\n", res);
241  }
242  void* sres;
243  if (decode_instructions_sv != NULL) {
244    printf("\nDecoding from %p to %p...with old decode_instructions\n", from, to, DECODE_INSTRUCTIONS_NAME);
245    if (raw) {
246      sres = (*decode_instructions_s)(from, to,
247                                      simple_handle_event, stdout,
248                                      NULL, stdout,
249                                      options);
250    } else {
251      sres = (*decode_instructions_s)(from, to,
252                                      handle_event, (void*) event_cookie,
253                                      fprintf_callback, stdout,
254                                      options);
255    }
256    if (sres != (void *)to)
257      printf("*** Result of decode_instructions %p!\n", sres);
258  }
259}
260