VirtualBox

Ignore:
Timestamp:
Jan 2, 2015 12:27:57 PM (10 years ago)
Author:
vboxsync
Message:

VBoxDTrace: libdtrace is mostly compiling, missing generated sources thouh. (r31)

Location:
trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_cc.c

    r53634 r53655  
    8181 */
    8282
     83#ifndef VBOX
    8384#include <sys/types.h>
    8485#include <sys/wait.h>
    … …  
    9596#include <ctype.h>
    9697#include <dirent.h>
     98#else  /* VBOX */
     99# include <ctype.h>
     100# include <iprt/dir.h>
     101# ifdef _MSC_VER
     102#  include <io.h>
     103#  define ftruncate64   _chsize
     104#  define lseek64       lseek
     105# else
     106#  include <unistd.h>
     107# endif
     108#endif /* VBOX */
    97109#include <dt_module.h>
    98110#include <dt_program.h>
    … …  
    14291441        const dtrace_pattr_t *pap;
    14301442        dt_probe_t *prp;
     1443#ifndef VBOX
    14311444        dt_provider_t *pvp;
     1445#endif
    14321446        dt_ident_t *idp;
    14331447        char attrstr[8];
    14341448        int err;
    14351449
     1450#ifndef VBOX
    14361451        /*
    14371452         * Both kernel and pid based providers are allowed to have names
    … …  
    14521467                longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
    14531468        }
     1469#endif
    14541470
    14551471        /*
    … …  
    15831599dt_preproc(dtrace_hdl_t *dtp, FILE *ifp)
    15841600{
     1601#ifndef VBOX
    15851602        int argc = dtp->dt_cpp_argc;
    15861603        char **argv = malloc(sizeof (char *) * (argc + 5));
    … …  
    17071724        (void) fclose(ofp);
    17081725        return (NULL);
     1726#else  /* VBOX */
     1727        (void) dt_set_errno(dtp, EDT_CPPERR);
     1728        return (NULL);
     1729#endif /* VBOX */
    17091730}
    17101731
    … …  
    19271948dt_load_libs_dir(dtrace_hdl_t *dtp, const char *path)
    19281949{
     1950#ifndef VBOX
    19291951        struct dirent *dp;
    19301952        const char *p;
    19311953        DIR *dirp;
     1954#else
     1955        PRTDIR pDir;
     1956        RTDIRENTRY DirEntry;
     1957        const char *p;
     1958        int rc;
     1959#endif
    19321960
    19331961        char fname[PATH_MAX];
    … …  
    19371965        dt_lib_depend_t *dld;
    19381966
     1967#ifndef VBOX
    19391968        if ((dirp = opendir(path)) == NULL) {
    19401969                dt_dprintf("skipping lib dir %s: %s\n", path, strerror(errno));
    19411970                return (0);
    19421971        }
     1972#else
     1973        rc = RTDirOpen(&pDir, path);
     1974        if (RT_FAILURE(rc)) {
     1975                dt_dprintf("skipping lib dir %s: %s\n", path, RTErrGetShort(rc));
     1976                return (0);
     1977        }
     1978#endif
    19431979
    19441980        /* First, parse each file for library dependencies. */
     1981#ifndef VBOX
    19451982        while ((dp = readdir(dirp)) != NULL) {
     1983#else
     1984        while (RT_SUCCESS(RTDirRead(pDir, &DirEntry, 0))) {
     1985                struct FakeDirEntry {
     1986                        const char *d_name;
     1987                } FakeDirEntry = { DirEntry.szName }, *dp = &FakeDirEntry;
     1988#endif
    19461989                if ((p = strrchr(dp->d_name, '.')) == NULL || strcmp(p, ".d"))
    19471990                        continue; /* skip any filename not ending in .d */
    … …  
    19772020        }
    19782021
     2022#ifndef VBOX
    19792023        (void) closedir(dirp);
     2024#else
     2025        RTDirClose(pDir);
     2026#endif
    19802027        /*
    19812028         * Finish building the graph containing the library dependencies

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_cg.c

    r53653 r53655  
    478478
    479479        dif_instr_t instr;
     480#ifndef VBOX
    480481        int reg, n;
     482#else
     483        int reg;
     484        uint64_t n;
     485#endif
    481486
    482487        if (dt_node_is_scalar(dst) && (dstsize < srcsize ||
    … …  
    522527        const dt_idsig_t *isp = idp->di_data;
    523528        dt_node_t *dnp;
    524         int i = 0;
     529        VBDTTYPE(uint_t,int) i = 0;
    525530
    526531        for (dnp = args; dnp != NULL; dnp = dnp->dn_list)
    … …  
    12181223        uint_t op;
    12191224        size_t size;
     1225#ifndef VBOX
    12201226        int reg, n;
     1227#else
     1228        int reg;
     1229        uint64_t n;
     1230#endif
    12211231
    12221232        assert(dnp->dn_kind == DT_NODE_VAR);
    … …  
    18601870                        dtrace_hdl_t *dtp = yypcb->pcb_hdl;
    18611871                        dtrace_syminfo_t *sip = dnp->dn_ident->di_data;
     1872#ifndef VBOX
    18621873                        GElf_Sym sym;
    18631874
    18641875                        if (dtrace_lookup_by_name(dtp,
    18651876                            sip->dts_object, sip->dts_name, &sym, NULL) == -1) {
     1877#endif
    18661878                                xyerror(D_UNKNOWN, "cg failed for symbol %s`%s:"
    18671879                                    " %s\n", sip->dts_object, sip->dts_name,
    18681880                                    dtrace_errmsg(dtp, dtrace_errno(dtp)));
     1881#ifndef VBOX
    18691882                        }
    18701883
    … …  
    18811894                                    dt_cg_node_alloc(DT_LBL_NONE, instr));
    18821895                        }
     1896#endif
    18831897                        break;
    18841898                }

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_consume.c

    r53634 r53655  
    2424 */
    2525
     26#ifndef VBOX
    2627#include <stdlib.h>
    2728#include <strings.h>
    … …  
    3233#include <ctype.h>
    3334#include <alloca.h>
     35#else  /* VBOX */
     36# include <ctype.h>
     37# include <iprt/mp.h>
     38# ifdef _MSC_VER
     39#  pragma warning(disable:4146) /* -uint64_t warnings */
     40#  include <io.h>
     41#  define ftruncate     _chsize
     42#  define fseeko                fseek
     43# else
     44#  include <unistd.h>
     45# endif
     46#endif /* VBOX */
    3447#include <dt_impl.h>
    3548
    … …  
    385398        static const char *r_str[2] = { " <- ", " <= " };
    386399        static const char *ent = "entry", *ret = "return";
    387         static int entlen = 0, retlen = 0;
     400        static VBDTTYPE(size_t,int) entlen = 0, retlen = 0;
    388401        dtrace_epid_t next, id = epd->dtepd_epid;
    389402        int rval;
    … …  
    824837    caddr_t addr, int depth, int size)
    825838{
     839#ifndef VBOX
    826840        dtrace_syminfo_t dts;
    827841        GElf_Sym sym;
     842#endif
    828843        int i, indent;
    829844        char c[PATH_MAX * 2];
    … …  
    857872                }
    858873
    859                 if (pc == NULL)
     874                if (pc == 0 /*VBOX: NULL is a ptr */)
    860875                        break;
    861876
    … …  
    865880                        return (-1);
    866881
     882#ifndef VBOX
    867883                if (dtrace_lookup_by_addr(dtp, pc, &sym, &dts) == 0) {
    868884                        if (pc > sym.st_value) {
    … …  
    884900                                    dts.dts_object, pc);
    885901                        } else {
     902#endif
    886903                                (void) snprintf(c, sizeof (c), "0x%llx", pc);
     904#ifndef VBOX
    887905                        }
    888906                }
     907#endif
    889908
    890909                if (dt_printf(dtp, fp, format, c) < 0)
    … …  
    910929        int err = 0;
    911930
     931#ifndef VBOX
    912932        char name[PATH_MAX], objname[PATH_MAX], c[PATH_MAX * 2];
    913933        struct ps_prochandle *P;
    914934        GElf_Sym sym;
     935#else
     936        char c[PATH_MAX * 2];
     937#endif
    915938        int i, indent;
    916939        pid_t pid;
    … …  
    937960         * this is a vector open, we just print the raw address or string.
    938961         */
     962#ifndef VBOX
    939963        if (dtp->dt_vector == NULL)
    940964                P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 0);
    … …  
    944968        if (P != NULL)
    945969                dt_proc_lock(dtp, P); /* lock handle while we perform lookups */
    946 
    947         for (i = 0; i < depth && pc[i] != NULL; i++) {
     970#endif
     971
     972        for (i = 0; VBDTCAST(uint_t)i < depth && pc[i] != 0/*NULL*/; i++) {
     973#ifndef VBOX
    948974                const prmap_t *map;
     975#endif
    949976
    950977                if ((err = dt_printf(dtp, fp, "%*s", indent, "")) < 0)
    951978                        break;
    952979
     980#ifndef VBOX
    953981                if (P != NULL && Plookup_by_addr(P, pc[i],
    954982                    name, sizeof (name), &sym) == 0) {
    … …  
    9861014                                    dt_basename(objname), (u_longlong_t)pc[i]);
    9871015                        } else {
     1016#else
     1017                {       {
     1018#endif
    9881019                                (void) snprintf(c, sizeof (c), "0x%llx",
    9891020                                    (u_longlong_t)pc[i]);
    … …  
    10231054        }
    10241055
     1056#ifndef VBOX
    10251057        if (P != NULL) {
    10261058                dt_proc_unlock(dtp, P);
    10271059                dt_proc_release(dtp, P);
    10281060        }
     1061#endif
    10291062
    10301063        return (err);
    … …  
    10421075        int n, len = 256;
    10431076
     1077#ifndef VBOX
    10441078        if (act == DTRACEACT_USYM && dtp->dt_vector == NULL) {
    10451079                struct ps_prochandle *P;
    … …  
    10581092                }
    10591093        }
     1094#endif
    10601095
    10611096        do {
    … …  
    10761111        int err = 0;
    10771112
     1113#ifndef VBOX
    10781114        char objname[PATH_MAX], c[PATH_MAX * 2];
    10791115        struct ps_prochandle *P;
     1116#else
     1117        char c[64];
     1118#endif
    10801119
    10811120        if (format == NULL)
    10821121                format = "  %-50s";
    10831122
     1123#ifndef VBOX
    10841124        /*
    10851125         * See the comment in dt_print_ustack() for the rationale for
    … …  
    11061146                dt_proc_release(dtp, P);
    11071147        }
     1148#else  /* VBOX */
     1149        snprintf(c, sizeof (c), "0x%llx", (u_longlong_t)pc);
     1150        err = dt_printf(dtp, fp, format, c);
     1151#endif /* VBOX */
    11081152
    11091153        return (err);
    … …  
    11151159        /* LINTED - alignment */
    11161160        uint64_t pc = *((uint64_t *)addr);
     1161#ifndef VBOX
    11171162        dtrace_syminfo_t dts;
    11181163        GElf_Sym sym;
    11191164        char c[PATH_MAX * 2];
     1165#else
     1166        char c[64];
     1167#endif
    11201168
    11211169        if (format == NULL)
    11221170                format = "  %-50s";
    11231171
     1172#ifndef VBOX
    11241173        if (dtrace_lookup_by_addr(dtp, pc, &sym, &dts) == 0) {
    11251174                (void) snprintf(c, sizeof (c), "%s`%s",
    … …  
    11391188                }
    11401189        }
     1190#else
     1191        snprintf(c, sizeof (c), "0x%llx", (u_longlong_t)pc);
     1192#endif
    11411193
    11421194        if (dt_printf(dtp, fp, format, c) < 0)
    … …  
    11511203        /* LINTED - alignment */
    11521204        uint64_t pc = *((uint64_t *)addr);
     1205#ifndef VBOX
    11531206        dtrace_syminfo_t dts;
     1207#endif
    11541208        char c[PATH_MAX * 2];
    11551209
    … …  
    11571211                format = "  %-50s";
    11581212
     1213#ifndef VBOX
    11591214        if (dtrace_lookup_by_addr(dtp, pc, NULL, &dts) == 0) {
    11601215                (void) snprintf(c, sizeof (c), "%s", dts.dts_object);
    1161         } else {
     1216        } else
     1217#endif
     1218        {
    11621219                (void) snprintf(c, sizeof (c), "0x%llx", (u_longlong_t)pc);
    11631220        }
    … …  
    15411598    const char *option, const char *value)
    15421599{
     1600#ifndef VBOX
    15431601        int len, rval;
     1602#else
     1603        size_t len;
     1604        int rval;
     1605#endif
    15441606        char *msg;
    15451607        const char *errstr;
    … …  
    21232185
    21242186        if (max_ncpus == 0)
     2187#ifndef VBOX
    21252188                max_ncpus = dt_sysconf(dtp, _SC_CPUID_MAX) + 1;
     2189#else
     2190                max_ncpus = RTMpGetMaxCpuId() + 1;
     2191#endif
    21262192
    21272193        for (i = 0; i < max_ncpus; i++) {
    … …  
    21892255
    21902256        if (dtp->dt_lastswitch != 0) {
    2191                 if (now - dtp->dt_lastswitch < interval)
     2257                if (now - dtp->dt_lastswitch < VBDTCAST(hrtime_t)interval)
    21922258                        return (0);
    21932259
    … …  
    22012267
    22022268        if (max_ncpus == 0)
     2269#ifndef VBOX
    22032270                max_ncpus = dt_sysconf(dtp, _SC_CPUID_MAX) + 1;
     2271#else
     2272                max_ncpus = RTMpGetMaxCpuId() + 1;
     2273#endif
    22042274
    22052275        if (pf == NULL)

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_decl.c

    r53634 r53655  
    2424 */
    2525
     26#ifndef VBOX
    2627#include <strings.h>
    2728#include <stdlib.h>
    … …  
    2930#include <alloca.h>
    3031#include <assert.h>
     32#endif
    3133
    3234#include <dt_decl.h>
    … …  
    701703        int value;
    702704
     705#ifndef VBOX
    703706        name = strdupa(s);
     707#else
     708        MY_STRDUPA(name, s);
     709#endif
    704710        free(s);
    705711

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_dis.c

    r53634 r53655  
    2525 */
    2626
     27#ifndef VBOX
    2728#pragma ident   "%Z%%M% %I%     %E% SMI"
    2829
    2930#include <strings.h>
    3031#include <stdio.h>
     32#endif
    3133
    3234#include <dt_impl.h>
    … …  
    120122        case 't': return (DIFV_SCOPE_THREAD);
    121123        case 'g': return (DIFV_SCOPE_GLOBAL);
    122         default: return (-1u);
     124        default: return (~0u /*VBOX: was -1u*/);
    123125        }
    124126}

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_dof.c

    r53634 r53655  
    2424 */
    2525
     26#ifndef VBOX
    2627#include <sys/types.h>
    2728#include <sys/sysmacros.h>
    … …  
    3334#include <errno.h>
    3435#include <limits.h>
     36#else  /* VBOX */
     37# include <iprt/asm.h>
     38#endif /* VBOX */
    3539
    3640#include <dt_impl.h>
    … …  
    191195{
    192196        dt_buf_t *bp = &ddo->ddo_strs;
    193         dof_stridx_t i = dt_buf_len(bp);
     197        dof_stridx_t i = VBDTCAST(dof_stridx_t)dt_buf_len(bp);
    194198
    195199        if (i != 0 && (s == NULL || *s == '\0'))
    … …  
    406410        dofpr.dofpr_addr = 0;
    407411        dofpr.dofpr_name = dof_add_string(ddo, prp->pr_name);
    408         dofpr.dofpr_nargv = dt_buf_len(&ddo->ddo_strs);
     412        dofpr.dofpr_nargv = VBDTCAST(dof_stridx_t)dt_buf_len(&ddo->ddo_strs);
    409413
    410414        for (dnp = prp->pr_nargs; dnp != NULL; dnp = dnp->dn_list) {
    … …  
    413417        }
    414418
    415         dofpr.dofpr_xargv = dt_buf_len(&ddo->ddo_strs);
     419        dofpr.dofpr_xargv = VBDTCAST(dof_stridx_t)dt_buf_len(&ddo->ddo_strs);
    416420
    417421        for (dnp = prp->pr_xargs; dnp != NULL; dnp = dnp->dn_list) {
    … …  
    420424        }
    421425
    422         dofpr.dofpr_argidx = dt_buf_len(&ddo->ddo_args) / sizeof (uint8_t);
     426        dofpr.dofpr_argidx = VBDTCAST(uint32_t)dt_buf_len(&ddo->ddo_args) / sizeof (uint8_t);
    423427
    424428        for (i = 0; i < prp->pr_xargc; i++) {
    … …  
    446450
    447451                dofpr.dofpr_offidx =
    448                     dt_buf_len(&ddo->ddo_offs) / sizeof (uint32_t);
     452                    VBDTCAST(uint32_t)(dt_buf_len(&ddo->ddo_offs) / sizeof (uint32_t));
    449453                dofpr.dofpr_noffs = pip->pi_noffs;
    450454                dt_buf_write(dtp, &ddo->ddo_offs, pip->pi_offs,
    … …  
    452456
    453457                dofpr.dofpr_enoffidx =
    454                     dt_buf_len(&ddo->ddo_enoffs) / sizeof (uint32_t);
     458                    VBDTCAST(uint32_t)(dt_buf_len(&ddo->ddo_enoffs) / sizeof (uint32_t));
    455459                dofpr.dofpr_nenoffs = pip->pi_nenoffs;
    456460                dt_buf_write(dtp, &ddo->ddo_enoffs, pip->pi_enoffs,
    … …  
    663667
    664668                if (sdp->dtsd_fmtdata != NULL) {
    665                         i = dtrace_printf_format(dtp,
     669                        i = VBDTCAST(uint_t)dtrace_printf_format(dtp,
    666670                            sdp->dtsd_fmtdata, NULL, 0);
    667671                        maxfmt = MAX(maxfmt, i);
    … …  
    822826                (void) dof_add_usect(ddo, _dtrace_version, DOF_SECT_COMMENTS,
    823827                    sizeof (char), 0, 0, strlen(_dtrace_version) + 1);
     828#ifndef VBOX
    824829                (void) dof_add_usect(ddo, &dtp->dt_uts, DOF_SECT_UTSNAME,
    825830                    sizeof (char), 0, 0, sizeof (struct utsname));
     831#endif
    826832        }
    827833

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_handle.c

    r53634 r53655  
    2424 */
    2525
     26#ifndef VBOX
    2627#pragma ident   "%Z%%M% %I%     %E% SMI"
    2728
    … …  
    3334#include <assert.h>
    3435#include <alloca.h>
     36#endif
    3537
    3638#include <dt_impl.h>
    … …  
    157159        const char *faultstr;
    158160        char *str;
    159         int len;
     161        VBDTTYPE(size_t,int) len;
    160162
    161163        assert(epd->dtepd_uarg == DT_ECB_ERROR);
    … …  
    240242        const int slop = 80;
    241243        char *str;
    242         int len;
     244        VBDTTYPE(size_t,int) len;
    243245
    244246        err.dteda_edesc = data->dtpda_edesc;
    … …  
    248250        err.dteda_offset = -1;
    249251        err.dteda_fault = DTRACEFLT_LIBRARY;
    250         err.dteda_addr = NULL;
     252        err.dteda_addr = 0 /*NULL*/;
    251253
    252254        len = strlen(faultstr) +
    … …  
    313315        dtrace_dropdata_t drop;
    314316        char str[80], *s;
    315         int size;
     317        VBDTTYPE(size_t,int) size;
    316318
    317319        assert(what == DTRACEDROP_PRINCIPAL || what == DTRACEDROP_AGGREGATION);
    … …  
    420422                            dt_droptag(_dt_droptab[i].dtdrt_kind));
    421423                        s = &str[strlen(str)];
    422                         size = sizeof (str) - (s - str);
     424                        size = VBDTCAST(int)sizeof (str) - (s - str);
    423425                } else {
    424426                        s = str;

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_ident.c

    r53634 r53655  
    2424 */
    2525
     26#ifndef VBOX
    2627#include <sys/sysmacros.h>
    2728#include <strings.h>
    … …  
    3334#include <sys/procfs_isa.h>
    3435#include <limits.h>
     36#else  /* VBOX */
     37# include <ctype.h>
     38#endif /* VBOX */
    3539
    3640#include <dt_ident.h>
    … …  
    179183
    180184                assert(idp->di_iarg != NULL);
     185#ifndef VBOX
    181186                s = strdupa(idp->di_iarg);
     187#else
     188                MY_STRDUPA(s, idp->di_iarg);
     189#endif
    182190
    183191                if ((p2 = strrchr(s, ')')) != NULL)

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_inttab.c

    r53634 r53655  
    2525 */
    2626
     27#ifndef VBOX
    2728#pragma ident   "%Z%%M% %I%     %E% SMI"
    2829
    2930#include <assert.h>
     31#endif
    3032
    3133#include <dt_inttab.h>

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_map.c

    r53634 r53655  
    2424 */
    2525
     26#ifndef VBOX
    2627#pragma ident   "%Z%%M% %I%     %E% SMI"
    2728
    … …  
    3132#include <unistd.h>
    3233#include <assert.h>
     34#endif
    3335
    3436#include <dt_impl.h>
    … …  
    4345        dtrace_probedesc_t *probe;
    4446
    45         while (id >= (max = dtp->dt_maxprobe) || dtp->dt_pdesc == NULL) {
     47        while (id >= (max = VBDTCAST(dtrace_id_t)dtp->dt_maxprobe) || dtp->dt_pdesc == NULL) {
    4648                dtrace_id_t new_max = max ? (max << 1) : 1;
    4749                size_t nsize = new_max * sizeof (void *);
    … …  
    293295        int rval;
    294296
    295         while (id >= (max = dtp->dt_maxagg) || dtp->dt_aggdesc == NULL) {
     297        while (id >= (max = VBDTCAST(dtrace_id_t)dtp->dt_maxagg) || dtp->dt_aggdesc == NULL) {
    296298                dtrace_id_t new_max = max ? (max << 1) : 1;
    297299                size_t nsize = new_max * sizeof (void *);
    … …  
    360362                 */
    361363                if (dtp->dt_options[DTRACEOPT_GRABANON] == DTRACEOPT_UNSET &&
    362                     agg->dtagd_rec[0].dtrd_uarg != NULL) {
     364                    agg->dtagd_rec[0].dtrd_uarg != 0 /*NULL*/) {
    363365                        dtrace_stmtdesc_t *sdp;
    364366                        dt_ident_t *aid;

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_module.c

    r53634 r53655  
    2424 */
    2525
     26#ifndef VBOX
    2627#include <sys/types.h>
    2728#include <sys/modctl.h>
    … …  
    4142#include <errno.h>
    4243#include <dirent.h>
     44#else  /* VBOX */
     45#endif /* VBOX */
    4346
    4447#include <dt_strtab.h>
    4548#include <dt_module.h>
    4649#include <dt_impl.h>
     50
     51#ifndef VBOX /** @todo port what is necessary here ! */
    4752
    4853static const char *dt_module_strtab; /* active strtab for qsort callbacks */
    … …  
    13121317        return (0);
    13131318}
     1319
     1320#endif /* !VBOX */

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_parser.c

    r53634 r53655  
    9292 */
    9393
     94#ifndef VBOX
    9495#include <sys/param.h>
    9596#include <limits.h>
    … …  
    103104#include <errno.h>
    104105#include <ctype.h>
     106#else  /* VBOX */
     107# include <ctype.h>
     108# ifdef _MSC_VER
     109#  pragma warning(disable:4146) /* -unsigned */
     110#  pragma warning(disable:4267) /* size_t to int */
     111# endif
     112#endif /* VBOX */
    105113
    106114#include <dt_impl.h>
    … …  
    761769dt_node_sizeof(const dt_node_t *dnp)
    762770{
     771#ifndef VBOX
    763772        dtrace_syminfo_t *sip;
    764773        GElf_Sym sym;
     774#endif
    765775        dtrace_hdl_t *dtp = yypcb->pcb_hdl;
    766776
    … …  
    777787                return (dt_node_type_size(dnp));
    778788
     789#ifndef VBOX
    779790        sip = dnp->dn_ident->di_data;
    780791
    … …  
    784795
    785796        return (sym.st_size);
     797#else
     798        return (0);
     799#endif
    786800}
    787801
    … …  
    14231437
    14241438        case DT_DC_EXTERN: {
     1439#ifndef VBOX
    14251440                dtrace_typeinfo_t ott;
    14261441                dtrace_syminfo_t dts;
    … …  
    14451460                            "failed to extern %s: %s\n", dsp->ds_ident,
    14461461                            dtrace_errmsg(dtp, dtrace_errno(dtp)));
    1447                 } else {
     1462                } else
     1463#endif
     1464                {
     1465
    14481466                        dt_dprintf("extern %s`%s type=<%s>\n",
    14491467                            dmp->dm_name, dsp->ds_ident,
    … …  
    17531771        uint_t kind;
    17541772
     1773#ifndef VBOX
    17551774        name = strdupa(s);
     1775#else
     1776        MY_STRDUPA(name, s);
     1777#endif
    17561778        free(s);
    17571779
    … …  
    25702592        dtrace_attribute_t attr = _dtrace_defattr;
    25712593        dt_ident_t *idp;
     2594#ifndef VBOX
    25722595        dtrace_syminfo_t dts;
    25732596        GElf_Sym sym;
     2597#endif
    25742598
    25752599        const char *scope, *mark;
    … …  
    26602684                dt_node_attr_assign(dnp, attr);
    26612685
     2686#ifndef VBOX
    26622687        } else if (dhp == dtp->dt_globals && scope != DTRACE_OBJ_EXEC &&
    26632688            dtrace_lookup_by_name(dtp, scope, name, &sym, &dts) == 0) {
    … …  
    27282753                        dnp->dn_flags |= DT_NF_USERLAND;
    27292754                }
    2730 
     2755#endif /* !VBOX */
    27312756        } else if (scope == DTRACE_OBJ_EXEC && create == B_TRUE) {
    27322757                uint_t flags = DT_IDFLG_WRITE;

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_pcb.c

    r53634 r53655  
    2525 */
    2626
     27#ifndef VBOX
    2728#pragma ident   "%Z%%M% %I%     %E% SMI"
     29#endif
    2830
    2931/*
    … …  
    4547 */
    4648
     49#ifndef VBOX
    4750#include <strings.h>
    4851#include <stdlib.h>
    4952#include <assert.h>
     53#endif
    5054
    5155#include <dt_impl.h>

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_pragma.c

    r53634 r53655  
    2424 */
    2525
     26#ifndef VBOX
    2627#include <assert.h>
    2728#include <strings.h>
    … …  
    2930#include <stdlib.h>
    3031#include <stdio.h>
     32#endif
    3133
    3234#include <dt_parser.h>
    … …  
    335337        }
    336338
     339#ifndef VBOX
    337340        opt = strdupa(dnp->dn_string);
     341#else
     342        MY_STRDUPA(opt, dnp->dn_string);
     343#endif
    338344
    339345        if ((val = strchr(opt, '=')) != NULL)

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_program.c

    r53634 r53655  
    2424 */
    2525
     26#ifndef VBOX
    2627#include <unistd.h>
    2728#include <strings.h>
    … …  
    3132#include <ctype.h>
    3233#include <alloca.h>
     34#else
     35# include <ctype.h>
     36#endif
    3337
    3438#include <dt_impl.h>
    … …  
    455459        char *mname, *fname;
    456460        const char *p;
    457         int i;
     461        VBDTTYPE(uint_t,int) i;
    458462
    459463        p = prp->pr_name;

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_provider.c

    r53634 r53655  
    2525 */
    2626
     27#ifndef VBOX
    2728#pragma ident   "%Z%%M% %I%     %E% SMI"
    2829
    … …  
    3738#include <unistd.h>
    3839#include <errno.h>
     40#else  /* VBOX */
     41# include <iprt/asm.h>
     42#endif /* VBOX */
    3943
    4044#include <dt_provider.h>

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_subr.c

    r53653 r53655  
    227227        dtrace_class_t c;
    228228        char *p, *q;
    229 #ifdef VBOX
    230         size_t cbStr;
    231 #endif
    232229
    233230        if (str == NULL || attr == NULL)
    … …  
    238235        p = strdupa(str);
    239236#else
    240         cbStr = strlen(str) + 1;
    241         p = alloca(cbStr);
    242         memcpy(p, str, cbStr);
     237        MY_STRDUPA(p, str);
    243238#endif
    244239

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/lib/libdtrace/common/dt_xlator.c

    r53634 r53655  
    2525 */
    2626
     27#ifndef VBOX
    2728#pragma ident   "%Z%%M% %I%     %E% SMI"
    2829
    2930#include <strings.h>
    3031#include <assert.h>
     32#endif
    3133
    3234#include <dt_xlator.h>
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette