6066 dis: support for System/370, System/390, and z/Architecture ELF bins
Reviewed by: Robert Mustacchi <rm@joyent.com>
Approved by: Dan McDonald <danmcd@omniti.com>
6070 libdisasm: attach/detach arch ops should be optional
Reviewed by: Robert Mustacchi <rm@joyent.com>
Approved by: Dan McDonald <danmcd@omniti.com>
6069 libdisasm: instrlen arch op should have a sane default
Reviewed by: Robert Mustacchi <rm@joyent.com>
Approved by: Dan McDonald <danmcd@omniti.com>
6068 libdisasm: previnstr arch op should have a sane default
Reviewed by: Robert Mustacchi <rm@joyent.com>
Approved by: Dan McDonald <danmcd@omniti.com>

@@ -50,18 +50,24 @@
 extern dis_arch_t dis_arch_i386;
 #endif
 #if !defined(DIS_STANDALONE) || defined(__sparc)
 extern dis_arch_t dis_arch_sparc;
 #endif
+#if !defined(DIS_STANDALONE) || defined(__s390) || defined(__s390x)
+extern dis_arch_t dis_arch_s390;
+#endif
 
 static dis_arch_t *dis_archs[] = {
 #if !defined(DIS_STANDALONE) || defined(__i386) || defined(__amd64)
         &dis_arch_i386,
 #endif
 #if !defined(DIS_STANDALONE) || defined(__sparc)
         &dis_arch_sparc,
 #endif
+#if !defined(DIS_STANDALONE) || defined(__s390) || defined(__s390x)
+        &dis_arch_s390,
+#endif
         NULL
 };
 
 /*
  * For the standalone library, we need to link against mdb's malloc/free.

@@ -141,11 +147,13 @@
 }
 
 void
 dis_handle_destroy(dis_handle_t *dhp)
 {
+        if (dhp->dh_arch->da_handle_detach != NULL)
         dhp->dh_arch->da_handle_detach(dhp);
+
         dis_free(dhp, sizeof (dis_handle_t));
 }
 
 dis_handle_t *
 dis_handle_create(int flags, void *data, dis_lookup_f lookup_func,

@@ -179,11 +187,12 @@
 
         /*
          * Allow the architecture-specific code to allocate
          * its private data.
          */
-        if (arch->da_handle_attach(dhp) != 0) {
+        if (arch->da_handle_attach != NULL &&
+            arch->da_handle_attach(dhp) != 0) {
                 dis_free(dhp, sizeof (dis_handle_t));
                 /* dis errno already set */
                 return (NULL);
         }
 

@@ -194,13 +203,71 @@
 dis_disassemble(dis_handle_t *dhp, uint64_t addr, char *buf, size_t buflen)
 {
         return (dhp->dh_arch->da_disassemble(dhp, addr, buf, buflen));
 }
 
+/*
+ * On some instruction sets (e.g., x86), we have no choice except to
+ * disassemble everything from the start of the symbol, and stop when we
+ * have reached our instruction address.  If we're not in the middle of a
+ * known symbol, then we return the same address to indicate failure.
+ */
+static uint64_t
+dis_generic_previnstr(dis_handle_t *dhp, uint64_t pc, int n)
+{
+        uint64_t *hist, addr, start;
+        int cur, nseen;
+        uint64_t res = pc;
+
+        if (n <= 0)
+                return (pc);
+
+        if (dhp->dh_lookup(dhp->dh_data, pc, NULL, 0, &start, NULL) != 0 ||
+            start == pc)
+                return (res);
+
+        hist = dis_zalloc(sizeof (uint64_t) * n);
+
+        for (cur = 0, nseen = 0, addr = start; addr < pc; addr = dhp->dh_addr) {
+                hist[cur] = addr;
+                cur = (cur + 1) % n;
+                nseen++;
+
+                /* if we cannot make forward progress, give up */
+                if (dis_disassemble(dhp, addr, NULL, 0) != 0)
+                        goto done;
+        }
+
+        if (addr != pc) {
+                /*
+                 * We scanned past %pc, but didn't find an instruction that
+                 * started at %pc.  This means that either the caller specified
+                 * an invalid address, or we ran into something other than code
+                 * during our scan.  Virtually any combination of bytes can be
+                 * construed as a valid Intel instruction, so any non-code bytes
+                 * we encounter will have thrown off the scan.
+                 */
+                goto done;
+        }
+
+        res = hist[(cur + n - MIN(n, nseen)) % n];
+
+done:
+        dis_free(hist, sizeof (uint64_t) * n);
+        return (res);
+}
+
+/*
+ * Return the nth previous instruction's address.  Return the same address
+ * to indicate failure.
+ */
 uint64_t
 dis_previnstr(dis_handle_t *dhp, uint64_t pc, int n)
 {
+        if (dhp->dh_arch->da_previnstr == NULL)
+                return (dis_generic_previnstr(dhp, pc, n));
+
         return (dhp->dh_arch->da_previnstr(dhp, pc, n));
 }
 
 int
 dis_min_instrlen(dis_handle_t *dhp)

@@ -212,13 +279,25 @@
 dis_max_instrlen(dis_handle_t *dhp)
 {
         return (dhp->dh_arch->da_max_instrlen(dhp));
 }
 
+static int
+dis_generic_instrlen(dis_handle_t *dhp, uint64_t pc)
+{
+        if (dis_disassemble(dhp, pc, NULL, 0) != 0)
+                return (-1);
+
+        return (dhp->dh_addr - pc);
+}
+
 int
 dis_instrlen(dis_handle_t *dhp, uint64_t pc)
 {
+        if (dhp->dh_arch->da_instrlen == NULL)
+                return (dis_generic_instrlen(dhp, pc));
+
         return (dhp->dh_arch->da_instrlen(dhp, pc));
 }
 
 int
 dis_vsnprintf(char *restrict s, size_t n, const char *restrict format,